@roomle/web-sdk 2.44.0-alpha.1 → 2.44.0-alpha.3

package/lib/legacy/static/DepthShadowGenerator-a3a9d85ff2c3d24c.js

@@ -0,0 +1,266 @@
+THREE.DepthShadowGenerator = {
+  clamp01: function (num) {
+    return num <= 0 ? 0 : num >= 1 ? 1 : num;
+  },
+
+  idealPowerOfTwoSize: function (num) {
+    // 2,4,8,16,32,64,128,256,512,1024
+    if (num > 800) {
+      return 1024;
+    } else if (num > 400) {
+      return 512;
+    } else if (num > 200) {
+      return 256;
+    } else if (num > 100) {
+      return 128;
+    } else if (num > 50) {
+      return 64;
+    } else if (num > 25) {
+      return 32;
+    } else {
+      return 16;
+    }
+  },
+
+  blurTexture: function (
+    data,
+    textureFormat,
+    shadowRenderRes,
+    blurRadiusRelative
+  ) {
+    var pixelSize = textureFormat === THREE.RGBFormat ? 3 : 4;
+
+    var shadowRes = blurRadiusRelative
+      .clone()
+      .multiplyScalar(2)
+      .addScalar(1)
+      .multiply(shadowRenderRes)
+      .multiply(blurRadiusRelative)
+      .multiplyScalar(2);
+    shadowRes.x = this.idealPowerOfTwoSize(shadowRes.x);
+    shadowRes.y = this.idealPowerOfTwoSize(shadowRes.y);
+
+    var shadowDataLength = shadowRes.x * shadowRes.y;
+    var shadowData = new Uint8Array(shadowDataLength);
+
+    for (var sx = 0; sx < shadowRes.x; sx++) {
+      var x = sx / (shadowRes.x - 1);
+
+      // xr is negative and above 1.0 when outside of objecgt bounding-box
+      var xr = (x - 0.5) * (1 + 2 * blurRadiusRelative.x) + 0.5;
+
+      var srcPosXmin = Math.round(
+        (xr - blurRadiusRelative.x) * shadowRenderRes.x
+      );
+      var srcPosXmax = Math.round(
+        (xr + blurRadiusRelative.x) * shadowRenderRes.x
+      );
+
+      for (var sy = 0; sy < shadowRes.y; sy++) {
+        var i = sy * shadowRes.x;
+
+        var y = sy / (shadowRes.y - 1);
+
+        // xr is negative and above 1.0 when outside of objecgt bounding-box
+        var yr = (y - 0.5) * (1 + 2 * blurRadiusRelative.y) + 0.5;
+
+        var srcPosYmin = Math.round(
+          (yr - blurRadiusRelative.y) * shadowRenderRes.y
+        );
+        var srcPosYmax = Math.round(
+          (yr + blurRadiusRelative.y) * shadowRenderRes.y
+        );
+
+        var value = 0;
+        var count = 0;
+
+        var xHalfRange = (srcPosXmax - srcPosXmin) / 2.0;
+        if (xHalfRange == 0) {
+          xHalfRange = 1;
+        }
+        var xCenter = (srcPosXmax + srcPosXmin) / 2.0;
+
+        var yHalfRange = (srcPosYmax - srcPosYmin) / 2.0;
+        if (yHalfRange == 0) {
+          yHalfRange = 1;
+        }
+        var yCenter = (srcPosYmax + srcPosYmin) / 2.0;
+
+        for (var dx = srcPosXmin; dx <= srcPosXmax; dx++) {
+          var xWeight = Math.abs(dx - xCenter) / xHalfRange;
+
+          for (var dy = srcPosYmin; dy <= srcPosYmax; dy++) {
+            var yWeight = Math.abs(dy - yCenter) / yHalfRange;
+
+            // weight = normalized distance to center (radius) inverted
+            var weight = 1 - Math.sqrt(xWeight * xWeight + yWeight * yWeight);
+
+            if (weight < 0.01) {
+              continue;
+            }
+
+            var newValue = 0;
+            if (
+              dx < 0 ||
+              dx >= shadowRenderRes.x ||
+              dy < 0 ||
+              dy >= shadowRenderRes.y
+            ) {
+              newValue = 1;
+            } else {
+              var srcPos = dx + dy * shadowRenderRes.x;
+              // sample red color value from source texture (is monochrome anyways)
+              newValue = data[srcPos * pixelSize] / 255.0;
+            }
+            value += 1 - (1 - newValue) * weight;
+            count++;
+          }
+        }
+
+        value = value / count;
+        value = Math.pow(value, 0.5);
+        value = 255 * value;
+
+        // sample original value for visual debug purpose
+        /*
+				var original = 255;
+				if(xr>=0 && xr<=1 && yr>=0 && yr<=1 ) {
+					var srcPos = Math.floor( xr * shadowRenderRes.x ) + Math.floor( yr * shadowRenderRes.y ) * shadowRenderRes.x;
+					original = data[srcPos*pixelSize];
+				}
+				//*/
+        var destIndex = i + sx;
+        shadowData[destIndex] = value;
+      }
+    }
+
+    rampTex = new THREE.DataTexture(
+      shadowData,
+      shadowRes.x,
+      shadowRes.y,
+      THREE.LuminanceFormat,
+      THREE.UnsignedByteType,
+      THREE.UVMapping,
+      THREE.ClampToEdgeWrapping,
+      THREE.ClampToEdgeWrapping,
+      THREE.LinearFilter,
+      THREE.LinearMipMapLinearFilter
+    );
+
+    return rampTex;
+  },
+
+  createShadowPlane: function (renderer, scene, objectSize3d, layers) {
+    var renderppm = 200; // pixel per meter render resolution
+    var blurRadius = 0.1; // meter
+    // blurRadius = 0;
+    var ppm = renderppm * 0.5; // pixel per meter final resolution
+
+    var objectSize = new THREE.Vector2(objectSize3d.x, objectSize3d.z);
+
+    var shadowRenderRes = objectSize.clone().multiplyScalar(renderppm);
+
+    shadowRenderRes.x = this.idealPowerOfTwoSize(shadowRenderRes.x);
+    shadowRenderRes.y = this.idealPowerOfTwoSize(shadowRenderRes.y);
+
+    var textureFormat = THREE.RGBAFormat;
+
+    // Create the texture that will store our result
+    var bufferTexture = new THREE.WebGLRenderTarget(
+      shadowRenderRes.x,
+      shadowRenderRes.y,
+      {
+        format: textureFormat,
+        minFilter: THREE.LinearFilter,
+        magFilter: THREE.NearestFilter,
+      }
+    );
+
+    var depthMaterial = new THREE.MeshDepthMaterial();
+    // var depthMaterial = new THREE.MeshBasicMaterial();
+    // depthMaterial.color = new THREE.Color(0,1,0);
+
+    var shadowCamera = new THREE.OrthographicCamera(
+      objectSize.x / -2,
+      objectSize.x / 2,
+      objectSize.y / -2,
+      objectSize.y / 2,
+      0.01,
+      1
+    );
+
+    shadowCamera.layers.set(layers);
+    shadowCamera.position.y = -0.011;
+    shadowCamera.rotation.x = Math.PI / 2;
+
+    var planeMaterial = new THREE.MeshBasicMaterial({
+      map: bufferTexture,
+      transparent: true,
+      blending: THREE.MultiplyBlending,
+    });
+
+    var planeSize = objectSize.clone().addScalar(blurRadius * 2);
+
+    var planeGeometry = new THREE.PlaneGeometry(planeSize.x, planeSize.y, 1);
+    var shadowPlaneObject = new THREE.Mesh(planeGeometry, planeMaterial);
+    shadowPlaneObject.rotation.x = -Math.PI / 2;
+    shadowPlaneObject.name = 'ShadowPlane';
+
+    renderer.setClearColor(new THREE.Color(1, 1, 1), 1);
+
+    scene.overrideMaterial = depthMaterial;
+
+    renderer.clearTarget(bufferTexture, true, true, true);
+
+    renderer.render(scene, shadowCamera, bufferTexture);
+
+    var dataLength = shadowRenderRes.x * shadowRenderRes.y;
+    var pixelSize = textureFormat === THREE.RGBFormat ? 3 : 4;
+    var data = new Uint8Array(dataLength * pixelSize);
+    renderer.readRenderTargetPixels(
+      bufferTexture,
+      0,
+      0,
+      shadowRenderRes.x,
+      shadowRenderRes.y,
+      data
+    );
+
+    var blurRadiusRelative = new THREE.Vector2(
+      blurRadius / objectSize.x,
+      blurRadius / objectSize.y
+    );
+
+    var rampTex = this.blurTexture(
+      data,
+      textureFormat,
+      shadowRenderRes,
+      blurRadiusRelative
+    );
+
+    // show original render target texture
+    /*
+		rampTex = new THREE.DataTexture(
+			data,
+			shadowRenderRes.x,
+			shadowRenderRes.y,
+			textureFormat,
+			THREE.UnsignedByteType,
+			THREE.UVMapping,
+			THREE.ClampToEdgeWrapping,
+			THREE.ClampToEdgeWrapping,
+			THREE.LinearFilter,
+			THREE.LinearMipMapLinearFilter
+			);
+		//*/
+
+    rampTex.generateMipmaps = true;
+    rampTex.needsUpdate = true;
+
+    planeMaterial.map = rampTex;
+
+    scene.overrideMaterial = null;
+
+    return shadowPlaneObject;
+  },
+};