Coin: SoLazyElement.h Source File

| Coin3D is Free Software, published under the BSD 3-clause license. | https://coin3d.github.io https://www.kongsberg.com/en/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
40class SoMFFloat;
41class SoMFColor;
42class SoColorPacker;
43class 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
53public:
54 static void initClass();
55protected:
56 ~SoLazyElement();
57public:
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
208protected:
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
241protected:
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
278private:
279 SoLazyElementP * pimpl; // for future use
280
281};
282
283 class COIN_DLL_API SoColorPacker {
284public:
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 }
312private:
313 SbUniqueId transpid;
314 SbUniqueId diffuseid;
315 uint32_t * array;
316 int32_t arraysize;
317};
318
319#endif // !COIN_SOLAZYELEMENT_H
SbColor
The SbColor class contains the red, green and blue components which make up a color value.
Definition SbColor.h:39
SoColorPacker
Definition SoLazyElement.h:283
SoElement
SoElement is the abstract base class for all elements.
Definition SoElement.h:43
SoElement::matches
virtual SbBool matches(const SoElement *element) const =0
Definition SoElement.cpp:609
SoElement::initClass
static void initClass(void)
Definition SoElement.cpp:507
SoElement::copyMatchInfo
virtual SoElement * copyMatchInfo(void) const =0
SoElement::init
virtual void init(SoState *state)
Definition SoElement.cpp:553
SoElement::push
virtual void push(SoState *state)
Definition SoElement.cpp:570
SoLazyElement
The SoLazyElement class is used to handle material and shape properties.
Definition SoLazyElement.h:48
SoMFColor
The SoMFColor class is a container for SbColor values.
Definition SoMFColor.h:40
SoMFFloat
The SoMFFloat class is a container for floating point values.
Definition SoMFFloat.h:39
SoNode
The SoNode class is the base class for nodes used in scene graphs.
Definition SoNode.h:56
SoState
The SoState class manages the Coin scene graph traversal state data.
Definition SoState.h:44
SoLazyElement::CoinState
Definition SoLazyElement.h:210