Coin Logo Coin3D is Free Software,
published under the BSD 3-clause license.
https://bitbucket.org/Coin3D/
http://www.kongsberg.com/kogt/
SoLazyElement.h
1 #ifndef COIN_SOLAZYELEMENT_H
2 #define COIN_SOLAZYELEMENT_H
3 
4 /**************************************************************************\
5  * Copyright (c) Kongsberg Oil & Gas Technologies AS
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions are
10  * met:
11  *
12  * Redistributions of source code must retain the above copyright notice,
13  * this list of conditions and the following disclaimer.
14  *
15  * Redistributions in binary form must reproduce the above copyright
16  * notice, this list of conditions and the following disclaimer in the
17  * documentation and/or other materials provided with the distribution.
18  *
19  * Neither the name of the copyright holder nor the names of its
20  * contributors may be used to endorse or promote products derived from
21  * this software without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
29  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
33  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 \**************************************************************************/
35 
36 #include <Inventor/elements/SoElement.h>
37 #include <Inventor/elements/SoSubElement.h>
38 #include <Inventor/SbColor.h>
39 
40 class SoMFFloat;
41 class SoMFColor;
42 class SoColorPacker;
43 class SoLazyElementP;
44 
45 #define SO_LAZY_SHINY_THRESHOLD 0.005f
46 
47 
48 class COIN_DLL_API SoLazyElement : public SoElement {
49  typedef SoElement inherited;
50 
51  SO_ELEMENT_HEADER(SoLazyElement);
52 
53 public:
54  static void initClass();
55 protected:
56  ~SoLazyElement();
57 public:
58  enum cases {
59  LIGHT_MODEL_CASE = 0,
60  COLOR_MATERIAL_CASE,
61  DIFFUSE_CASE,
62  AMBIENT_CASE,
63  EMISSIVE_CASE,
64  SPECULAR_CASE,
65  SHININESS_CASE,
66  BLENDING_CASE,
67  TRANSPARENCY_CASE,
68  VERTEXORDERING_CASE,
69  TWOSIDE_CASE,
70  CULLING_CASE,
71  SHADE_MODEL_CASE,
72  ALPHATEST_CASE,
73  GLIMAGE_CASE, // OBSOLETED
74  LAZYCASES_LAST // must be last
75  };
76  enum masks{
77  LIGHT_MODEL_MASK = 1 << LIGHT_MODEL_CASE, // 0x0001
78  COLOR_MATERIAL_MASK = 1 << COLOR_MATERIAL_CASE, // 0x0002
79  DIFFUSE_MASK = 1 << DIFFUSE_CASE, // 0x0004
80  AMBIENT_MASK = 1 << AMBIENT_CASE, // 0x0008
81  EMISSIVE_MASK = 1<<EMISSIVE_CASE, // 0x0010
82  SPECULAR_MASK = 1 << SPECULAR_CASE, // 0x0020
83  SHININESS_MASK = 1 << SHININESS_CASE, // 0x0040
84  TRANSPARENCY_MASK = 1 << TRANSPARENCY_CASE, // 0x0080
85  BLENDING_MASK = 1 << BLENDING_CASE, // 0x0100
86  VERTEXORDERING_MASK = 1 << VERTEXORDERING_CASE, // 0x0200
87  TWOSIDE_MASK = 1 << TWOSIDE_CASE, // 0x0400
88  CULLING_MASK = 1 << CULLING_CASE, // 0x0800
89  SHADE_MODEL_MASK = 1 << SHADE_MODEL_CASE, // 0x1000
90  ALPHATEST_MASK = 1 << ALPHATEST_CASE, // 0x2000
91  GLIMAGE_MASK = 1 << GLIMAGE_CASE, // obsoleted
92  ALL_MASK = (1 << LAZYCASES_LAST)-1
93  };
94 
95  enum internalMasks{
96  OTHER_COLOR_MASK = AMBIENT_MASK|EMISSIVE_MASK|SPECULAR_MASK|SHININESS_MASK,
97  ALL_COLOR_MASK = OTHER_COLOR_MASK|DIFFUSE_MASK,
98  NO_COLOR_MASK = ALL_MASK & (~ALL_COLOR_MASK),
99  ALL_BUT_DIFFUSE_MASK = ALL_MASK &(~ DIFFUSE_MASK),
100  DIFFUSE_ONLY_MASK = ALL_MASK &(~ OTHER_COLOR_MASK)
101  };
102 
103  enum LightModel {
104  BASE_COLOR,
105  PHONG
106  };
107 
108  enum VertexOrdering {
109  CW,
110  CCW
111  };
112 
113  virtual void init(SoState *state);
114  virtual void push(SoState *state);
115  virtual SbBool matches(const SoElement *) const;
116  virtual SoElement *copyMatchInfo(void) const;
117 
118  static void setToDefault(SoState * state);
119  static void setDiffuse(SoState * state, SoNode * node, int32_t numcolors,
120  const SbColor * colors, SoColorPacker * packer);
121  static void setTransparency(SoState *state, SoNode *node, int32_t numvalues,
122  const float * transparency, SoColorPacker * packer);
123  static void setPacked(SoState * state, SoNode * node,
124  int32_t numcolors, const uint32_t * colors,
125  const SbBool packedtransparency = FALSE);
126  static void setColorIndices(SoState *state, SoNode *node,
127  int32_t numindices, const int32_t *indices);
128  static void setAmbient(SoState *state, const SbColor * color);
129  static void setEmissive(SoState *state, const SbColor * color);
130  static void setSpecular(SoState *state, const SbColor * color);
131  static void setShininess(SoState *state, float value);
132  static void setColorMaterial(SoState *state, SbBool value);
133  static void enableBlending(SoState *state,
134  int sfactor,
135  int dfactor);
136  static void enableSeparateBlending(SoState *state,
137  int sfactor,
138  int dfactor,
139  int alpha_sfactor,
140  int alpha_dfactor);
141 
142  static void disableBlending(SoState * state);
143  static void setLightModel(SoState *state, const int32_t model);
144  static void setVertexOrdering(SoState * state, VertexOrdering ordering);
145  static void setBackfaceCulling(SoState * state, SbBool onoff);
146  static void setTwosideLighting(SoState * state, SbBool onoff);
147  static void setShadeModel(SoState * state, SbBool flatshading);
148  static void setAlphaTest(SoState * state, int func, float value);
149 
150  static const SbColor & getDiffuse(SoState* state, int index);
151  static float getTransparency(SoState*, int index);
152  static const uint32_t * getPackedColors(SoState*);
153  static const int32_t * getColorIndices(SoState*);
154  static int32_t getColorIndex(SoState*, int num);
155  static const SbColor & getAmbient(SoState *);
156  static const SbColor & getEmissive(SoState *);
157  static const SbColor & getSpecular(SoState *);
158  static float getShininess(SoState*);
159  static SbBool getColorMaterial(SoState*);
160  static SbBool getBlending(SoState *,
161  int & sfactor, int & dfactor);
162  static SbBool getAlphaBlending(SoState *,
163  int & sfactor, int & dfactor);
164 
165  static int32_t getLightModel(SoState*);
166  static int getAlphaTest(SoState * state, float & value);
167  static SbBool getTwoSidedLighting(SoState * state);
168 
169  int32_t getNumDiffuse(void) const;
170  int32_t getNumTransparencies(void) const;
171  int32_t getNumColorIndices(void) const;
172  SbBool isPacked(void) const;
173  SbBool isTransparent(void) const;
174  static SoLazyElement * getInstance(SoState *state);
175  static float getDefaultAmbientIntensity(void);
176 
177  static SbColor getDefaultDiffuse(void);
178  static SbColor getDefaultAmbient(void);
179  static SbColor getDefaultSpecular(void);
180  static SbColor getDefaultEmissive(void);
181  static float getDefaultShininess(void);
182  static uint32_t getDefaultPacked(void);
183  static float getDefaultTransparency(void);
184  static int32_t getDefaultLightModel(void);
185  static int32_t getDefaultColorIndex(void);
186 
187  static void setMaterials(SoState * state, SoNode *node, uint32_t bitmask,
188  SoColorPacker * cPacker,
189  const SbColor * diffuse,
190  const int numdiffuse,
191  const float * transp,
192  const int numtransp,
193  const SbColor & ambient,
194  const SbColor & emissive,
195  const SbColor & specular,
196  const float shininess,
197  const SbBool istransparent);
198 
199  static SoLazyElement * getWInstance(SoState *state);
200 
201  const uint32_t * getPackedPointer(void) const;
202  const SbColor * getDiffusePointer(void) const;
203  const int32_t * getColorIndexPointer(void) const;
204 
205  const float * getTransparencyPointer(void) const;
206  static void setTransparencyType(SoState * state, int32_t type);
207 
208 protected:
209 
210  struct COIN_DLL_API CoinState {
211  SbColor ambient;
212  SbColor specular;
213  SbColor emissive;
214  float shininess;
215  SbBool blending;
216  int blend_sfactor;
217  int blend_dfactor;
218  int alpha_blend_sfactor;
219  int alpha_blend_dfactor;
220  int32_t lightmodel;
221  SbBool packeddiffuse;
222  int32_t numdiffuse;
223  int32_t numtransp;
224  const SbColor * diffusearray;
225  const uint32_t * packedarray;
226  const float * transparray;
227  const int32_t * colorindexarray;
228  int32_t transptype;
229  SbBool istransparent;
230  SbUniqueId diffusenodeid;
231  SbUniqueId transpnodeid;
232  int32_t stipplenum;
233  VertexOrdering vertexordering;
234  SbBool twoside;
235  SbBool culling;
236  SbBool flatshading;
237  int alphatestfunc;
238  float alphatestvalue;
239  } coinstate;
240 
241 protected:
242  virtual void lazyDidSet(uint32_t mask);
243  virtual void lazyDidntSet(uint32_t mask);
244 
245  virtual void setDiffuseElt(SoNode*, int32_t numcolors,
246  const SbColor * colors, SoColorPacker * packer);
247  virtual void setPackedElt(SoNode * node, int32_t numcolors,
248  const uint32_t * colors, const SbBool packedtransparency);
249  virtual void setColorIndexElt(SoNode * node, int32_t numindices,
250  const int32_t * indices);
251  virtual void setTranspElt(SoNode * node, int32_t numtransp,
252  const float * transp, SoColorPacker * packer);
253 
254  virtual void setTranspTypeElt(int32_t type);
255  virtual void setAmbientElt(const SbColor* color);
256  virtual void setEmissiveElt(const SbColor* color);
257  virtual void setSpecularElt(const SbColor* color);
258  virtual void setShininessElt(float value);
259  virtual void setColorMaterialElt(SbBool value);
260  virtual void enableBlendingElt(int sfactor, int dfactor, int alpha_sfactor, int alpha_dfactor);
261  virtual void disableBlendingElt(void);
262  virtual void setLightModelElt(SoState *state, int32_t model);
263  virtual void setMaterialElt(SoNode * node, uint32_t bitmask,
264  SoColorPacker * packer,
265  const SbColor * diffuse, const int numdiffuse,
266  const float * transp, const int numtransp,
267  const SbColor & ambient,
268  const SbColor & emissive,
269  const SbColor & specular,
270  const float shininess,
271  const SbBool istransparent);
272  virtual void setVertexOrderingElt(VertexOrdering ordering);
273  virtual void setBackfaceCullingElt(SbBool onoff);
274  virtual void setTwosideLightingElt(SbBool onoff);
275  virtual void setShadeModelElt(SbBool flatshading);
276  virtual void setAlphaTestElt(int func, float value);
277 
278 private:
279  SoLazyElementP * pimpl; // for future use
280 
281 };
282 
283 class COIN_DLL_API SoColorPacker {
284 public:
285  SoColorPacker(void);
286  ~SoColorPacker();
287 
288  uint32_t * getPackedColors(void) const {
289  return this->array;
290  }
291  SbBool diffuseMatch(const SbUniqueId nodeid) const {
292  return nodeid == this->diffuseid;
293  }
294  SbBool transpMatch(const SbUniqueId nodeid) const {
295  return nodeid == this->transpid;
296  }
297  void setNodeIds(const SbUniqueId diffuse, const SbUniqueId transp) {
298  this->diffuseid = diffuse;
299  this->transpid = transp;
300  }
301  int32_t getSize(void) const {
302  return this->arraysize;
303  }
304  void reallocate(const int32_t size);
305 
306  SbUniqueId getDiffuseId(void) const {
307  return this->diffuseid;
308  }
309  SbUniqueId getTranspId(void) const {
310  return this->transpid;
311  }
312 private:
313  SbUniqueId transpid;
314  SbUniqueId diffuseid;
315  uint32_t * array;
316  int32_t arraysize;
317 };
318 
319 #endif // !COIN_SOLAZYELEMENT_H
The SoMFFloat class is a container for floating point values.
Definition: SoMFFloat.h:39
The SbColor class contains the red, green and blue components which make up a color value...
Definition: SbColor.h:39
The SoMFColor class is a container for SbColor values.
Definition: SoMFColor.h:40
static void initClass(void)
Definition: SoElement.cpp:506
virtual SbBool matches(const SoElement *element) const =0
Definition: SoElement.cpp:608
virtual void push(SoState *state)
Definition: SoElement.cpp:569
The SoNode class is the base class for nodes used in scene graphs.
Definition: SoNode.h:56
SoElement is the abstract base class for all elements.
Definition: SoElement.h:43
The SoState class manages the Coin scenegraph traversal state data.
Definition: SoState.h:44
virtual void init(SoState *state)
Definition: SoElement.cpp:552
Definition: SoLazyElement.h:210
virtual SoElement * copyMatchInfo(void) const =0
Definition: SoLazyElement.h:283
The SoLazyElement class is used to handle material and shape properties.
Definition: SoLazyElement.h:48