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

Revision 13041, 12.7 kB (checked in by robert, 2 years ago)

Ran script to remove trailing spaces and tabs

  • 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            COMPUTE_NEAR_USING_PRIMITIVES
166        };
167
168        void setComputeNearFarMode(ComputeNearFarMode cnfm) { _computeNearFar=cnfm; applyMaskAction(COMPUTE_NEAR_FAR_MODE); }
169        ComputeNearFarMode getComputeNearFarMode() const { return _computeNearFar;}
170
171        void setNearFarRatio(double ratio) { _nearFarRatio = ratio; applyMaskAction(NEAR_FAR_RATIO); }
172        double getNearFarRatio() const { return _nearFarRatio; }
173
174        enum CullingModeValues
175        {
176            NO_CULLING                  = 0x0,
177            VIEW_FRUSTUM_SIDES_CULLING  = 0x1,
178            NEAR_PLANE_CULLING          = 0x2,
179            FAR_PLANE_CULLING           = 0x4,
180            VIEW_FRUSTUM_CULLING        = VIEW_FRUSTUM_SIDES_CULLING|
181                                          NEAR_PLANE_CULLING|
182                                          FAR_PLANE_CULLING,
183            SMALL_FEATURE_CULLING       = 0x8,
184            SHADOW_OCCLUSION_CULLING    = 0x10,
185            CLUSTER_CULLING             = 0x20,
186            DEFAULT_CULLING             = VIEW_FRUSTUM_SIDES_CULLING|
187                                          SMALL_FEATURE_CULLING|
188                                          SHADOW_OCCLUSION_CULLING|
189                                          CLUSTER_CULLING,
190            ENABLE_ALL_CULLING          = VIEW_FRUSTUM_CULLING|
191                                          SMALL_FEATURE_CULLING|
192                                          SHADOW_OCCLUSION_CULLING|
193                                          CLUSTER_CULLING
194        };
195
196        typedef int CullingMode;
197
198        /** Set the culling mode for the CullVisitor to use.*/
199        void setCullingMode(CullingMode mode) { _cullingMode = mode; applyMaskAction(CULLING_MODE); }
200
201        /** Returns the current CullingMode.*/
202        CullingMode getCullingMode() const { return _cullingMode; }
203
204
205        void setCullMask(osg::Node::NodeMask nm) { _cullMask = nm; applyMaskAction(CULL_MASK); }
206        osg::Node::NodeMask getCullMask() const { return _cullMask; }
207
208        void setCullMaskLeft(osg::Node::NodeMask nm) { _cullMaskLeft = nm; applyMaskAction(CULL_MASK_LEFT); }
209        osg::Node::NodeMask getCullMaskLeft() const { return _cullMaskLeft; }
210
211        void setCullMaskRight(osg::Node::NodeMask nm) { _cullMaskRight = nm; applyMaskAction(CULL_MASK_RIGHT); }
212        osg::Node::NodeMask getCullMaskRight() const { return _cullMaskRight; }
213
214        /** Set the LOD bias for the CullVisitor to use.*/
215        void setLODScale(float scale) { _LODScale = scale; applyMaskAction(LOD_SCALE); }
216
217        /** Get the LOD bias.*/
218        float getLODScale() const { return _LODScale; }
219
220        /** Threshold at which small features are culled.
221        \param value Boulding volume size in screen space. Default is 2.0. */
222        void setSmallFeatureCullingPixelSize(float value) { _smallFeatureCullingPixelSize=value; applyMaskAction(SMALL_FEATURE_CULLING_PIXEL_SIZE); }
223
224        /** Get the Small Feature Culling Pixel Size.*/
225        float getSmallFeatureCullingPixelSize() const { return _smallFeatureCullingPixelSize; }
226
227
228
229        /** Callback for overriding the CullVisitor's default clamping of the projection matrix to computed near and far values.
230          * Note, both Matrixf and Matrixd versions of clampProjectionMatrixImplementation must be implemented as the CullVisitor
231          * can target either Matrix data type, configured at compile time.*/
232        struct ClampProjectionMatrixCallback : public osg::Referenced
233        {
234            virtual bool clampProjectionMatrixImplementation(osg::Matrixf& projection, double& znear, double& zfar) const = 0;
235            virtual bool clampProjectionMatrixImplementation(osg::Matrixd& projection, double& znear, double& zfar) const = 0;
236        };
237
238        /** set the ClampProjectionMatrixCallback.*/
239        void setClampProjectionMatrixCallback(ClampProjectionMatrixCallback* cpmc) { _clampProjectionMatrixCallback = cpmc; applyMaskAction(CLAMP_PROJECTION_MATRIX_CALLBACK); }
240        /** get the non const ClampProjectionMatrixCallback.*/
241        ClampProjectionMatrixCallback* getClampProjectionMatrixCallback() { return _clampProjectionMatrixCallback.get(); }
242        /** get the const ClampProjectionMatrixCallback.*/
243        const ClampProjectionMatrixCallback* getClampProjectionMatrixCallback() const { return _clampProjectionMatrixCallback.get(); }
244
245
246        /** Write out internal settings of CullSettings. */
247        void write(std::ostream& out);
248
249    protected:
250
251        InheritanceMask                             _inheritanceMask;
252        InheritanceMaskActionOnAttributeSetting     _inheritanceMaskActionOnAttributeSetting;
253
254        ComputeNearFarMode                          _computeNearFar;
255        CullingMode                                 _cullingMode;
256        float                                       _LODScale;
257        float                                       _smallFeatureCullingPixelSize;
258
259        ref_ptr<ClampProjectionMatrixCallback>      _clampProjectionMatrixCallback;
260        double                                      _nearFarRatio;
261        bool                                        _impostorActive;
262        bool                                        _depthSortImpostorSprites;
263        float                                       _impostorPixelErrorThreshold;
264        int                                         _numFramesToKeepImpostorSprites;
265
266        Node::NodeMask                              _cullMask;
267        Node::NodeMask                              _cullMaskLeft;
268        Node::NodeMask                              _cullMaskRight;
269
270
271};
272
273
274}
275
276#endif
Note: See TracBrowser for help on using the browser.