occt-gltf-addon-linux-x64 0.1.1 → 0.1.2

package/resources/SHMessage/SHAPE.us

@@ -0,0 +1,267 @@
+
+! Message file for Shape Healing
+
+
+! ------------------------------------------------------------------------------
+! Messages for shape names
+!
+.Name.Shape.MSG0
+!
+.Name.Vertex.MSG0
+!
+.Name.Edge.MSG0
+!
+.Name.Wire.MSG0
+!
+.Name.Face.MSG0
+!
+.Name.Shell.MSG0
+!
+.Name.Solid.MSG0
+!
+.Name.CompSolid.MSG0
+!
+.Name.Compound.MSG0
+!
+! ------------------------------------------------------------------------------
+! Messages for sequence of operators
+! 
+.SP.Sequence.Info.Seq
+Info: Shape Processing: Sequence of operators: %s
+!
+.SP.Sequence.Info.Operator
+Info: Shape Processing: Operator %d/%d: %s
+!
+.SP.Sequence.Error.NoOp
+Error: Shape Processing: Operator %s is not found
+!
+.SP.Sequence.Error.Except
+Error: Shape Processing: Operator %s failed with exception %s
+!
+.SP.Sequence.Warn.NoSeq
+Warning: Shape Processing: Sequence not defined for %s, nothing to do
+!
+! ------------------------------------------------------------------------------
+! Messages for printing results of shape processing
+! 
+.PrResult.Print.MSG50
+  Shells:
+!
+.PrResult.Print.MSG55
+  Faces:
+!
+.PrResult.Print.MSG100
+Mapping:
+!
+.PrResult.Print.MSG110
+    Result is Shell                 : %d
+!
+.PrResult.Print.MSG115
+    Result is Face                  : %d
+!
+.PrResult.Print.MSG150
+    No Result                       : %d
+!
+.PrResult.Print.MSG200
+Preparation ratio:
+!
+.PrResult.Print.MSG205
+  Shells: %d per cent
+!
+.PrResult.Print.MSG210
+  Faces : %d per cent
+!
+! ==============================================================================
+! Messages for Shape Healing
+! 
+! ------------------------------------------------------------------------------
+! Messages for ShapeFix_Wire
+! 
+.FixWire.FixDegenerated.MSG0
+Degenerated edge(s) detected
+!
+.FixWire.FixDegenerated.MSG5
+Degenerated edge %d detected
+!
+.FixWire.FixCurve3d.Removed
+Incomplete edge (with no pcurves or 3d curve) removed
+!
+.FixAdvWire.FixSmall.MSG0
+Small edge(s) removed
+! 
+.FixAdvWire.FixSmall.MSG5
+Edge %d was small, removed
+! 
+.FixAdvWire.FixIntersection.MSG0
+Self-intersection corrected
+!
+.FixAdvWire.FixIntersection.MSG5
+Edge was self-intersecting, corrected
+!
+.FixAdvWire.FixIntersection.MSG10
+Edges were intersecting, corrected
+!
+.FixAdvWire.FixLacking.MSG0
+Lacking edge(s) inserted
+!
+.FixAdvWire.FixLacking.MSG5
+Lacking edge %d inserted
+!
+.FixAdvWire..MSG0
+!
+.FixAdvWire..MSG5
+!
+.FixAdvWire..MSG10
+!
+! ------------------------------------------------------------------------------
+! Messages for ShapeFix_Face
+!
+.FixAdvFace.FixMissingSeam.MSG0
+Missing seam-edge added
+!
+.FixAdvFace.FixSmallAreaWire.MSG0
+Null area wire detected, wire skipped
+!
+.FixAdvFace.FixOrientation.MSG0
+Face created with natural bounds
+!
+.FixAdvFace.FixOrientation.MSG5
+Wire on face was reversed
+!
+.FixAdvFace.FixOrientation.MSG11
+Cannot orient wire
+!
+! ------------------------------------------------------------------------------
+! Messages for ShapeFix_Wireframe
+! 
+.FixWireframe.FixSmallEdges.MSG0
+Small edge removed
+!
+.FixWireframe.FixSmallEdges.MSG1
+Small wire removed
+!
+.FixWireframe.FixSmallEdges.MSG2
+Small face removed
+!
+.FixWireframe.FixFixWireGaps.MSG0
+Gaps in a wire fixed
+!
+!
+.Fix.SplitCommonVertex.MSG0
+Wires with common vertex fixed
+!
+!
+.FixAdvShell.FixOrientation.MSG20
+Impossible to orient faces in shell, several shells created
+!
+.FixAdvShell.FixOrientation.MSG30
+Improperly connected shell split into parts
+!
+.FixAdvSolid.FixShell.MSG10
+Solid cannot be created from an open shell
+!
+.FixAdvSolid.FixOrientation.MSG20
+Orientation of shell(s) in solid was corrected
+!
+.FixAdvSolid.FixOrientation.MSG30
+Improperly connected solid split into several parts
+!
+.FixAdvFace.FixLoopWire.MSG0
+Wire was split on several wires
+!
+.FixAdvFace..MSG5
+!
+.FixAdvFace..MSG10
+!
+.FixEdge.SameParameter.MSG0
+Not same parameter edge fixed
+!
+! ------------------------------------------------------------------------------
+! Messages for ShapeFix_FixSmallFace
+!
+.FixAdvFace.FixSpotFace.MSG0
+Spot face removed
+!
+.FixAdvFace.FixStripFace.MSG0
+Strip face removed
+!
+! ------------------------------------------------------------------------------
+! Messages for ShapeFix_FixSmallSolid
+!
+.ShapeFix.FixSmallSolid.MSG0
+Small solid removed
+!
+.ShapeFix.FixSmallSolid.MSG1
+Small solid merged with other
+!
+! ------------------------------------------------------------------------------
+! Messages for ShapeFix_Shell
+!
+.FixAdvShell.FixOrientation.MSG0
+Faces were incorrectly oriented in the shell, corrected
+!
+.FixAdvShell.FixOrientation.MSG5
+Faces were incorrectly oriented in the shell, not corrected
+!
+.FixAdvShell.FixClosedFlag.MSG0
+Shell has incorrect flag isClosed
+!
+.FixAdvShell..MSG5
+!
+.FixAdvShell..MSG10
+!
+! ------------------------------------------------------------------------------
+! Messages for ShapeUpgrade
+!
+.ShapeDivide.FaceDivide.MSG0
+Face divided
+!
+.ShapeDivide.WireDivide.MSG0
+Wire divided
+!
+.ShapeDivide.EdgeDivide.MSG0
+Edge divided
+!
+.ShapeDivide.FaceConvertToBezier.MSG0
+Face converted to Bezier
+!
+.ShapeDivide.WireConvertToBezier.MSG0
+Wire converted to Bezier
+!
+.ShapeDivide.EdgeConvertToBezier.MSG0
+Edge converted to Bezier
+!
+! ------------------------------------------------------------------------------
+! Messages for ShapeCustom
+!
+.BSplineRestriction.NewSurface.MSG0
+Face converted to BSpline
+!
+.BSplineRestriction.NewSurface.MSG1
+BSpline Face re-approximated
+!
+.BSplineRestriction.NewCurve.MSG0
+Edge converted to BSpline
+!
+.BSplineRestriction.NewCurve.MSG1
+BSpline Edge re-approximated
+!
+!
+.ConvertToBSpline.NewSurface.MSG0
+Face converted to BSpline
+!
+.ConvertToBSpline.NewCurve.MSG0
+Edge converted to BSpline
+!
+!
+.ConvertToRevolution.NewSurface.MSG0
+Face converted to surface of revolution
+!
+!
+.DirectModification.NewSurface.MSG0
+Direction of Face of revolution corrected
+!
+!
+.SweptToElementary.NewSurface.MSG0
+Swept Face converted to elementary
+!

package/resources/Shaders/Declarations.glsl

@@ -0,0 +1,276 @@
+
+//! @file Declarations.glsl includes definition of common uniform variables in OCCT GLSL programs
+//! @def THE_MAX_LIGHTS
+//! Specifies the length of array of lights, which is 8 by default. Defined by Shader Manager.
+// #define THE_MAX_LIGHTS 8
+
+//! @def THE_MAX_CLIP_PLANES
+//! Specifies the length of array of clipping planes, which is 8 by default. Defined by Shader Manager.
+// #define THE_MAX_CLIP_PLANES 8
+
+//! @def THE_NB_FRAG_OUTPUTS
+//! Specifies the length of array of Fragment Shader outputs, which is 1 by default. Defined by Shader Manager.
+// #define THE_NB_FRAG_OUTPUTS 1
+
+// compatibility macros
+#if (__VERSION__ >= 130)
+  #define THE_ATTRIBUTE  in
+  #define THE_SHADER_IN  in
+  #define THE_SHADER_OUT out
+  #define THE_OUT        out
+  #define occTexture1D   texture
+  #define occTexture2D   texture
+  #define occTexture3D   texture
+  #define occTextureCube texture
+  #define occTextureCubeLod textureLod
+#else
+  #define THE_ATTRIBUTE  attribute
+  #define THE_SHADER_IN  varying
+  #define THE_SHADER_OUT varying
+  #define THE_OUT
+  #define occTexture1D   texture1D
+  #define occTexture2D   texture2D
+  #define occTexture3D   texture3D
+  #define occTextureCube textureCube
+  #if !defined(GL_ES) || defined(textureCubeLod)
+    #define occTextureCubeLod textureCubeLod
+  #else // fallback
+    #define occTextureCubeLod(theSampl,theCoord,theLod) textureCube(theSampl,theCoord)
+  #endif
+#endif
+
+#ifdef GL_ES
+#if (__VERSION__ >= 300)
+  #define THE_PREC_ENUM highp // lowp should be enough for enums but triggers driver bugs
+#else
+  #define THE_PREC_ENUM lowp
+#endif
+#else
+  #define THE_PREC_ENUM
+#endif
+
+// Vertex attributes
+#ifdef VERTEX_SHADER
+  THE_ATTRIBUTE vec4 occVertex;
+  THE_ATTRIBUTE vec3 occNormal;
+  THE_ATTRIBUTE vec4 occTexCoord;
+  THE_ATTRIBUTE vec4 occVertColor;
+#elif defined(FRAGMENT_SHADER)
+  #if (__VERSION__ >= 130)
+    #ifdef OCC_ENABLE_draw_buffers
+      out vec4 occFragColorArray[THE_NB_FRAG_OUTPUTS];
+      #define occFragColorArrayAlias occFragColorArray
+      #define occFragColor0 occFragColorArray[0]
+    #else
+      out vec4 occFragColor0;
+    #endif
+  #else
+    #ifdef OCC_ENABLE_draw_buffers
+      #define occFragColorArrayAlias gl_FragData
+      #define occFragColor0 gl_FragData[0]
+    #else
+      #define occFragColor0 gl_FragColor
+    #endif
+  #endif
+
+  #if (THE_NB_FRAG_OUTPUTS >= 2)
+    #define occFragColor1 occFragColorArrayAlias[1]
+  #else
+    vec4 occFragColor1;
+  #endif
+  #if (THE_NB_FRAG_OUTPUTS >= 3)
+    #define occFragColor2 occFragColorArrayAlias[2]
+  #else
+    vec4 occFragColor2;
+  #endif
+  #if (THE_NB_FRAG_OUTPUTS >= 4)
+    #define occFragColor3 occFragColorArrayAlias[3]
+  #else
+    vec4 occFragColor3;
+  #endif
+
+  // Built-in outputs notation
+  #define occFragColor    occFragColor0
+  #define occFragCoverage occFragColor1
+
+  #define occPeelDepth      occFragColor0
+  #define occPeelFrontColor occFragColor1
+  #define occPeelBackColor  occFragColor2
+
+  //! Define the main Fragment Shader early return procedure.
+  bool occFragEarlyReturn();
+
+  //! Define the main Fragment Shader output - color value.
+  void occSetFragColor (in vec4 theColor);
+#endif
+
+// Pi number definitions
+#define PI       3.141592654
+#define PI_2     6.283185307
+#define PI_DIV_2 1.570796327
+#define PI_DIV_3 1.047197551
+#define PI_DIV_4 0.785398163
+#define INV_PI   0.318309886
+#define INV_PI_2 0.159154943
+
+// Matrix state
+uniform mat4 occWorldViewMatrix;  //!< World-view  matrix
+uniform mat4 occProjectionMatrix; //!< Projection  matrix
+uniform mat4 occModelWorldMatrix; //!< Model-world matrix
+
+uniform mat4 occWorldViewMatrixInverse;    //!< Inverse of the world-view  matrix
+uniform mat4 occProjectionMatrixInverse;   //!< Inverse of the projection  matrix
+uniform mat4 occModelWorldMatrixInverse;   //!< Inverse of the model-world matrix
+
+uniform mat4 occWorldViewMatrixTranspose;  //!< Transpose of the world-view  matrix
+uniform mat4 occProjectionMatrixTranspose; //!< Transpose of the projection  matrix
+uniform mat4 occModelWorldMatrixTranspose; //!< Transpose of the model-world matrix
+
+uniform mat4 occWorldViewMatrixInverseTranspose;  //!< Transpose of the inverse of the world-view  matrix
+uniform mat4 occProjectionMatrixInverseTranspose; //!< Transpose of the inverse of the projection  matrix
+uniform mat4 occModelWorldMatrixInverseTranspose; //!< Transpose of the inverse of the model-world matrix
+
+#if defined(THE_IS_PBR)
+uniform sampler2D   occEnvLUT;             //!< Environment Lookup Table
+uniform sampler2D   occDiffIBLMapSHCoeffs; //!< Packed diffuse (irradiance) IBL map's spherical harmonics coefficients
+uniform samplerCube occSpecIBLMap;         //!< Specular IBL map
+uniform int         occNbSpecIBLLevels;    //!< Number of mipmap levels used in occSpecIBLMap to store different roughness values maps
+
+vec3 occDiffIBLMap (in vec3 theNormal); //!< Unpacks spherical harmonics coefficients to diffuse IBL map's values
+#endif
+
+// light type enumeration (same as Graphic3d_TypeOfLightSource)
+const int OccLightType_Direct = 1; //!< directional     light source
+const int OccLightType_Point  = 2; //!< isotropic point light source
+const int OccLightType_Spot   = 3; //!< spot            light source
+
+// Light sources
+uniform               vec4 occLightAmbient;      //!< Cumulative ambient color
+#if defined(THE_MAX_LIGHTS) && (THE_MAX_LIGHTS > 0)
+#if (THE_MAX_LIGHTS > 1)
+  #define occLight_Index(theId) theId
+#else
+  #define occLight_Index(theId) 0
+#endif
+uniform THE_PREC_ENUM int  occLightSourcesCount; //!< Total number of light sources
+
+//! Type of light source, int (see OccLightType enum).
+#define occLight_Type(theId)              occLightSourcesTypes[occLight_Index(theId)]
+
+//! Specular intensity (equals to diffuse), vec3.
+#define occLight_Specular(theId)          occLightSources[occLight_Index(theId) * 4 + 0].rgb
+
+//! Intensity of light source (>= 0), float.
+#define occLight_Intensity(theId)         occLightSources[occLight_Index(theId) * 4 + 0].a
+
+//! Is light a headlight, bool? DEPRECATED method.
+#define occLight_IsHeadlight(theId) false
+
+//! Position of specified light source or direction of directional light source, vec3.
+#define occLight_Position(theId)          occLightSources[occLight_Index(theId) * 4 + 1].xyz
+
+//! Direction of specified spot light source, vec3.
+#define occLight_SpotDirection(theId)     occLightSources[occLight_Index(theId) * 4 + 2].xyz
+
+//! Range on which point light source (positional or spot) can affect (>= 0), float.
+#define occLight_Range(theId)             occLightSources[occLight_Index(theId) * 4 + 2].w
+
+//! Maximum spread angle of the spot light (in radians), float.
+#define occLight_SpotCutOff(theId)        occLightSources[occLight_Index(theId) * 4 + 3].z
+
+//! Attenuation of the spot light intensity (from 0 to 1), float.
+#define occLight_SpotExponent(theId)      occLightSources[occLight_Index(theId) * 4 + 3].w
+
+#if !defined(THE_IS_PBR)
+//! Diffuse intensity (equals to Specular), vec3.
+#define occLight_Diffuse(theId)           occLightSources[occLight_Index(theId) * 4 + 0].rgb
+
+//! Const attenuation factor of positional light source, float.
+#define occLight_ConstAttenuation(theId)  occLightSources[occLight_Index(theId) * 4 + 3].x
+
+//! Linear attenuation factor of positional light source, float.
+#define occLight_LinearAttenuation(theId) occLightSources[occLight_Index(theId) * 4 + 3].y
+#endif
+#endif
+
+#if defined(THE_IS_PBR)
+//! Converts roughness value from range [0, 1] to real value for calculations
+float occRoughness (in float theNormalizedRoughness);
+
+// Front/back material properties accessors
+vec4  occPBRMaterial_Color(in bool theIsFront);    //!< Base color of PBR material
+float occPBRMaterial_Metallic(in bool theIsFront); //!< Metallic coefficient
+float occPBRMaterial_NormalizedRoughness(in bool theIsFront); //!< Normalized roughness coefficient
+vec3  occPBRMaterial_Emission(in bool theIsFront); //!< Light intensity emitted by material
+float occPBRMaterial_IOR(in bool theIsFront);      //!< Index of refraction
+#define occMaterial_Emission occPBRMaterial_Emission
+#define occMaterial_Color occPBRMaterial_Color
+#else
+vec4  occMaterial_Diffuse(in bool theIsFront);     //!< Diffuse  reflection
+vec3  occMaterial_Specular(in bool theIsFront);    //!< Specular reflection
+float occMaterial_Shininess(in bool theIsFront);   //!< Specular exponent
+vec3  occMaterial_Ambient(in bool theIsFront);     //!< Ambient  reflection
+vec3  occMaterial_Emission(in bool theIsFront);    //!< Emission color
+#define occMaterial_Color occMaterial_Diffuse
+#endif
+
+#ifdef THE_HAS_DEFAULT_SAMPLER
+#define occActiveSampler    occSampler0  //!< alias for backward compatibility
+#define occSamplerBaseColor occSampler0  //!< alias to a base color texture
+uniform sampler2D           occSampler0; //!< current active sampler;
+#endif                                   //!  occSampler1, occSampler2,... should be defined in GLSL program body for multitexturing
+
+#if defined(THE_HAS_TEXTURE_COLOR) && defined(FRAGMENT_SHADER)
+#define occMaterialBaseColor(theIsFront, theTexCoord) (occMaterial_Color(theIsFront) * occTexture2D(occSamplerBaseColor, theTexCoord))
+#else
+#define occMaterialBaseColor(theIsFront, theTexCoord) occMaterial_Color(theIsFront)
+#endif
+
+#if defined(THE_HAS_TEXTURE_OCCLUSION) && defined(FRAGMENT_SHADER)
+uniform sampler2D occSamplerOcclusion;   //!< R occlusion texture sampler
+#define occMaterialOcclusion(theColor, theTexCoord) theColor *= occTexture2D(occSamplerOcclusion, theTexCoord).r;
+#else
+#define occMaterialOcclusion(theColor, theTexCoord)
+#endif
+
+#if defined(THE_HAS_TEXTURE_EMISSIVE) && defined(FRAGMENT_SHADER)
+uniform sampler2D occSamplerEmissive;    //!< RGB emissive texture sampler
+#define occMaterialEmission(theIsFront, theTexCoord) (occMaterial_Emission(theIsFront) * occTexture2D(occSamplerEmissive, theTexCoord).rgb)
+#else
+#define occMaterialEmission(theIsFront, theTexCoord) occMaterial_Emission(theIsFront)
+#endif
+
+#if defined(THE_HAS_TEXTURE_NORMAL) && defined(FRAGMENT_SHADER)
+uniform sampler2D occSamplerNormal;      //!< XYZ normal texture sampler with W==0 indicating no texture
+#define occTextureNormal(theTexCoord) occTexture2D(occSamplerNormal, theTexCoord)
+#else
+#define occTextureNormal(theTexCoord) vec4(0.0) // no normal map
+#endif
+
+#if defined(THE_HAS_TEXTURE_METALROUGHNESS) && defined(FRAGMENT_SHADER)
+uniform sampler2D occSamplerMetallicRoughness; //!< BG metallic-roughness texture sampler
+#define occMaterialRoughness(theIsFront, theTexCoord) (occPBRMaterial_NormalizedRoughness(theIsFront) * occTexture2D(occSamplerMetallicRoughness, theTexCoord).g)
+#define occMaterialMetallic(theIsFront,  theTexCoord) (occPBRMaterial_Metallic(theIsFront) * occTexture2D(occSamplerMetallicRoughness, theTexCoord).b)
+#else
+#define occMaterialRoughness(theIsFront, theTexCoord) occPBRMaterial_NormalizedRoughness(theIsFront)
+#define occMaterialMetallic(theIsFront,  theTexCoord) occPBRMaterial_Metallic(theIsFront)
+#endif
+
+uniform               vec4      occColor;              //!< color value (in case of disabled lighting)
+uniform THE_PREC_ENUM int       occDistinguishingMode; //!< Are front and back faces distinguished?
+uniform THE_PREC_ENUM int       occTextureEnable;      //!< Is texture enabled?
+uniform               vec4      occTexTrsf2d[2];       //!< 2D texture transformation parameters
+uniform               float     occPointSize;          //!< point size
+
+//! Parameters of blended order-independent transparency rendering algorithm
+uniform               int       occOitOutput;      //!< Enable bit for writing output color buffers for OIT (occFragColor, occFragCoverage)
+uniform               float     occOitDepthFactor; //!< Influence of the depth component to the coverage of the accumulated fragment
+uniform               float     occAlphaCutoff;    //!< alpha test cutoff value
+
+//! Parameters of clipping planes
+#if defined(THE_MAX_CLIP_PLANES) && (THE_MAX_CLIP_PLANES > 0)
+uniform               vec4 occClipPlaneEquations[THE_MAX_CLIP_PLANES];
+uniform THE_PREC_ENUM int  occClipPlaneChains[THE_MAX_CLIP_PLANES]; //! Indicating the number of planes in the Chain
+uniform THE_PREC_ENUM int  occClipPlaneCount;   //!< Total number of clip planes
+#endif
+//! @endfile Declarations.glsl

package/resources/Shaders/DeclarationsImpl.glsl

@@ -0,0 +1,121 @@
+
+//! @file DeclarationsImpl.glsl includes implementation of common functions and properties accessors
+#if defined(FRAGMENT_SHADER)
+
+#if defined(OCC_DEPTH_PEEL_OIT)
+uniform sampler2D occDepthPeelingDepth;
+uniform sampler2D occDepthPeelingFrontColor;
+int IsFrontPeelLayer = -1;
+bool occFragEarlyReturn()
+{
+  #define THE_DEPTH_CLEAR_VALUE -1e15f
+  ivec2  aFragCoord = ivec2 (gl_FragCoord.xy);
+  vec2   aLastDepth = texelFetch (occDepthPeelingDepth, aFragCoord, 0).rg;
+  occPeelFrontColor = texelFetch (occDepthPeelingFrontColor, aFragCoord, 0);
+  occPeelDepth.rg   = vec2 (THE_DEPTH_CLEAR_VALUE); // depth value always increases, so that MAX blend equation can be used
+  occPeelBackColor  = vec4 (0.0); // back color is blend after each peeling pass
+
+  float aNearDepth = -aLastDepth.x;
+  float aFarDepth  =  aLastDepth.y;
+  float aFragDepth = gl_FragCoord.z; // 0 - 1
+  if (aFragDepth < aNearDepth || aFragDepth > aFarDepth)
+  {
+    return true; // skip peeled depth
+  }
+  else if (aFragDepth > aNearDepth && aFragDepth < aFarDepth)
+  {
+    // to be rendered at next peeling pass
+    occPeelDepth.rg = vec2 (-aFragDepth, aFragDepth);
+    return true;
+  }
+
+  IsFrontPeelLayer = (gl_FragCoord.z == aNearDepth) ? 1 : 0;
+  return false;
+}
+#else
+bool occFragEarlyReturn() { return false; }
+#endif
+
+void occSetFragColor (in vec4 theColor)
+{
+#if defined(OCC_ALPHA_TEST)
+  if (theColor.a < occAlphaCutoff) discard;
+#endif
+#if defined(OCC_WRITE_WEIGHT_OIT_COVERAGE)
+  float aWeight     = theColor.a * clamp (1e+2 * pow (1.0 - gl_FragCoord.z * occOitDepthFactor, 3.0), 1e-2, 1e+2);
+  occFragCoverage.r = theColor.a * aWeight;
+  occFragColor      = vec4 (theColor.rgb * theColor.a * aWeight, theColor.a);
+#elif defined(OCC_DEPTH_PEEL_OIT)
+  if (IsFrontPeelLayer == 1) // front is blended directly
+  {
+    vec4 aLastColor = occPeelFrontColor;
+    float anAlphaMult = 1.0 - aLastColor.a;
+    occPeelFrontColor.rgb = aLastColor.rgb + theColor.rgb * theColor.a * anAlphaMult;
+    occPeelFrontColor.a = 1.0 - anAlphaMult * (1.0 - theColor.a);
+  }
+  else if (IsFrontPeelLayer == 0) // back is blended afterwards
+  {
+    occPeelBackColor = theColor;
+  }
+#else
+  occFragColor = theColor;
+#endif
+}
+#endif
+
+#if defined(THE_MAX_LIGHTS) && (THE_MAX_LIGHTS > 0)
+// arrays of light sources
+uniform               vec4 occLightSources[THE_MAX_LIGHTS * 4]; //!< packed light sources parameters
+uniform THE_PREC_ENUM int occLightSourcesTypes[THE_MAX_LIGHTS]; //!< packed light sources types
+#endif
+
+#if defined(THE_IS_PBR)
+vec3 occDiffIBLMap (in vec3 theNormal)
+{
+  vec3 aSHCoeffs[9];
+  for (int i = 0; i < 9; ++i)
+  {
+    aSHCoeffs[i] = occTexture2D (occDiffIBLMapSHCoeffs, vec2 ((float(i) + 0.5) / 9.0, 0.0)).rgb;
+  }
+  return aSHCoeffs[0]
+
+       + aSHCoeffs[1] * theNormal.x
+	   + aSHCoeffs[2] * theNormal.y
+	   + aSHCoeffs[3] * theNormal.z
+
+	   + aSHCoeffs[4] * theNormal.x * theNormal.z
+	   + aSHCoeffs[5] * theNormal.y * theNormal.z
+	   + aSHCoeffs[6] * theNormal.x * theNormal.y
+
+	   + aSHCoeffs[7] * (3.0 * theNormal.z * theNormal.z - 1.0)
+	   + aSHCoeffs[8] * (theNormal.x * theNormal.x - theNormal.y * theNormal.y);
+}
+#endif
+
+// front and back material properties accessors
+#if defined(THE_IS_PBR)
+uniform vec4 occPbrMaterial[3 * 2];
+
+#define MIN_ROUGHNESS 0.01
+float occRoughness (in float theNormalizedRoughness) { return theNormalizedRoughness * (1.0 - MIN_ROUGHNESS) + MIN_ROUGHNESS; }
+vec4  occPBRMaterial_Color(in bool theIsFront)     { return theIsFront ? occPbrMaterial[0]     : occPbrMaterial[3]; }
+vec3  occPBRMaterial_Emission(in bool theIsFront)  { return theIsFront ? occPbrMaterial[1].rgb : occPbrMaterial[4].rgb; }
+float occPBRMaterial_IOR(in bool theIsFront)       { return theIsFront ? occPbrMaterial[1].w   : occPbrMaterial[4].w; }
+float occPBRMaterial_Metallic(in bool theIsFront)  { return theIsFront ? occPbrMaterial[2].b   : occPbrMaterial[5].b; }
+float occPBRMaterial_NormalizedRoughness(in bool theIsFront) { return theIsFront ? occPbrMaterial[2].g : occPbrMaterial[5].g; }
+#else
+uniform vec4 occCommonMaterial[4 * 2];
+
+vec4  occMaterial_Diffuse(in bool theIsFront)   { return theIsFront ? occCommonMaterial[0]     : occCommonMaterial[4]; }
+vec3  occMaterial_Emission(in bool theIsFront)  { return theIsFront ? occCommonMaterial[1].rgb : occCommonMaterial[5].rgb; }
+vec3  occMaterial_Specular(in bool theIsFront)  { return theIsFront ? occCommonMaterial[2].rgb : occCommonMaterial[6].rgb; }
+float occMaterial_Shininess(in bool theIsFront) { return theIsFront ? occCommonMaterial[2].a   : occCommonMaterial[6].a; }
+vec3  occMaterial_Ambient(in bool theIsFront)   { return theIsFront ? occCommonMaterial[3].rgb : occCommonMaterial[7].rgb; }
+#endif
+
+// 2D texture coordinates transformation
+vec2  occTextureTrsf_Translation(void) { return occTexTrsf2d[0].xy; }
+vec2  occTextureTrsf_Scale(void)       { return occTexTrsf2d[0].zw; }
+float occTextureTrsf_RotationSin(void) { return occTexTrsf2d[1].x; }
+float occTextureTrsf_RotationCos(void) { return occTexTrsf2d[1].y; }
+//! @endfile DeclarationsImpl.glsl