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

package/resources/Shaders/Display.fs

@@ -0,0 +1,157 @@
+#ifdef ADAPTIVE_SAMPLING
+
+  #extension GL_ARB_shader_image_load_store : require
+
+  #extension GL_ARB_shader_image_size : enable
+
+  //! OpenGL image used for accumulating rendering result.
+  volatile restrict layout(r32f) uniform image2D uRenderImage;
+
+  //! OpenGL image storing variance of sampled pixels blocks.
+  volatile restrict layout(r32i) uniform iimage2D uVarianceImage;
+
+  //! Scale factor used to quantize visual error (float) into signed integer.
+  uniform float uVarianceScaleFactor;
+
+  //! Screen space tile size.
+  uniform ivec2 uTileSize;
+
+#else // ADAPTIVE_SAMPLING
+
+  //! Input image.
+  uniform sampler2D uInputTexture;
+
+  //! Ray tracing depth image.
+  uniform sampler2D uDepthTexture;
+
+#endif // ADAPTIVE_SAMPLING
+
+//! Number of accumulated frames.
+uniform int uAccumFrames;
+
+//! Is debug mode enabled for importance screen sampling.
+uniform int uDebugAdaptive;
+
+//! Exposure value for tone mapping.
+uniform float uExposure;
+
+#ifdef TONE_MAPPING_FILMIC
+
+//! White point value for filmic tone mapping.
+uniform float uWhitePoint;
+
+#endif // TONE_MAPPING
+
+//! Output pixel color.
+out vec4 OutColor;
+
+//! RGB weight factors to calculate luminance.
+#define LUMA vec3 (0.2126f, 0.7152f, 0.0722f)
+
+// =======================================================================
+// function : ToneMappingFilmic
+// purpose  :
+// =======================================================================
+vec4 ToneMappingFilmic(vec4 theColor, float theWhitePoint)
+{
+  vec4 aPackColor = vec4 (theColor.rgb, theWhitePoint);
+  vec4 aFilmicCurve = 1.425f * aPackColor + vec4 (0.05f);
+  vec4 aResultColor = (aPackColor * aFilmicCurve + vec4 (0.004f)) / (aPackColor * (aFilmicCurve + vec4 (0.55f)) + vec4 (0.0491f)) - vec4 (0.0821f);
+  return vec4 (aResultColor.rgb / aResultColor.www, 1.0);
+}
+
+// =======================================================================
+// function : main
+// purpose  :
+// =======================================================================
+void main (void)
+{
+#ifndef ADAPTIVE_SAMPLING
+
+  vec4 aColor = texelFetch (uInputTexture, ivec2 (gl_FragCoord.xy), 0);
+
+#ifdef PATH_TRACING
+  float aDepth = aColor.w; // path tracing uses averaged depth
+#else
+  float aDepth = texelFetch (uDepthTexture, ivec2 (gl_FragCoord.xy), 0).r;
+#endif
+
+  gl_FragDepth = aDepth;
+
+#else // ADAPTIVE_SAMPLING
+
+  ivec2 aPixel = ivec2 (gl_FragCoord.xy);
+
+  vec4 aColor = vec4 (0.0);
+
+  // fetch accumulated color and total number of samples
+  aColor.x = imageLoad (uRenderImage, ivec2 (3 * aPixel.x + 0,
+                                             2 * aPixel.y + 0)).x;
+  aColor.y = imageLoad (uRenderImage, ivec2 (3 * aPixel.x + 1,
+                                             2 * aPixel.y + 0)).x;
+  aColor.z = imageLoad (uRenderImage, ivec2 (3 * aPixel.x + 1,
+                                             2 * aPixel.y + 1)).x;
+  aColor.w = imageLoad (uRenderImage, ivec2 (3 * aPixel.x + 0,
+                                             2 * aPixel.y + 1)).x;
+
+  // calculate normalization factor
+  float aSampleWeight = 1.f / max (1.0, aColor.w);
+
+  // calculate averaged depth value
+  gl_FragDepth = imageLoad (uRenderImage, ivec2 (3 * aPixel.x + 2,
+                                                 2 * aPixel.y + 1)).x * aSampleWeight;
+
+  // calculate averaged radiance for all samples and even samples only
+  float aHalfRad = imageLoad (uRenderImage, ivec2 (3 * aPixel.x + 2,
+                                                   2 * aPixel.y + 0)).x * aSampleWeight * 2.f;
+
+  float aAverRad = dot (aColor.rgb, LUMA) * aSampleWeight;
+
+  // apply our 'tone mapping' operator (gamma correction and clamping)
+  aHalfRad = min (1.f, sqrt (aHalfRad));
+  aAverRad = min (1.f, sqrt (aAverRad));
+
+  // calculate visual error
+  float anError = (aAverRad - aHalfRad) * (aAverRad - aHalfRad);
+
+  // accumulate visual error to current block; estimated error is written only
+  // after the first 40 samples and path length has reached 10 bounces or more
+  imageAtomicAdd (uVarianceImage, aPixel / uTileSize,
+                  int (mix (uVarianceScaleFactor, anError * uVarianceScaleFactor, aColor.w > 40.f)));
+
+  if (uDebugAdaptive == 0) // normal rendering
+  {
+    aColor = vec4 (aColor.rgb * aSampleWeight, 1.0);
+  }
+  else // showing number of samples
+  {
+    vec2 aRatio = vec2 (1.f, 1.f);
+#ifdef GL_ARB_shader_image_size
+    aRatio = vec2 (imageSize (uRenderImage)) / vec2 (3.f * 512.f, 2.f * 512.f);
+#endif
+    aColor = vec4 (0.5f * aColor.rgb * aSampleWeight + vec3 (0.f, sqrt (aRatio.x * aRatio.y) * aColor.w / uAccumFrames * 0.35f, 0.f), 1.0);
+  }
+
+#endif // ADAPTIVE_SAMPLING
+
+#ifdef PATH_TRACING
+
+  aColor *= pow (2.0, uExposure);
+
+#ifdef TONE_MAPPING_FILMIC
+  aColor = ToneMappingFilmic (aColor, uWhitePoint);
+#endif // TONE_MAPPING
+
+#ifdef THE_SHIFT_sRGB
+  // apply gamma correction (we use gamma = 2)
+  OutColor = vec4 (sqrt (aColor.rgb), 0.f);
+#else
+  OutColor = vec4 (aColor.rgb, 0.f);
+#endif
+
+#else // not PATH_TRACING
+
+  OutColor = aColor;
+
+#endif
+}

package/resources/Shaders/FILES

@@ -0,0 +1,27 @@
+srcinc:::Declarations.glsl
+srcinc:::DeclarationsImpl.glsl
+srcinc:::LightShadow.glsl
+srcinc:::PBRCookTorrance.glsl
+srcinc:::PBRDirectionalLight.glsl
+srcinc:::PBRDistribution.glsl
+srcinc:::PBREnvBaking.fs
+srcinc:::PBREnvBaking.vs
+srcinc:::PBRFresnel.glsl
+srcinc:::PBRGeometry.glsl
+srcinc:::PBRIllumination.glsl
+srcinc:::PBRPointLight.glsl
+srcinc:::PBRSpotLight.glsl
+srcinc:::PhongShading.fs
+srcinc:::PhongShading.vs
+srcinc:::PhongDirectionalLight.glsl
+srcinc:::PhongPointLight.glsl
+srcinc:::PhongSpotLight.glsl
+srcinc:::PointLightAttenuation.glsl
+srcinc:::Display.fs
+srcinc:::RaytraceBase.fs
+srcinc:::RaytraceRender.fs
+srcinc:::PathtraceBase.fs
+srcinc:::RaytraceBase.vs
+srcinc:::RaytraceSmooth.fs
+srcinc:::TangentSpaceNormal.glsl
+srcinc:::SkydomBackground.fs

package/resources/Shaders/LightShadow.glsl

@@ -0,0 +1,48 @@
+#if (__VERSION__ >= 120)
+//! Coefficients for gathering close samples for antialiasing.
+//! Use only with decent OpenGL (array constants cannot be initialized with GLSL 1.1 / GLSL ES 1.1)
+const vec2 occPoissonDisk16[16] = vec2[](
+ vec2(-0.94201624,-0.39906216), vec2( 0.94558609,-0.76890725), vec2(-0.09418410,-0.92938870), vec2( 0.34495938, 0.29387760),
+ vec2(-0.91588581, 0.45771432), vec2(-0.81544232,-0.87912464), vec2(-0.38277543, 0.27676845), vec2( 0.97484398, 0.75648379),
+ vec2( 0.44323325,-0.97511554), vec2( 0.53742981,-0.47373420), vec2(-0.26496911,-0.41893023), vec2( 0.79197514, 0.19090188),
+ vec2(-0.24188840, 0.99706507), vec2(-0.81409955, 0.91437590), vec2( 0.19984126, 0.78641367), vec2( 0.14383161,-0.14100790)
+);
+#endif
+
+//! Function computes directional and spot light shadow attenuation (1.0 means no shadow).
+float occLightShadow (in sampler2D theShadow,
+                      in int  theId,
+                      in vec3 theNormal)
+{
+  vec4 aPosLightSpace = PosLightSpace[occLight_Index(theId)];
+  vec3 aLightDir = occLight_Position (theId);
+  vec3 aProjCoords = (aPosLightSpace.xyz / aPosLightSpace.w);
+#ifdef THE_ZERO_TO_ONE_DEPTH
+  aProjCoords.xy = aProjCoords.xy * 0.5 + vec2 (0.5);
+#else
+  aProjCoords = aProjCoords * 0.5 + vec3 (0.5);
+#endif
+  float aCurrentDepth = aProjCoords.z;
+  if (aProjCoords.x < 0.0 || aProjCoords.x > 1.0
+   || aProjCoords.y < 0.0 || aProjCoords.y > 1.0
+   || aCurrentDepth > 1.0)
+  {
+    return 1.0;
+  }
+
+  vec2 aTexelSize = vec2 (occShadowMapSizeBias.x);
+  float aBias = max (occShadowMapSizeBias.y * (1.0 - dot (theNormal, aLightDir)), occShadowMapSizeBias.y * 0.1);
+#if (__VERSION__ >= 120)
+  float aShadow = 0.0;
+  for (int aPosIter = 0; aPosIter < 16; ++aPosIter)
+  {
+    float aClosestDepth = occTexture2D (theShadow, aProjCoords.xy + occPoissonDisk16[aPosIter] * aTexelSize).r;
+    aShadow += (aCurrentDepth - aBias) > aClosestDepth ? 1.0 : 0.0;
+  }
+  return 1.0 - aShadow / 16.0;
+#else
+  float aClosestDepth = occTexture2D (theShadow, aProjCoords.xy).r;
+  float aShadow = (aCurrentDepth - aBias) > aClosestDepth ? 1.0 : 0.0;
+  return 1.0 - aShadow;
+#endif
+}

package/resources/Shaders/PBRCookTorrance.glsl

@@ -0,0 +1,20 @@
+//! Calculates Cook-Torrance BRDF.
+vec3 occPBRCookTorrance (in vec3  theView,
+                         in vec3  theLight,
+                         in vec3  theNormal,
+                         in vec3  theBaseColor,
+                         in float theMetallic,
+                         in float theRoughness,
+                         in float theIOR)
+{
+  vec3 aHalf = normalize (theView + theLight);
+  float aCosV = max(dot(theView, theNormal), 0.0);
+  float aCosL = max(dot(theLight, theNormal), 0.0);
+  float aCosH = max(dot(aHalf, theNormal), 0.0);
+  float aCosVH = max(dot(aHalf, theView), 0.0);
+  vec3 aCookTorrance = occPBRDistribution (aCosH, theRoughness)
+                     * occPBRGeometry     (aCosV, aCosL, theRoughness)
+                     * occPBRFresnel      (theBaseColor, theMetallic, theIOR, aCosVH);
+  aCookTorrance /= 4.0;
+  return aCookTorrance;
+}

package/resources/Shaders/PBRDirectionalLight.glsl

@@ -0,0 +1,20 @@
+//! Function computes contribution of directional light source
+//! into global variable DirectLighting (PBR shading).
+//! @param theId      light source index
+//! @param theNormal  surface normal
+//! @param theView    view direction
+//! @param theIsFront front/back face flag
+//! @param theShadow  shadow attenuation
+void occDirectionalLight (in int  theId,
+                          in vec3 theNormal,
+                          in vec3 theView,
+                          in bool theIsFront,
+                          in float theShadow)
+{
+  vec3 aLight = occLight_Position (theId);
+  theNormal = theIsFront ? theNormal : -theNormal;
+  DirectLighting += occPBRIllumination (theView, aLight, theNormal,
+                                        BaseColor, Metallic, Roughness, IOR,
+                                        occLight_Specular (theId),
+                                        occLight_Intensity(theId)) * theShadow;
+}

package/resources/Shaders/PBRDistribution.glsl

@@ -0,0 +1,9 @@
+//! Calculates micro facet normals distribution.
+float occPBRDistribution (in float theCosH,
+                          in float theRoughness)
+{
+  float aDistribution = theRoughness * theRoughness;
+  aDistribution = aDistribution / (theCosH * theCosH * (aDistribution * aDistribution - 1.0) + 1.0);
+  aDistribution = INV_PI * aDistribution * aDistribution;
+  return aDistribution;
+}

package/resources/Shaders/PBREnvBaking.fs

@@ -0,0 +1,226 @@
+THE_SHADER_IN vec3 ViewDirection; //!< direction of fetching from environment cubemap
+
+#if (__VERSION__ >= 120)
+uniform int uSamplesNum;     //!< number of samples in Monte-Carlo integration
+#else
+const int uSamplesNum = 256;
+#endif
+uniform samplerCube uEnvMap; //!< source of baking (environment cubemap)
+
+#ifdef THE_TO_BAKE_DIFFUSE
+uniform int uYCoeff; //!< coefficient of Y controlling horizontal flip of cubemap
+uniform int uZCoeff; //!< coefficient of Z controlling vertical flip of cubemap
+#endif
+
+#ifdef THE_TO_BAKE_SPECULAR
+uniform int   uCurrentLevel;        //!< current level of specular IBL map (ignored in case of diffuse map's processing)
+uniform float uEnvSolidAngleSource; //!< source solid angle sample computed from one edge's size of source environment map's zero mipmap level
+#endif
+
+//! Returns coordinates of point theNumber from Hammersley point set having size theSize.
+vec2 hammersley (in int theNumber,
+                 in int theSize)
+{
+  int aDenominator = 2;
+  int aNumber = theNumber;
+  float aVanDerCorput = 0.0;
+  for (int i = 0; i < 32; ++i)
+  {
+    if (aNumber > 0)
+    {
+      aVanDerCorput += mod(float(aNumber), 2.0) / float(aDenominator);
+      aNumber /= 2;
+      aDenominator *= 2;
+    }
+  }
+  return vec2(float(theNumber) / float(theSize), aVanDerCorput);
+}
+
+//! This function does importance sampling on hemisphere surface using GGX normal distribution function
+//! in tangent space (positive z axis is surface normal direction).
+vec3 importanceSample (in vec2  theHammersleyPoint,
+                       in float theRoughness)
+{
+  float aPhi = PI_2 * theHammersleyPoint.x;
+  theRoughness *= theRoughness;
+  theRoughness *= theRoughness;
+  float aCosTheta = sqrt((1.0 - theHammersleyPoint.y) / (1.0 + (theRoughness - 1.0) * theHammersleyPoint.y));
+  float aSinTheta = sqrt(1.0 - aCosTheta * aCosTheta);
+  return vec3(aSinTheta * cos(aPhi),
+              aSinTheta * sin(aPhi),
+              aCosTheta);
+}
+
+//! This function uniformly generates samples on whole sphere.
+vec3 sphereUniformSample (in vec2 theHammersleyPoint)
+{
+  float aPhi = PI_2 * theHammersleyPoint.x;
+  float aCosTheta = 2.0 * theHammersleyPoint.y - 1.0;
+  float aSinTheta = sqrt(1.0 - aCosTheta * aCosTheta);
+  return vec3(aSinTheta * cos(aPhi),
+              aSinTheta * sin(aPhi),
+              aCosTheta);
+}
+
+//! Transforms resulted sampled direction from tangent space to world space considering the surface normal.
+vec3 fromTangentSpace (in vec3 theVector,
+                       in vec3 theNormal)
+{
+  vec3 anUp = (abs(theNormal.z) < 0.999) ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
+  vec3 anX = normalize(cross(anUp, theNormal));
+  vec3 anY = cross(theNormal, anX);
+  return anX * theVector.x + anY * theVector.y + theNormal * theVector.z;
+}
+
+#ifdef THE_TO_BAKE_DIFFUSE
+#if (__VERSION__ >= 120)
+const float aSHBasisFuncCoeffs[9] = float[9]
+(
+  0.282095 * 0.282095,
+  0.488603 * 0.488603,
+  0.488603 * 0.488603,
+  0.488603 * 0.488603,
+  1.092548 * 1.092548,
+  1.092548 * 1.092548,
+  1.092548 * 1.092548,
+  0.315392 * 0.315392,
+  0.546274 * 0.546274
+);
+const float aSHCosCoeffs[9] = float[9]
+(
+  3.141593,
+  2.094395,
+  2.094395,
+  2.094395,
+  0.785398,
+  0.785398,
+  0.785398,
+  0.785398,
+  0.785398
+);
+#else
+uniform float aSHBasisFuncCoeffs[9];
+uniform float aSHCosCoeffs[9];
+#endif
+
+//! Bakes diffuse IBL map's spherical harmonics coefficients.
+vec3 bakeDiffuseSH()
+{
+  int anId = int(gl_FragCoord.x);
+  float aCoef;
+#if (__VERSION__ >= 120)
+  aCoef = aSHCosCoeffs[anId] * aSHBasisFuncCoeffs[anId];
+#else
+  if      (anId == 0) { aCoef = aSHCosCoeffs[0] * aSHBasisFuncCoeffs[0]; }
+  else if (anId == 1) { aCoef = aSHCosCoeffs[1] * aSHBasisFuncCoeffs[1]; }
+  else if (anId == 2) { aCoef = aSHCosCoeffs[2] * aSHBasisFuncCoeffs[2]; }
+  else if (anId == 3) { aCoef = aSHCosCoeffs[3] * aSHBasisFuncCoeffs[3]; }
+  else if (anId == 4) { aCoef = aSHCosCoeffs[4] * aSHBasisFuncCoeffs[4]; }
+  else if (anId == 5) { aCoef = aSHCosCoeffs[5] * aSHBasisFuncCoeffs[5]; }
+  else if (anId == 6) { aCoef = aSHCosCoeffs[6] * aSHBasisFuncCoeffs[6]; }
+  else if (anId == 7) { aCoef = aSHCosCoeffs[7] * aSHBasisFuncCoeffs[7]; }
+  else                { aCoef = aSHCosCoeffs[8] * aSHBasisFuncCoeffs[8]; }
+#endif
+  vec3 aRes = vec3 (0.0);
+  for (int aSampleIter = 0; aSampleIter < uSamplesNum; ++aSampleIter)
+  {
+    vec2 aHammersleyPoint = hammersley (aSampleIter, uSamplesNum);
+    vec3 aDir = sphereUniformSample (aHammersleyPoint);
+
+    vec3 aVal = occTextureCube (uEnvMap, cubemapVectorTransform (aDir, uYCoeff, uZCoeff)).rgb;
+  #if (__VERSION__ >= 120)
+    float aFunc[9];
+    aFunc[0] = 1.0;
+
+    aFunc[1] = aDir.x;
+    aFunc[2] = aDir.y;
+    aFunc[3] = aDir.z;
+
+    aFunc[4] = aDir.x * aDir.z;
+    aFunc[5] = aDir.y * aDir.z;
+    aFunc[6] = aDir.x * aDir.y;
+
+    aFunc[7] = 3.0 * aDir.z * aDir.z - 1.0;
+    aFunc[8] = aDir.x * aDir.x - aDir.y * aDir.y;
+
+    aRes += aVal * aFunc[anId];
+  #else
+    if      (anId == 0) { aRes += aVal * 1.0; }
+    else if (anId == 1) { aRes += aVal * aDir.x; }
+    else if (anId == 2) { aRes += aVal * aDir.y; }
+    else if (anId == 3) { aRes += aVal * aDir.z; }
+    else if (anId == 4) { aRes += aVal * (aDir.x * aDir.z); }
+    else if (anId == 5) { aRes += aVal * (aDir.y * aDir.z); }
+    else if (anId == 6) { aRes += aVal * (aDir.x * aDir.y); }
+    else if (anId == 7) { aRes += aVal * (3.0 * aDir.z * aDir.z - 1.0); }
+    else                { aRes += aVal * (aDir.x * aDir.x - aDir.y * aDir.y); }
+  #endif
+  }
+
+  return 4.0 * aRes * aCoef / float(uSamplesNum);
+}
+#endif
+
+#ifdef THE_TO_BAKE_SPECULAR
+//! Computes a single sample for specular IBL map.
+vec4 specularMapSample (in vec3  theNormal,
+                        in float theRoughness,
+                        in int   theNumber,
+                        in int   theSize)
+{
+  vec2 aHammersleyPoint = hammersley (theNumber, theSize);
+  vec3 aHalf = importanceSample (aHammersleyPoint, occRoughness (theRoughness));
+  float aHdotV = aHalf.z;
+  aHalf = fromTangentSpace (aHalf, theNormal);
+  vec3  aLight = -reflect (theNormal, aHalf);
+  float aNdotL = dot (aLight, theNormal);
+  if (aNdotL > 0.0)
+  {
+    float aSolidAngleSample = 1.0 / (float(theSize) * (occPBRDistribution (aHdotV, theRoughness) * 0.25 + 0.0001) + 0.0001);
+    float aLod = (theRoughness == 0.0) ? 0.0 : 0.5 * log2 (aSolidAngleSample / uEnvSolidAngleSource);
+    return vec4 (occTextureCubeLod (uEnvMap, aLight, aLod).rgb * aNdotL, aNdotL);
+  }
+  return vec4 (0.0);
+}
+
+//! Bakes specular IBL map.
+vec3 bakeSpecularMap (in vec3  theNormal,
+                      in float theRoughness)
+{
+  vec4 aResult = vec4(0.0);
+  if (theRoughness == 0.0)
+  {
+    aResult = specularMapSample (theNormal, theRoughness, 0, 1);
+  }
+  else
+  {
+    for (int aSampleIter = 0; aSampleIter < uSamplesNum; ++aSampleIter)
+    {
+      aResult += specularMapSample (theNormal, theRoughness, aSampleIter, uSamplesNum);
+    }
+  }
+  return aResult.xyz / aResult.w;
+}
+#endif
+
+void main()
+{
+  vec3 aViewDirection = normalize (ViewDirection);
+#ifdef THE_TO_BAKE_DIFFUSE
+  vec4 aRes = vec4 (bakeDiffuseSH(), 1.0);
+#ifdef THE_TO_PACK_FLOAT
+  int aCompIndex = int(gl_FragCoord.y);
+  float aComp = aCompIndex == 0 ? aRes.x : (aCompIndex == 1 ? aRes.y : aRes.z);
+  int aFixedPrec = int(aComp * 2147483647.0);
+  int aFixedDiv1 = aFixedPrec / 256;
+  int aFixedDiv2 = aFixedDiv1 / 256;
+  int aFixedDiv3 = aFixedDiv2 / 256;
+  vec4 aPacked = vec4(float(aFixedPrec), float(aFixedDiv1), float(aFixedDiv2), float(aFixedDiv3));
+  aRes = fract (aPacked * (1.0 / 256.0));
+#endif
+  occFragColor = aRes;
+#else
+  float aRoughness = float(uCurrentLevel) / float(occNbSpecIBLLevels - 1);
+  occFragColor = vec4 (bakeSpecularMap (aViewDirection, aRoughness), 1.0);
+#endif
+}

package/resources/Shaders/PBREnvBaking.vs

@@ -0,0 +1,55 @@
+THE_SHADER_OUT vec3 ViewDirection; //!< direction of fetching from environment cubemap
+
+uniform int uCurrentSide; //!< current side of cubemap
+uniform int uYCoeff;      //!< coefficient of Y controlling horizontal flip of cubemap
+uniform int uZCoeff;      //!< coefficient of Z controlling vertical flip of cubemap
+
+void main()
+{
+  vec3 aDir;
+  vec2 aCoord;
+  if (uCurrentSide == 0)
+  {
+    aCoord = mat2( 0,-1,-1, 0) * occVertex.xy;
+    aDir.x = 1.0;
+    aDir.y = aCoord.x;
+    aDir.z = aCoord.y;
+  }
+  else if (uCurrentSide == 1)
+  {
+    aCoord = mat2( 0, 1,-1, 0) * occVertex.xy;
+    aDir.x = -1.0;
+    aDir.y = aCoord.x;
+    aDir.z = aCoord.y;
+  }
+  else if (uCurrentSide == 2)
+  {
+    aCoord = mat2( 0, 1, 1, 0) * occVertex.xy;
+    aDir.x = aCoord.y;
+    aDir.y = 1.0;
+    aDir.z = aCoord.x;
+  }
+  else if (uCurrentSide == 3)
+  {
+    aCoord = mat2( 0, 1,-1, 0) * occVertex.xy;
+    aDir.x = aCoord.y;
+    aDir.y = -1.0;
+    aDir.z = aCoord.x;
+  }
+  else if (uCurrentSide == 4)
+  {
+    aCoord = mat2( 1, 0, 0,-1) * occVertex.xy;
+    aDir.x = aCoord.x;
+    aDir.y = aCoord.y;
+    aDir.z = 1.0;
+  }
+  else //if (uCurrentSide == 5)
+  {
+    aCoord = mat2(-1, 0, 0,-1) * occVertex.xy;
+    aDir.x = aCoord.x;
+    aDir.y = aCoord.y;
+    aDir.z = -1.0;
+  }
+  ViewDirection = cubemapVectorTransform (aDir, uYCoeff, uZCoeff);
+  gl_Position = vec4 (occVertex.xy, 0.0, 1.0);
+}

package/resources/Shaders/PBRFresnel.glsl

@@ -0,0 +1,36 @@
+//! Functions to calculate fresnel coefficient and approximate zero fresnel value.
+vec3 occPBRFresnel (in vec3  theBaseColor,
+                    in float theMetallic,
+                    in float theIOR)
+{
+  theIOR = (1.0 - theIOR) / (1.0 + theIOR);
+  theIOR *= theIOR;
+  vec3 f0 = vec3(theIOR);
+  f0 = mix (f0, theBaseColor.rgb, theMetallic);
+  return f0;
+}
+
+vec3 occPBRFresnel (in vec3  theBaseColor,
+                    in float theMetallic,
+                    in float theIOR,
+                    in float theCosVH)
+{
+  vec3 f0 = occPBRFresnel (theBaseColor, theMetallic, theIOR);
+  theCosVH = 1.0 - theCosVH;
+  theCosVH *= theCosVH;
+  theCosVH *= theCosVH * theCosVH * theCosVH * theCosVH;
+  return f0 + (vec3 (1.0) - f0) * theCosVH;
+}
+
+vec3 occPBRFresnel (in vec3  theBaseColor,
+                    in float theMetallic,
+                    in float theRoughness,
+                    in float theIOR,
+                    in float theCosV)
+{
+  vec3 f0 = occPBRFresnel (theBaseColor, theMetallic, theIOR);
+  theCosV = 1.0 - theCosV;
+  theCosV *= theCosV;
+  theCosV *= theCosV * theCosV * theCosV * theCosV;
+  return f0 + (max(vec3(1.0 - theRoughness), f0) - f0) * theCosV;
+}

package/resources/Shaders/PBRGeometry.glsl

@@ -0,0 +1,13 @@
+//! Calculates geometry factor for Cook-Torrance BRDF.
+float occPBRGeometry (in float theCosV,
+                      in float theCosL,
+                      in float theRoughness)
+{
+  float k = theRoughness + 1.0;
+  k *= 0.125 * k;
+  float g1 = 1.0;
+  g1 /= theCosV * (1.0 - k) + k;
+  float g2 = 1.0;
+  g2 /= theCosL * (1.0 - k) + k;
+  return g1 * g2;
+}

package/resources/Shaders/PBRIllumination.glsl

@@ -0,0 +1,28 @@
+//! Calculates direct illumination using Cook-Torrance BRDF.
+vec3 occPBRIllumination (in vec3  theView,
+                         in vec3  theLight,
+                         in vec3  theNormal,
+                         in vec4  theBaseColor,
+                         in float theMetallic,
+                         in float theRoughness,
+                         in float theIOR,
+                         in vec3  theLightColor,
+                         in float theLightIntensity)
+{
+  vec3 aHalf = normalize (theView + theLight);
+  float aCosVH = max(dot(theView, aHalf), 0.0);
+  vec3 aFresnel = occPBRFresnel (theBaseColor.rgb, theMetallic, theIOR, aCosVH);
+  vec3 aSpecular = occPBRCookTorrance (theView,
+                                       theLight,
+                                       theNormal,
+                                       theBaseColor.rgb,
+                                       theMetallic,
+                                       theRoughness,
+                                       theIOR);
+  vec3 aDiffuse = vec3(1.0) - aFresnel;
+  aDiffuse *= 1.0 - theMetallic;
+  aDiffuse *= INV_PI;
+  aDiffuse *= theBaseColor.rgb;
+  aDiffuse = mix (vec3(0.0), aDiffuse, theBaseColor.a);
+  return (aDiffuse + aSpecular) * theLightColor * theLightIntensity * max(0.0, dot(theLight, theNormal));
+}

package/resources/Shaders/PBRPointLight.glsl

@@ -0,0 +1,27 @@
+//! Function computes contribution of isotropic point light source
+//! into global variable DirectLighting (PBR shading).
+//! @param theId      light source index
+//! @param theNormal  surface normal
+//! @param theView    view direction
+//! @param thePoint   3D position (world space)
+//! @param theIsFront front/back face flag
+void occPointLight (in int  theId,
+                    in vec3 theNormal,
+                    in vec3 theView,
+                    in vec3 thePoint,
+                    in bool theIsFront)
+{
+  vec3 aLight = occLight_Position (theId) - thePoint;
+
+  float aDist = length (aLight);
+  float aRange = occLight_Range (theId);
+  float anAtten = occPointLightAttenuation (aDist, aRange);
+  if (anAtten <= 0.0) return;
+  aLight /= aDist;
+
+  theNormal = theIsFront ? theNormal : -theNormal;
+  DirectLighting += occPBRIllumination (theView, aLight, theNormal,
+                                        BaseColor, Metallic, Roughness, IOR,
+                                        occLight_Specular (theId),
+                                        occLight_Intensity(theId) * anAtten);
+}