Inventor/elements/SoLazyElement.h

Go to the documentation of this file.

/*=======================================================================
 * Copyright 1991-1996, Silicon Graphics, Inc.
 * ALL RIGHTS RESERVED
 *
 * UNPUBLISHED -- Rights reserved under the copyright laws of the United
 * States.   Use of a copyright notice is precautionary only and does not
 * imply publication or disclosure.
 *
 * U.S. GOVERNMENT RESTRICTED RIGHTS LEGEND:
 * Use, duplication or disclosure by the Government is subject to restrictions
 * as set forth in FAR 52.227.19(c)(2) or subparagraph (c)(1)(ii) of the Rights
 * in Technical Data and Computer Software clause at DFARS 252.227-7013 and/or
 * in similar or successor clauses in the FAR, or the DOD or NASA FAR
 * Supplement.  Contractor/manufacturer is Silicon Graphics, Inc.,
 * 2011 N. Shoreline Blvd. Mountain View, CA 94039-7311.
 *
 * THE CONTENT OF THIS WORK CONTAINS CONFIDENTIAL AND PROPRIETARY
 * INFORMATION OF SILICON GRAPHICS, INC. ANY DUPLICATION, MODIFICATION,
 * DISTRIBUTION, OR DISCLOSURE IN ANY FORM, IN WHOLE, OR IN PART, IS STRICTLY
 * PROHIBITED WITHOUT THE PRIOR EXPRESS WRITTEN PERMISSION OF SILICON
 * GRAPHICS, INC.
**=======================================================================*/
/*=======================================================================
** Author      : Alan Norton (MMM yyyy)
** Modified by : Gavin Bell (MMM yyyy)
**=======================================================================*/
/*=======================================================================
 *** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
 ***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
 ***                                                                                ***
 ***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
 ***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
 ***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
 ***                                                                                ***
 ***                        RESTRICTED RIGHTS LEGEND                                ***
 ***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
 ***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
 ***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
 ***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
 ***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
 ***                                                                                ***
 ***                   COPYRIGHT (C) 1996-2020 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Modified by : VSG (MMM YYYY)
**=======================================================================*/


#ifndef _SO_LAZY_ELEMENT
#define _SO_LAZY_ELEMENT

#include <Inventor/SbBasic.h>
#include <Inventor/SbColor.h>
#include <Inventor/elements/SoElement.h>
#include <Inventor/elements/SoSubElement.h>
#include <math.h>

class SoMFFloat;
class SoMFColor;
class SoColorPacker;
class SbThreadMutex;

#define SO_LAZY_SHINY_THRESHOLD 0.005

#define SO_LAZY_NUM_COMPONENTS 12

SoEXTENDER_Documented class  SoLazyElement : public SoElement {

  SO_ELEMENT_HEADER(SoLazyElement);

 public:
 enum cases {
   LIGHT_MODEL_CASE = 0,
   COLOR_MATERIAL_CASE = 1,
   DIFFUSE_CASE = 2,
   AMBIENT_CASE = 3,
   EMISSIVE_CASE = 4,
   SPECULAR_CASE = 5,
   SHININESS_CASE = 6,
   BLENDING_CASE = 7,
   TRANSPARENCY_CASE = 8,
   PATTERN_CASE = 9,
   SMOOTHING_CASE = 10,
   LINE_WIDTH_CASE = 11
  };

 enum masks {
   LIGHT_MODEL_MASK = 1 << LIGHT_MODEL_CASE,
   COLOR_MATERIAL_MASK = 1 << COLOR_MATERIAL_CASE,
   DIFFUSE_MASK = 1 << DIFFUSE_CASE,
   AMBIENT_MASK = 1 << AMBIENT_CASE,
   EMISSIVE_MASK = 1 << EMISSIVE_CASE,
   SPECULAR_MASK = 1 << SPECULAR_CASE,
   SHININESS_MASK = 1 << SHININESS_CASE,
   TRANSPARENCY_MASK = 1 << TRANSPARENCY_CASE,
   BLENDING_MASK = 1 << BLENDING_CASE,
   SMOOTHING_MASK = 1 << SMOOTHING_CASE,
   ALL_MASK = (1 << SO_LAZY_NUM_COMPONENTS)-1,
   PATTERN_MASK = 1 << PATTERN_CASE,
   LINE_WIDTH_MASK = 1 << LINE_WIDTH_CASE
 };

  enum LightModel {
    BASE_COLOR = 0,
    PHONG = 1
  };

  static void setDiffuse(SoState *state,
                         SoNode *node,
                         int32_t numColors,
                         const SbColor *colors,
                         SoColorPacker *cPacker);
  static void setTransparency(SoState *state,
                              SoNode *node,
                              int32_t numTransp,
                              const float *transp,
                              SoColorPacker *cPacker);
  static void setPacked(SoState *state,
                        SoNode *node,
                        SoColorPacker *cPacker,
                        int32_t numColors,
                        const uint32_t *colors);
  static void setColorIndices(SoState *state,
                              SoNode *node,
                              int32_t numIndices,
                              const int32_t *indices);

#if 1             SoDEPRECATED
  static void setAmbient(SoState *state, const SbColor *color)
  { setAmbient(state,*color); }SoDEPRECATED
  static void setEmissive(SoState *state, const SbColor *color)
  { setEmissive(state,*color); }SoDEPRECATED
  static void setSpecular(SoState *state, const SbColor *color)
  { setSpecular(state,*color); }

#endif 
  static void setAmbient(SoState *state, const SbColor &color);
  static void setEmissive(SoState *state, const SbColor &color);
  static void setSpecular(SoState *state, const SbColor &color);

  static void setShininess(SoState *state, float value);
  static void setColorMaterial(SoState *state, SbBool value);
  static void setBlending(SoState *state, SbBool value);
  static void setSmoothing(SoState *state, SbBool value);
  static void setLightModel(SoState *state, const int32_t model);

  static const SbColor &getDiffuse(SoState *state, int index);
  static float getTransparency(SoState *, int index);
  static const uint32_t *getPackedColors(SoState *state);
  static const int32_t *getColorIndices(SoState *state);
  static int32_t getColorIndex(SoState *, int num);
  static const SbColor &getAmbient(SoState *);
  static const SbColor &getEmissive(SoState *);
  static const SbColor &getSpecular(SoState *);
  static float getShininess(SoState *);
  static SbBool getColorMaterial(SoState *);
  static SbBool getBlending(SoState *);
  static SbBool getSmoothing(SoState *);
  static int32_t getLightModel(SoState *);

  int32_t getNumDiffuse() const {
    return ivState.numDiffuseColors;
  }
  int32_t getNumTransparencies() const {
    return ivState.numTransparencies;
  }
  int32_t getNumColorIndices() const {
    return (ivState.colorIndices ? ivState.numDiffuseColors : 0);
  }
  SbBool isPacked() const {
    return ivState.packed;
  }
  SbBool isTransparent() const;

  static SoLazyElement *getInstance(SoState *state) {
    return (SoLazyElement *)(state->getElementNoPush(SoLazyElement::getClassTypeId(), getClassStackIndex()));
  }
   static float getDefaultAmbientIntensity() {
    return 0.2F;
  }

  static SbColor getDefaultDiffuse() {
    return SbColor(0.8F, 0.8F, 0.8F);
  }
   static SbColor getDefaultAmbient() {
    return SbColor(0.2F, 0.2F, 0.2F);
  }
   static SbColor getDefaultSpecular() {
    return SbColor(0.0F, 0.0F, 0.0F);
  }
   static SbColor getDefaultEmissive() {
    return SbColor(0.0F, 0.0F, 0.0F);
  }
   static float getDefaultShininess() {
    return 0.2F;
  }
   static uint32_t getDefaultPackedInternal();
   static uint32_t getDefaultPacked() {
    return (0xccccccff);
  }
   static float getDefaultTransparency() {
    return 0.0F;
  }
   static int32_t getDefaultLightModel() {
    return PHONG;
  }
   static int32_t getDefaultColorIndex() {
    return 1;
  }
   static float getDefaultLineWidth() {
     return 0.0f;
   }
  virtual void push(SoState *state);

private:

  virtual void commonInit();

  virtual void init(SoState *state);

  virtual SbBool matches(const SoElement *) const;

  virtual SoElement* copyMatchInfo() const;

 private:

  // set method for use in SoMaterial nodes:
  static void setMaterials(SoState *state,
                           SoNode *node,
                           uint32_t bitmask,
                           SoColorPacker *cPacker,
                           const SoMFColor &diffuse,
                           const SoMFFloat &transp,
                           const SoMFColor &ambient,
                           const SoMFColor &emissive,
                           const SoMFColor &specular,
                           const SoMFFloat &shininess);

  // set method for use in SoMaterial nodes:
  static void setMaterials(SoState *state,
                           SoNode *node,
                           uint32_t bitmask,
                           SoColorPacker *cPacker,
                           SoMFColor *diffuse,
                           SoMFFloat *transp,
                           SoMFColor *ambient,
                           SoMFColor *emissive,
                           SoMFColor *specular,
                           SoMFFloat *shininess);

  //Get a Writable instance, so will force a push if needed:
  static SoLazyElement  *getWInstance(SoState *state) {
    return state->getElement<SoLazyElement>();
  }

  // Prints element (for debugging)
  virtual void print(FILE *fp) const;

  // Initializes the SoLazyElement class
  static void initClass();
  static void exitClass();

  //Following SoINTERNAL get() methods do NOT cause cache dependency, should
  //only be invoked by nodes that use the reallySend method on SoGLLazyElement
  //to establish correct cache dependencies by tracking what was actually
  //sent to GL.
  const uint32_t *getPackedPointer() const {
    return ivState.packedColors;
  }
  const SbColor *getDiffusePointer() const {
    return ivState.diffuseColors;
  }
  const int32_t *getColorIndexPointer() const {
    return ivState.colorIndices;
  }
  const float *getTransparencyPointer() const {
    return ivState.transparencies;
  }

  // set method for transparency type is SoINTERNAL, because it should
  // only be invoked by SoGLRenderAction
  static void setTransparencyType(SoState *state, int32_t type);

  // return true if the transparency is usefull in the current pass
  // and the current ivState has some transparency
  // only invoked by node before sendAllMaterial to avoid unnecessary GL calls (ie. SoMaterial)
  static bool shouldSendMaterial(SoState *state);

  // set method for usePattern is SoINTERNAL, because it should
  // only be invoked by SoPatternElement
  static void setPatternFlag(SoState *state, SbBool flag);

  // set method for lineWidth is SoINTERNAL because it should only be
  // invoked by SoLineWidthElement.
  static void setLineWidth(SoState *state, float width);

  enum internalMasks {
    OTHER_COLOR_MASK = AMBIENT_MASK|EMISSIVE_MASK|SPECULAR_MASK|SHININESS_MASK,
    ALL_COLOR_MASK = OTHER_COLOR_MASK|DIFFUSE_MASK,
    NO_COLOR_MASK = ALL_MASK & (~ALL_COLOR_MASK),
    ALL_BUT_DIFFUSE_MASK = ALL_MASK &(~ DIFFUSE_MASK),
    DIFFUSE_ONLY_MASK = ALL_MASK &(~ OTHER_COLOR_MASK)
  };

  // method to register dependence due to get().
  // only the GL version does any work
  virtual void registerGetDependence(SoState *, uint32_t);

  // little endian encode in SoColorPacker
  void leEncodeColorPacker( SoColorPacker *cPacker ) const;

private:

  // method to tell the cache that a redundant set was issued.
  // only the GL version does any work.
  virtual void registerRedundantSet(SoState *, uint32_t);
    
  //Struct to hold the inventor state:
  class   __ivstate {
    public:
    __ivstate()
      : diffuseNodeId(0)
      , transpNodeId(0)
      , ambientColor(0,0,0)
      , emissiveColor(0,0,0)
      , specularColor(0,0,0)
      , shininess(0)
      , colorMaterial(0)
      , blending(0)
      , smoothing(0)
      , lightModel(0)
      , stippleNum(0)
      , lineWidth(0.0f)
      , packed(false)
      , packedTransparent(false)
      , numDiffuseColors(0)
      , numTransparencies(0)
      , diffuseColors(0)
      , transparencies(0)
      , packedColors(0)
      , packedColors2(0)
      , colorIndices(0)
      , transpType(0)
      , cacheLevelSetBits(0)
      , cacheLevelSendBits(0)
      , patternStippleNum(0)
    {
    }

    // keep nodeID to compare diffuse GL and diffuse inventor state:
    // 0 is initial value, 1 is invalid
    uint64_t diffuseNodeId;

    // for transparency, keep either nodeid, or 0 if opaque. Value of
    // 1 indicates invalid.
    uint64_t transpNodeId;

    // store a value of each color component; ambient, emissive,
    // specular, shininess, or appropriate info to identify state.
    SbColor ambientColor;
    SbColor emissiveColor;
    SbColor specularColor;
    float shininess;
    int32_t colorMaterial;
    int32_t blending;
    int32_t smoothing;
    int32_t lightModel;
    int32_t stippleNum;
    float lineWidth;

    // following are not used for matching GL & IV, but must
    // be copied on push:
    SbBool packed;
    SbBool packedTransparent;
    int32_t numDiffuseColors;
    int32_t numTransparencies;
    const SbColor *diffuseColors;
    const float *transparencies;
    const uint32_t *packedColors;
    const uint32_t *packedColors2;
    const int32_t *colorIndices;
    int32_t transpType;
    uint32_t cacheLevelSetBits;
    uint32_t cacheLevelSendBits;
    int32_t patternStippleNum;
  };
  __ivstate ivState;

  virtual ~SoLazyElement();

  // This is more convenient here, but might logically be kept with
  // SoGLLazyElement. This is a bitmask indicating what components
  // have not been sent to GL.
  uint32_t invalidBits;

  // store pointers to the default color, transp so that we can set
  // point to them if no other color or transp has been set.
  static SbColor *defaultDiffuseColor;
  static float *defaultTransparency;
  static int32_t *defaultColorIndices;
  static uint32_t *defaultPackedColor;

  // Returns number of transparency levels supported with stipple
  // patterns. (Add one - solid - that is not included in this number.)
  static int getNumPatterns() {
    return 64;
  }
  // -1 = don't know yet, 0 = no transp, 1 = has transp
  int m_hasTransparency;

 private:
  // Virtual setElt methods, to be overridden by GL versions.
  virtual void setDiffuseElt(SoNode *,
                             int32_t numColors,
                             const SbColor *colors,
                             SoColorPacker *cPacker);
  virtual void setPackedElt(SoNode *,
                            int32_t numColors,
                            const uint32_t *colors,
                            SoColorPacker *cPacker);
  virtual void setColorIndexElt(SoNode *,
                                int32_t numIndices,
                                const int32_t *indices);
  virtual void setTranspElt(SoNode *,
                            int32_t numTrans,
                            const float *trans,
                            SoColorPacker *cPacker);
  virtual void setPatternFlagElt(SbBool flag);
  virtual void setTranspTypeElt(int32_t type);
  virtual void setAmbientElt(const SbColor *color);
  virtual void setEmissiveElt(const SbColor *color);
  virtual void setSpecularElt(const SbColor *color);
  virtual void setShininessElt(float value);
  virtual void setColorMaterialElt(SbBool value);
  virtual void setBlendingElt(SbBool value);
  virtual void setSmoothingElt(SbBool value);
  virtual void setLightModelElt(SoState *state, int32_t model);
  virtual void setLineWidthElt(float lineWidth);
  virtual void setMaterialElt(SoNode *,
                              uint32_t bitmask,
                              SoColorPacker *cPacker,
                              const SoMFColor &,
                              const SoMFFloat &,
                              const SoMFColor &,
                              const SoMFColor &,
                              const SoMFColor &,
                              const SoMFFloat &);
  virtual void setMaterialElt(SoNode *,
                              uint32_t bitmask,
                              SoColorPacker *cPacker,
                              SoMFColor *,
                              SoMFFloat *,
                              SoMFColor *,
                              SoMFColor *,
                              SoMFColor *,
                              SoMFFloat *);
};

//
// Class: SoColorPacker
// This class is meant to be used by all property nodes that set either
// a diffuse color or transparency in the lazy element. It maintains
// a cache of the current diffuse color and transparency in a packed
// color array.

class  SoColorPacker {

 public:

  //Constructor, makes a colorPacker with NULL packedColor pointer:
  SoColorPacker();

  // destructor, deletes packed color array
  ~SoColorPacker();

  uint32_t *getPackedColors() const {
    return packedColors;
  }
  SbBool diffuseMatch(uint64_t nodeId) {
    return (nodeId == diffuseNodeId);
  }
  SbBool transpMatch(uint64_t nodeId) {
    return (nodeId == transpNodeId);
  }
  void setNodeIds(uint64_t diffNodeId, uint64_t tNodeId) {
    diffuseNodeId = diffNodeId;
    transpNodeId = tNodeId;
  }
  int32_t getSize() {
    return packedArraySize;
  }
  void reallocate(int32_t size);

  static void exitClass();

 private:

  // nodeids are used for testing cache validity
  uint64_t transpNodeId;
  uint64_t diffuseNodeId;
  // array of packed colors, or NULL if empty
  uint32_t *packedColors;
  // size of packed color array (not necessarily number of valid colors)
  int32_t packedArraySize;

  static SbThreadMutex *m_mutex;

};

#endif /* _SO_LAZY_ELEMENT */

---

Open Inventor Toolkit reference manual, generated on 12 Feb 2024
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/