So a little while ago I said that I was going to review the new Open Scene Graph 3: Beginners Guide book from Packt Publishing. Unfortunately, I still haven’t had time to do the review. However, I thought I would mention that all through April Packt Publishing are running discounts on all of their Graphics books!

During April, Packt will be running a series of discounts and promotions on a selection of its Open Source Graphic books wherein readers can avail exclusive discounts of 20% and 30% off the cover price of Graphic print books and eBooks.

So, I suggest you go check out what they have to offer:

http://www.packtpub.com/article/graphic-open-source

Cheers
Michael

Full Disclosure: I have nothing to do with Packt Publishing. However, they did give me a free e-book version of the OSG3 Beginners Guide for me to review. I feel a little bit guilty that I haven’t done the review yet. Other than that, I have no affiliation with Packt Publishing, and I didn’t get anything for posting this. So I haven’t sold out. In my opinion, someone going out of their way to produce documentation and reference books for Open Source Software is a good thing!

Just a quick note to say that I’ve put all the Java video tutorials up on Youtube. Things have changed since I started making the videos – Youtube has finally allowed videos longer than 15 minutes, which means I can upload them without having to slice them all up.

Youtube Playlist

Cheers
Michael

3DUI has wrapped up for the year, so here is our second publication. We introduce a new material for freeform sculpting in spatial augmented reality environments. Please read the paper, and have a look at the video below.

So right now I am at the IEEE Symposium on 3D User Interfaces in Singapore. We have a couple of publications which I’ll be posting over the next few days. First up is Adaptive Color Marker for SAR Environments. In a previous study we created interactive virtual control panels by projecting onto otherwise blank designs. We used a simple orange marker to track the position of the user’s finger. However, in a SAR environment, this approach suffers from several problems:

• The tracking system can’t track the marker if we project the same colour as the marker.
• Projecting onto the marker changes it’s appearance, causing tracking to fail.
• Users could not tell when they were pressing virtual controls, because their finger occluded the projection.

We address these problems with an active colour marker. We use a colour sensor to detect what is being projected onto the marker, and change the colour of the marker to an opposite colour, so that tracking continues to work. In addition, we can use the active marker as a form of visual feedback. For example, we can change the colour to indicate a virtual button press.

I’ve added the publication to my publications page, and here’s the video of the marker in action.

So this week I became a member sponsor on www.3dbuzz.com. The first thing I had a look at was their XNA Behaviour Programming videos, which are the first in their set on AI programming. However, not being particularly interested in XNA, I implemented the algorithms presented in the videos for Android.

Here’s a video of the demo running on my Nexus One:

Since I was on Android and only using the Android and OpenGL ES libraries, I had to write a lot of low level code to replace the XNA functionality that 3DBuzz’s videos rely on. I also had to implement an on-screen joystick. I might write up a couple of posts on the more interesting parts of the code (what is not in the videos) soon.

Thanks
Michael

Hi Everyone

The guys over at Packt Publishing have kindly asked me to review a new book on programming with OpenSceneGraph. I haven’t looked at the book yet, but will get the review done sometime this week. In the mean time, checkout the book:

http://link.packtpub.com/NwneHs

Multiple X Screens

The easiest way to do dual screen output is if you have your X server configured so each output is its own X screen. The first thing you need to do is make sure you have enough screens. Finding this out is easy enough:

int getNumScreens()
{
    osg::GraphicsContext::WindowingSystemInterface* wsi = osg::GraphicsContext::getWindowingSystemInterface();
    osg::GraphicsContext::ScreenIdentifier si;
    si.readDISPLAY();
    return wsi->getNumScreens(si);
}

You should do this before attempting to create your screens to make sure the X server is configured correctly. Otherwise OSG will throw an error when you try and create a graphics context for a screen that doesn’t exist. Setting up the viewers is fairly straight forward:

//Create main scene viewer
 
ref_ptr<osgViewer::CompositeViewer> compositeViewer = new osgViewer::CompositeViewer;
 
// create first view
osgViewer::View* v0 = new osgViewer::View();
v0->setUpViewOnSingleScreen(0);
 
// add view to the composite viewer
compositeViewer->addView(v0);
 
// do the same with the second view
osgViewer::View* v1 = new osgViewer::View();
v1->setUpViewOnSingleScreen(1);
compositeViewer->addView(1);

And thats it. You also need to set the scene data for each of your views and a couple of things I’ve missed, but that is the basic idea. The problem with this method is it creates 2 graphics contexts, which in most cases will cause a performance hit.

Single X Screen, Single Context

I looked into this method because I use TwinView on my Linux desktop boxes. Of course, TwinView means that there is only 1 XScreen that spans both monitors. Therefore, the getNumScreens function above will return 1. I have also set up our projector setup to use TwinView, so I don’t need to have one lot of code for testing on the desktop and then do something completely different when using the projectors. The other benefit of this approach is you only create one graphics context.

First thing we do is get the dimensions of the screen, which will be the combination of both screens.

// get the total resolution of the xscreen
osg::GraphicsContext::WindowingSystemInterface* wsi = osg::GraphicsContext::getWindowingSystemInterface();
unsigned width, height;
wsi->getScreenResolution(osg::GraphicsContext::ScreenIdentifier(0), width, height);

Once that is done we can create our (single) graphics context.

// create a context that spans the entire x screen
traits->x = 0;
traits->y = 0;
traits->width = width;
traits->height = height;
traits->windowDecoration = false;
traits->doubleBuffer = true;
traits->sharedContext = 0;
traits->overrideRedirect = true;
osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());

The important one here is overrideRedirect. Some window managers (I’m looking at you Gnome) will redirect the position of your graphics context, so it won’t appear where you want it. The overrideRedirect option is kindof new, it does not exist in the version of OSG shipping with Ubuntu 8.10. Therefore, I am running the latest stable release (2.6) compiled from source.

To get the equivalent of 2 screens to draw on, we create 2 views like before. However, we have to set their viewport manually. Here we just make v0 use the left half of the screen, and v1 use the right half. Easy enough?

//first screen
osgViewer::View* v0 = new osgViewer::View();
 
osg::ref_ptr<osg::Camera> cam = v0->getCamera();
cam->setGraphicsContext(gc.get());
cam->setViewport(0, 0, width/2, height);
compositeViewer->addView(v);
 
//second screen
osgViewer::View* v1 = new osgViewer::View();
osg::ref_ptr<osg::Camera> cam2 = v1->getCamera();
cam2->setGraphicsContext(gc.get());
cam2->setViewport(width/2, 0, width/2, height);
compositeViewer->addView(v1);

setViewport sets the viewport of the camera. The first 2 parameters are the position in the context’s window, the next 2 are the dimensions. So, each view gets width/2 for the width, and the second screen’s position is offset by half the screen width meaning it starts on the second monitor.

Conclusion

And there you have it. Two methods for dual screen using OpenSceneGraph. Looking at the code, it is fairly simple. However, after browsing the doxygen docs for OSG it was not at all obvious to me. Of course, the osg-users mailing list was a big help here. In fact, here is the thread from the mailing list

Cheers
Michael

Note that this video is 1024×768, so hit the full screen button to get more readable detail.

Notes:

This video is the property of 3DBuzz Inc. Jason and Zak have kindly given me permission to host it on this website. Because it is not owned by me, I would appreciate it if you did not distribute this video. Cheers!

Note that this video is 1024×768, so hit the full screen button to get more readable detail.

Notes:

You can get Eclipse from http://www.eclipse.org. It is available for pretty much all platforms. If you’re on Linux it is probably in your distribution’s repository.

Note that this video is 1024×768, so hit the full screen button to get more readable detail.

Notes:

The 3DBuzz C++ videos include the following code:

main() {
   cout << "Hello World" << endl;
}

This code fails to compile on newer versions of Visual C++ and GCC. All that needs to be done is to specify that main will return an int, and then actually return one:

int main() {
   cout << "Hello World" << endl;
   return 0;
}

Of course, whether this actually needed a video is debatable!