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-2025 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,
 };

  enum Face
  {
    FRONT,

    BACK,
  };

  static void setDiffuse(SoState* state, Face face, SoNode* node, int32_t numColors, const SbColor* colors);

  static void setTransparency(SoState* state, Face face, SoNode* node, int32_t numTransp, const float* transp);

  static void setPacked(SoState* state, Face face, SoNode* node, int32_t numColors, const uint32_t* colors);
  
  static void setColorIndices(SoState* state, Face face, SoNode* node, int32_t numIndices, const int32_t* indices);
 
  static void setAmbient(SoState* state, Face face, SoNode* node, const SbColor& color);
  static void setEmissive(SoState* state, Face face, SoNode* node, const SbColor& color);
  static void setSpecular(SoState* state, Face face, SoNode* node, const SbColor& color);
 
  static void setShininess(SoState* state, Face face, SoNode* node, float value);
  static void setColorMaterial(SoState* state, Face face, SoNode* node, SbBool value);
 
  // Physically based parameters
  static void setSpecularFactor(SoState* state, Face face, SoNode* node, float value);
  static void setRoughness(SoState* state, Face face, SoNode* node, float value);
  static void setMetallic(SoState* state, Face face, SoNode* node, float value);

  static SbColor getDiffuse(SoState* state, Face face, int index);

  static float getTransparency(SoState* state, Face face, int index);

  static SoCpuBufferObject* getPackedColors(SoState* state, Face face);

  static const int32_t* getColorIndices(SoState* state, Face face);
 
  static int32_t getColorIndex(SoState* state, Face face, int num);
 
  static const SbColor& getAmbient(SoState* state, Face face);
  static const SbColor& getEmissive(SoState* state, Face face);
  static const SbColor& getSpecular(SoState* state, Face face);
  static float getShininess(SoState* state, Face face);
 
  static SbBool getColorMaterial(SoState* state, Face face);
 
  // Physically based parameters
  static float getSpecularFactor(SoState* state, Face face);
  static float getRoughness(SoState* state, Face face);
  static float getMetallic(SoState* state, Face face);

  static size_t getNumDiffuse(SoState* state, Face face);

  static size_t getNumColorIndices(SoState* state, Face face);

  static int32_t getNumTransparencies(SoState* state, Face face);

  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 );
 
#if 1             SoDEPRECATED
  static void setDiffuse(SoState* state, SoNode* node, int32_t numColors, const SbColor* colors)
  {
    setDiffuse(state, FRONT, node, numColors, colors);
  }
SoDEPRECATED
  static void setTransparency(SoState* state, SoNode* node, int32_t numTransp, const float* transp)
  {
    setTransparency(state, FRONT, node, numTransp, transp);
  }
SoDEPRECATED
  static void setPacked(SoState* state, SoNode* node, int32_t numColors, const uint32_t* colors)
  {
    setPacked(state, FRONT, node, numColors, colors);
  }
SoDEPRECATED
  static void setColorIndices(SoState* state, SoNode* node, int32_t numIndices, const int32_t* indices)
  {
    setColorIndices(state, FRONT, node, numIndices, indices);
  }
SoDEPRECATED
  static void setAmbient(SoState* state, SoNode* node, const SbColor& color)
  {
    setAmbient(state, FRONT, node, color);
  }
SoDEPRECATED
  static void setEmissive(SoState* state, SoNode* node, const SbColor& color)
  {
    setEmissive(state, FRONT, node, color);
  }
SoDEPRECATED
  static void setSpecular(SoState* state, SoNode* node, const SbColor& color)
  {
    setSpecular(state, FRONT, node, color);
  }
SoDEPRECATED
  static void setShininess(SoState* state, SoNode* node, float value)
  {
    setShininess(state, FRONT, node, value);
  }
SoDEPRECATED
  static void setColorMaterial(SoState* state, SoNode* node, SbBool value)
  {
    setColorMaterial(state, FRONT, node, value);
  }
 
  // Physically-based parameters
SoDEPRECATED
  static void setSpecularFactor(SoState* state, SoNode* node, float value)
  {
    setSpecularFactor(state, FRONT, node, value);
  }
SoDEPRECATED
  static void setRoughness(SoState* state, SoNode* node, float value)
  {
    setRoughness(state, FRONT, node, value);
  }
SoDEPRECATED
  static void setMetallic(SoState* state, SoNode* node, float value)
  {
    setMetallic(state, FRONT, node, value);
  }
 
SoDEPRECATED
  static SbColor getDiffuse(SoState* state, int index)
  {
    return getDiffuse(state, FRONT, index);
  }
SoDEPRECATED
  static float getTransparency(SoState* state, int index)
  {
    return getTransparency(state, FRONT, index);
  }
SoDEPRECATED
  static SoCpuBufferObject* getPackedColors(SoState* state)
  {
    return getPackedColors(state, FRONT);
  }
SoDEPRECATED
  static const int32_t* getColorIndices(SoState* state)
  {
    return getColorIndices(state, FRONT);
  }
SoDEPRECATED
  static int32_t getColorIndex(SoState* state, int num)
  {
    return getColorIndex(state, FRONT, num);
  }
SoDEPRECATED
  static const SbColor& getAmbient(SoState* state)
  {
    return getAmbient(state, FRONT);
  }
SoDEPRECATED
  static const SbColor& getEmissive(SoState* state)
  {
    return getEmissive(state, FRONT);
  }
SoDEPRECATED
  static const SbColor& getSpecular(SoState* state)
  {
    return getSpecular(state, FRONT);
  }
SoDEPRECATED
  static float getShininess(SoState* state)
  {
    return getShininess(state, FRONT);
  }
SoDEPRECATED
  static SbBool getColorMaterial(SoState* state)
  {
    return getColorMaterial(state, FRONT);
  }
SoDEPRECATED
  static float getSpecularFactor(SoState* state)
  {
    return getSpecularFactor(state, FRONT);
  }
SoDEPRECATED
  static float getRoughness(SoState* state)
  {
    return getRoughness(state, FRONT);
  }
SoDEPRECATED
  static float getMetallic(SoState* state)
  {
    return getMetallic(state, FRONT);
  }
SoDEPRECATED
  static size_t getNumDiffuse(SoState* state)
  {
    return getNumDiffuse(state, FRONT);
  }
SoDEPRECATED
  static size_t getNumColorIndices(SoState* state)
  {
    return getNumColorIndices(state, FRONT);
  }
SoDEPRECATED
  static int32_t getNumTransparencies(SoState* state)
  {
    return getNumTransparencies(state, FRONT);
  }
#endif 
 
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,
                           Face face,
                           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, Face face);
  const SbColor* getDiffusePointer(Face face) const;
 
  static const int32_t* getColorIndexPointer(SoState* state, Face face);
  static const float* getTransparencyPointer(SoState* state, Face face);
  const float* getTransparencyPointer(Face face) const;
 
  static void setHasTransparency( SoState* state, SoNode* node, int hasTransparency );
 
  static const SoMaterialElement* getInstance( SoState* state );
 
  const SbColor& getAmbient(Face face) const;
  const SbColor& getEmissive(Face face) const;
  const SbColor& getSpecular(Face face) const;
  float getShininess(Face face) const;
 
  // Physically based parameters
  float getSpecularFactor(Face face) const;
  float getRoughness(Face face) const;
  float getMetallic(Face face) const;
 
  int32_t getNumDiffuse(Face face) const
  {
    return m_materialProperties[face].numDiffuseColors;
  }
 
  int32_t getNumColorIndices(Face face) const
  {
    return (m_materialProperties[face].colorIndices ? m_materialProperties[face].numDiffuseColors : 0);
  }
 
  int32_t getNumTransparencies(Face face) const;
  bool isTransparent() const;
  SoCpuBufferObject* getPackedColors(Face face) const;
 
  bool isPacked(Face face) const
  {
    return m_materialProperties[face].packedColors.ptr() != nullptr;
  }
 
#if 1             
SoDEPRECATED
  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)
  {
    setMaterials(state, FRONT, node, bitmask, diffuse, transp, ambient, emissive, specular, shininess);
  }
SoDEPRECATED
  static const SbColor* getDiffusePointer(SoState* state)
  {
    return getDiffusePointer(state, FRONT);
  }
SoDEPRECATED
  const SbColor* getDiffusePointer() const
  {
    return getDiffusePointer(FRONT);
  }
SoDEPRECATED
  static const int32_t* getColorIndexPointer(SoState* state)
  {
    return getColorIndexPointer(state, FRONT);
  }
SoDEPRECATED
  static const float* getTransparencyPointer(SoState* state)
  {
    return getTransparencyPointer(state, FRONT);
  }
SoDEPRECATED
  const float* getTransparencyPointer() const
  {
    return getTransparencyPointer(FRONT);
  }
SoDEPRECATED
  const SbColor& getAmbient() const
  {
    return getAmbient(FRONT);
  }
SoDEPRECATED
  const SbColor& getEmissive() const
  {
    return getEmissive(FRONT);
  }
SoDEPRECATED
  const SbColor& getSpecular() const
  {
    return getSpecular(FRONT);
  }
SoDEPRECATED
  float getShininess() const
  {
    return getShininess(FRONT);
  }
 
  // Physically-based parameters
SoDEPRECATED
  float getSpecularFactor() const
  {
    return getSpecularFactor(FRONT);
  }
SoDEPRECATED
  float getRoughness() const
  {
    return getRoughness(FRONT);
  }
SoDEPRECATED
  float getMetallic() const
  {
    return getMetallic(FRONT);
  }
 
SoDEPRECATED
  int32_t getNumDiffuse() const
  {
    return getNumDiffuse(FRONT);
  }
SoDEPRECATED
  int32_t getNumColorIndices() const
  {
    return getNumColorIndices(FRONT);
  }
SoDEPRECATED
  int32_t getNumTransparencies() const
  {
    return getNumTransparencies(FRONT);
  }
SoDEPRECATED
  SoCpuBufferObject* getPackedColors() const
  {
    return getPackedColors(FRONT);
  }
SoDEPRECATED
  bool isPacked() const
  {
    return isPacked(FRONT);
  }
 
#endif 
 
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;
  };
 
  // 2 for front & back materials
  Material m_materialProperties[2];
 
  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 s_defaultDiffuseColor;
  static float s_defaultTransparency;
  static int32_t s_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(Face face);
  
  void setDiffuseElt(Face face, int32_t numColors, const SbColor *colors);
  void setColorIndexElt(Face face, int32_t numIndices, const int32_t *indices);
  void setTranspElt(Face face, int32_t numTrans, const float *trans);
  void setAmbientElt(Face face, const SbColor *color);
  void setEmissiveElt(Face face, const SbColor *color);
  void setSpecularElt(Face face, const SbColor *color);
  void setShininessElt(Face face, float value);
  void setColorMaterialElt(Face face, SbBool value);
  void setMaterialElt(Face face, uint32_t bitmask,
                      const SoMFColor &, const SoMFFloat &, const SoMFColor &,
                      const SoMFColor &, const SoMFColor &, const SoMFFloat &);
 
  // Physically based parameters
  void setSpecularFactorElt(Face face, float value);
  void setRoughnessElt(Face face, float value);
  void setMetallicElt(Face face, float value);
 
  static const float S_SHINY_THRESHOLD;
};
 
#endif /* _SO_MATERIAL_ELEMENT */