EIC code displayed by LXR master/​include/​opencascade/​OpenGl_Material.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-09-24 09:16:55

 // Created on: 2011-09-20
 // Created by: Sergey ZERCHANINOV
 // Copyright (c) 2011-2013 OPEN CASCADE SAS
 //
 // This file is part of Open CASCADE Technology software library.
 //
 // This library is free software; you can redistribute it and/or modify it under
 // the terms of the GNU Lesser General Public License version 2.1 as published
 // by the Free Software Foundation, with special exception defined in the file
 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
 // distribution for complete text of the license and disclaimer of any warranty.
 //
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
 #ifndef _OpenGl_Material_Header
 #define _OpenGl_Material_Header
 
 #include <Graphic3d_MaterialAspect.hxx>
 #include <OpenGl_Vec.hxx>
 
 class OpenGl_Context;
 
 //! OpenGL material definition
 struct OpenGl_MaterialCommon
 {
 
   NCollection_Vec4<float> Diffuse;           //!< diffuse RGB coefficients + alpha
   NCollection_Vec4<float> Emission;          //!< material RGB emission
   NCollection_Vec4<float> SpecularShininess; //!< glossy  RGB coefficients + shininess
   NCollection_Vec4<float> Ambient;           //!< ambient RGB coefficients
 
   float Shine() const { return SpecularShininess.a(); }
 
   float& ChangeShine() { return SpecularShininess.a(); }
 
   //! Empty constructor.
   OpenGl_MaterialCommon()
       : Diffuse(1.0f),
         Emission(1.0f),
         SpecularShininess(1.0f, 1.0f, 1.0f, 0.0f),
         Ambient(1.0f)
   {
   }
 
   //! Set material color.
   void SetColor(const NCollection_Vec3<float>& theColor)
   {
     // apply the same formula as in Graphic3d_MaterialAspect::SetColor()
     Ambient.SetValues(theColor * 0.25f, Ambient.a());
     Diffuse.SetValues(theColor, Diffuse.a());
   }
 };
 
 //! OpenGL material definition
 struct OpenGl_MaterialPBR
 {
 
   NCollection_Vec4<float> BaseColor; //!< base color of PBR material with alpha component
                                      // clang-format off
   NCollection_Vec4<float> EmissionIOR; //!< light intensity which is emitted by PBR material and index of refraction
                                      // clang-format on
   NCollection_Vec4<float> Params;    //!< extra packed parameters
 
   float Metallic() const { return Params.b(); }
 
   float& ChangeMetallic() { return Params.b(); }
 
   float Roughness() const { return Params.g(); }
 
   float& ChangeRoughness() { return Params.g(); }
 
   //! Empty constructor.
   OpenGl_MaterialPBR()
       : BaseColor(1.0f),
         EmissionIOR(1.0f),
         Params(1.0f, 1.0f, 1.0f, 1.0f)
   {
   }
 
   //! Set material color.
   void SetColor(const NCollection_Vec3<float>& theColor)
   {
     BaseColor.SetValues(theColor, BaseColor.a());
   }
 };
 
 //! OpenGL material definition
 struct OpenGl_Material
 {
   OpenGl_MaterialCommon Common[2];
   OpenGl_MaterialPBR    Pbr[2];
 
   //! Set material color.
   void SetColor(const NCollection_Vec3<float>& theColor)
   {
     Common[0].SetColor(theColor);
     Common[1].SetColor(theColor);
     Pbr[0].SetColor(theColor);
     Pbr[1].SetColor(theColor);
   }
 
   //! Initialize material
   void Init(const OpenGl_Context&           theCtx,
             const Graphic3d_MaterialAspect& theFront,
             const Quantity_Color&           theFrontColor,
             const Graphic3d_MaterialAspect& theBack,
             const Quantity_Color&           theBackColor);
 
   //! Check this material for equality with another material (without tolerance!).
   bool IsEqual(const OpenGl_Material& theOther) const
   {
     return std::memcmp(this, &theOther, sizeof(OpenGl_Material)) == 0;
   }
 
   //! Check this material for equality with another material (without tolerance!).
   bool operator==(const OpenGl_Material& theOther) { return IsEqual(theOther); }
 
   bool operator==(const OpenGl_Material& theOther) const { return IsEqual(theOther); }
 
   //! Check this material for non-equality with another material (without tolerance!).
   bool operator!=(const OpenGl_Material& theOther) { return !IsEqual(theOther); }
 
   bool operator!=(const OpenGl_Material& theOther) const { return !IsEqual(theOther); }
 
   //! Returns packed (serialized) representation of common material properties
   const NCollection_Vec4<float>* PackedCommon() const
   {
     return reinterpret_cast<const NCollection_Vec4<float>*>(Common);
   }
 
   static int NbOfVec4Common() { return 4 * 2; }
 
   //! Returns packed (serialized) representation of PBR material properties
   const NCollection_Vec4<float>* PackedPbr() const
   {
     return reinterpret_cast<const NCollection_Vec4<float>*>(Pbr);
   }
 
   static int NbOfVec4Pbr() { return 3 * 2; }
 
 private:
   //! Initialize material
   void init(const OpenGl_Context&           theCtx,
             const Graphic3d_MaterialAspect& theMat,
             const Quantity_Color&           theColor,
             const int                       theIndex);
 };
 
 //! Material flag
 enum OpenGl_MaterialFlag
 {
   OpenGl_MaterialFlag_Front, //!< material for front faces
   OpenGl_MaterialFlag_Back   //!< material for back  faces
 };
 
 #endif // _OpenGl_Material_Header

This page was automatically generated by the 2.3.7 LXR engine. The LXR team