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

package/resources/Shaders/RaytraceBase.vs

@@ -0,0 +1,12 @@
+in vec4 occVertex;
+
+//! Normalized pixel coordinates.
+out vec2 vPixel;
+
+void main (void)
+{
+  vPixel = vec2 ((occVertex.x + 1.f) * 0.5f,
+                 (occVertex.y + 1.f) * 0.5f);
+
+  gl_Position = occVertex;
+}

package/resources/Shaders/RaytraceRender.fs

@@ -0,0 +1,134 @@
+out vec4 OutColor;
+
+// Seed for random number generator (generated on CPU).
+uniform int uFrameRndSeed;
+
+//! Enables/disables using of single RNG seed for 16x16 image
+//! blocks. Increases performance up to 4x, but the noise has
+//! become structured. Can be used fo final rendering.
+uniform int uBlockedRngEnabled;
+
+//! Number of previously rendered frames (used in non-ISS mode).
+uniform int uAccumSamples;
+
+#ifndef ADAPTIVE_SAMPLING
+  //! Input image with previously accumulated samples.
+  uniform sampler2D uAccumTexture;
+#endif
+
+//! Maximum radiance that can be added to the pixel.
+//! Decreases noise level, but introduces some bias.
+uniform float uMaxRadiance;
+
+#ifdef ADAPTIVE_SAMPLING
+//! Wrapper over imageLoad()+imageStore() having similar syntax as imageAtomicAdd().
+//! Modifies one component of 3Wx2H uRenderImage:
+//! |RGL| Red, Green, Luminance
+//! |SBH| Samples, Blue, Hit time transformed into OpenGL NDC space
+//! Returns previous value of the component.
+float addRenderImageComp (in ivec2 theFrag, in ivec2 theComp, in float theVal)
+{
+  ivec2 aCoord = ivec2 (3 * theFrag.x + theComp.x,
+                        2 * theFrag.y + theComp.y);
+#ifdef ADAPTIVE_SAMPLING_ATOMIC
+  return imageAtomicAdd (uRenderImage, aCoord, theVal);
+#else
+  float aVal = imageLoad (uRenderImage, aCoord).x;
+  imageStore (uRenderImage, aCoord, vec4 (aVal + theVal));
+  return aVal;
+#endif
+}
+#endif
+
+// =======================================================================
+// function : main
+// purpose  :
+// =======================================================================
+void main (void)
+{
+  SeedRand (uFrameRndSeed, uWinSizeX, uBlockedRngEnabled == 0 ? 1 : 16);
+
+#ifndef PATH_TRACING
+
+  SRay aRay = GenerateRay (vPixel);
+
+#else
+
+  ivec2 aFragCoord = ivec2 (gl_FragCoord.xy);
+
+#ifdef ADAPTIVE_SAMPLING
+
+#ifdef ADAPTIVE_SAMPLING_ATOMIC
+  ivec2 aTileXY = imageLoad (uOffsetImage, aFragCoord / uTileSize).xy * uTileSize;
+  if (aTileXY.x < 0) { discard; }
+
+  ivec2 aRealBlockSize = ivec2 (min (uWinSizeX - aTileXY.x, uTileSize.x),
+                                min (uWinSizeY - aTileXY.y, uTileSize.y));
+
+  aFragCoord.x = aTileXY.x + (aFragCoord.x % aRealBlockSize.x);
+  aFragCoord.y = aTileXY.y + (aFragCoord.y % aRealBlockSize.y);
+#else
+  int aNbTileSamples = imageAtomicAdd (uTilesImage, aFragCoord / uTileSize, int(-1));
+  if (aNbTileSamples <= 0)
+  {
+    discard;
+  }
+#endif
+
+#endif // ADAPTIVE_SAMPLING
+
+  vec2 aPnt = vec2 (float(aFragCoord.x) + RandFloat(),
+                    float(aFragCoord.y) + RandFloat());
+
+  SRay aRay = GenerateRay (aPnt / vec2 (uWinSizeX, uWinSizeY));
+
+#endif // PATH_TRACING
+
+  vec3 aInvDirect = InverseDirection (aRay.Direct);
+
+#ifdef PATH_TRACING
+
+#ifndef ADAPTIVE_SAMPLING
+  vec4 aColor = PathTrace (aRay, aInvDirect, uAccumSamples);
+#else
+  float aNbSamples = addRenderImageComp (aFragCoord, ivec2 (0, 1), 1.0);
+  vec4 aColor = PathTrace (aRay, aInvDirect, int (aNbSamples));
+#endif
+
+  if (any (isnan (aColor.rgb)))
+  {
+    aColor.rgb = ZERO;
+  }
+  aColor.rgb = min (aColor.rgb, vec3 (uMaxRadiance));
+
+#ifdef ADAPTIVE_SAMPLING
+
+  // accumulate RGB color and depth
+  addRenderImageComp (aFragCoord, ivec2 (0, 0), aColor.r);
+  addRenderImageComp (aFragCoord, ivec2 (1, 0), aColor.g);
+  addRenderImageComp (aFragCoord, ivec2 (1, 1), aColor.b);
+  addRenderImageComp (aFragCoord, ivec2 (2, 1), aColor.w);
+  if (int (aNbSamples) % 2 == 0) // accumulate luminance for even samples only
+  {
+    addRenderImageComp (aFragCoord, ivec2 (2, 0), dot (LUMA, aColor.rgb));
+  }
+
+#else
+
+  if (uAccumSamples == 0)
+  {
+    OutColor = aColor;
+  }
+  else
+  {
+    OutColor = mix (texture (uAccumTexture, vPixel), aColor, 1.0 / float(uAccumSamples + 1));
+  }
+
+#endif // ADAPTIVE_SAMPLING
+
+#else
+
+  OutColor = clamp (Radiance (aRay, aInvDirect), 0.f, 1.f);
+
+#endif // PATH_TRACING
+}

package/resources/Shaders/RaytraceSmooth.fs

@@ -0,0 +1,80 @@
+//! Input ray-traced image.
+uniform sampler2D uFSAAInputTexture;
+
+//! Number of accumulated FSAA samples.
+uniform int uSamples;
+
+//! Output pixel color.
+out vec4 OutColor;
+
+#define LUM_DIFFERENCE 0.085f
+
+// =======================================================================
+// function : main
+// purpose  :
+// =======================================================================
+void main (void)
+{
+#ifndef PATH_TRACING
+
+  int aPixelX = int (gl_FragCoord.x);
+  int aPixelY = int (gl_FragCoord.y);
+
+  // Adjust FLIPTRI pattern used for adaptive FSAA
+  float anOffsetX = mix (uFsaaOffset.x, -uFsaaOffset.x, float (aPixelX % 2));
+  float anOffsetY = mix (uFsaaOffset.y, -uFsaaOffset.y, float (aPixelY % 2));
+
+  vec4 aClr0 = texelFetch (uFSAAInputTexture, ivec2 (aPixelX + 0, aPixelY + 0), 0);
+  vec4 aClr1 = texelFetch (uFSAAInputTexture, ivec2 (aPixelX + 0, aPixelY - 1), 0);
+  vec4 aClr2 = texelFetch (uFSAAInputTexture, ivec2 (aPixelX + 0, aPixelY + 1), 0);
+
+  vec4 aClr3 = texelFetch (uFSAAInputTexture, ivec2 (aPixelX + 1, aPixelY + 0), 0);
+  vec4 aClr4 = texelFetch (uFSAAInputTexture, ivec2 (aPixelX + 1, aPixelY - 1), 0);
+  vec4 aClr5 = texelFetch (uFSAAInputTexture, ivec2 (aPixelX + 1, aPixelY + 1), 0);
+
+  vec4 aClr6 = texelFetch (uFSAAInputTexture, ivec2 (aPixelX - 1, aPixelY + 0), 0);
+  vec4 aClr7 = texelFetch (uFSAAInputTexture, ivec2 (aPixelX - 1, aPixelY - 1), 0);
+  vec4 aClr8 = texelFetch (uFSAAInputTexture, ivec2 (aPixelX - 1, aPixelY + 1), 0);
+
+  float aLum = dot (LUMA, aClr0.xyz);
+
+  bool aRender = abs (aClr1.w - aClr0.w) > LUM_DIFFERENCE ||
+                 abs (aClr2.w - aClr0.w) > LUM_DIFFERENCE ||
+                 abs (aClr3.w - aClr0.w) > LUM_DIFFERENCE ||
+                 abs (aClr4.w - aClr0.w) > LUM_DIFFERENCE ||
+                 abs (aClr5.w - aClr0.w) > LUM_DIFFERENCE ||
+                 abs (aClr6.w - aClr0.w) > LUM_DIFFERENCE ||
+                 abs (aClr7.w - aClr0.w) > LUM_DIFFERENCE ||
+                 abs (aClr8.w - aClr0.w) > LUM_DIFFERENCE;
+
+  if (!aRender)
+  {
+    aRender = abs (dot (LUMA, aClr1.xyz) - aLum) > LUM_DIFFERENCE ||
+              abs (dot (LUMA, aClr2.xyz) - aLum) > LUM_DIFFERENCE ||
+              abs (dot (LUMA, aClr3.xyz) - aLum) > LUM_DIFFERENCE ||
+              abs (dot (LUMA, aClr4.xyz) - aLum) > LUM_DIFFERENCE ||
+              abs (dot (LUMA, aClr5.xyz) - aLum) > LUM_DIFFERENCE ||
+              abs (dot (LUMA, aClr6.xyz) - aLum) > LUM_DIFFERENCE ||
+              abs (dot (LUMA, aClr7.xyz) - aLum) > LUM_DIFFERENCE ||
+              abs (dot (LUMA, aClr8.xyz) - aLum) > LUM_DIFFERENCE;
+  }
+
+  vec4 aColor = aClr0;
+
+  if (aRender)
+  {
+    SRay aRay = GenerateRay (vPixel + vec2 (anOffsetX, anOffsetY));
+
+    vec3 aInvDirect = 1.f / max (abs (aRay.Direct), SMALL);
+
+    aInvDirect = vec3 (aRay.Direct.x < 0.f ? -aInvDirect.x : aInvDirect.x,
+                       aRay.Direct.y < 0.f ? -aInvDirect.y : aInvDirect.y,
+                       aRay.Direct.z < 0.f ? -aInvDirect.z : aInvDirect.z);
+
+    aColor = mix (aClr0, clamp (Radiance (aRay, aInvDirect), 0.0, 1.0), 1.0 / float(uSamples));
+  }
+
+  OutColor = aColor;
+
+#endif
+}

package/resources/Shaders/SkydomBackground.fs

@@ -0,0 +1,300 @@
+// Constants
+const float M_PI = 3.1415926535;
+const float THE_EARTH_RADIUS = 6360e3;
+const vec3  THE_EARTH_CENTER = vec3 (0.0, -THE_EARTH_RADIUS, 0.0);
+const float THE_ATMO_RADIUS  = 6380e3;  // atmosphere radius (6420e3?)
+const float THE_G            = 0.76;    // anisotropy of the medium (papers use 0.76)
+const float THE_G2           = THE_G * THE_G;
+const float THE_HR           = 8000.0;  // Thickness of the atmosphere
+const float THE_HM           = 1000.0;  // Same as above but for Mie
+const vec3  THE_BETA_R       = vec3 (5.8e-6, 13.5e-6, 33.1e-6); // Reyleigh scattering normal earth
+const vec3  THE_BETA_M       = vec3 (21e-6); // Normal Mie scattering
+
+// Parameters
+const float THE_SunAttenuation = 1.0;   // sun intensity
+const float THE_EyeHeight      = 100.0; // viewer height
+const float THE_HorizonWidth   = 0.002;
+const int   THE_NbSamples      = 8;
+const int   THE_NbSamplesLight = 8;     // integral sampling rate (might highly hit performance)
+const float THE_SunPower       = 5.0;
+const float THE_StarTreshold   = 0.98;
+
+// Uniforms
+uniform vec3  uSunDir;
+uniform float uTime;
+uniform float uCloudy;
+uniform float uFog;
+
+float hash13 (in vec3 p3)
+{
+  p3  = fract (p3 * 0.1031);
+  p3 += dot (p3, p3.zyx + 31.32);
+  return fract ((p3.x + p3.y) * p3.z);
+}
+
+float hash12 (in vec2 p)
+{
+  vec3 p3  = fract (vec3(p.xyx) * .1031);
+  p3 += dot (p3, p3.yzx + 33.33);
+  return fract ((p3.x + p3.y) * p3.z);
+}
+
+float smoothStarField (in vec2 theSamplePos)
+{
+  vec2 aFract = fract (theSamplePos);
+  vec2 aFloorSample = floor (theSamplePos);
+  float v1 = hash12 (aFloorSample);
+  float v2 = hash12 (aFloorSample + vec2( 0.0, 1.0 ));
+  float v3 = hash12 (aFloorSample + vec2( 1.0, 0.0 ));
+  float v4 = hash12 (aFloorSample + vec2( 1.0, 1.0 ));
+
+  vec2 u = aFract * aFract * (3.0 - 2.0 * aFract);
+
+  return mix(v1, v2, u.x) +
+            (v3 - v1) * u.y * (1.0 - u.x) +
+            (v4 - v2) * u.x * u.y;
+}
+
+float noisyStarField (in vec2 theSamplePos)
+{
+  float aStarVal = smoothStarField (theSamplePos);
+  if (aStarVal >= THE_StarTreshold)
+  {
+    aStarVal = pow ((aStarVal - THE_StarTreshold) / (1.0 - THE_StarTreshold), 6.0);
+  }
+  else
+  {
+    aStarVal = 0.0;
+  }
+  return aStarVal;
+}
+
+float smoothNoise (in vec3 theCoord)
+{
+  vec3 anInt   = floor (theCoord);
+  vec3 anFract = fract (theCoord);
+  anFract = anFract * anFract * (3.0 - (2.0 * anFract));
+  return mix(mix(mix(hash13(anInt                      ),
+                     hash13(anInt + vec3(1.0, 0.0, 0.0)), anFract.x),
+                 mix(hash13(anInt + vec3(0.0, 1.0, 0.0)),
+                     hash13(anInt + vec3(1.0, 1.0, 0.0)), anFract.x), anFract.y),
+             mix(mix(hash13(anInt + vec3(0.0, 0.0, 1.0)),
+                     hash13(anInt + vec3(1.0, 0.0, 1.0)), anFract.x),
+                 mix(hash13(anInt + vec3(0.0, 1.0, 1.0)),
+                     hash13(anInt + vec3(1.0, 1.0, 1.0)), anFract.x), anFract.y), anFract.z);
+}
+
+float fnoise (in vec3 theCoord, in float theTime)
+{
+  theCoord *= .25;
+  float aNoise;
+
+  aNoise =  0.5000 * smoothNoise (theCoord);
+  theCoord = theCoord * 3.02; theCoord.y -= theTime * 0.2;
+  aNoise += 0.2500 * smoothNoise (theCoord);
+  theCoord = theCoord * 3.03; theCoord.y += theTime * 0.06;
+  aNoise += 0.1250 * smoothNoise (theCoord);
+  theCoord = theCoord * 3.01;
+  aNoise += 0.0625 * smoothNoise (theCoord);
+  theCoord = theCoord * 3.03;
+  aNoise += 0.03125 * smoothNoise (theCoord);
+  theCoord = theCoord * 3.02;
+  aNoise += 0.015625 * smoothNoise (theCoord);
+  return aNoise;
+}
+
+float clouds (in vec3 theTs, in float theTime)
+{
+  float aCloud = fnoise (theTs * 2e-4, theTime) + uCloudy * 0.1;
+  aCloud = smoothstep (0.44, 0.64, aCloud);
+  aCloud *= 70.0;
+  return aCloud + uFog;
+}
+
+void densities (in vec3 thePos, out float theRayleigh, out float theMie, in float theTime)
+{
+  float aHeight = length (thePos - THE_EARTH_CENTER) - THE_EARTH_RADIUS;
+  theRayleigh = exp (-aHeight / THE_HR);
+
+  float aCloud = 0.0;
+  if (aHeight > 5000.0 && aHeight < 8000.0)
+  {
+    aCloud  = clouds (thePos + vec3 (0.0, 0.,-theTime*3e3), theTime);
+    aCloud *= sin (M_PI*(aHeight - 5e3) / 5e3) * uCloudy;
+  }
+
+  float aCloud2 = 0.0;
+  if (aHeight > 12e3 && aHeight < 15.5e3)
+  {
+    aCloud2 = fnoise (thePos * 3e-4, theTime) * clouds (thePos * 32.0, theTime);
+    aCloud2 *= sin (M_PI * (aHeight - 12e3) / 12e3) * 0.05;
+    aCloud2 = clamp (aCloud2, 0.0, 1.0);
+  }
+
+  theMie = exp (-aHeight / THE_HM) + aCloud + uFog;
+  theMie += aCloud2;
+}
+
+// ray with sphere intersection problem is reduced to solving the equation
+// (P - C)^2 = r^2             <--- sphere equation
+// where P is P(t) = A + t*B   <--- point on ray
+// t^2*dot(B, B) + t*2*dot(B, A-C) + dot(A-C, A-C) - r^2 = 0
+//     [   A   ]     [     B     ]   [        C        ]
+// We just need to solve the above quadratic equation
+float raySphereIntersect (in vec3 theOrig, in vec3 theDir, in float theRadius)
+{
+  theOrig = theOrig - THE_EARTH_CENTER;
+  // A coefficient will be always 1 (theDir is normalized)
+  float B = dot (theOrig, theDir);
+  float C = dot (theOrig, theOrig) - theRadius * theRadius;
+  // optimized version of classic (-b +- sqrt(b^2 - 4ac)) / 2a
+  float aDet2 = B * B - C;
+  if (aDet2 < 0.0) { return -1.0; }
+  float aDet = sqrt (aDet2);
+  float aT1 = -B - aDet;
+  float aT2 = -B + aDet;
+  return aT1 >= 0.0 ? aT1 : aT2;
+}
+
+void scatter (in vec3 theEye, in vec3 theRay, in vec3 theSun,
+              out vec3 theCol, out float theScat, in float theTime)
+{
+  float aRayLen = raySphereIntersect (theEye, theRay, THE_ATMO_RADIUS);
+  float aMu     = dot (theRay, theSun);
+  float aMu2    = 1.0 + aMu*aMu;
+  // The Raleigh phase function looks like this:
+  float aPhaseR = 3.0/(16.0 * M_PI) * aMu2;
+  // And the Mie phase function equation is:
+  float aPhaseM = (3.0 / (8.0 * M_PI) * (1.0 - THE_G2) * aMu2)
+                / ((2.0 + THE_G2) * pow (1.0 + THE_G2 - 2.0 * THE_G * aMu, 1.5));
+
+  float anOpticalDepthR = 0.0;
+  float anOpticalDepthM = 0.0;
+  vec3 aSumR = vec3 (0.0);
+  vec3 aSumM = vec3 (0.0); // Mie and Rayleigh contribution
+
+  float dl = aRayLen / float (THE_NbSamples);
+  for (int i = 0; i < THE_NbSamples; ++i)
+  {
+    float l = float(i) * dl;
+    vec3 aSamplePos = theEye + theRay * l;
+
+    float dR, dM;
+    densities (aSamplePos, dR, dM, theTime);
+    dR *= dl;
+    dM *= dl;
+    anOpticalDepthR += dR;
+    anOpticalDepthM += dM;
+
+    float aSegmentLengthLight = raySphereIntersect (aSamplePos, theSun, THE_ATMO_RADIUS);
+    if (aSegmentLengthLight > 0.0)
+    {
+      float dls = aSegmentLengthLight / float (THE_NbSamplesLight);
+      float anOpticalDepthRs = 0.0;
+      float anOpticalDepthMs = 0.0;
+      for (int j = 0; j < THE_NbSamplesLight; ++j)
+      {
+        float ls = float (j) * dls;
+        vec3 aSamplePosS = aSamplePos + theSun * ls;
+        float dRs, dMs;
+        densities (aSamplePosS, dRs, dMs, theTime);
+        anOpticalDepthRs += dRs * dls;
+        anOpticalDepthMs += dMs * dls;
+      }
+
+      vec3 anAttenuation = exp (-(THE_BETA_R * (anOpticalDepthR + anOpticalDepthRs)
+                                + THE_BETA_M * (anOpticalDepthM + anOpticalDepthMs)));
+      aSumR += anAttenuation * dR;
+      aSumM += anAttenuation * dM;
+    }
+  }
+
+  theCol = THE_SunPower * (aSumR * THE_BETA_R * aPhaseR + aSumM * THE_BETA_M * aPhaseM);
+  theScat = 1.0 - clamp (anOpticalDepthM*1e-5, 0.0, 1.0);
+}
+
+// This is where all the magic happens. We first raymarch along the primary ray
+// (from the camera origin to the point where the ray exits the atmosphere).
+// For each sample along the primary ray,
+// we then "cast" a light ray and raymarch along that ray as well.
+// We basically shoot a ray in the direction of the sun.
+vec4 computeIncidentLight (in vec3 theRayDirection, in vec2 theUv, in float theTime)
+{
+  float aSunAttenuation = THE_SunAttenuation;
+  vec3 aSunDir = uSunDir;
+  // conversion to moon
+  float aStarAttenuation = 0.0;
+  if (aSunDir.y < 0.0)
+  {
+    aSunDir *= -1.0;
+    aSunAttenuation = aSunAttenuation * 0.1;
+    aStarAttenuation = sqrt (aSunDir.y);
+  }
+
+  vec3 anEyePosition = vec3(0.0, THE_EyeHeight, 0.0);
+
+  // draw a water surface horizontally symmetrically to the sky
+  if (theRayDirection.y <= -THE_HorizonWidth / 2.0)
+  {
+    theRayDirection.y = -THE_HorizonWidth - theRayDirection.y;
+  }
+
+  float aScattering = 0.0;
+  vec3  aColor = vec3 (0.0);
+
+  scatter (anEyePosition, theRayDirection, aSunDir, aColor, aScattering, theTime);
+  aColor *= aSunAttenuation;
+  float aStarIntensity = noisyStarField (theUv * 2048.0);
+  vec3 aStarColor = vec3 (aScattering * aStarIntensity * aStarAttenuation);
+  aColor += aStarColor;
+
+  return vec4 (1.18 * pow (aColor, vec3(0.7)), 1.0);
+}
+
+uniform int uSide;
+
+void main()
+{
+  vec2 anUv = vec2 (2.0 * TexCoord.x - 1.0,
+                    2.0 * TexCoord.y - 1.0);
+  vec3 aPlanes[6];
+  aPlanes[0] = vec3 (+1.0, 0.0, 0.0);
+  aPlanes[1] = vec3 (-1.0, 0.0, 0.0);
+  aPlanes[2] = vec3 ( 0.0,+1.0, 0.0);
+  aPlanes[3] = vec3 ( 0.0,-1.0, 0.0);
+  aPlanes[4] = vec3 ( 0.0, 0.0,+1.0);
+  aPlanes[5] = vec3 ( 0.0, 0.0,-1.0);
+  vec3 aRayDirection;
+  if (uSide == 0)
+  {
+    // Positive X side
+    aRayDirection = aPlanes[0] + vec3 (0.0, +anUv.y, -anUv.x);
+  }
+  else if (uSide == 1)
+  {
+    // Negative X side
+    aRayDirection = aPlanes[1] + vec3 (0.0, +anUv.y, +anUv.x);
+  }
+  else if (uSide == 2)
+  {
+    // Positive Y side
+    aRayDirection = aPlanes[2] + vec3 (+anUv.x, 0.0, +anUv.y);
+  }
+  else if (uSide == 3)
+  {
+    // Negative Y side
+    aRayDirection = aPlanes[3] + vec3 (+anUv.x, 0.0, -anUv.y);
+  }
+  else if (uSide == 4)
+  {
+    // Positive Z side
+    aRayDirection = aPlanes[4] + vec3 (+anUv.x, +anUv.y, 0.0);
+  }
+  else if (uSide == 5)
+  {
+    // Negative Z side
+    aRayDirection = aPlanes[5] + vec3 (-anUv.x, +anUv.y, 0.0);
+  }
+
+  occFragColor = computeIncidentLight (normalize (aRayDirection), anUv, uTime);
+}

package/resources/Shaders/TangentSpaceNormal.glsl

@@ -0,0 +1,17 @@
+//! Calculates transformation from tangent space and apply it to value from normal map to get normal in object space
+vec3 TangentSpaceNormal (in mat2 theDeltaUVMatrix,
+                         in mat2x3 theDeltaVectorMatrix,
+                         in vec3 theNormalMapValue,
+                         in vec3 theNormal,
+                         in bool theIsInverse)
+{
+  theNormalMapValue = normalize(theNormalMapValue * 2.0 - vec3(1.0));
+  // Inverse matrix
+  theDeltaUVMatrix = mat2 (theDeltaUVMatrix[1][1], -theDeltaUVMatrix[0][1], -theDeltaUVMatrix[1][0], theDeltaUVMatrix[0][0]);
+  theDeltaVectorMatrix = theDeltaVectorMatrix * theDeltaUVMatrix;
+  // Gram-Schmidt orthogonalization
+  theDeltaVectorMatrix[1] = normalize(theDeltaVectorMatrix[1] - dot(theNormal, theDeltaVectorMatrix[1]) * theNormal);
+  theDeltaVectorMatrix[0] = cross(theDeltaVectorMatrix[1], theNormal);
+  float aDirection = theIsInverse ? -1.0 : 1.0;
+  return mat3 (aDirection * theDeltaVectorMatrix[0], aDirection * theDeltaVectorMatrix[1], theNormal) * theNormalMapValue;
+}

package/resources/StdResource/FILES

@@ -0,0 +1,6 @@
+appresource:::Standard
+appresource:::StandardLite
+appresource:::TObj
+appresource:::XCAF
+appresource:::MigrationSheet.txt
+loginfile:::Plugin

package/resources/StdResource/MigrationSheet.txt

@@ -0,0 +1,21 @@
+TDataStd_Shape          TDataXtd_Shape
+TDataStd_Constraint     TDataXtd_Constraint
+TDataStd_Geometry       TDataXtd_Geometry
+TDataStd_Axis           TDataXtd_Axis
+TDataStd_Point          TDataXtd_Point
+TDataStd_Plane          TDataXtd_Plane
+TDataStd_Position       TDataXtd_Position
+TDataStd_Placement      TDataXtd_Placement
+TDataStd_PatternStd     TDataXtd_PatternStd
+TPrsStd_AISPresentation TDataXtd_Presentation
+PDataStd_Shape		PDataXtd_Shape
+PDataStd_Constraint	PDataXtd_Constraint
+PDataStd_Geometry	PDataXtd_Geometry
+PDataStd_Axis		PDataXtd_Axis
+PDataStd_Point		PDataXtd_Point
+PDataStd_Plane		PDataXtd_Plane
+PDataStd_Position	PDataXtd_Position
+PDataStd_Placement	PDataXtd_Placement
+PDataStd_PatternStd	PDataXtd_PatternStd
+
+

package/resources/StdResource/Plugin

@@ -0,0 +1,52 @@
+! Description of available plugins
+! ********************************
+!
+! standard attribute drivers plugin
+!
+ad696001-5b34-11d1-b5ba-00a0c9064368.Location: TKStd
+!
+! standard attribute drivers plugin
+!
+bd696001-5b34-11d1-b5ba-00a0c9064368.Location: TKStdL
+!
+! XmlOcaf Document Plugin
+!
+03a56820-8269-11d5-aab2-0050044b1af1.Location: TKXml
+03a56822-8269-11d5-aab2-0050044b1af1.Location: TKXml
+03a56824-8269-11d5-aab2-0050044b1af1.Location: TKXml
+!
+! XmlLOcaf Document Plugin
+!
+13a56820-8269-11d5-aab2-0050044b1af1.Location: TKXmlL
+13a56822-8269-11d5-aab2-0050044b1af1.Location: TKXmlL
+13a56824-8269-11d5-aab2-0050044b1af1.Location: TKXmlL
+!
+! BinOcaf Document Plugin
+!
+03a56835-8269-11d5-aab2-0050044b1af1.Location: TKBin
+03a56836-8269-11d5-aab2-0050044b1af1.Location: TKBin
+!
+! BinLOcaf Document Plugin
+!
+13a56835-8269-11d5-aab2-0050044b1af1.Location: TKBinL
+13a56836-8269-11d5-aab2-0050044b1af1.Location: TKBinL
+!
+! XmlXCAF Document Plugin
+!
+f78ff496-a779-11d5-aab4-0050044b1af1.Location: TKXmlXCAF
+f78ff497-a779-11d5-aab4-0050044b1af1.Location: TKXmlXCAF
+!
+! BinXCAF Document Plugin
+!
+a78ff496-a779-11d5-aab4-0050044b1af1.Location: TKBinXCAF
+a78ff497-a779-11d5-aab4-0050044b1af1.Location: TKBinXCAF
+!
+! TObjXml Document Plugin
+!
+f78ff4a0-a779-11d5-aab4-0050044b1af1.Location: TKXmlTObj
+f78ff4a1-a779-11d5-aab4-0050044b1af1.Location: TKXmlTObj
+!
+! TObjBin Document Plugin
+!
+f78ff4a2-a779-11d5-aab4-0050044b1af1.Location: TKBinTObj
+f78ff4a3-a779-11d5-aab4-0050044b1af1.Location: TKBinTObj

package/resources/StdResource/Standard

@@ -0,0 +1,25 @@
+formatlist:MDTV-Standard|XmlOcaf|BinOcaf
+!
+! Default format
+xml.FileFormat: XmlOcaf
+cbf.FileFormat: BinOcaf
+!
+! standard attributes
+!
+MDTV-Standard.Description: Standard Document Version 1.0
+MDTV-Standard.FileExtension: std
+MDTV-Standard.RetrievalPlugin: ad696001-5b34-11d1-b5ba-00a0c9064368
+!
+! XmlOcaf format
+!
+XmlOcaf.Description: Xml Document Version 1.0
+XmlOcaf.FileExtension: xml
+XmlOcaf.StoragePlugin: 03a56820-8269-11d5-aab2-0050044b1af1
+XmlOcaf.RetrievalPlugin: 03a56822-8269-11d5-aab2-0050044b1af1
+!
+! BinOcaf format
+!
+BinOcaf.Description: Bin Ocaf Document Version 1.0
+BinOcaf.FileExtension: cbf
+BinOcaf.StoragePlugin: 03a56835-8269-11d5-aab2-0050044b1af1
+BinOcaf.RetrievalPlugin: 03a56836-8269-11d5-aab2-0050044b1af1

package/resources/StdResource/StandardLite

@@ -0,0 +1,22 @@
+formatlist:OCC-StdLite|BinLOcaf|XmlLOcaf
+!
+!
+! Lite attributes
+!
+OCC-StdLite.Description: Lite Document Version 1.0
+OCC-StdLite.FileExtension: stdl
+OCC-StdLite.RetrievalPlugin: bd696001-5b34-11d1-b5ba-00a0c9064368
+!
+! BinLOcaf format
+!
+BinLOcaf.Description: Lite Bin Ocaf Document Version 1.0
+BinLOcaf.FileExtension: cbfl
+BinLOcaf.StoragePlugin: 13a56835-8269-11d5-aab2-0050044b1af1
+BinLOcaf.RetrievalPlugin: 13a56836-8269-11d5-aab2-0050044b1af1
+!
+! XmlLOcaf format
+!
+XmlLOcaf.Description: Lite Xml Document Version 1.0
+XmlLOcaf.FileExtension: xmll
+XmlLOcaf.StoragePlugin: 13a56820-8269-11d5-aab2-0050044b1af1
+XmlLOcaf.RetrievalPlugin: 13a56822-8269-11d5-aab2-0050044b1af1

package/resources/StdResource/TObj

@@ -0,0 +1,17 @@
+formatlist: TObjXml|TObjBin
+!
+! Default format
+xml.FileFormat: TObjXml
+cbf.FileFormat: TObjBin
+!
+! TObjXml format
+TObjXml.Description: TObj XML Document Version 1.0
+TObjXml.FileExtension: xml
+TObjXml.StoragePlugin: f78ff4a0-a779-11d5-aab4-0050044b1af1
+TObjXml.RetrievalPlugin: f78ff4a1-a779-11d5-aab4-0050044b1af1
+!
+! TObjBin format
+TObjBin.Description: TObj BIN Document Version 1.0
+TObjBin.FileExtension: cbf
+TObjBin.StoragePlugin: f78ff4a2-a779-11d5-aab4-0050044b1af1
+TObjBin.RetrievalPlugin: f78ff4a3-a779-11d5-aab4-0050044b1af1