223 lines
8.8 KiB
C++
223 lines
8.8 KiB
C++
// -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
|
|
// $Id: osgwidgetwindow.cpp 66 2008-07-14 21:54:09Z cubicool $
|
|
|
|
#include <iostream>
|
|
#include <osgDB/ReadFile>
|
|
#include <osgGA/StateSetManipulator>
|
|
#include <osgViewer/Viewer>
|
|
#include <osgViewer/ViewerEventHandlers>
|
|
#include <osgWidget/WindowManager>
|
|
#include <osgWidget/ViewerEventHandlers>
|
|
#include <osgWidget/Box>
|
|
|
|
const unsigned int MASK_2D = 0xF0000000;
|
|
const unsigned int MASK_3D = 0x0F000000;
|
|
|
|
// Here we create (and later demonstrate) the use of a simple function callback.
|
|
bool windowClicked(osgWidget::Event& ev) {
|
|
std::cout << "windowClicked: " << ev.getWindow()->getName() << std::endl;
|
|
|
|
if(ev.getData()) {
|
|
std::string* s = static_cast<std::string*>(ev.getData());
|
|
|
|
std::cout << "This is data attached to the event: " << *s << std::endl;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool windowScrolled(osgWidget::Event& ev) {
|
|
osgWidget::warn()
|
|
<< "scrolling up? " << ev.getWindowManager()->isMouseScrollingUp()
|
|
<< std::endl
|
|
;
|
|
|
|
return true;
|
|
}
|
|
|
|
// Here we dcreate a new class and show how to use a method callback (which differs from
|
|
// a function callback in that we are required to also pass the "this" argument).
|
|
struct Object {
|
|
bool windowClicked(osgWidget::Event& ev) {
|
|
std::cout << "Object::windowClicked " << ev.getWindow()->getName() << std::endl;
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
// This is the more "traditional" method of creating a callback.
|
|
struct CallbackObject: public osgWidget::Callback {
|
|
CallbackObject(osgWidget::EventType evType):
|
|
osgWidget::Callback(evType) {
|
|
}
|
|
|
|
virtual bool operator()(osgWidget::Event& ev) {
|
|
std::cout << "here" << std::endl;
|
|
|
|
return false;
|
|
}
|
|
};
|
|
|
|
int main(int argc, char** argv) {
|
|
osgViewer::Viewer viewer;
|
|
|
|
// Let's get busy! The WindowManager class is actually an osg::Switch,
|
|
// so you can add it to (ideally) an orthographic camera and have it behave as
|
|
// expected. Note that you create a WindowManager with a NodeMask--it is very important
|
|
// that this be unique for picking to work properly. This also makes it possible to have
|
|
// multiple WindowManagers each operating on their own, unique set of Window objects.
|
|
// The final bool argument is a group of flags that introduce optional functionality
|
|
// for the WindowManager. In our case we include the flags USE_PYTHON and USE_LUA,
|
|
// to demonstrate (and test) their usage. Finally, we pass the temporary WM_NO_BETA_WARN
|
|
// argument, which prevents creating the orange warning window. :) It will be shown
|
|
// in other examples...
|
|
osgWidget::WindowManager* wm = new osgWidget::WindowManager(
|
|
&viewer,
|
|
1280.0f,
|
|
1024.0f,
|
|
MASK_2D,
|
|
osgWidget::WindowManager::WM_USE_LUA |
|
|
osgWidget::WindowManager::WM_USE_PYTHON |
|
|
osgWidget::WindowManager::WM_PICK_DEBUG
|
|
);
|
|
|
|
// An actual osgWidget::Window is pure virtual, so we've got to use the osgWidget::Box
|
|
// implementation for now. At a later time, support for Tables and other kinds of
|
|
// advanced layout Window types will be added.
|
|
osgWidget::Window* box = new osgWidget::Box("box", osgWidget::Box::HORIZONTAL);
|
|
|
|
// Now we actually attach our two types of callbacks to the box instance. The first
|
|
// uses the simple function signature, the second uses a bound method, passing "this"
|
|
// as the second argument to the Callback constructor.
|
|
Object obj;
|
|
|
|
static std::string data = "lol ur face!";
|
|
|
|
/*
|
|
box->addCallback(new osgWidget::Callback(&windowClicked, osgWidget::EVENT_MOUSE_PUSH, &data));
|
|
box->addCallback(new osgWidget::Callback(&windowScrolled, osgWidget::EVENT_MOUSE_SCROLL));
|
|
box->addCallback(osgWidget::Callback(
|
|
&Object::windowClicked,
|
|
&obj,
|
|
osgWidget::EVENT_MOUSE_PUSH
|
|
));
|
|
*/
|
|
|
|
box->addCallback(new CallbackObject(osgWidget::EVENT_MOUSE_PUSH));
|
|
|
|
// Create some of our "testing" Widgets; included are two Widget subclasses I made
|
|
// during testing which I've kept around for testing purposes. You'll notice
|
|
// that you cannot move the box using the NullWidget, and that the NotifyWidget
|
|
// is a bit verbose. :)
|
|
osgWidget::Widget* widget1 = new osgWidget::NotifyWidget("widget1", 300.0f, 100.0f);
|
|
osgWidget::Widget* widget2 = new osgWidget::NullWidget("widget2", 400.0f, 75.0f);
|
|
osgWidget::Widget* widget3 = new osgWidget::Widget("widget3", 100.0f, 100.0f);
|
|
// Set the colors of widget1 and widget3 to green.
|
|
widget1->setColor(0.0f, 1.0f, 0.0f, 1.0f);
|
|
widget1->setCanFill(true);
|
|
widget3->setColor(0.0f, 1.0f, 0.0f, 1.0f);
|
|
|
|
widget1->setImage(osgDB::readImageFile("Images/Saturn.TGA"), true);
|
|
|
|
// Set the color of widget2, to differentiate it and make it sassy. This is
|
|
// like a poor man's gradient!
|
|
widget2->setColor(0.9f, 0.0f, 0.0f, 0.9f, osgWidget::Widget::LOWER_LEFT);
|
|
widget2->setColor(0.9f, 0.0f, 0.0f, 0.9f, osgWidget::Widget::LOWER_RIGHT);
|
|
widget2->setColor(0.0f, 0.0f, 0.9f, 0.9f, osgWidget::Widget::UPPER_RIGHT);
|
|
widget2->setColor(0.0f, 0.0f, 0.9f, 0.9f, osgWidget::Widget::UPPER_LEFT);
|
|
|
|
// Now add our newly created widgets to our box.
|
|
box->addWidget(widget1);
|
|
box->addWidget(widget2);
|
|
box->addWidget(widget3);
|
|
|
|
// For maximum efficiency, Windows don't automatically reallocate their geometry
|
|
// and internal positioning every time a widget is added. Thus, we either have to
|
|
// call the WindowManger::resizeAllWindows method or manually call
|
|
// Window::resize when we're ready.
|
|
box->resize();
|
|
|
|
// Now, lets clone our existing box and create a new copy of of it, also adding that
|
|
// to the WindowManager. This demonstrates the usages of OSG's ->clone() support,
|
|
// though that is abstracted by our META_UIObject macro.
|
|
osgWidget::Window* boxCopy = osg::clone(box, "newBox", osg::CopyOp::DEEP_COPY_ALL);
|
|
|
|
// Move our copy to make it visible.
|
|
boxCopy->setOrigin(0.0f, 125.0f);
|
|
|
|
boxCopy->getByName("widget1")->setColor(0.5f, 0.0f, 1.0f, 1.0f);
|
|
boxCopy->getByName("widget3")->setColor(0.5f, 0.0f, 1.0f, 1.0f);
|
|
|
|
// Add the successfully created Box (if we get this far) into the WindowManager, so
|
|
// that they can receive events.
|
|
wm->addChild(box);
|
|
wm->addChild(boxCopy);
|
|
|
|
// Now, ask our new box to be 100% the width of the WindowManager.
|
|
boxCopy->resizePercent(100.0f, 0.0f);
|
|
|
|
// Here we demonstrate the use of osgWidget/io_utils. This is really only useful for
|
|
// debugging at the moment, but later I'll make it more generic for .osg and .ive
|
|
// creation.
|
|
// std::cout << *box << std::endl << *boxCopy << std::endl;
|
|
|
|
// Setup our OSG objects for our scene; note the use of the utility function
|
|
// createOrthoCamera, which is just a helper for setting up a proper viewing area.
|
|
// An alternative (and a MUCH easier alternative at that!) is to
|
|
// simply use the createParentOrthoCamera method of the WindowManager class,
|
|
// which will wrap the calls to createOrthoCamera and addChild for us! Check out
|
|
// some of the other examples to see this in action...
|
|
osg::Group* group = new osg::Group();
|
|
osg::Camera* camera = osgWidget::createOrthoCamera(1280.0f, 1024.0f);
|
|
osg::Node* model = osgDB::readNodeFile("cow.osg");
|
|
|
|
// Add our event handler; is this better as a MatrixManipulator? Add a few other
|
|
// helpful ViewerEventHandlers.
|
|
viewer.addEventHandler(new osgWidget::MouseHandler(wm));
|
|
viewer.addEventHandler(new osgWidget::KeyboardHandler(wm));
|
|
viewer.addEventHandler(new osgWidget::ResizeHandler(wm, camera));
|
|
viewer.addEventHandler(new osgWidget::CameraSwitchHandler(wm, camera));
|
|
viewer.addEventHandler(new osgViewer::StatsHandler());
|
|
viewer.addEventHandler(new osgViewer::WindowSizeHandler());
|
|
viewer.addEventHandler(new osgGA::StateSetManipulator(
|
|
viewer.getCamera()->getOrCreateStateSet()
|
|
));
|
|
|
|
// Set our first non-UI node to be something other than the mask we created our
|
|
// WindowManager with to avoid picking.
|
|
// TODO: Do I need to create a mechanism for doing this automatically, or should
|
|
// that be the responsibility of the users of osgWidget?
|
|
model->setNodeMask(MASK_3D);
|
|
|
|
// Add the WindowManager instance to the 2D camera. This isn't strictly necessary,
|
|
// and you can get some cool results putting the WindowManager directly into a
|
|
// 3D scene. This is not necessary if you use WindowManager::createParentOrthoCamera.
|
|
camera->addChild(wm);
|
|
|
|
// Add our camera and a testing 3D model to the scene.
|
|
group->addChild(camera);
|
|
group->addChild(model);
|
|
|
|
// Here we show how to both run simple strings of code AND run entire files. These
|
|
// assume that you're running the osgwidgetwindow example from the build directory,
|
|
// otherwise you'll need to adjust the file path below in the call to runFile().
|
|
wm->getLuaEngine()->eval("window = osgwidget.newWindow()");
|
|
wm->getLuaEngine()->runFile("osgWidget/osgwidgetwindow.lua");
|
|
|
|
wm->getPythonEngine()->eval("import osgwidget");
|
|
wm->getPythonEngine()->runFile("osgWidget/osgwidgetwindow.py");
|
|
|
|
viewer.setUpViewInWindow(0, 0, 1280, 1024);
|
|
viewer.setSceneData(group);
|
|
|
|
/*
|
|
osgViewer::Viewer::Cameras cameras;
|
|
viewer.getCameras(cameras);
|
|
osg::Camera* c = cameras[0];
|
|
osg::Matrix s = osg::Matrix::scale(1.0f, -1.0f, 1.0f);
|
|
c->setProjectionMatrix(s * c->getProjectionMatrix());
|
|
*/
|
|
|
|
return viewer.run();
|
|
}
|