SoMaterialElement.h

/*=======================================================================
 *** 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-2024 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Modified by : VSG (MMM YYYY)
**=======================================================================*/
 
 
#ifndef _SO_MATERIAL_ELEMENT
#define _SO_MATERIAL_ELEMENT
 
#include <Inventor/SbBasic.h>
#include <Inventor/SbColor.h>
#include <Inventor/elements/SoReplacedElement.h>
#include <Inventor/elements/SoSubElement.h>
#include <Inventor/devices/SoCpuBufferObject.h>
#include <math.h>
 
class SoMFFloat;
class SoMFColor;
class SbThreadMutex;
 
SoEXTENDER_Documented class  SoMaterialElement : public SoReplacedElement {
  SO_ELEMENT_HEADER(SoMaterialElement);
 
 public:
 
 enum masks {
   COLOR_MATERIAL_MASK = 1 << 1,
   DIFFUSE_MASK = 1 << 2,
   AMBIENT_MASK = 1 << 3,
   EMISSIVE_MASK = 1 << 4,
   SPECULAR_MASK = 1 << 5,
   SHININESS_MASK = 1 << 6,
   TRANSPARENCY_MASK = 1 << 8,
   ALL_MASK = 0xFFFF,
 };
 
  static void setDiffuse(SoState *state,
                         SoNode *node,
                         int32_t numColors,
                         const SbColor *colors);
  static void setTransparency(SoState *state,
                              SoNode *node,
                              int32_t numTransp,
                              const float *transp);
 
  static void setPacked(SoState *state,
                        SoNode *node,
                        int32_t numColors,
                        const uint32_t *colors);
  
  static void setColorIndices(SoState *state,
                              SoNode *node,
                              int32_t numIndices,
                              const int32_t *indices);
 
  static void setAmbient(SoState *state, SoNode* node, const SbColor &color);
  static void setEmissive(SoState *state, SoNode* node, const SbColor &color);
  static void setSpecular(SoState *state, SoNode* node, const SbColor &color);
 
  static void setShininess(SoState *state, SoNode* node, float value);
  static void setColorMaterial(SoState *state, SoNode* node, SbBool value);
 
  // Physically based parameters
  static void setSpecularFactor(SoState* state, SoNode* node, float value);
  static void setRoughness(SoState* state, SoNode* node, float value);
  static void setMetallic(SoState* state, SoNode* node, float value);
 
  static SbColor getDiffuse(SoState *state, int index);
  static float getTransparency(SoState *, int index);
 
  static SoCpuBufferObject* 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 *);
 
  // Physically based parameters
  static float getSpecularFactor(SoState* state);
  static float getRoughness(SoState* state);
  static float getMetallic(SoState* state);
 
  static size_t getNumDiffuse(SoState* state);
 
  static size_t getNumColorIndices(SoState* state);
  
  int32_t getNumDiffuse() const {
    return m_materialProperties.numDiffuseColors;
  }
  static int32_t getNumTransparencies( SoState* state );
 
  int32_t getNumColorIndices() const {
    return (m_materialProperties.colorIndices ? m_materialProperties.numDiffuseColors : 0);
  }
 
  static bool isTransparent( SoState* state );
 
   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;
  }
 
  // Physically based parameters
 
  static float getDefaultSpecularFactor()
  {
    return 0.0f;
  }
 
  static float getDefaultRoughness()
  {
    return 0.8f;
  }
 
  static float getDefaultMetallic()
  {
    return 0.0f;
  }
 
   static float getDefaultTransparency() {
    return 0.0F;
  }
   static int32_t getDefaultColorIndex() {
    return 1;
  }
 
  virtual void push(SoState *state);
  virtual void pop( SoState* state, const SoElement* prevTopElement );
 
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,
                           const SoMFColor &diffuse,
                           const SoMFFloat &transp,
                           const SoMFColor &ambient,
                           const SoMFColor &emissive,
                           const SoMFColor &specular,
                           const SoMFFloat &shininess);
 
  // Prints element (for debugging)
  virtual void print(FILE *fp) const;
 
  // Initializes the SoMaterialElement class
  static void initClass();
  static void exitClass();
 
  static const SbColor* getDiffusePointer( SoState* state );
  const SbColor* getDiffusePointer() const;
 
  static const int32_t* getColorIndexPointer( SoState* state );
  static const float* getTransparencyPointer( SoState* state );
  const float* getTransparencyPointer() const;
 
  static void setHasTransparency( SoState* state, SoNode* node, int hasTransparency );
 
  static const SoMaterialElement* getInstance( SoState* state );
 
  const SbColor& getAmbient() const;
  const SbColor& getEmissive() const;
  const SbColor& getSpecular() const;
  float getShininess() const;
 
  // Physically based parameters
  float getSpecularFactor() const;
  float getRoughness() const;
  float getMetallic() const;
 
  int32_t getNumTransparencies() const;
  bool isTransparent() const;
  SoCpuBufferObject* getPackedColors() const;
  bool isPacked() const
  {
    return m_materialProperties.packedColors.ptr() != nullptr;
  }
 
private:  
  //Struct to hold material parameters
  struct Material
  {
    public:
    Material()
    {
      //The memset ensure that we are also clearing the possible padding
      //which is needed when doing memcmp in match method
      memset(this, 0, sizeof(Material));
      dirtyPackedColor = true;
      packedColorExplicitelySet = false;
    }
    const SbColor *diffuseColors;
    SoRef<SoCpuBufferObject> packedColors;
    const float *transparencies;
    const int32_t *colorIndices;
 
    SbColor ambientColor;
    SbColor emissiveColor;
    SbColor specularColor;
    float shininess;
    int32_t colorMaterial;
 
    // Physically based parameters
    float specularFactor;
    float roughness;
    float metallic;
 
    int32_t numDiffuseColors;
    int32_t numTransparencies;
 
    //True if we need to recreate the packed color buffer
    bool dirtyPackedColor : 1;
 
    bool packedColorExplicitelySet : 1;
  };
  Material m_materialProperties;
 
  virtual ~SoMaterialElement();
 
  // store 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 SoCpuBufferObject* s_defaultPackedColorBuffer;
 
  // -1 = don't know yet, 0 = no transp, 1 = has transp
  int m_hasTransparency;
 
 private:
  static SoMaterialElement* getWInstance( SoState* state, SoNode* node = nullptr );
 
  SoCpuBufferObject* packDiffuseColors();
  
  void setDiffuseElt(int32_t numColors, const SbColor *colors);
  void setColorIndexElt(int32_t numIndices, const int32_t *indices);
  void setTranspElt(int32_t numTrans, const float *trans);
  void setAmbientElt(const SbColor *color);
  void setEmissiveElt(const SbColor *color);
  void setSpecularElt(const SbColor *color);
  void setShininessElt(float value);
  void setColorMaterialElt(SbBool value);
  void setMaterialElt(uint32_t bitmask, const SoMFColor &, const SoMFFloat &,
                      const SoMFColor &, const SoMFColor &, const SoMFColor &,
                      const SoMFFloat &);
 
  // Physically based parameters
  void setSpecularFactorElt(float value);
  void setRoughnessElt(float value);
  void setMetallicElt(float value);
 
  static const float S_SHINY_THRESHOLD;
};
 
#endif /* _SO_MATERIAL_ELEMENT */