root/OpenSceneGraph/trunk/include/osg/CullSettings @ 11164

Revision 11164, 12.7 kB (checked in by robert, 5 years ago)

Replaced use of unsigned int/enum mask combinations with int/enum mask combinations to avoid the need for casting enums to unsigned ints,
and to avoid associated warnings.

Update wrappers to reflect these changes.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
2 *
3 * This library is open source and may be redistributed and/or modified under 
4 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
5 * (at your option) any later version.  The full license is in LICENSE file
6 * included with this distribution, and on the openscenegraph.org website.
7 *
8 * This library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 * OpenSceneGraph Public License for more details.
12*/
13
14#ifndef OSG_CULLSETTINGS
15#define OSG_CULLSETTINGS 1
16
17#include <iosfwd>
18#include <osg/Matrix>
19#include <osg/ClearNode>
20
21namespace osg {
22
23// forward declare
24class ArgumentParser;
25class ApplicationUsage;
26
27class OSG_EXPORT CullSettings
28{
29    public:
30
31        CullSettings()
32        {
33            setDefaults();
34            readEnvironmentalVariables();
35        }
36
37        CullSettings(ArgumentParser& arguments)
38        {
39            setDefaults();
40            readEnvironmentalVariables();
41            readCommandLine(arguments);
42        }
43
44        CullSettings(const CullSettings& cs);
45
46        virtual ~CullSettings() {}
47       
48        CullSettings& operator = (const CullSettings& settings)
49        {
50            if (this==&settings) return *this;
51            setCullSettings(settings);
52            return *this;
53        }
54
55
56        virtual void setDefaults();
57
58       
59        enum VariablesMask
60        {
61            COMPUTE_NEAR_FAR_MODE                   = (0x1 << 0),
62            CULLING_MODE                            = (0x1 << 1),
63            LOD_SCALE                               = (0x1 << 2),
64            SMALL_FEATURE_CULLING_PIXEL_SIZE        = (0x1 << 3),
65            CLAMP_PROJECTION_MATRIX_CALLBACK        = (0x1 << 4),
66            NEAR_FAR_RATIO                          = (0x1 << 5),
67            IMPOSTOR_ACTIVE                         = (0x1 << 6),
68            DEPTH_SORT_IMPOSTOR_SPRITES             = (0x1 << 7),
69            IMPOSTOR_PIXEL_ERROR_THRESHOLD          = (0x1 << 8),
70            NUM_FRAMES_TO_KEEP_IMPOSTORS_SPRITES    = (0x1 << 9),
71            CULL_MASK                               = (0x1 << 10),
72            CULL_MASK_LEFT                          = (0x1 << 11),
73            CULL_MASK_RIGHT                         = (0x1 << 12),
74            CLEAR_COLOR                             = (0x1 << 13),
75            CLEAR_MASK                              = (0x1 << 14),
76            LIGHTING_MODE                           = (0x1 << 15),
77            LIGHT                                   = (0x1 << 16),
78            DRAW_BUFFER                             = (0x1 << 17),
79            READ_BUFFER                             = (0x1 << 18),
80
81            NO_VARIABLES                            = 0x00000000,
82            ALL_VARIABLES                           = 0x7FFFFFFF
83        };
84
85        typedef int InheritanceMask;
86
87        /** Set the inheritance mask used in inheritCullSettings to control which variables get overwritten by the passed in CullSettings object.*/
88        void setInheritanceMask(InheritanceMask mask) { _inheritanceMask = mask; }
89
90        /** Get the inheritance mask used in inheritCullSettings to control which variables get overwritten by the passed in CullSettings object.*/
91        InheritanceMask getInheritanceMask() const { return _inheritanceMask; }
92       
93        /** Set the local cull settings values from specified CullSettings object.*/
94        void setCullSettings(const CullSettings& settings);
95
96        /** Inherit the local cull settings variable from specified CullSettings object, according to the inheritance mask.*/
97        virtual void inheritCullSettings(const CullSettings& settings) { inheritCullSettings(settings, _inheritanceMask); }
98
99        /** Inherit the local cull settings variable from specified CullSettings object, according to the inheritance mask.*/
100        virtual void inheritCullSettings(const CullSettings& settings, unsigned int inheritanceMask);
101
102        /** read the environmental variables.*/
103        void readEnvironmentalVariables();
104
105        /** read the commandline arguments.*/
106        void readCommandLine(ArgumentParser& arguments);
107
108
109        enum InheritanceMaskActionOnAttributeSetting
110        {
111            DISABLE_ASSOCIATED_INHERITANCE_MASK_BIT,
112            DO_NOT_MODIFY_INHERITANCE_MASK
113        };
114       
115        void setInheritanceMaskActionOnAttributeSetting(InheritanceMaskActionOnAttributeSetting action) { _inheritanceMaskActionOnAttributeSetting = action; }
116        InheritanceMaskActionOnAttributeSetting getInheritanceMaskActionOnAttributeSetting() const { return _inheritanceMaskActionOnAttributeSetting; }
117
118        /** Apply the action, specified by the InheritanceMaskActionOnAttributeSetting, to apply to the inheritance bit mask.
119          * This method is called by CullSettings::set*() parameter methods to ensure that CullSettings inheritance mechanisms doesn't overwrite the local parameter settings.*/
120        inline void applyMaskAction(unsigned int maskBit)
121        {
122            if (_inheritanceMaskActionOnAttributeSetting==DISABLE_ASSOCIATED_INHERITANCE_MASK_BIT)
123            {
124                _inheritanceMask = _inheritanceMask & (~maskBit);
125            }
126        }
127
128
129        /** Switch the creation of Impostors on or off.
130          * Setting active to false forces the CullVisitor to use the Impostor
131          * LOD children for rendering. Setting active to true forces the
132          * CullVisitor to create the appropriate pre-rendering stages which
133          * render to the ImpostorSprite's texture.*/
134        void setImpostorsActive(bool active) { _impostorActive = active; applyMaskAction(IMPOSTOR_ACTIVE); }
135
136        /** Get whether impostors are active or not. */
137        bool getImpostorsActive() const { return _impostorActive; }
138
139        /** Set the impostor error threshold.
140          * Used in calculation of whether impostors remain valid.*/
141        void setImpostorPixelErrorThreshold(float numPixels) { _impostorPixelErrorThreshold=numPixels;  applyMaskAction(IMPOSTOR_PIXEL_ERROR_THRESHOLD); }
142
143        /** Get the impostor error threshold.*/
144        float getImpostorPixelErrorThreshold() const { return _impostorPixelErrorThreshold; }
145
146        /** Set whether ImpostorSprite's should be placed in a depth sorted bin for rendering.*/
147        void setDepthSortImpostorSprites(bool doDepthSort) { _depthSortImpostorSprites = doDepthSort; applyMaskAction(DEPTH_SORT_IMPOSTOR_SPRITES); }
148
149        /** Get whether ImpostorSprite's are depth sorted bin for rendering.*/
150        bool getDepthSortImpostorSprites() const { return _depthSortImpostorSprites; }
151
152        /** Set the number of frames that an ImpostorSprite is kept whilst not being beyond,
153          * before being recycled.*/
154        void setNumberOfFrameToKeepImpostorSprites(int numFrames) { _numFramesToKeepImpostorSprites = numFrames; applyMaskAction(NUM_FRAMES_TO_KEEP_IMPOSTORS_SPRITES); }
155
156        /** Get the number of frames that an ImpostorSprite is kept whilst not being beyond,
157          * before being recycled.*/
158        int getNumberOfFrameToKeepImpostorSprites() const { return _numFramesToKeepImpostorSprites; }
159
160        enum ComputeNearFarMode
161        {
162            DO_NOT_COMPUTE_NEAR_FAR = 0,
163            COMPUTE_NEAR_FAR_USING_BOUNDING_VOLUMES,
164            COMPUTE_NEAR_FAR_USING_PRIMITIVES
165        };
166
167        void setComputeNearFarMode(ComputeNearFarMode cnfm) { _computeNearFar=cnfm; applyMaskAction(COMPUTE_NEAR_FAR_MODE); }
168        ComputeNearFarMode getComputeNearFarMode() const { return _computeNearFar;}
169
170        void setNearFarRatio(double ratio) { _nearFarRatio = ratio; applyMaskAction(NEAR_FAR_RATIO); }
171        double getNearFarRatio() const { return _nearFarRatio; }
172
173        enum CullingModeValues
174        {
175            NO_CULLING                  = 0x0,
176            VIEW_FRUSTUM_SIDES_CULLING  = 0x1,
177            NEAR_PLANE_CULLING          = 0x2,
178            FAR_PLANE_CULLING           = 0x4,
179            VIEW_FRUSTUM_CULLING        = VIEW_FRUSTUM_SIDES_CULLING|
180                                          NEAR_PLANE_CULLING|
181                                          FAR_PLANE_CULLING,
182            SMALL_FEATURE_CULLING       = 0x8,
183            SHADOW_OCCLUSION_CULLING    = 0x10,
184            CLUSTER_CULLING             = 0x20,
185            DEFAULT_CULLING             = VIEW_FRUSTUM_SIDES_CULLING|
186                                          SMALL_FEATURE_CULLING|
187                                          SHADOW_OCCLUSION_CULLING|
188                                          CLUSTER_CULLING,
189            ENABLE_ALL_CULLING          = VIEW_FRUSTUM_CULLING|
190                                          SMALL_FEATURE_CULLING|
191                                          SHADOW_OCCLUSION_CULLING|
192                                          CLUSTER_CULLING
193        };
194       
195        typedef int CullingMode;
196
197        /** Set the culling mode for the CullVisitor to use.*/
198        void setCullingMode(CullingMode mode) { _cullingMode = mode; applyMaskAction(CULLING_MODE); }
199       
200        /** Returns the current CullingMode.*/
201        CullingMode getCullingMode() const { return _cullingMode; }
202
203
204        void setCullMask(osg::Node::NodeMask nm) { _cullMask = nm; applyMaskAction(CULL_MASK); }
205        osg::Node::NodeMask getCullMask() const { return _cullMask; }
206
207        void setCullMaskLeft(osg::Node::NodeMask nm) { _cullMaskLeft = nm; applyMaskAction(CULL_MASK_LEFT); }
208        osg::Node::NodeMask getCullMaskLeft() const { return _cullMaskLeft; }
209
210        void setCullMaskRight(osg::Node::NodeMask nm) { _cullMaskRight = nm; applyMaskAction(CULL_MASK_RIGHT); }
211        osg::Node::NodeMask getCullMaskRight() const { return _cullMaskRight; }
212
213        /** Set the LOD bias for the CullVisitor to use.*/
214        void setLODScale(float scale) { _LODScale = scale; applyMaskAction(LOD_SCALE); }
215       
216        /** Get the LOD bias.*/
217        float getLODScale() const { return _LODScale; }
218
219        /** Set the Small Feature Culling Pixel Size.*/
220        void setSmallFeatureCullingPixelSize(float value) { _smallFeatureCullingPixelSize=value; applyMaskAction(SMALL_FEATURE_CULLING_PIXEL_SIZE); }
221
222        /** Get the Small Feature Culling Pixel Size.*/
223        float getSmallFeatureCullingPixelSize() const { return _smallFeatureCullingPixelSize; }
224
225
226
227        /** Callback for overriding the CullVisitor's default clamping of the projection matrix to computed near and far values.
228          * Note, both Matrixf and Matrixd versions of clampProjectionMatrixImplementation must be implemented as the CullVisitor
229          * can target either Matrix data type, configured at compile time.*/
230        struct ClampProjectionMatrixCallback : public osg::Referenced
231        {
232            virtual bool clampProjectionMatrixImplementation(osg::Matrixf& projection, double& znear, double& zfar) const = 0;
233            virtual bool clampProjectionMatrixImplementation(osg::Matrixd& projection, double& znear, double& zfar) const = 0;
234        };
235       
236        /** set the ClampProjectionMatrixCallback.*/
237        void setClampProjectionMatrixCallback(ClampProjectionMatrixCallback* cpmc) { _clampProjectionMatrixCallback = cpmc; applyMaskAction(CLAMP_PROJECTION_MATRIX_CALLBACK); }
238        /** get the non const ClampProjectionMatrixCallback.*/
239        ClampProjectionMatrixCallback* getClampProjectionMatrixCallback() { return _clampProjectionMatrixCallback.get(); }
240        /** get the const ClampProjectionMatrixCallback.*/
241        const ClampProjectionMatrixCallback* getClampProjectionMatrixCallback() const { return _clampProjectionMatrixCallback.get(); }
242
243
244        /** Write out internal settings of CullSettings. */
245        void write(std::ostream& out);
246
247    protected:
248
249        InheritanceMask                             _inheritanceMask;
250        InheritanceMaskActionOnAttributeSetting     _inheritanceMaskActionOnAttributeSetting;
251
252        ComputeNearFarMode                          _computeNearFar;
253        CullingMode                                 _cullingMode;
254        float                                       _LODScale;
255        float                                       _smallFeatureCullingPixelSize;
256
257        ref_ptr<ClampProjectionMatrixCallback>      _clampProjectionMatrixCallback;
258        double                                      _nearFarRatio;
259        bool                                        _impostorActive;
260        bool                                        _depthSortImpostorSprites;
261        float                                       _impostorPixelErrorThreshold;
262        int                                         _numFramesToKeepImpostorSprites;   
263
264        Node::NodeMask                              _cullMask;
265        Node::NodeMask                              _cullMaskLeft;
266        Node::NodeMask                              _cullMaskRight;
267 
268
269};
270
271
272}
273
274#endif
Note: See TracBrowser for help on using the browser.