/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield * * This library is open source and may be redistributed and/or modified under * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or * (at your option) any later version. The full license is in LICENSE file * included with this distribution, and on the openscenegraph.org website. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * OpenSceneGraph Public License for more details. */ #ifndef OSG_GRAPHICSCONTEXT #define OSG_GRAPHICSCONTEXT 1 #include #include namespace osg { // forward declare osg::Camera class Camera; /** Base class for providing Windowing API agnostic access to creating and managing graphics context.*/ class OSG_EXPORT GraphicsContext : public Object { public: struct OSG_EXPORT ScreenIdentifier { ScreenIdentifier(); ScreenIdentifier(int in_screenNum); ScreenIdentifier(const std::string& in_hostName,int in_displayNum, int in_screenNum); /** Return the display name in the form hostName::displayNum:screenNum. */ std::string displayName() const; /** Read the DISPLAY environmental variable, and set the ScreenIdentifier accordingly. * Note, if either of displayNum or screenNum are not defined then -1 is set respectively to * signify the this parameter has not been set. When parameters are undefined one can call * call setUndefinedScreenDetalstoDefaultScreen() method after readDISPLAY() to ensure valid values. */ void readDISPLAY(); /** Set the screenIndentifier from the displayName string. * Note, if either of displayNum or screenNum are not defined then -1 is set respectively to * signify the this parameter has not been set. When parameters are undefined one can call * call setUndefinedScreenDetalstoDefaultScreen() method after readDISPLAY() to ensure valid values. */ void setScreenIdentifier(const std::string& displayName); /** Set any undefined displayNum or screenNum values (i.e. -1) to the default display & screen of 0 respectively.*/ void setUndefinedScreenDetailsToDefaultScreen() { if (displayNum<0) displayNum = 0; if (screenNum<0) screenNum = 0; } std::string hostName; int displayNum; int screenNum; }; /** GraphicsContext Traits object provides the specification of what type of graphics context is required.*/ struct Traits : public osg::Referenced, public ScreenIdentifier { Traits(): x(0), y(0), width(0), height(0), windowDecoration(false), supportsResize(true), red(8), blue(8), green(8), alpha(0), depth(24), stencil(0), sampleBuffers(0), samples(0), pbuffer(false), quadBufferStereo(false), doubleBuffer(false), target(0), format(0), level(0), face(0), mipMapGeneration(false), vsync(true), useMultiThreadedOpenGLEngine(false), useCursor(true), sharedContext(0), setInheritedWindowPixelFormat(false), overrideRedirect(false) {} // graphics context original and size int x; int y; int width; int height; // window decoration and behaviour std::string windowName; bool windowDecoration; bool supportsResize; // buffer depths, 0 equals off. unsigned int red; unsigned int blue; unsigned int green; unsigned int alpha; unsigned int depth; unsigned int stencil; // multi sample parameters unsigned int sampleBuffers; unsigned int samples; // buffer configuration bool pbuffer; bool quadBufferStereo; bool doubleBuffer; // render to texture GLenum target; GLenum format; unsigned int level; unsigned int face; unsigned int mipMapGeneration; // V-sync bool vsync; // use multithreaded OpenGL-engine (OS X only) bool useMultiThreadedOpenGLEngine; // enable cursor bool useCursor; // shared context GraphicsContext* sharedContext; osg::ref_ptr inheritedWindowData; // ask the GraphicsWindow implementation to set the pixel format of an inherited window bool setInheritedWindowPixelFormat; // X11 hint whether to override the window managers window size/position redirection bool overrideRedirect; }; /** Callback to be implemented to provide access to Windowing API's ability to create Windows/pbuffers.*/ struct WindowingSystemInterface : public osg::Referenced { virtual unsigned int getNumScreens(const ScreenIdentifier& screenIdentifier = ScreenIdentifier()) = 0; virtual void getScreenResolution(const ScreenIdentifier& screenIdentifier, unsigned int& width, unsigned int& height) = 0; virtual bool setScreenResolution(const ScreenIdentifier& /*screenIdentifier*/, unsigned int /*width*/, unsigned int /*height*/) { return false; } virtual bool setScreenRefreshRate(const ScreenIdentifier& /*screenIdentifier*/, double /*refreshRate*/) { return false; } virtual GraphicsContext* createGraphicsContext(Traits* traits) = 0; virtual ~WindowingSystemInterface() {}; }; /** Set the query the windowing system for screens and create graphics context - this functor should be supplied by the windows toolkit. */ static void setWindowingSystemInterface(WindowingSystemInterface* wsInterface); /** Get the WindowingSystemInterface*/ static WindowingSystemInterface* getWindowingSystemInterface(); /** Create a graphics context for a specified set of traits.*/ static GraphicsContext* createGraphicsContext(Traits* traits); /** Create a contextID for a new graphics context, this contextID is used to set up the osg::State associate with context. * Automatically increments the usage count of the contextID to 1.*/ static unsigned int createNewContextID(); /** Get the current max ContextID.*/ static unsigned int getMaxContextID(); /** Increment the usage count associate with a contextID. The usage count specifies how many graphics contexts a specific contextID is shared between.*/ static void incrementContextIDUsageCount(unsigned int contextID); /** Decrement the usage count associate with a contextID. Once the contextID goes to 0 the contextID is then free to be reused.*/ static void decrementContextIDUsageCount(unsigned int contextID); typedef std::vector GraphicsContexts; /** Get all the registered graphics contexts.*/ static GraphicsContexts getAllRegisteredGraphicsContexts(); /** Get all the registered graphics contexts associated with a specific contextID.*/ static GraphicsContexts getRegisteredGraphicsContexts(unsigned int contextID); /** Get the GraphicsContext for doing background compilation for GraphicsContexts associated with specified contextID.*/ static void setCompileContext(unsigned int contextID, GraphicsContext* gc); /** Get existing or create a new GraphicsContext to do background compilation for GraphicsContexts associated with specified contextID.*/ static GraphicsContext* getOrCreateCompileContext(unsigned int contextID); /** Get the GraphicsContext for doing background compilation for GraphicsContexts associated with specified contextID.*/ static GraphicsContext* getCompileContext(unsigned int contextID); public: /** Add operation to end of OperationQueue.*/ void add(Operation* operation); /** Remove operation from OperationQueue.*/ void remove(Operation* operation); /** Remove named operation from OperationQueue.*/ void remove(const std::string& name); /** Remove all operations from OperationQueue.*/ void removeAllOperations(); /** Run the operations. */ void runOperations(); typedef std::list< ref_ptr > OperationQueue; /** Get the operations queue, not you must use the OperationsMutex when accessing the queue.*/ OperationQueue& getOperationsQueue() { return _operations; } /** Get the operations queue mutex.*/ OpenThreads::Mutex* getOperationsMutex() { return &_operationsMutex; } /** Get the operations queue block used to mark an empty queue, if you end items into the empty queue you must release this block.*/ osg::RefBlock* getOperationsBlock() { return _operationsBlock.get(); } /** Get the current operations that is being run.*/ Operation* getCurrentOperation() { return _currentOperation.get(); } public: /** Get the traits of the GraphicsContext.*/ inline const Traits* getTraits() const { return _traits.get(); } /** Return whether a valid and usable GraphicsContext has been created.*/ virtual bool valid() const = 0; /** Set the State object which tracks the current OpenGL state for this graphics context.*/ inline void setState(State* state) { _state = state; } /** Get the State object which tracks the current OpenGL state for this graphics context.*/ inline State* getState() { return _state.get(); } /** Get the const State object which tracks the current OpenGL state for this graphics context.*/ inline const State* getState() const { return _state.get(); } /** Sets the clear color. */ inline void setClearColor(const Vec4& color) { _clearColor = color; } /** Returns the clear color. */ inline const Vec4& getClearColor() const { return _clearColor; } /** Set the clear mask used in glClear(..). * Defaults to 0 - so no clear is done by default by the GraphicsContext, instead the Camera's attached the GraphicsContext will do the clear. * GraphicsContext::setClearMask() is useful for when the Camera's Viewports don't conver the whole context, so the context will fill in the gaps. */ inline void setClearMask(GLbitfield mask) { _clearMask = mask; } /** Get the clear mask.*/ inline GLbitfield getClearMask() const { return _clearMask; } /** Do an OpenGL clear of the full graphics context/window. * Note, must only be called from a thread with this context current.*/ virtual void clear(); /** Realize the GraphicsContext.*/ bool realize(); /** close the graphics context. * close(bool) stops any associated graphics threads, releases the contextID for the GraphicsContext then * optional calls closeImplementation() to do the actual deletion of the graphics. This call is made optional * as there are times when the graphics context has already been deleted externally and only the OSG side * of the its data need to be closed down. */ void close(bool callCloseImplementation=true); /** swap the front and back buffers.*/ void swapBuffers(); /** Return true if the graphics context has been realized and is ready to use.*/ inline bool isRealized() const { return isRealizedImplementation(); } /** Make this graphics context current. * Implemented by calling makeCurrentImplementation(). * Returns true on success. */ bool makeCurrent(); /** Make this graphics context current with specified read context. * Implemented by calling makeContextCurrentImplementation(). * Returns true on success. */ bool makeContextCurrent(GraphicsContext* readContext); /** Release the graphics context. * Returns true on success. */ bool releaseContext(); /** Return true if the current thread has this OpenGL graphics context.*/ inline bool isCurrent() const { return _threadOfLastMakeCurrent == OpenThreads::Thread::CurrentThread(); } /** Bind the graphics context to associated texture.*/ inline void bindPBufferToTexture(GLenum buffer) { bindPBufferToTextureImplementation(buffer); } /** Create a graphics thread to the graphics context, so that the thread handles all OpenGL operations.*/ void createGraphicsThread(); /** Assign a graphics thread to the graphics context, so that the thread handles all OpenGL operations.*/ void setGraphicsThread(GraphicsThread* gt); /** Get the graphics thread assigned the graphics context.*/ GraphicsThread* getGraphicsThread() { return _graphicsThread.get(); } /** Get the const graphics thread assigned the graphics context.*/ const GraphicsThread* getGraphicsThread() const { return _graphicsThread.get(); } /** Realize the GraphicsContext implementation, * Pure virtual - must be implemented by concrete implementations of GraphicsContext. */ virtual bool realizeImplementation() = 0; /** Return true if the graphics context has been realized, and is ready to use, implementation. * Pure virtual - must be implemented by concrete implementations of GraphicsContext. */ virtual bool isRealizedImplementation() const = 0; /** Close the graphics context implementation. * Pure virtual - must be implemented by concrete implementations of GraphicsContext. */ virtual void closeImplementation() = 0; /** Make this graphics context current implementation. * Pure virtual - must be implemented by concrete implementations of GraphicsContext. */ virtual bool makeCurrentImplementation() = 0; /** Make this graphics context current with specified read context implementation. * Pure virtual - must be implemented by concrete implementations of GraphicsContext. */ virtual bool makeContextCurrentImplementation(GraphicsContext* readContext) = 0; /** Release the graphics context implementation.*/ virtual bool releaseContextImplementation() = 0; /** Pure virtual, Bind the graphics context to associated texture implementation. * Pure virtual - must be implemented by concrete implementations of GraphicsContext. */ virtual void bindPBufferToTextureImplementation(GLenum buffer) = 0; /** Swap the front and back buffers implementation. * Pure virtual - must be implemented by concrete implementations of GraphicsContext. */ virtual void swapBuffersImplementation() = 0; /** resized method should be called when the underlying window has been resized and the GraphicsWindow and associated Cameras must be updated to keep in sync with the new size. */ void resized(int x, int y, int width, int height) { if (_resizedCallback.valid()) _resizedCallback->resizedImplementation(this, x, y, width, height); else resizedImplementation(x, y, width, height); } struct ResizedCallback : public osg::Referenced { virtual void resizedImplementation(GraphicsContext* gc, int x, int y, int width, int height) = 0; }; /** Set the resized callback which overrides the GraphicsConext::realizedImplementation(), allow developers to provide custom behavior * in response to a window being resized.*/ void setResizedCallback(ResizedCallback* rc) { _resizedCallback = rc; } /** Get the resized callback which overrides the GraphicsConext::realizedImplementation().*/ ResizedCallback* getResizedCallback() { return _resizedCallback.get(); } /** Get the const resized callback which overrides the GraphicsConext::realizedImplementation().*/ const ResizedCallback* getResizedCallback() const { return _resizedCallback.get(); } /** resized implementation, by default resizes the viewports and aspect ratios the cameras associated with the graphics Window. */ virtual void resizedImplementation(int x, int y, int width, int height); typedef std::list< osg::Camera* > Cameras; /** Get the the list of cameras associated with this graphics context.*/ Cameras& getCameras() { return _cameras; } /** Get the the const list of cameras associated with this graphics context.*/ const Cameras& getCameras() const { return _cameras; } public: virtual bool isSameKindAs(const Object* object) const { return dynamic_cast(object)!=0; } virtual const char* libraryName() const { return "osg"; } virtual const char* className() const { return "GraphicsContext"; } protected: GraphicsContext(); GraphicsContext(const GraphicsContext&, const osg::CopyOp&); virtual ~GraphicsContext(); virtual Object* cloneType() const { return 0; } virtual Object* clone(const CopyOp&) const { return 0; } /** Register a GraphicsContext.*/ static void registerGraphicsContext(GraphicsContext* gc); /** Unregister a GraphicsContext.*/ static void unregisterGraphicsContext(GraphicsContext* gc); void addCamera(osg::Camera* camera); void removeCamera(osg::Camera* camera); Cameras _cameras; friend class osg::Camera; ref_ptr _traits; ref_ptr _state; Vec4 _clearColor; GLbitfield _clearMask; OpenThreads::Thread* _threadOfLastMakeCurrent; OpenThreads::Mutex _operationsMutex; osg::ref_ptr _operationsBlock; OperationQueue _operations; osg::ref_ptr _currentOperation; ref_ptr _graphicsThread; ref_ptr _resizedCallback; }; } #endif