> Hi,
>
> after some time spending on other task, I have now restarted my
> project using the OpenSG library.
> As you can see below I have spend some time into the OpenSG framework
> and did reach a lot.
>
> But now I'm stuck and need some input from outside.
>
> I have written some new classes in order to handle rendering into
> multiple windows and viewports
> with the same scene graph, possibly with different camera setups.
>
> However, I'm facing a situation that when I have more then two windows
> the rendering of one
> window stalls for some time and eventually all windows get frozen.
> With only one or two windows all is working perfektly fine.
>
> What is happening when one window stalls for some time I don't know.
> But, when all windows
> eventually freeze I could see that the the program endlessly runs into
> the glErr macro in the
> function RenderAction::start().
>
> With the help of the gliIntercept tool I could see that the last call
> before the error
> GL_INVALID_OPERATION (0x502) was a call to glDisable(GL_SCISSOR_TEST).
>
> Extract from the log:
>
> glGetError()=GL_NO_ERROR
> glLoadMatrixf([-0.766076,0.445564,-0.463248,0.000000,-0.393384,0.24495
> 1,0.886141,0.000000,0.508305,0.861088,-0.012371,0.000000,49.977875,41.
> 081268,-234.204254,1.000000])
> glCallList(3)
> glDisable(GL_LIGHTING)
> glDisable(GL_COLOR_MATERIAL)
> glDisable(GL_LIGHT0)
> glDepthMask(true)
> glFinish()
> wglSwapBuffers(0x0000)=false
> glGetError()=GL_NO_ERROR
> wglMakeCurrent(0x0000,0x0000)=true
> wglMakeCurrent(0x0000,0x10001)=false
> wglMakeCurrent(0x0000,0x10001)=false
> glViewport(0,0,600,227)
> glDisable(GL_SCISSOR_TEST)
> glGetError()=GL_INVALID_OPERATION
>
> Below I try to outline some of my code. It is unfortunately a little
> bit lengthy so I don't show it all.
> The protagonists are instances form the following classes:
> SceneManager, CompositeViewer, View, GLCanvas and Gc3SystemData
>
> So I ask for some help. Can someone tell me what I'm doing wrong? Is
> this a multthreading issue? What is disturbing me most is
> that I do not have any problems with two windows but with more than
> two of them.
>
> With best regards
> Johannes
>
>
> SceneManager :
> This one is used as a singleton and holds the scene. Since I
> have situations when I need to render small parts of my scene
> dynamically without flickering, I have a setup with the split
> into static and dynamic parts. However, for my current problem
> this part of my implementation is not in use at all.
>
> class SceneManager : private boost::noncopyable
> {
> public:
> osg::NodePtr getRoot () const;
> void setRoot (osg::NodePtr node);
>
> osg::NodePtr getDynamicRoot () const;
> void setDynamicRoot (osg::NodePtr node);
> osg::SwitchPtr getSwitchCore () const;
>
> osg::NodePtr getInternalRoot () const;
> osg::NodePtr getRootBeacon () const;
>
> osg::NodePtr getHighlight () const;
> void setHighlight (osg::NodePtr obj);
> void updateHighlight ();
>
> typedef osg::DirectionalLightPtr DLight;
> DLight getHeadlight () const;
> void setHeadlight (bool on);
> bool getHeadlightState () const;
> void turnHeadlightOn ();
> void turnHeadlightOff ();
>
> public:
> SceneManager();
> ~SceneManager();
>
> private:
> //
> // You have to grant friendship the the Creator policy class.
> //
> friend Loki::CreateUsingNew< SceneManager >;
>
> private:
> void initialize ();
> void highlightChanged();
>
> osg::NodePtr _internalRoot;
> osg::NodePtr _internalStatic;
> osg::NodePtr _internalDynamic;
> osg::NodePtr _switchNode;
> osg::NodePtr _staticRoot;
> osg::NodePtr _dynamicRoot;
> osg::NodePtr _highlight;
> osg::NodePtr _highlightNode;
> osg::SimpleMaterialPtr _highlightMaterial;
> osg::GeoPositions3fPtr _highlightPoints;
> osg::DirectionalLightPtr _headlight;
> osg::TransformPtr _cartesian;
> osg::NodePtr _cartesianNode;
> };
>
> typedef Loki::SingletonHolder< SceneManager > TheSceneManagerT;
>
> void SceneManager::initialize() // Called on startup
> {
> _internalStatic = Node::create();
> {
> FCEditGuard guard(_internalStatic);
> _internalStatic->setCore(Group::create());
> }
>
> _internalDynamic = Node::create();
> {
> FCEditGuard guard(_internalDynamic);
> _internalDynamic->setCore(Group::create());
> }
>
> SwitchPtr switch_core = Switch::create();
> {
> FCEditGuard guard(switch_core);
> switch_core->setChoice(Switch::ALL);
> }
>
> _switchNode = Node::create();
> {
> FCEditGuard guard(_switchNode);
> _switchNode->setCore(switch_core);
> _switchNode->addChild(_internalStatic);
> _switchNode->addChild(_internalDynamic);
> }
>
> // the camera and light beacon
> _cartesianNode = Node::create();
> _cartesian = Transform::create();
> {
> FCEditGuard guard(_cartesianNode);
> _cartesianNode->setCore(_cartesian);
> }
>
> // the headlight
> _internalRoot = Node::create();
> _headlight = DirectionalLight::create();
> addRefCP(_internalRoot);
> {
> FCEditGuard guard(_internalRoot);
> _internalRoot->setCore(_headlight);
> _internalRoot->addChild(_cartesianNode);
> _internalRoot->addChild(_switchNode);
> }
>
> {
> FCEditGuard guard(_headlight);
> _headlight->setAmbient (.3, .3, .3, 1);
> _headlight->setDiffuse ( 1, 1, 1, 1);
> _headlight->setSpecular ( 1, 1, 1, 1);
> _headlight->setDirection( 0, 0, 1);
> _headlight->setBeacon (_cartesianNode);
> }
> }
>
> void SceneManager::setRoot(NodePtr root) // This is called after
> I have constructed my scene
> {
> if(_staticRoot != root)
> {
> if(_staticRoot != NullFC)
> {
> FCEditGuard guard(_internalStatic,
> Node::ChildrenFieldMask);
> _internalStatic->subChild(_staticRoot);
> }
>
> _staticRoot = root;
> if(_staticRoot != NullFC)
> {
> FCEditGuard guard(_internalStatic,
> Node::ChildrenFieldMask);
> _internalStatic->addChild(_staticRoot);
> }
> }
> }
>
> CompositeViewer :
> This class administer a set of View objects, the WindowPtr and
> the RenderAction. It provides public Render function
> and the following entry functions: mouseMove, mouseButtonPress,
> mouseButtonRelease, resize and redraw.
>
> class CompositeViewer;
> typedef boost::shared_ptr<CompositeViewer> CompositeViewerT;
>
> class CompositeViewer : public
> boost::enable_shared_from_this<CompositeViewer>
> , private boost::noncopyable
> {
> private:
> typedef std::vector<ViewT> VecViewsT;
> public:
> typedef VecViewsT::iterator iterator;
> typedef VecViewsT::const_iterator const_iterator;
>
> void push_back (ViewT view);
> iterator insert (iterator pos, ViewT view);
> void erase (ViewT view);
> void erase (iterator iter);
> ViewT operator[] (VecViewsT::size_type idx) const;
> ViewT at (VecViewsT::size_type idx) const;
> void clear ();
> iterator find (ViewT view);
> const_iterator find (ViewT view) const;
> iterator begin ();
> const_iterator begin () const;
> iterator end ();
> const_iterator end () const;
>
> public:
> osg::WindowPtr getWindow ();
> osg::DrawActionBase* getAction ();
>
> void setWindow (osg::WindowPtr win);
> void setAction (osg::RenderAction* action);
>
> void Render ();
> void TickRender ();
>
> void setDynamicMode (bool flag);
> bool getDynamicMode () const;
> void setRenderStatic (bool flag);
> void setRenderDynamic(bool flag);
>
> void redraw ();
> void resize (osg::UInt16 width,
> osg::UInt16 height);
>
> void mouseMove (osg::Int16 x,
> osg::Int16 y);
> void mouseButtonPress (osg::UInt16 button,
> osg::Int16 x, osg::Int16 y);
> void mouseButtonRelease (osg::UInt16 button,
> osg::Int16 x, osg::Int16 y);
> void key (osg::UChar8 key,
> osg::Int16 x, osg::Int16 y);
>
> public:
> static CompositeViewerT create();
>
> ~CompositeViewer();
> protected:
> CompositeViewer();
>
> private:
> void DoRenderStatic ();
> void DoRenderDynamic ();
> void DoRender ();
>
> enum {
> RENDER_STATIC = 0,
> RENDER_DYNAMIC = 1
> };
>
> private:
> VecViewsT _views;
> osg::WindowPtr _win;
> osg::RenderAction* _action;
> osg::RenderAction* _ownAction;
> int _iDynamicCnt;
> bool _bRenderStatic;
> bool _bRenderDynamic;
> };
>
> // Multiple views are possible, but the problem case does use multiple
> CompositeViewer each
> // containing exactly one View instance.
>
> void CompositeViewer::push_back(ViewT view)
> {
> iterator iter = find(view);
> if (iter != end())
> return;
>
> _views.push_back(view);
>
> beginEditCP(_win);
> _win->addPort(view->getPort());
> endEditCP(_win);
>
> view->setViewer(shared_from_this());
> }
>
> WindowPtr CompositeViewer::getWindow()
> {
> return _win;
> }
>
> void CompositeViewer::setWindow(WindowPtr win)
> {
> _win = win;
> }
>
> DrawActionBase *CompositeViewer::getAction()
> {
> return _action;
> }
>
> void CompositeViewer::setAction(RenderAction *action)
> {
> BOOST_FOREACH(ViewT& view, _views)
> {
> bool statstate = view->getStatistics();
>
> if(_action != NULL && statstate)
> view->setStatistics(false);
>
> if(action == NULL)
> {
> _action = _ownAction;
> }
> else
> {
> _action = action;
> }
>
> if(statstate)
> view->setStatistics(true);
> }
> }
>
> void CompositeViewer::redraw()
> {
> if (!_action) {
> _ownAction = RenderAction::create();
> _action = _ownAction;
> }
>
> BOOST_FOREACH(ViewT& view, _views) {
> assert(view->getSceneManager());
> if (view->getSceneManager()->getInternalRoot() == NullFC)
> {
> view->showAll();
> }
>
> if (view->getNavigatorOn() && view->getNavigator())
> view->getNavigator()->updateCameraTransformation();
>
> view->getSceneManager()->updateHighlight();
> }
>
> _win->render(_action);
> }
>
> void CompositeViewer::Render()
> {
> if (!_win) return;
>
> if (!_iDynamicCnt) {
> redraw(); // This is the branch
> which is used in the problem scenario. The other is not called at all.
> _win->deactivate();
> } else {
> DoRenderStatic();
> }
> }
>
> void CompositeViewer::resize(UInt16 width, UInt16 height)
> {
> _win->resize(width, height);
>
> if (_iDynamicCnt) {
> BOOST_FOREACH(ViewT& view, _views) {
> if (!view->getPassive()) {
> view->onResize();
> }
> }
> _bRenderStatic = true;
> }
> }
>
> void CompositeViewer::mouseMove(osg::Int16 x, osg::Int16 y)
> {
> BOOST_FOREACH(ViewT& view, _views) {
> view->mouseMove(x, y);
> }
> }
>
>
> View :
> This class carries the viewport, background, camera, navigator,
> and a lot of other stuff not relevant for the case.
>
> typedef boost::logic::tribool TriBoolT;
>
> class CompositeViewer;
> typedef boost::shared_ptr<CompositeViewer> CompositeViewerT;
>
> class View;
> typedef boost::shared_ptr<View> ViewT;
>
> class View : public boost::enable_shared_from_this<View>
> , private boost::noncopyable
> {
> public:
> enum {
> MouseLeft = 0,
> MouseMiddle = 1,
> MouseRight = 2,
> MouseUp = 3,
> MouseDown = 4,
> NoButton = -1
> };
>
> public:
> typedef boost::tuple<osg::Real32, osg::Real32, osg::Real32,
> osg::Real32> DimT;
> DimT getDimensions () const;
> osg::ViewportPtr getPort ();
> osg::NodePtr getRoot () const;
> SceneManager* getSceneManager () const;
> osg::CameraPtr getCamera () const;
> TriBoolT getPerspective () const;
> osg::Navigator* getNavigator () const;
> bool getNavigatorOn () const;
> CompositeViewerT getViewer () const;
> bool getStatistics () const;
> bool getPassive () const;
> bool getDepthClearBgnd () const;
> osg::BackgroundPtr getBackground () const;
>
> void setDimensions (osg::Real32 left,
> osg::Real32 bottom, osg::Real32 right, osg::Real32 top);
> void setRoot (osg::NodePtr root);
> void setSceneManager (SceneManager* p);
> void setCamera (osg::CameraPtr camera);
> void setPerspective (TriBoolT perspective);
> void setNavigator (osg::Navigator*
> navigator);
> void setNavigatorOn (bool on);
> void setNavigationMode (osg::Navigator::Mode
> new_mode);
> bool setClickCenter (bool mode);
> void setStatistics (bool on);
> void setViewer (CompositeViewerT viewer);
> void setPassive (bool passive);
> void setDepthClearBgnd (bool flag);
> void setBackground (osg::BackgroundPtr bg);
> void restoreBackground (bool image);
> void setDynamicMode (bool flag);
> void setGrabForeground (bool flag);
> void onResize ();
>
> osg::Line calcViewRay (osg::Int16 x,
> osg::Int16 y);
>
> Frustum calcViewFrustum (osg::Int16 x,
> osg::Int16 y, osg::Int16 size, osg::Pnt3f* ap = NULL);
> Frustum calcViewFrustum (osg::Int16 x0,
> osg::Int16 y0, osg::Int16 x1, osg::Int16 y1, osg::Pnt3f* ap = NULL);
> osg::FrustumVolume calcViewFrustumVolume (osg::Int16 x,
> osg::Int16 y, osg::Int16 size, osg::Pnt3f* ap = NULL);
> osg::FrustumVolume calcViewFrustumVolume (osg::Int16 x0,
> osg::Int16 y0, osg::Int16 x1, osg::Int16 y1, osg::Pnt3f* ap = NULL);
>
>
> void getViewMatrix (osg::Matrix& m)
> const;
> void getProjectionMatrix (osg::Matrix& m)
> const;
> void getProjectionTranslation (osg::Matrix& m)
> const;
> osg::Matrix computeWindowMatrix () const;
>
> void idle ();
> void showAll ();
> void useOpenSGLogo ();
>
> void mouseMove (osg::Int16 x, osg::Int16
> y);
> void mouseButtonPress (osg::UInt16 button,
> osg::Int16 x, osg::Int16 y);
> void mouseButtonRelease (osg::UInt16 button,
> osg::Int16 x, osg::Int16 y);
> void key (osg::UChar8 key,
> osg::Int16 x, osg::Int16 y);
>
> public:
> static ViewT create();
>
> ~View();
> protected:
> View();
>
> private:
> void initialize();
>
> private:
> osg::ViewportPtr _viewport;
> osg::ImageForegroundPtr _foreground;
> osg::StatisticsForegroundPtr _statforeground;
> osg::BackgroundPtr _background;
> osg::BackgroundPtr _passiveBackground;
> bool _statstate;
> osg::CameraPtr _camera;
> TriBoolT _perspective; // true, false,
> boost::logic::indeterminate
> osg::Navigator* _navigator;
> bool _navigatorOn;
> osg::Int16 _lastx;
> osg::Int16 _lasty;
> osg::UInt16 _mousebuttons;
> SceneManager* _sceneManager;
> CompositeViewerT _viewer; // A
> View knows about the Viewer it belongs to
> osg::Real32 _left, _bottom, _right, _top;
> bool _passive;
> bool _depthClearBgnd;
> bool _initialized;
> osg::GrabForegroundPtr _grabForeground;
> osg::ImagePtr _grabImage;
> osg::ImageBackgroundPtr _imageBackground;
> bool _bDynamicMode;
> };
>
> NodePtr View::getRoot() const
> {
> assert(_sceneManager);
> return _sceneManager->getRoot();
> }
>
> void View::setRoot(NodePtr root)
> {
> assert(_sceneManager);
> _sceneManager->setRoot(root);
> }
>
> CameraPtr View::getCamera(void) const
> {
> return _camera;
> }
>
> void View::setCamera(CameraPtr camera)
> {
> if(camera == NullFC)
> return;
>
> if (camera->getTypeId() == PerspectiveCamera::getClassTypeId())
> _perspective = true;
> else if (camera->getTypeId() ==
> OrthographicCamera::getClassTypeId())
> _perspective = false;
> else
> _perspective = boost::logic::indeterminate;
>
> {
> FCEditGuard guard(camera);
> camera->setBeacon(_camera->getBeacon());
> camera->setNear (_camera->getNear());
> camera->setFar (_camera->getFar());
> }
>
> if (_viewport != NullFC) {
> FCEditGuard guard(_viewport);
> _viewport->setCamera(camera);
> }
>
> subRefCP(_camera);
> _camera = camera;
> addRefCP(_camera);
> }
>
> Navigator* View::getNavigator(void) const
> {
> return _navigator;
> }
>
> void View::setNavigator(Navigator* navigator)
> {
> if (_navigator)
> delete _navigator;
>
> _navigator = navigator;
> if (_navigator) {
> if (_viewport != NullFC)
> _navigator->setViewport(_viewport);
> if (_sceneManager)
>
> _navigator->setCameraTransformation(_sceneManager->getRootBeacon());
> }
> }
>
> CompositeViewerT View::getViewer() const
> {
> return _viewer;
> }
>
> void View::setViewer(CompositeViewerT viewer)
> {
> if (_viewer) {
> _viewer->erase(shared_from_this());
> }
> _viewer = viewer;
> }
>
> void View::mouseMove(Int16 x, Int16 y)
> {
> if (!_navigatorOn || !_navigator)
> return;
>
> if (_mousebuttons)
> _navigator->moveTo(x,y);
>
> _lastx = x;
> _lasty = y;
>
> }
>
>
> void View::initialize()
> {
> if (_initialized)
> return;
>
> _initialized = true;
>
> assert(_sceneManager);
>
> // the camera
> if (_perspective) {
> PerspectiveCameraPtr camera = PerspectiveCamera::create();
>
> addRefCP(camera);
> FCEditGuard guard(camera);
> camera->setBeacon(_sceneManager->getRootBeacon());
> camera->setFov (deg2rad(60.f));
> camera->setNear (0.1f);
> camera->setFar (10000.f);
>
> _camera = camera;
> } else if (!_perspective) {
> OrthographicCameraPtr camera = OrthographicCamera::create();
>
> addRefCP(camera);
> FCEditGuard guard(camera);
> camera->setBeacon(_sceneManager->getRootBeacon());
> camera->setVerticalSize(0);
> camera->setNear (0.1f);
> camera->setFar (10000.f);
>
> _camera = camera;
> } else {
> MatrixCameraPtr camera = MatrixCamera::create();
>
> addRefCP(camera);
> FCEditGuard guard(camera);
> camera->setBeacon(_sceneManager->getRootBeacon());
> camera->setNear (0.1f);
> camera->setFar (10000.f);
> Matrix m;
> m.setIdentity();
> camera->setProjectionMatrix(m);
> camera->setModelviewMatrix(m);
>
> _camera = camera;
> }
>
> if(_viewport == NullFC)
> {
> _foreground = ImageForeground::create();
>
> BackgroundPtr bg;
> if (_passive) {
> if (_depthClearBgnd)
> _passiveBackground = DepthClearBackground::create();
> else
> _passiveBackground = PassiveBackground::create();
>
> bg = _passiveBackground;
> } else {
> SolidBackgroundPtr bgnd = SolidBackground::create();
> FCEditGuard guard(bgnd);
> bgnd->setColor(Color3f(0, 0, 0));
>
> _background = bgnd;
> bg = _background;
> }
>
> _viewport = Viewport::create();
> {
> FCEditGuard guard(_viewport);
> _viewport->setCamera(_camera);
> _viewport->setRoot(_sceneManager->getInternalRoot());
> _viewport->setSize(_left, _bottom, _right, _top);
> _viewport->setBackground(bg);
> _viewport->getForegrounds().push_back(_foreground);
> }
> }
>
> if (_navigator) {
> _navigator->setViewport(_viewport);
>
> _navigator->setCameraTransformation(_sceneManager->getRootBeacon());
> }
> }
>
> GLCanvas :
> This class is a child class of the gui toolkit window class I'm
> using. Actually, it contains only
> a pointer to the Gc3SystemData instance which contains the
> CompositeViewer instance.
> The example instance is just a convenience I use to build
> different test programs with
> minimal code change. It contains the actual start up code.
>
> class Gc3SystemData;
> class Example;
>
> class GLCanvas : public ZafWindow
> {
> public:
> GLCanvas();
> virtual ~GLCanvas();
>
> public:
> void SetExample(Example* p) { _example.reset(p); }
>
> Gc3SystemData* pSystemData() const { return _pSystemData; }
>
> void Render(); // Delegate to _pSystemData->Render()
> void TickRender();
> void SleepTickTimer();
> void WakeTickTimer();
>
> void AddVisualizer (components::VisualizerT visualizer);
> void RemoveVisualizer(components::VisualizerT visualizer);
>
> void PushVisualizer (components::VisualizerT
> cursor);
> void PopVisualizer ();
> components::VisualizerT TopVisualizer () const;
>
> protected:
> virtual ZafEventType Event (const ZafEventStruct& event);
> // Delegate to _pSystemData
> virtual ZafEventType OSEvent (const ZafEventStruct& event);
> // Delegate to _pSystemData
> virtual ZafEventType Draw (const ZafEventStruct& event,
> ZafEventType ccode); // Delegate to Render()
>
> private:
> void InitializeTickTimer();
> void DeinitalizeTickTimer();
>
> private:
> Gc3SystemData* _pSystemData;
> tools::timer_ptr _spTimer;
> boost::scoped_ptr<Example> _example;
> };
>
> Gc3SystemData :
> This class wraps the CompositeViewer for the window toolkit and
> handles the operating system requests for drawing and mouse.
>
> typedef graphic::CompositeViewerT ViewerT;
>
> class Gc3SystemData
> {
> public:
> ViewerT getViewer () { return _viewer; }
>
> void Event (const ZafEventStruct& event);
> void OSEvent (const ZafEventStruct& event);
> void Render ();
> void TickRender ();
>
> bool eIsInitialized () { return _bIsInitialized; }
>
> void AddVisualizer (components::VisualizerT
> visualizer);
> void RemoveVisualizer(components::VisualizerT
> visualizer);
>
> void PushVisualizer (components::VisualizerT
> visualizer);
> void PopVisualizer ();
> components::VisualizerT TopVisualizer () const;
>
> int Width () const;
> int Height () const;
>
> private:
> void Initialize ();
>
> public:
> explicit Gc3SystemData (HWND hWnd);
> ~Gc3SystemData ();
>
> private:
> HWND _hWnd;
> ViewerT _viewer;
> bool _bIsInitialized;
>
> typedef std::vector<components::VisualizerT> VecVisualizerT;
> VecVisualizerT _vecVisualizer; // for things like
> tripods, clipplane visualization etc.
>
> typedef std::stack<components::VisualizerT> StackVisualizerT;
> StackVisualizerT _stackVisualizer; // for things like
> selection box etc.
> };
>
> Gc3SystemData::Gc3SystemData(HWND hWnd)
> : _hWnd(hWnd)
> , _viewer(graphic::CompositeViewer::create())
> , _bIsInitialized(false)
> , _vecVisualizer()
> , _stackVisualizer()
> {
> DWORD dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL |
> PFD_DOUBLEBUFFER;
> PIXELFORMATDESCRIPTOR pixelFormat = {
> sizeof(PIXELFORMATDESCRIPTOR),
> 1,
> dwFlags,
> PFD_TYPE_RGBA,
> 24,
> 0, 0, 0, 0, 0, 0,
> 0, 0,
> 0, 0, 0, 0, 0,
> 32,
> 0,
> 0,
> PFD_MAIN_PLANE,
> 0,
> 0, 0, 0
> };
>
> HDC hdc = ::GetDC(_hWnd);
> if (!hdc) {
> ::DestroyWindow(_hWnd);
> return;
> }
>
> int pixelFormatIndex = ::ChoosePixelFormat(hdc, &pixelFormat);
> if (!pixelFormatIndex) {
> ::ReleaseDC(_hWnd, hdc);
> ::DestroyWindow(_hWnd);
> return;
> }
>
> if (!::SetPixelFormat(hdc, pixelFormatIndex, &pixelFormat)) {
> ::ReleaseDC(_hWnd, hdc);
> ::DestroyWindow(_hWnd);
> return;
> }
>
> Initialize();
> }
>
> void Gc3SystemData::Initialize()
> {
> osg::osgInit(0,NULL);
>
> osg::WIN32WindowPtr window = osg::WIN32Window::create();
> window->setHwnd(_hWnd);
>
> window->init();
> window->deactivate();
>
> graphic::ViewT view(graphic::View::create());
>
> osg::Navigator* nav = new osg::Navigator;
> nav->setMode(osg::Navigator::TRACKBALL);
> view->setNavigator(nav);
>
> view->setSceneManager(&graphic::TheSceneManagerT::Instance());
> _viewer->setWindow(window);
> _viewer->push_back(view);
>
> _bIsInitialized = true;
> }
>
> void Gc3SystemData::OSEvent(const ZafEventStruct& event)
> {
> if (!_vecVisualizer.empty()) {
> VecVisualizerT::iterator iter;
> for (iter = _vecVisualizer.begin(); iter !=
> _vecVisualizer.end(); ++iter) {
> components::VisualizerT vis = *iter;
> vis->OSEvent(event);
> }
> }
>
> if (!_stackVisualizer.empty())
> _stackVisualizer.top()->OSEvent(event);
>
> switch (event.osEvent.message) {
> case WM_SIZE:
> {
> int w = LOWORD(event.osEvent.lParam);
> int h = HIWORD(event.osEvent.lParam);
> _viewer->resize(w, h);
> }
> break;
> case WM_LBUTTONDOWN:
> {
> int x = LOWORD(event.osEvent.lParam);
> int y = HIWORD(event.osEvent.lParam);
> _viewer->mouseButtonPress(graphic::View::MouseLeft, x,
> y);
> }
> break;
> ...
> case WM_MOUSEMOVE:
> {
> int x = LOWORD(event.osEvent.lParam);
> int y = HIWORD(event.osEvent.lParam);
> _viewer->mouseMove(x, y);
> }
> break;
> }
> }
>
> void Gc3SystemData::Render()
> {
> if (_bIsInitialized) {
> _viewer->Render();
> }
> }
>
> void Gc3SystemData::TickRender()
> {
> if (_bIsInitialized) {
> _viewer->TickRender();
> }
> }
>
> int Main(int argc, char** argv) // The main entry point of the program
> {
> ZafWindow* window1 = new ZafWindow(0, 0, 600, 800);
> ZafWindow* window2 = new ZafWindow(0, 0, 600, 800);
> ZafWindow* window3 = new ZafWindow(0, 0, 600, 800);
>
> GLCanvas* pCanvas1 = new GLCanvas;
> GLCanvas* pCanvas2 = new GLCanvas;
> GLCanvas* pCanvas3 = new GLCanvas;
> MultipleGenericOpenSG* pExample1 = new
> MultipleGenericOpenSG(pCanvas1);
> MultipleGenericOpenSG* pExample2 = new
> MultipleGenericOpenSG(pCanvas2);
> MultipleGenericOpenSG* pExample3 = new
> MultipleGenericOpenSG(pCanvas3);
>
> window1->Add(pCanvas1);
> window2->Add(pCanvas2);
> window3->Add(pCanvas3);
>
> // Center the window.
> zafWindowManager->Center(window1);
> zafWindowManager->Center(window2);
> zafWindowManager->Center(window3);
>
> // Add the window to the window manager.
> zafWindowManager->Add(window1);
> zafWindowManager->Add(window2);
> zafWindowManager->Add(window3);
>
> int ret1 = pExample1->Main(argc, argv);
> int ret2 = pExample2->Main(argc, argv);
> int ret3 = pExample3->Main(argc, argv);
>
> return ret1;
> }
>
> class MultipleGenericOpenSG : public Example
> {
> public:
> explicit MultipleGenericOpenSG(GLCanvas* p) : Example(p);
> virtual ~MultipleGenericOpenSG(){};
>
> public:
> virtual int Main(int argc, char** argv);
> virtual void Run ();
> };
>
> MultipleGenericOpenSG ::MultipleGenericOpenSG (GLCanvas* p)
> : Example(p)
> {
> p->SetExample(this);
> }
>
> int MultipleGenericOpenSG::Main(int argc, char** argv)
> {
> Example::Main(argc, argv);
> Run();
> return 0;
> }
>
> void MultipleGenericOpenSG::Run()
> {
> //
> // The entity manager is responsible for storing loaded Acis
> entities
> //
> acis::EntityManager sEntMan;
>
> //
> // static because root should be only created once in this example
> // root contains the complete scene
> static components::FileHandler fileHandler(sEntMan);
> static osg::NodePtr root = fileHandler.Evaluate(_sCmdOptMap);
> // sCmdOptMap contains file to load
>
> components::SetupViewer setupViewer(_pGLCanvas, true);
> setupViewer.setup(root);
> }
>
> SetupViewer :
> Helper class for conveniently setup the scene
>
> class SetupViewer
> {
> public:
> void setup (osg::NodePtr root);
> void setup (osg::NodePtr root_static, osg::NodePtr
> root_dynamic);
> void changeBackground(bool flag);
>
> public:
> explicit SetupViewer (GLCanvas* pGLCanvas, bool perspective);
> virtual ~SetupViewer ();
>
> private:
> GLCanvas* _pGLCanvas;
> bool _perspective;
> };
>
>
> SetupViewer::SetupViewer(GLCanvas* pGLCanvas, bool perspective)
> : _pGLCanvas(pGLCanvas)
> , _perspective(perspective)
> {
> }
>
> void SetupViewer::setup(osg::NodePtr root)
> {
> using namespace osg;
>
> GradientBackgroundPtr background = GradientBackground::create();
> {
> FCEditGuard guard(background);
> background->addLine(Color3f(0,0,0), 0);
> background->addLine(Color3f(1,1,1), 1);
> }
>
> ViewerT viewer = _pGLCanvas->pSystemData()->getViewer();
> (*viewer)[0]->setPerspective(_perspective);
> (*viewer)[0]->setBackground(background);
> (*viewer)[0]->setRoot(root); // This
> delegates to SceneManager instance
> (*viewer)[0]->showAll();
> }
>
>
>
>
> ____________
> Virus checked by G DATA AntiVirusKit
> Version: AVK 18.3779 from 14.05.2008
> Virus news: www.antiviruslab.com
>
>
> ____________
> Virus checked by G DATA AntiVirusKit
> Version: AVK 18.3780 from 14.05.2008
> Virus news: www.antiviruslab.com
-------------------------------------------------------------------------
This SF.net email is sponsored by: Microsoft
Defy all challenges. Microsoft(R) Visual Studio 2008.
http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/
_______________________________________________
Opensg-users mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/opensg-users
