Source

Coin / src / nodes / SoShapeHints.cpp

Full commit
Morten Eriksen 08431c9 
Marius Kintel 3ba6b41 




























Morten Eriksen 08431c9 



Morten Eriksen b007b08 
Morten Eriksen 08431c9 

Morten Eriksen b007b08 



Jostein 6f8b04d 

















































Morten Eriksen b007b08 











Morten Eriksen 6d3a809 








Morten Eriksen 04053cf 
Morten Eriksen 6d3a809 

Peder Blekken 60d3767 
Morten Eriksen 04053cf 


Peder Blekken 60d3767 
Morten Eriksen 6d3a809 
Morten Eriksen 04053cf 
Peder Blekken 60d3767 

Morten Eriksen 6d3a809 

Peder Blekken 5e899d2 





Morten Eriksen 37c5269 
Morten Eriksen b60274e 

Morten Eriksen 37c5269 





Morten Eriksen b60274e 
Morten Eriksen 08431c9 

Morten Eriksen 37c5269 
Morten Eriksen f9a2eff 
Morten Eriksen b007b08 
Lars J. Aas 92263e4 
Morten Eriksen b007b08 
Morten Eriksen 08431c9 
Morten Eriksen 310dd16 
Morten Eriksen b007b08 
Morten Eriksen 08431c9 
Morten Eriksen 310dd16 
Morten Eriksen 08431c9 
Lars J. Aas 92263e4 

Morten Eriksen 37c5269 
Morten Eriksen 3523436 
Morten Eriksen 08431c9 

Morten Eriksen b007b08 


Morten Eriksen 08431c9 


Morten Eriksen b007b08 

Morten Eriksen 08431c9 


Morten Eriksen b007b08 
Morten Eriksen 4644f41 
Morten Eriksen 08431c9 


Morten Eriksen b007b08 
Morten Eriksen 4644f41 
Morten Eriksen 08431c9 



Morten Eriksen b007b08 
Morten Eriksen 08431c9 


Morten Eriksen b007b08 
Morten Eriksen 08431c9 


Morten Eriksen b007b08 

Morten Eriksen 04053cf 

Morten Eriksen 08431c9 



Morten Eriksen b007b08 
Morten Eriksen 08431c9 


Morten Eriksen b007b08 
Morten Eriksen 04053cf 





















Morten Eriksen 08431c9 


Morten Eriksen b007b08 

Morten Eriksen 03ff79a 
Morten Eriksen c811563 



Morten Eriksen 08431c9 




Morten Eriksen b007b08 







Morten Eriksen 08431c9 


Morten Eriksen b007b08 


Morten Eriksen 08431c9 


Morten Eriksen b007b08 


Morten Eriksen 08431c9 


Morten Eriksen b007b08 







Peder Blekken 60d3767 


Morten Eriksen 08431c9 



Morten Eriksen f9a2eff 
Morten Eriksen 08431c9 



Morten Eriksen b007b08 
Morten Eriksen 08431c9 
Morten Eriksen c36f67e 
Morten Eriksen 08431c9 
Morten Eriksen b007b08 



Morten Eriksen b66cdde 
Morten Eriksen 08431c9 






















Morten Eriksen 70c4e7d 
Morten Eriksen 08431c9 


Peder Blekken 6c32f39 
Morten Eriksen 08431c9 
Morten Eriksen b007b08 




Morten Eriksen 08431c9 
Morten Eriksen b007b08 
Morten Eriksen 310dd16 
Morten Eriksen 08431c9 

Morten Eriksen b66cdde 
Morten Eriksen 08431c9 

Morten Eriksen b007b08 
Morten Eriksen 310dd16 


Morten Eriksen b66cdde 
Morten Eriksen 310dd16 




Morten Eriksen b66cdde 
Morten Eriksen b007b08 

Morten Eriksen dd1af9f 



Morten Eriksen b007b08 

Morten Eriksen dd1af9f 



Morten Eriksen b007b08 

Morten Eriksen dd1af9f 



Morten Eriksen 08431c9 
Morten Eriksen b66cdde 

Morten Eriksen b007b08 
Peder Blekken cf50a1f 









Morten Eriksen dd1af9f 



Morten Eriksen 310dd16 
Morten Eriksen 08431c9 

Morten Eriksen b66cdde 
Morten Eriksen 08431c9 

Morten Eriksen b007b08 
Morten Eriksen 08431c9 

Morten Eriksen b66cdde 
Morten Eriksen 08431c9 

Morten Eriksen b007b08 
Morten Eriksen 08431c9 

Morten Eriksen b66cdde 
Morten Eriksen 08431c9 

Morten Eriksen b007b08 
Morten Eriksen 08431c9 

Morten Eriksen b66cdde 
Morten Eriksen 08431c9 

Morten Eriksen b007b08 
Morten Eriksen 08431c9 
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
/**************************************************************************\
 * Copyright (c) Kongsberg Oil & Gas Technologies AS
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 * 
 * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 * 
 * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 * 
 * Neither the name of the copyright holder nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\**************************************************************************/

/*!
  \class SoShapeHints SoShapeHints.h Inventor/nodes/SoShapeHints.h
  \brief The SoShapeHints class is a node containing hints about how to render geometry.
  \ingroup nodes

  The SoShapeHints node is used to set up clues to the rendering
  subsystem about how particular aspects of the subsequent geometry in
  the scene graph should be drawn.

  Here is an example on how to display a scene in wireframe mode
  which only shows the triangles facing towards the camera.

  \code
  #include <Inventor/nodes/SoCone.h>
  #include <Inventor/nodes/SoDrawStyle.h>
  #include <Inventor/nodes/SoLightModel.h>
  #include <Inventor/nodes/SoSeparator.h>
  #include <Inventor/nodes/SoShapeHints.h>
  #include <Inventor/Win/SoWin.h>
  #include <Inventor/Win/viewers/SoWinExaminerViewer.h>

  int main(int, char * argv[])
  {
    HWND window = SoWin::init(argv[0]);

    SoSeparator * root = new SoSeparator;

    // wireframe
    SoDrawStyle * drawStyle = new SoDrawStyle;
    drawStyle->style = SoDrawStyle::LINES;
    root->addChild(drawStyle);

    // back-face culling
    SoShapeHints * shapeHints = new SoShapeHints;
    shapeHints->vertexOrdering = SoShapeHints::COUNTERCLOCKWISE;
    shapeHints->shapeType = SoShapeHints::SOLID;
    root->addChild(shapeHints);

    // keep a solid color
    SoLightModel * lightModel = new SoLightModel;
    lightModel->model = SoLightModel::BASE_COLOR;
    root->addChild(lightModel);

    // a cone
    SoCone * cone = new SoCone;
    root->addChild(cone);

    // set up a window
    SoWinExaminerViewer * viewer = new SoWinExaminerViewer(window);
    SbViewportRegion vpRegion = viewer->getViewportRegion();
    viewer->setSceneGraph(root);
    viewer->show();

    SoWin::mainLoop();
    delete viewer;
    return 0;
  }
  \endcode

  The default settings of the rendering system is tuned towards
  programmer convenience. For instance, the default is to render both
  sides of all polygons to make sure we avoid any "holes" in the
  geometry if the vertex ordering should happen to differ for
  different polygons.

  If the programmer gives up some of this convenience and uses
  SoShapeHints nodes to more closely specify information about the
  scene graph geometry, the clues given by the SoShapeHints node(s)
  will then be used by the rendering subsystem to avoid certain costly
  operations. Significant gains in rendering speed could be seen as a
  result.

  Be aware that the way backface culling and two-sided lighting is
  decided by the rendering system is not at all intuitive.  Here are
  the common rules of how primitive shapes will render themselves with
  regard to how the SoShapeHints::vertexOrdering and
  SoShapeHints::shapeType fields are set:

  <ul>

  <li>vertexOrdering == CLOCKWISE or COUNTERCLOCKWISE, shapeType ==
      SOLID: causes primitives to be backface culled and rendered with
      one-sided lighting.

  <li>vertexOrdering == CLOCKWISE or COUNTERCLOCKWISE, shapeType ==
      UNKNOWN_SHAPE_TYPE: primitives are \e not backface culled, and
      they are rendered with two-sided lighting.

  <li>vertexOrdering == UNKNOWN_ORDERING, any shapeType: primitives
      are \e not backface culled, and they are rendered with one-sided
      lighting. The OpenGL vertex ordering will be set to counter clockwise
      ordering.
  </ul>

  The UNKNOWN_ORDERING enum has a special and non-intuitive meaning.
  The ordering is really set to counter clockwise -- in OpenGL and
  when generating normals. However, if you want to render your
  geometry with one-sided lighting and backface culling disabled, you
  have to use this enum value, and your polygons need to be in counter
  clockwise ordering.

  <b>FILE FORMAT/DEFAULTS:</b>
  \code
    ShapeHints {
        vertexOrdering UNKNOWN_ORDERING
        shapeType UNKNOWN_SHAPE_TYPE
        faceType CONVEX
        creaseAngle 0
    }
  \endcode
*/

// *************************************************************************

#include <Inventor/actions/SoCallbackAction.h>

#include <Inventor/actions/SoGLRenderAction.h>
#include <Inventor/actions/SoGetBoundingBoxAction.h>
#include <Inventor/actions/SoPickAction.h>
#include <Inventor/elements/SoCreaseAngleElement.h>
#include <Inventor/elements/SoGLShapeHintsElement.h>
#include <Inventor/elements/SoOverrideElement.h>

#include "nodes/SoSubNodeP.h"

// *************************************************************************

/*!
  \enum SoShapeHints::VertexOrdering

  Enumeration of available ways to specify ordering of vertices for a
  polygon.
*/
/*!
  \var SoShapeHints::VertexOrdering SoShapeHints::UNKNOWN_ORDERING

  Ordering not known, render both sides of the polygon.
*/
/*!
  \var SoShapeHints::VertexOrdering SoShapeHints::CLOCKWISE

  Vertices are specified in a clockwise order.
*/
/*!
  \var SoShapeHints::VertexOrdering SoShapeHints::COUNTERCLOCKWISE

  Vertices are specified in a counter-clockwise order.
*/

/*!
  \enum SoShapeHints::ShapeType
  Enumeration of different shape types.
*/
/*!
  \var SoShapeHints::ShapeType SoShapeHints::UNKNOWN_SHAPE_TYPE
  Nothing known about the shape, be conservative when rendering.
*/
/*!
  \var SoShapeHints::ShapeType SoShapeHints::SOLID

  The subsequent shapes in the graph are all known to be completely
  "closed", solid 3D shapes. Backface culling will be done if
  vertexOrdering is known.
*/

/*!
  \enum SoShapeHints::FaceType
  Enumeration of polygon face types.
*/
/*!
  \var SoShapeHints::FaceType SoShapeHints::UNKNOWN_FACE_TYPE

  Signifies: nothing is known about subsequent polygon data, be
  conservative when rendering.

  All polygons in the scene will be analyzed to see if they needs to
  be tessellated (broken up) into triangles before passed on to the
  underlying immediate mode rendering system.

  The OpenGL rendering system handles most complex polygon types, but
  not all: it can for instance have problems with many-sided, concave
  polygons (concave polygons are "hollow", that is: rounded
  inwards). Coin's internal tessellator will most often handle the
  cases that OpenGL fails on.

  So if you are seeing weird artifacts in how complex polygons are
  rendered, try to change the SoShapeHints::faceType field to this
  value and see if they are then rendered correctly.

  Beware that turning on this functionality might have the effect of
  making the rendering performance worse. If it has a noticable effect
  on your particular scenegraph, we advise that you investigate
  whether you could change how the polygons are generated for Coin
  rendering and then avoid using this flag.
*/
/*!
  \var SoShapeHints::FaceType SoShapeHints::CONVEX

  Subsequent faces are all convex, so turn off the check for and
  tessellation of inconvex faces.

  Subsequent polygons from faceset-type nodes (like SoFaceSet and
  SoIndexedFaceSet) will be sent unmodified to OpenGL, thereby
  assuming that the polygons are in a form handled by OpenGL.
*/


/*!
  \var SoSFEnum SoShapeHints::vertexOrdering

  Specifies how vertices are ordered for polygon faces.

  Set this field to SoShapeHints::CLOCKWISE or
  SoShapeHints::COUNTERCLOCKWISE if possible to turn on backface
  culling and thereby optimize rendering.

  Default value is SoShapeHints::UNKNOWN_ORDERING.
*/
/*!
  \var SoSFEnum SoShapeHints::shapeType

  Hint about whether or not shapes are known to be "closed".  Default
  value is SoShapeHints::UNKNOWN_SHAPE_TYPE.
*/
/*!
  \var SoSFEnum SoShapeHints::faceType

  Hint about whether or not polygon faces are known to be convex.
  Default value is SoShapeHints::CONVEX.
*/
/*!
  \var SoSFFloat SoShapeHints::creaseAngle

  When normals are automatically generated by Coin (i.e. SoNormal
  nodes are not used), this is the smallest angle between two faces
  where we would still calculate normals to do flatshading.

  If the angle between the normals of two neighboring faces is less
  than the value of this field, the faces will be smoothshaded around
  their common edge.
  
  The angle is specified in radians, and the default value is 0.0, 
  meaning no smoothing will be done by default.
*/

// *************************************************************************

SO_NODE_SOURCE(SoShapeHints);

/*!
  Constructor.
*/
SoShapeHints::SoShapeHints(void)
{
  SO_NODE_INTERNAL_CONSTRUCTOR(SoShapeHints);

  SO_NODE_ADD_FIELD(vertexOrdering, (UNKNOWN_ORDERING));
  SO_NODE_ADD_FIELD(shapeType, (UNKNOWN_SHAPE_TYPE));
  SO_NODE_ADD_FIELD(faceType, (CONVEX));
  SO_NODE_ADD_FIELD(creaseAngle, (0.0f));

  SO_NODE_DEFINE_ENUM_VALUE(VertexOrdering, UNKNOWN_ORDERING);
  SO_NODE_DEFINE_ENUM_VALUE(VertexOrdering, CLOCKWISE);
  SO_NODE_DEFINE_ENUM_VALUE(VertexOrdering, COUNTERCLOCKWISE);

  SO_NODE_DEFINE_ENUM_VALUE(ShapeType, UNKNOWN_SHAPE_TYPE);
  SO_NODE_DEFINE_ENUM_VALUE(ShapeType, SOLID);

  SO_NODE_DEFINE_ENUM_VALUE(FaceType, UNKNOWN_FACE_TYPE);
  SO_NODE_DEFINE_ENUM_VALUE(FaceType, CONVEX);

  SO_NODE_SET_SF_ENUM_TYPE(vertexOrdering, VertexOrdering);
  SO_NODE_SET_SF_ENUM_TYPE(shapeType, ShapeType);
  SO_NODE_SET_SF_ENUM_TYPE(faceType, FaceType);

}

/*!
  Destructor.
*/
SoShapeHints::~SoShapeHints()
{
}

// doc in super
void
SoShapeHints::initClass(void)
{
  SO_NODE_INTERNAL_INIT_CLASS(SoShapeHints, SO_FROM_INVENTOR_2_0|SoNode::VRML1);

  SO_ENABLE(SoCallbackAction, SoCreaseAngleElement);
  SO_ENABLE(SoCallbackAction, SoShapeHintsElement);
  SO_ENABLE(SoGLRenderAction, SoCreaseAngleElement);
  SO_ENABLE(SoGLRenderAction, SoGLShapeHintsElement);
  SO_ENABLE(SoGetBoundingBoxAction, SoCreaseAngleElement);
  SO_ENABLE(SoGetBoundingBoxAction, SoShapeHintsElement);
  SO_ENABLE(SoPickAction, SoCreaseAngleElement);
  SO_ENABLE(SoPickAction, SoShapeHintsElement);
}

void
SoShapeHints::doAction(SoAction * action)
{
  SoState * state = action->getState();

  uint32_t flags = SoOverrideElement::getFlags(state);
#define TEST_OVERRIDE(bit) ((SoOverrideElement::bit & flags) != 0)

  // store current values, in case some are overridden or ignored
  SoShapeHintsElement::VertexOrdering vo;
  SoShapeHintsElement::ShapeType st;
  SoShapeHintsElement::FaceType ft;
  SoShapeHintsElement::get(state, vo, st, ft);

  if (!this->vertexOrdering.isIgnored() && !TEST_OVERRIDE(SHAPE_HINTS)) {
    vo = (SoShapeHintsElement::VertexOrdering) this->vertexOrdering.getValue();
    if (this->isOverride()) {
      SoOverrideElement::setShapeHintsOverride(state, this, TRUE);
    }
  }
  if (!this->shapeType.isIgnored() && !TEST_OVERRIDE(SHAPE_HINTS)) {
    st = (SoShapeHintsElement::ShapeType) this->shapeType.getValue();
    if (this->isOverride()) {
      SoOverrideElement::setShapeHintsOverride(state, this, TRUE);
    }
  }
  if (!this->faceType.isIgnored() && !TEST_OVERRIDE(SHAPE_HINTS)) {
    ft = (SoShapeHintsElement::FaceType) this->faceType.getValue();
    if (this->isOverride()) {
      SoOverrideElement::setShapeHintsOverride(state, this, TRUE);
    }
  }
  SoShapeHintsElement::set(action->getState(), this,
                           vo, st, ft);

  if (!this->creaseAngle.isIgnored() && !TEST_OVERRIDE(CREASE_ANGLE)) {
    float ca = this->creaseAngle.getValue();
    // Fix to handle VRML1 ShapeHints nodes correctly. The default
    // creaseAngle value for VRML1 is 0.5, while it's 0.0 for
    // Inventor 2.1
    if (this->creaseAngle.isDefault() &&
        (this->getNodeType() == SoNode::VRML1) &&
        (ca == 0.0f)) {
      ca = 0.5f;
    }
    SoCreaseAngleElement::set(state, this, ca);
    if (this->isOverride()) {
      SoOverrideElement::setCreaseAngleOverride(state, this, TRUE);
    }
  }
#undef TEST_OVERRIDE
}

void
SoShapeHints::GLRender(SoGLRenderAction * action)
{
  SoShapeHints::doAction(action);
}

void
SoShapeHints::callback(SoCallbackAction * action)
{
  SoShapeHints::doAction(action);
}

void
SoShapeHints::pick(SoPickAction * action)
{
  SoShapeHints::doAction(action);
}

void
SoShapeHints::getBoundingBox(SoGetBoundingBoxAction * action)
{
  SoShapeHints::doAction(action);
}