1 #ifndef COIN_SOOVERRIDEELEMENT_H 
    2 #define COIN_SOOVERRIDEELEMENT_H 
   27 #include <Inventor/elements/SoSubElement.h> 
   28 #include <Inventor/system/inttypes.h> 
   43     AMBIENT_COLOR     = 0x00000001,
 
   44     COLOR_INDEX       = 0x00000002,
 
   45     COMPLEXITY        = 0x00000004,
 
   46     COMPLEXITY_TYPE   = 0x00000008,
 
   47     CREASE_ANGLE      = 0x00000010,
 
   48     DIFFUSE_COLOR     = 0x00000020,
 
   49     DRAW_STYLE        = 0x00000040,
 
   50     EMISSIVE_COLOR    = 0x00000080,
 
   51     FONT_NAME         = 0x00000100,
 
   52     FONT_SIZE         = 0x00000200,
 
   53     LIGHT_MODEL       = 0x00000400,
 
   54     LINE_PATTERN      = 0x00000800,
 
   55     LINE_WIDTH        = 0x00001000,
 
   56     MATERIAL_BINDING  = 0x00002000,
 
   57     POINT_SIZE        = 0x00004000,
 
   58     PICK_STYLE        = 0x00008000,
 
   59     SHAPE_HINTS       = 0x00010000,
 
   60     SHININESS         = 0x00020000,
 
   61     SPECULAR_COLOR    = 0x00040000,
 
   62     POLYGON_OFFSET    = 0x00080000,
 
   63     TRANSPARENCY      = 0x00100000,
 
   64     TRANSPARENCY_TYPE = 0x00200000, 
 
   65     NORMAL_VECTOR     = 0x00400000,
 
   66     NORMAL_BINDING    = 0x00800000
 
   76   static uint32_t getFlags(
SoState * 
const state) {
 
   77     return (static_cast<const SoOverrideElement*>(
getConstElement(state, classStackIndex)))->flags;
 
   80   static SbBool getAmbientColorOverride(
SoState * 
const state);
 
   81   static SbBool getColorIndexOverride(
SoState * 
const state);
 
   82   static SbBool getComplexityOverride(
SoState * 
const state);
 
   83   static SbBool getComplexityTypeOverride(
SoState * 
const state);
 
   84   static SbBool getCreaseAngleOverride(
SoState * 
const state);
 
   85   static SbBool getDiffuseColorOverride(
SoState * 
const state);
 
   86   static SbBool getDrawStyleOverride(
SoState * 
const state);
 
   87   static SbBool getEmissiveColorOverride(
SoState * 
const state);
 
   88   static SbBool getFontNameOverride(
SoState * 
const state);
 
   89   static SbBool getFontSizeOverride(
SoState * 
const state);
 
   90   static SbBool getLightModelOverride(
SoState * 
const state);
 
   91   static SbBool getLinePatternOverride(
SoState * 
const state);
 
   92   static SbBool getLineWidthOverride(
SoState * 
const state);
 
   93   static SbBool getMaterialBindingOverride(
SoState * 
const state);
 
   94   static SbBool getPickStyleOverride(
SoState * 
const state);
 
   95   static SbBool getPointSizeOverride(
SoState * 
const state);
 
   96   static SbBool getPolygonOffsetOverride(
SoState * 
const state);
 
   97   static SbBool getShapeHintsOverride(
SoState * 
const state);
 
   98   static SbBool getShininessOverride(
SoState * 
const state);
 
   99   static SbBool getSpecularColorOverride(
SoState * 
const state);
 
  100   static SbBool getTransparencyOverride(
SoState * 
const state);
 
  101   static SbBool getTransparencyTypeOverride(
SoState * 
const state);
 
  102   static SbBool getNormalVectorOverride(
SoState * 
const state);
 
  103   static SbBool getNormalBindingOverride(
SoState * 
const state);
 
  105   static void setAmbientColorOverride(
SoState * 
const state,
 
  107                                       const SbBool 
override);
 
  108   static void setColorIndexOverride(
SoState * 
const state,
 
  110                                     const SbBool 
override);
 
  111   static void setComplexityOverride(
SoState * 
const state,
 
  113                                     const SbBool 
override);
 
  114   static void setComplexityTypeOverride(
SoState * 
const state,
 
  116                                         const SbBool 
override);
 
  117   static void setCreaseAngleOverride(
SoState * 
const state,
 
  119                                      const SbBool 
override);
 
  120   static void setDiffuseColorOverride(
SoState * 
const state,
 
  122                                       const SbBool 
override);
 
  123   static void setDrawStyleOverride(
SoState * 
const state,
 
  125                                    const SbBool 
override);
 
  126   static void setEmissiveColorOverride(
SoState * 
const state,
 
  128                                        const SbBool 
override);
 
  129   static void setFontNameOverride(
SoState * 
const state,
 
  131                                   const SbBool 
override);
 
  132   static void setFontSizeOverride(
SoState * 
const state,
 
  134                                   const SbBool 
override);
 
  135   static void setLightModelOverride(
SoState * 
const state,
 
  137                                     const SbBool 
override);
 
  138   static void setLinePatternOverride(
SoState * 
const state,
 
  140                                      const SbBool 
override);
 
  141   static void setLineWidthOverride(
SoState * 
const state,
 
  143                                    const SbBool 
override);
 
  144   static void setMaterialBindingOverride(
SoState * 
const state,
 
  146                                          const SbBool 
override);
 
  147   static void setPickStyleOverride(
SoState * 
const state,
 
  149                                    const SbBool 
override);
 
  150   static void setPointSizeOverride(
SoState * 
const state,
 
  152                                    const SbBool 
override);
 
  153   static void setPolygonOffsetOverride(
SoState * 
const state,
 
  155                                        const SbBool 
override);
 
  156   static void setShapeHintsOverride(
SoState * 
const state,
 
  158                                     const SbBool 
override);
 
  159   static void setShininessOverride(
SoState * 
const state,
 
  161                                    const SbBool 
override);
 
  162   static void setSpecularColorOverride(
SoState * 
const state,
 
  164                                        const SbBool 
override);
 
  165   static void setTransparencyOverride(
SoState * 
const state,
 
  167                                       const SbBool 
override);
 
  168   static void setTransparencyTypeOverride(
SoState * 
const state,
 
  170                                           const SbBool 
override);
 
  171   static void setNormalVectorOverride(
SoState * 
const state,
 
  173                                       const SbBool 
override);
 
  174   static void setNormalBindingOverride(
SoState * 
const state,
 
  176                                        const SbBool 
override);
 
  178   virtual void print(FILE * file) 
const;
 
  185 #endif // !COIN_SOOVERRIDEELEMENT_H 
FlagBits
Definition: SoOverrideElement.h:42
static const SoElement * getConstElement(SoState *const state, const int stackIndex)
Definition: SoElement.h:114
static void initClass(void)
Definition: SoElement.cpp:507
virtual SbBool matches(const SoElement *element) const =0
Definition: SoElement.cpp:609
virtual void push(SoState *state)
Definition: SoElement.cpp:570
virtual void print(FILE *file=stdout) const 
Definition: SoElement.cpp:595
The SoNode class is the base class for nodes used in scene graphs.Coin is a retained mode 3D visualiz...
Definition: SoNode.h:47
SoElement is the abstract base class for all elements. 
Definition: SoElement.h:34
The SoOverrideElement maintains a list of overridable elements and a list over which elements should ...
Definition: SoOverrideElement.h:32
The SoState class manages the Coin scenegraph traversal state data.The SoState class is used by actio...
Definition: SoState.h:35
virtual void init(SoState *state)
Definition: SoElement.cpp:553
virtual SoElement * copyMatchInfo(void) const =0
The SoType class is the basis for the run-time type system in Coin.Many of the classes in the Coin li...
Definition: SoType.h:50