@shapediver/viewer.rendering-engine.rendering-engine-threejs 3.18.1 → 3.19.0

package/dist/managers/postprocessing/ao/ssao/shader/ssao.js

@@ -1,120 +1,120 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ssao = void 0;
-exports.ssao = `
-varying vec2 vUv;
-
-uniform highp sampler2D depthTexture;
-uniform mat4 projectionViewMatrix;
-uniform mat4 cameraMatrixWorld;
-
-uniform sampler2D blueNoiseTexture;
-uniform vec2 blueNoiseRepeat;
-uniform vec2 texSize;
-uniform float aoDistance;
-uniform float distancePower;
-uniform float cameraNear;
-uniform float cameraFar;
-uniform int frame;
-
-uniform vec3[spp] samples;
-uniform float[spp] samplesR;
-
-#include <common>
-#include <packing>
-#include <sampleBlueNoise>
-#include <ao_utils>
-
-highp float linearize_depth(highp float d, highp float zNear, highp float zFar) {
-    highp float z_n = 2.0 * d - 1.0;
-    return 2.0 * zNear * zFar / (zFar + zNear - z_n * (zFar - zNear));
-}
-
-void main() {
-    float depth = textureLod(depthTexture, vUv, 0.).x;
-    vec3 normal = computeNormal(vUv);
-
-    // filter out background
-    if (depth == 1.0) {
-        gl_FragColor = vec4(normal, 1.0);
-        return;
-    }
-
-    vec3 worldPos = computeWorldPosition(depth, vUv);
-    vec3 screenSpaceNormal = getUnpackedNormal(vUv);
-
-    #ifdef animatedNoise
-        int seed = frame;
-    #else
-        int seed = 0;
-    #endif
-
-    vec4 noise = sampleBlueNoise(blueNoiseTexture, seed, blueNoiseRepeat, texSize);
-
-    vec3 randomVec = normalize(noise.rgb * 2.0 - 1.0);
-    vec3 tangent = normalize(randomVec - normal * dot(randomVec, normal));
-    vec3 bitangent = cross(normal, tangent);
-    mat3 tbn = mat3(tangent, bitangent, normal);
-
-    float occluded = 0.0;
-    float totalWeight = 0.0;
-
-    vec3 samplePos;
-
-    float sppF = float(spp);
-
-    for (float i = 0.0; i < sppF; i++) {
-        vec3 sampleDirection = tbn * samples[int(i)];
-
-        // make sure sample direction is in the same hemisphere as the normal
-        if (dot(sampleDirection, normal) < 0.0) sampleDirection *= -1.0;
-
-        float moveAmt = samplesR[int(mod(i + noise.a * sppF, sppF))];
-        samplePos = worldPos + aoDistance * moveAmt * sampleDirection;
-
-        vec4 offset = projectionViewMatrix * vec4(samplePos, 1.0);
-        offset.xyz /= offset.w;
-        offset.xyz = offset.xyz * 0.5 + 0.5;
-
-        float sampleDepth = textureLod(depthTexture, offset.xy, 0.0).x;
-
-        if(sampleDepth == 1.0) {
-            occluded += 0.0;
-            totalWeight += 1.0;
-            continue;
-        }
-
-        vec3 sampleNormal = getUnpackedNormal(offset.xy);
-
-        float distSample = linearize_depth(sampleDepth, cameraNear, cameraFar);
-        float distWorld = linearize_depth(offset.z, cameraNear, cameraFar);
-
-        float depthBias = 0.001;
-        float rangeCheck = smoothstep(0.0, 1.0, aoDistance / (abs(distSample - distWorld) + depthBias));
-        rangeCheck = pow(rangeCheck, distancePower);
-        rangeCheck = clamp(rangeCheck, 0.0, 1.0);
-        float weight = dot(sampleDirection, normal);
-        weight = clamp(weight, 0.0, 1.0);
-
-        
-        // check if the normals are in the same direction
-        float dotProduct = dot(screenSpaceNormal, normalize(sampleNormal));
-        if (dotProduct < 0.9999) {
-            occluded += rangeCheck * weight * (distSample < distWorld ? 1.0 : 0.0);
-            totalWeight += weight;
-        } else {
-            if(areDepthsOnSamePlane(depth, sampleDepth, vUv, offset.xy, normal, 0.1)) {
-                occluded += 0.0;
-                totalWeight += 1.0;
-            } else {
-                occluded += rangeCheck * weight * (distSample < distWorld ? 1.0 : 0.0);
-                totalWeight += weight;
-            }
-        }
-    }
-
-    float occ = clamp(1.0 - occluded / totalWeight, 0.0, 1.0);
-    gl_FragColor = vec4(normal, occ);
-}
+exports.ssao = `
+varying vec2 vUv;
+
+uniform highp sampler2D depthTexture;
+uniform mat4 projectionViewMatrix;
+uniform mat4 cameraMatrixWorld;
+
+uniform sampler2D blueNoiseTexture;
+uniform vec2 blueNoiseRepeat;
+uniform vec2 texSize;
+uniform float aoDistance;
+uniform float distancePower;
+uniform float cameraNear;
+uniform float cameraFar;
+uniform int frame;
+
+uniform vec3[spp] samples;
+uniform float[spp] samplesR;
+
+#include <common>
+#include <packing>
+#include <sampleBlueNoise>
+#include <ao_utils>
+
+highp float linearize_depth(highp float d, highp float zNear, highp float zFar) {
+    highp float z_n = 2.0 * d - 1.0;
+    return 2.0 * zNear * zFar / (zFar + zNear - z_n * (zFar - zNear));
+}
+
+void main() {
+    float depth = textureLod(depthTexture, vUv, 0.).x;
+    vec3 normal = computeNormal(vUv);
+
+    // filter out background
+    if (depth == 1.0) {
+        gl_FragColor = vec4(normal, 1.0);
+        return;
+    }
+
+    vec3 worldPos = computeWorldPosition(depth, vUv);
+    vec3 screenSpaceNormal = getUnpackedNormal(vUv);
+
+    #ifdef animatedNoise
+        int seed = frame;
+    #else
+        int seed = 0;
+    #endif
+
+    vec4 noise = sampleBlueNoise(blueNoiseTexture, seed, blueNoiseRepeat, texSize);
+
+    vec3 randomVec = normalize(noise.rgb * 2.0 - 1.0);
+    vec3 tangent = normalize(randomVec - normal * dot(randomVec, normal));
+    vec3 bitangent = cross(normal, tangent);
+    mat3 tbn = mat3(tangent, bitangent, normal);
+
+    float occluded = 0.0;
+    float totalWeight = 0.0;
+
+    vec3 samplePos;
+
+    float sppF = float(spp);
+
+    for (float i = 0.0; i < sppF; i++) {
+        vec3 sampleDirection = tbn * samples[int(i)];
+
+        // make sure sample direction is in the same hemisphere as the normal
+        if (dot(sampleDirection, normal) < 0.0) sampleDirection *= -1.0;
+
+        float moveAmt = samplesR[int(mod(i + noise.a * sppF, sppF))];
+        samplePos = worldPos + aoDistance * moveAmt * sampleDirection;
+
+        vec4 offset = projectionViewMatrix * vec4(samplePos, 1.0);
+        offset.xyz /= offset.w;
+        offset.xyz = offset.xyz * 0.5 + 0.5;
+
+        float sampleDepth = textureLod(depthTexture, offset.xy, 0.0).x;
+
+        if(sampleDepth == 1.0) {
+            occluded += 0.0;
+            totalWeight += 1.0;
+            continue;
+        }
+
+        vec3 sampleNormal = getUnpackedNormal(offset.xy);
+
+        float distSample = linearize_depth(sampleDepth, cameraNear, cameraFar);
+        float distWorld = linearize_depth(offset.z, cameraNear, cameraFar);
+
+        float depthBias = 0.001;
+        float rangeCheck = smoothstep(0.0, 1.0, aoDistance / (abs(distSample - distWorld) + depthBias));
+        rangeCheck = pow(rangeCheck, distancePower);
+        rangeCheck = clamp(rangeCheck, 0.0, 1.0);
+        float weight = dot(sampleDirection, normal);
+        weight = clamp(weight, 0.0, 1.0);
+
+        
+        // check if the normals are in the same direction
+        float dotProduct = dot(screenSpaceNormal, normalize(sampleNormal));
+        if (dotProduct < 0.9999) {
+            occluded += rangeCheck * weight * (distSample < distWorld ? 1.0 : 0.0);
+            totalWeight += weight;
+        } else {
+            if(areDepthsOnSamePlane(depth, sampleDepth, vUv, offset.xy, normal, 0.1)) {
+                occluded += 0.0;
+                totalWeight += 1.0;
+            } else {
+                occluded += rangeCheck * weight * (distSample < distWorld ? 1.0 : 0.0);
+                totalWeight += weight;
+            }
+        }
+    }
+
+    float occ = clamp(1.0 - occluded / totalWeight, 0.0, 1.0);
+    gl_FragColor = vec4(normal, occ);
+}
 `;
 //# sourceMappingURL=ssao.js.map

package/dist/managers/postprocessing/ao/utils/shader/basic.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.basic = void 0;
-exports.basic = `
-varying vec2 vUv;
-
-out mat4 viewMatrixInverse;
-
-void main() {
-    viewMatrixInverse = inverse(viewMatrix);
-    vUv = position.xy * 0.5 + 0.5;
-    gl_Position = vec4(position.xy, 1.0, 1.0);
-}
+exports.basic = `
+varying vec2 vUv;
+
+out mat4 viewMatrixInverse;
+
+void main() {
+    viewMatrixInverse = inverse(viewMatrix);
+    vUv = position.xy * 0.5 + 0.5;
+    gl_Position = vec4(position.xy, 1.0, 1.0);
+}
 `;
 //# sourceMappingURL=basic.js.map

package/dist/managers/postprocessing/ao/utils/shader/sampleBlueNoise.js

@@ -1,42 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sampleBlueNoise = void 0;
-exports.sampleBlueNoise = `
-const float g = 1.6180339887498948482;
-const float a1 = 1.0 / g;
-
-// reference: https://extremelearning.com.au/unreasonable-effectiveness-of-quasirandom-sequences/
-float r1(float n) {
-    // 7th harmonious number
-    return fract(1.1127756842787055 + a1 * n);
-}
-
-const vec4 hn = vec4(0.618033988749895, 0.3247179572447458, 0.2207440846057596, 0.1673039782614187);
-
-vec4 sampleBlueNoise(sampler2D texture, int seed, vec2 repeat, vec2 texSize) {
-    vec2 size = vUv * texSize;
-    vec2 blueNoiseSize = texSize / repeat;
-    float blueNoiseIndex = floor(floor(size.y / blueNoiseSize.y) * repeat.x) + floor(size.x / blueNoiseSize.x);
-
-    // get the offset of this pixel's blue noise tile
-    // int blueNoiseTileOffset = int(r1(blueNoiseIndex + 1.0) * 65536.);
-
-    vec2 blueNoiseUv = vUv * repeat;
-
-    // fetch blue noise for this pixel
-    vec4 blueNoise = textureLod(texture, blueNoiseUv, 0.);
-
-    // animate blue noise
-    if (seed != 0) {
-        blueNoise = fract(blueNoise + hn * float(seed));
-
-        blueNoise.r = (blueNoise.r > 0.5 ? 1.0 - blueNoise.r : blueNoise.r) * 2.0;
-        blueNoise.g = (blueNoise.g > 0.5 ? 1.0 - blueNoise.g : blueNoise.g) * 2.0;
-        blueNoise.b = (blueNoise.b > 0.5 ? 1.0 - blueNoise.b : blueNoise.b) * 2.0;
-        blueNoise.a = (blueNoise.a > 0.5 ? 1.0 - blueNoise.a : blueNoise.a) * 2.0;
-    }
-
-    return blueNoise;
-}
+exports.sampleBlueNoise = `
+const float g = 1.6180339887498948482;
+const float a1 = 1.0 / g;
+
+// reference: https://extremelearning.com.au/unreasonable-effectiveness-of-quasirandom-sequences/
+float r1(float n) {
+    // 7th harmonious number
+    return fract(1.1127756842787055 + a1 * n);
+}
+
+const vec4 hn = vec4(0.618033988749895, 0.3247179572447458, 0.2207440846057596, 0.1673039782614187);
+
+vec4 sampleBlueNoise(sampler2D texture, int seed, vec2 repeat, vec2 texSize) {
+    vec2 size = vUv * texSize;
+    vec2 blueNoiseSize = texSize / repeat;
+    float blueNoiseIndex = floor(floor(size.y / blueNoiseSize.y) * repeat.x) + floor(size.x / blueNoiseSize.x);
+
+    // get the offset of this pixel's blue noise tile
+    // int blueNoiseTileOffset = int(r1(blueNoiseIndex + 1.0) * 65536.);
+
+    vec2 blueNoiseUv = vUv * repeat;
+
+    // fetch blue noise for this pixel
+    vec4 blueNoise = textureLod(texture, blueNoiseUv, 0.);
+
+    // animate blue noise
+    if (seed != 0) {
+        blueNoise = fract(blueNoise + hn * float(seed));
+
+        blueNoise.r = (blueNoise.r > 0.5 ? 1.0 - blueNoise.r : blueNoise.r) * 2.0;
+        blueNoise.g = (blueNoise.g > 0.5 ? 1.0 - blueNoise.g : blueNoise.g) * 2.0;
+        blueNoise.b = (blueNoise.b > 0.5 ? 1.0 - blueNoise.b : blueNoise.b) * 2.0;
+        blueNoise.a = (blueNoise.a > 0.5 ? 1.0 - blueNoise.a : blueNoise.a) * 2.0;
+    }
+
+    return blueNoise;
+}
 `;
 //# sourceMappingURL=sampleBlueNoise.js.map

package/dist/managers/postprocessing/effects/tone-mapping/tone-mapping.js

@@ -1,97 +1,97 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tone_mapping = void 0;
-exports.tone_mapping = `
-#include <tonemapping_pars_fragment>
-
-uniform float whitePoint;
-
-#if TONE_MAPPING_MODE == 2 || TONE_MAPPING_MODE == 3
-
-	// Reinhard 2
-
-	uniform float middleGrey;
-
-	#if TONE_MAPPING_MODE == 3
-
-		uniform lowp sampler2D luminanceBuffer;
-
-	#else
-
-		uniform float averageLuminance;
-
-	#endif
-
-	vec3 Reinhard2ToneMapping(vec3 color) {
-
-		color *= toneMappingExposure;
-
-		// Calculate the luminance of the current pixel.
-		float l = luminance(color);
-
-		#if TONE_MAPPING_MODE == 3
-
-			// Get the average luminance from the adaptive 1x1 buffer.
-			float lumAvg = unpackRGBAToFloat(texture2D(luminanceBuffer, vec2(0.5)));
-
-		#else
-
-			float lumAvg = averageLuminance;
-
-		#endif
-
-		float lumScaled = (l * middleGrey) / max(lumAvg, 1e-6);
-		float lumCompressed = lumScaled * (1.0 + lumScaled / (whitePoint * whitePoint));
-		lumCompressed /= (1.0 + lumScaled);
-
-		return clamp(lumCompressed * color, 0.0, 1.0);
-
-	}
-
-#elif TONE_MAPPING_MODE == 4
-
-	// Uncharted 2: http://filmicworlds.com/blog/filmic-tonemapping-operators
-
-	#define A 0.15
-	#define B 0.50
-	#define C 0.10
-	#define D 0.20
-	#define E 0.02
-	#define F 0.30
-
-	vec3 Uncharted2Helper(const in vec3 x) {
-
-		return ((x * (A * x + C * B) + D * E) / (x * (A * x + B) + D * F)) - E / F;
-
-	}
-
-	vec3 Uncharted2ToneMapping(vec3 color) {
-
-		color *= toneMappingExposure;
-		return clamp(Uncharted2Helper(color) / Uncharted2Helper(vec3(whitePoint)), 0.0, 1.0);
-
-	}
-
-#endif
-
-void mainImage(const in vec4 inputColor, const in vec2 uv, const in float depth, out vec4 outputColor) {
-	#if TONE_MAPPING_MODE == 2 || TONE_MAPPING_MODE == 3
-
-		outputColor = vec4(Reinhard2ToneMapping(inputColor.rgb), inputColor.a);
-
-	#elif TONE_MAPPING_MODE == 4
-
-		outputColor = vec4(Uncharted2ToneMapping(inputColor.rgb), inputColor.a);
-
-	#else
-
-		outputColor = vec4(toneMapping(inputColor.rgb), inputColor.a);
-
-	#endif
-
-    if(depth >= 1.0) {
-        outputColor = inputColor;
-    }
-}
+exports.tone_mapping = `
+#include <tonemapping_pars_fragment>
+
+uniform float whitePoint;
+
+#if TONE_MAPPING_MODE == 2 || TONE_MAPPING_MODE == 3
+
+	// Reinhard 2
+
+	uniform float middleGrey;
+
+	#if TONE_MAPPING_MODE == 3
+
+		uniform lowp sampler2D luminanceBuffer;
+
+	#else
+
+		uniform float averageLuminance;
+
+	#endif
+
+	vec3 Reinhard2ToneMapping(vec3 color) {
+
+		color *= toneMappingExposure;
+
+		// Calculate the luminance of the current pixel.
+		float l = luminance(color);
+
+		#if TONE_MAPPING_MODE == 3
+
+			// Get the average luminance from the adaptive 1x1 buffer.
+			float lumAvg = unpackRGBAToFloat(texture2D(luminanceBuffer, vec2(0.5)));
+
+		#else
+
+			float lumAvg = averageLuminance;
+
+		#endif
+
+		float lumScaled = (l * middleGrey) / max(lumAvg, 1e-6);
+		float lumCompressed = lumScaled * (1.0 + lumScaled / (whitePoint * whitePoint));
+		lumCompressed /= (1.0 + lumScaled);
+
+		return clamp(lumCompressed * color, 0.0, 1.0);
+
+	}
+
+#elif TONE_MAPPING_MODE == 4
+
+	// Uncharted 2: http://filmicworlds.com/blog/filmic-tonemapping-operators
+
+	#define A 0.15
+	#define B 0.50
+	#define C 0.10
+	#define D 0.20
+	#define E 0.02
+	#define F 0.30
+
+	vec3 Uncharted2Helper(const in vec3 x) {
+
+		return ((x * (A * x + C * B) + D * E) / (x * (A * x + B) + D * F)) - E / F;
+
+	}
+
+	vec3 Uncharted2ToneMapping(vec3 color) {
+
+		color *= toneMappingExposure;
+		return clamp(Uncharted2Helper(color) / Uncharted2Helper(vec3(whitePoint)), 0.0, 1.0);
+
+	}
+
+#endif
+
+void mainImage(const in vec4 inputColor, const in vec2 uv, const in float depth, out vec4 outputColor) {
+	#if TONE_MAPPING_MODE == 2 || TONE_MAPPING_MODE == 3
+
+		outputColor = vec4(Reinhard2ToneMapping(inputColor.rgb), inputColor.a);
+
+	#elif TONE_MAPPING_MODE == 4
+
+		outputColor = vec4(Uncharted2ToneMapping(inputColor.rgb), inputColor.a);
+
+	#else
+
+		outputColor = vec4(toneMapping(inputColor.rgb), inputColor.a);
+
+	#endif
+
+    if(depth >= 1.0) {
+        outputColor = inputColor;
+    }
+}
 `;
 //# sourceMappingURL=tone-mapping.js.map

package/dist/managers/postprocessing/utils/CopyMaterial.js

@@ -2,43 +2,43 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CopyMaterial = void 0;
 const three_1 = require("three");
-const vertexShader = `
-varying vec2 vUv;
-
-void main() {
-
-	vUv = position.xy * 0.5 + 0.5;
-	gl_Position = vec4(position.xy, 1.0, 1.0);
-
-}
+const vertexShader = `
+varying vec2 vUv;
+
+void main() {
+
+	vUv = position.xy * 0.5 + 0.5;
+	gl_Position = vec4(position.xy, 1.0, 1.0);
+
+}
 `;
-const fragmentShader = `
-#include <common>
-#include <dithering_pars_fragment>
-
-#ifdef FRAMEBUFFER_PRECISION_HIGH
-
-	uniform mediump sampler2D inputBuffer;
-
-#else
-
-	uniform lowp sampler2D inputBuffer;
-
-#endif
-
-uniform float opacity;
-
-varying vec2 vUv;
-
-void main() {
-
-	vec4 texel = texture2D(inputBuffer, vUv);
-	gl_FragColor = opacity * texel;
-
-	#include <colorspace_fragment>
-	#include <dithering_fragment>
-
-}
+const fragmentShader = `
+#include <common>
+#include <dithering_pars_fragment>
+
+#ifdef FRAMEBUFFER_PRECISION_HIGH
+
+	uniform mediump sampler2D inputBuffer;
+
+#else
+
+	uniform lowp sampler2D inputBuffer;
+
+#endif
+
+uniform float opacity;
+
+varying vec2 vUv;
+
+void main() {
+
+	vec4 texel = texture2D(inputBuffer, vUv);
+	gl_FragColor = opacity * texel;
+
+	#include <colorspace_fragment>
+	#include <dithering_fragment>
+
+}
 `;
 /**
  * A simple copy shader material.

package/dist/managers/postprocessing/utils/CopyShader.js

@@ -7,30 +7,30 @@ exports.CopyShader = {
         tDiffuse: { value: null },
         opacity: { value: 1.0 },
     },
-    vertexShader: /* glsl */ `
-
-		varying vec2 vUv;
-
-		void main() {
-
-			vUv = uv;
-			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
+    vertexShader: /* glsl */ `
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
 		}`,
-    fragmentShader: /* glsl */ `
-
-		uniform float opacity;
-
-		uniform sampler2D tDiffuse;
-
-		varying vec2 vUv;
-
-		void main() {
-
-			gl_FragColor = texture2D( tDiffuse, vUv );
-			gl_FragColor.a *= opacity;
-
-
+    fragmentShader: /* glsl */ `
+
+		uniform float opacity;
+
+		uniform sampler2D tDiffuse;
+
+		varying vec2 vUv;
+
+		void main() {
+
+			gl_FragColor = texture2D( tDiffuse, vUv );
+			gl_FragColor.a *= opacity;
+
+
 		}`,
 };
 //# sourceMappingURL=CopyShader.js.map

package/dist/managers/sceneTree/SDTFUtils.d.ts

@@ -1,5 +1,5 @@
-import { ITreeNode, ITreeNodeData, SDTFItemData } from "@shapediver/viewer.shared.node-tree";
-import { ISDTFOverview } from "@shapediver/viewer.shared.types";
+import { type ITreeNode, type ITreeNodeData, SDTFItemData } from "@shapediver/viewer.shared.node-tree";
+import { type ISDTFOverview } from "@shapediver/viewer.shared.types";
 import { RenderingEngine } from "../..";
 export declare const collectSDTFItemData: (node: ITreeNode) => SDTFItemData | undefined;
 export declare const createSDTFOverview: (node: ITreeNode) => ISDTFOverview;