/* -*-c++-*- OpenSceneGraph - setCullSettingsright (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_CULLSETTINGS #define OSG_CULLSETTINGS 1 #include #include namespace osg { // forward declare class ArgumentParser; class ApplicationUsage; class OSG_EXPORT CullSettings { public: CullSettings() { setDefaults(); readEnvironmentalVariables(); } CullSettings(ArgumentParser& arguments) { setDefaults(); readEnvironmentalVariables(); readCommandLine(arguments); } CullSettings(const CullSettings& cs); virtual ~CullSettings() {} CullSettings& operator = (const CullSettings& settings) { if (this==&settings) return *this; setCullSettings(settings); return *this; } virtual void setDefaults(); enum VariablesMask { COMPUTE_NEAR_FAR_MODE = 0x0001, CULLING_MODE = 0x0002, LOD_SCALE = 0x0004, SMALL_FEATURE_CULLING_PIXEL_SIZE = 0x0008, CLAMP_PROJECTION_MATRIX_CALLBACK = 0x0010, NEAR_FAR_RATIO = 0x0020, IMPOSTOR_ACTIVE = 0x0040, DEPTH_SORT_IMPOSTOR_SPRITES = 0x0080, IMPOSTOR_PIXEL_ERROR_THRESHOLD = 0x0100, NUM_FRAMES_TO_KEEP_IMPOSTORS_SPRITES = 0x0200, CULL_MASK = 0x0400, CULL_MASK_LEFT = 0x0800, CULL_MASK_RIGHT = 0x1000, CLEAR_COLOR = 0x2000, LIGHTING_MODE = 0x4000, LIGHT = 0x8000, NO_VARIABLES = 0x0000, ALL_VARIABLES = 0xFFFF }; /** Set the inheritance mask used in inheritCullSettings to control which variables get overwritten by the passed in CullSettings object.*/ void setInheritanceMask(unsigned int mask) { _inheritanceMask = mask; } /** Get the inheritance mask used in inheritCullSettings to control which variables get overwritten by the passed in CullSettings object.*/ unsigned int getInheritanceMask() const { return _inheritanceMask; } /** Set the local cull settings values from specified CullSettings object.*/ void setCullSettings(const CullSettings& settings); /** Inherit the local cull settings variable from specified CullSettings object, according to the inheritance mask.*/ virtual void inheritCullSettings(const CullSettings& settings) { inheritCullSettings(settings, _inheritanceMask); } /** Inherit the local cull settings variable from specified CullSettings object, according to the inheritance mask.*/ virtual void inheritCullSettings(const CullSettings& settings, unsigned int inheritanceMask); /** read the environmental variables.*/ void readEnvironmentalVariables(); /** read the commandline arguments.*/ void readCommandLine(ArgumentParser& arguments); enum InheritanceMaskActionOnAttributeSetting { DISABLE_ASSOCIATED_INHERITANCE_MASK_BIT, DO_NOT_MODIFY_INHERITANCE_MASK }; void setInheritanceMaskActionOnAttributeSetting(InheritanceMaskActionOnAttributeSetting action) { _inheritanceMaskActionOnAttributeSetting = action; } InheritanceMaskActionOnAttributeSetting getInheritanceMaskActionOnAttributeSetting() const { return _inheritanceMaskActionOnAttributeSetting; } /** Apply the action, specified by the InheritanceMaskActionOnAttributeSetting, to apply to the inheritance bit mask. * This method is called by CullSettings::set*() parameter methods to ensure that CullSettings inheritance mechanisms doesn't overwrite the local parameter settings.*/ inline void applyMaskAction(unsigned int maskBit) { if (_inheritanceMaskActionOnAttributeSetting==DISABLE_ASSOCIATED_INHERITANCE_MASK_BIT) { _inheritanceMask = _inheritanceMask & (~maskBit); } } /** Switch the creation of Impostors on or off. * Setting active to false forces the CullVisitor to use the Impostor * LOD children for rendering. Setting active to true forces the * CullVisitor to create the appropriate pre-rendering stages which * render to the ImpostorSprite's texture.*/ void setImpostorsActive(bool active) { _impostorActive = active; applyMaskAction(IMPOSTOR_ACTIVE); } /** Get whether impostors are active or not. */ bool getImpostorsActive() const { return _impostorActive; } /** Set the impostor error threshold. * Used in calculation of whether impostors remain valid.*/ void setImpostorPixelErrorThreshold(float numPixels) { _impostorPixelErrorThreshold=numPixels; applyMaskAction(IMPOSTOR_PIXEL_ERROR_THRESHOLD); } /** Get the impostor error threshold.*/ float getImpostorPixelErrorThreshold() const { return _impostorPixelErrorThreshold; } /** Set whether ImpostorSprite's should be placed in a depth sorted bin for rendering.*/ void setDepthSortImpostorSprites(bool doDepthSort) { _depthSortImpostorSprites = doDepthSort; applyMaskAction(DEPTH_SORT_IMPOSTOR_SPRITES); } /** Get whether ImpostorSprite's are depth sorted bin for rendering.*/ bool getDepthSortImpostorSprites() const { return _depthSortImpostorSprites; } /** Set the number of frames that an ImpostorSprite is kept whilst not being beyond, * before being recycled.*/ void setNumberOfFrameToKeepImpostorSprites(int numFrames) { _numFramesToKeepImpostorSprites = numFrames; applyMaskAction(NUM_FRAMES_TO_KEEP_IMPOSTORS_SPRITES); } /** Get the number of frames that an ImpostorSprite is kept whilst not being beyond, * before being recycled.*/ int getNumberOfFrameToKeepImpostorSprites() const { return _numFramesToKeepImpostorSprites; } enum ComputeNearFarMode { DO_NOT_COMPUTE_NEAR_FAR = 0, COMPUTE_NEAR_FAR_USING_BOUNDING_VOLUMES, COMPUTE_NEAR_FAR_USING_PRIMITIVES }; void setComputeNearFarMode(ComputeNearFarMode cnfm) { _computeNearFar=cnfm; applyMaskAction(COMPUTE_NEAR_FAR_MODE); } ComputeNearFarMode getComputeNearFarMode() const { return _computeNearFar;} void setNearFarRatio(double ratio) { _nearFarRatio = ratio; applyMaskAction(NEAR_FAR_RATIO); } double getNearFarRatio() const { return _nearFarRatio; } enum CullingModeValues { NO_CULLING = 0x0, VIEW_FRUSTUM_SIDES_CULLING = 0x1, NEAR_PLANE_CULLING = 0x2, FAR_PLANE_CULLING = 0x4, VIEW_FRUSTUM_CULLING = VIEW_FRUSTUM_SIDES_CULLING| NEAR_PLANE_CULLING| FAR_PLANE_CULLING, SMALL_FEATURE_CULLING = 0x8, SHADOW_OCCLUSION_CULLING = 0x10, CLUSTER_CULLING = 0x20, DEFAULT_CULLING = VIEW_FRUSTUM_SIDES_CULLING| SMALL_FEATURE_CULLING| SHADOW_OCCLUSION_CULLING| CLUSTER_CULLING, ENABLE_ALL_CULLING = VIEW_FRUSTUM_CULLING| SMALL_FEATURE_CULLING| SHADOW_OCCLUSION_CULLING| CLUSTER_CULLING }; typedef unsigned int CullingMode; /** Set the culling mode for the CullVisitor to use.*/ void setCullingMode(CullingMode mode) { _cullingMode = mode; applyMaskAction(CULLING_MODE); } /** Returns the current CullingMode.*/ CullingMode getCullingMode() const { return _cullingMode; } void setCullMask(osg::Node::NodeMask nm) { _cullMask = nm; applyMaskAction(CULL_MASK); } osg::Node::NodeMask getCullMask() const { return _cullMask; } void setCullMaskLeft(osg::Node::NodeMask nm) { _cullMaskLeft = nm; applyMaskAction(CULL_MASK_LEFT); } osg::Node::NodeMask getCullMaskLeft() const { return _cullMaskLeft; } void setCullMaskRight(osg::Node::NodeMask nm) { _cullMaskRight = nm; applyMaskAction(CULL_MASK_RIGHT); } osg::Node::NodeMask getCullMaskRight() const { return _cullMaskRight; } /** Set the LOD bias for the CullVisitor to use.*/ void setLODScale(float bias) { _LODScale = bias; applyMaskAction(LOD_SCALE); } /** Get the LOD bias.*/ float getLODScale() const { return _LODScale; } /** Set the Small Feature Culling Pixel Size.*/ void setSmallFeatureCullingPixelSize(float value) { _smallFeatureCullingPixelSize=value; applyMaskAction(SMALL_FEATURE_CULLING_PIXEL_SIZE); } /** Get the Small Feature Culling Pixel Size.*/ float getSmallFeatureCullingPixelSize() const { return _smallFeatureCullingPixelSize; } /** Callback for overriding the CullVisitor's default clamping of the projection matrix to computed near and far values. * Note, both Matrixf and Matrixd versions of clampProjectionMatrixImplementation must be implemented as the CullVisitor * can target either Matrix data type, configured at compile time.*/ struct ClampProjectionMatrixCallback : public osg::Referenced { virtual bool clampProjectionMatrixImplementation(osg::Matrixf& projection, double& znear, double& zfar) const = 0; virtual bool clampProjectionMatrixImplementation(osg::Matrixd& projection, double& znear, double& zfar) const = 0; }; /** set the ClampProjectionMatrixCallback.*/ void setClampProjectionMatrixCallback(ClampProjectionMatrixCallback* cpmc) { _clampProjectionMatrixCallback = cpmc; applyMaskAction(CLAMP_PROJECTION_MATRIX_CALLBACK); } /** get the non const ClampProjectionMatrixCallback.*/ ClampProjectionMatrixCallback* getClampProjectionMatrixCallback() { return _clampProjectionMatrixCallback.get(); } /** get the const ClampProjectionMatrixCallback.*/ const ClampProjectionMatrixCallback* getClampProjectionMatrixCallback() const { return _clampProjectionMatrixCallback.get(); } protected: unsigned int _inheritanceMask; InheritanceMaskActionOnAttributeSetting _inheritanceMaskActionOnAttributeSetting; ComputeNearFarMode _computeNearFar; CullingMode _cullingMode; float _LODScale; float _smallFeatureCullingPixelSize; ref_ptr _clampProjectionMatrixCallback; double _nearFarRatio; bool _impostorActive; bool _depthSortImpostorSprites; float _impostorPixelErrorThreshold; int _numFramesToKeepImpostorSprites; Node::NodeMask _cullMask; Node::NodeMask _cullMaskLeft; Node::NodeMask _cullMaskRight; }; } #endif