@itwin/core-frontend 4.1.0-dev.35 → 4.1.0-dev.40

package/lib/cjs/render/webgl/glsl/Decode.js

@@ -9,67 +9,67 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decode3Float32 = exports.decodeFloat32 = exports.addUnpackAndNormalize2Bytes = exports.unpackAndNormalize2Bytes = exports.unpack2Bytes = exports.pack2Bytes = exports.encodeDepthRgb = exports.decodeDepthRgb = exports.unquantize2d = exports.unquantize3d = exports.decodeUint24 = exports.decodeUint16 = void 0;
 /** @internal */
-exports.decodeUint16 = `
-float decodeUInt16(vec2 v) {
-  return dot(v, vec2(1.0, 256.0)); // v.x | (v.y << 8)
-}
+exports.decodeUint16 = `
+float decodeUInt16(vec2 v) {
+  return dot(v, vec2(1.0, 256.0)); // v.x | (v.y << 8)
+}
 `;
 /** @internal */
-exports.decodeUint24 = `
-float decodeUInt24(vec3 v) {
-  return dot(v, vec3(1.0, 256.0, 256.0*256.0)); // v.x | (v.y << 8) | (v.z << 16)
-}
+exports.decodeUint24 = `
+float decodeUInt24(vec3 v) {
+  return dot(v, vec3(1.0, 256.0, 256.0*256.0)); // v.x | (v.y << 8) | (v.z << 16)
+}
 `;
 /** @internal */
-exports.unquantize3d = `
-vec3 unquantize3d(vec3 qpos, vec3 origin, vec3 scale) { return origin + scale * qpos; }
+exports.unquantize3d = `
+vec3 unquantize3d(vec3 qpos, vec3 origin, vec3 scale) { return origin + scale * qpos; }
 `;
 /** @internal */
-exports.unquantize2d = `
-// params.xy = origin. params.zw = scale.
-vec2 unquantize2d(vec2 qpos, vec4 params) { return params.xy + params.zw * qpos; }
+exports.unquantize2d = `
+// params.xy = origin. params.zw = scale.
+vec2 unquantize2d(vec2 qpos, vec4 params) { return params.xy + params.zw * qpos; }
 `;
 /** @internal */
-exports.decodeDepthRgb = `
-float decodeDepthRgb(vec3 rgb) { return dot(rgb, vec3(1.0, 1.0 / 255.0, 1.0 / 65025.0)); }
+exports.decodeDepthRgb = `
+float decodeDepthRgb(vec3 rgb) { return dot(rgb, vec3(1.0, 1.0 / 255.0, 1.0 / 65025.0)); }
 `;
 /** @internal */
-exports.encodeDepthRgb = `
-vec3 encodeDepthRgb(float depth) {
-  // 1.0 must be reduced slightly; otherwise decoding will produce zero. It's the far plane, so we don't care (and decoding produces 1.0 anyway).
-  depth = min(depth, 16777215.0/16777216.0);
-
-  vec3 enc = vec3(1.0, 255.0, 65025.0) * depth;
-  enc = fract(enc);
-  enc.xy -= enc.yz / 255.0;
-  return enc;
-}
+exports.encodeDepthRgb = `
+vec3 encodeDepthRgb(float depth) {
+  // 1.0 must be reduced slightly; otherwise decoding will produce zero. It's the far plane, so we don't care (and decoding produces 1.0 anyway).
+  depth = min(depth, 16777215.0/16777216.0);
+
+  vec3 enc = vec3(1.0, 255.0, 65025.0) * depth;
+  enc = fract(enc);
+  enc.xy -= enc.yz / 255.0;
+  return enc;
+}
 `;
 /** Pack 2 floats in the integer range [0..255] into a single float equal to v.x | (v.y << 8)
  * @internal
  */
-exports.pack2Bytes = `
-float pack2Bytes(vec2 v) {
-  return v.x + (v.y * 256.0);
-}
+exports.pack2Bytes = `
+float pack2Bytes(vec2 v) {
+  return v.x + (v.y * 256.0);
+}
 `;
 /** Unpack a float in the integer range [0..0xffff] into a vec2 containing 2 integers in the range [0..255]
  * @internal
  */
-exports.unpack2Bytes = `
-vec2 unpack2Bytes(float f) {
-  f = floor(f + 0.5);
-  vec2 v;
-  v.y = floor(f / 256.0);
-  v.x = floor(f - v.y * 256.0);
-  return v;
-}
+exports.unpack2Bytes = `
+vec2 unpack2Bytes(float f) {
+  f = floor(f + 0.5);
+  vec2 v;
+  v.y = floor(f / 256.0);
+  v.x = floor(f - v.y * 256.0);
+  return v;
+}
 `;
 /** @internal */
-exports.unpackAndNormalize2Bytes = `
-vec2 unpackAndNormalize2Bytes(float f) {
-  return unpack2Bytes(f) / 255.0;
-}
+exports.unpackAndNormalize2Bytes = `
+vec2 unpackAndNormalize2Bytes(float f) {
+  return unpack2Bytes(f) / 255.0;
+}
 `;
 /** @internal */
 function addUnpackAndNormalize2Bytes(builder) {
@@ -82,30 +82,30 @@ exports.addUnpackAndNormalize2Bytes = addUnpackAndNormalize2Bytes;
  * From https://github.com/CesiumGS/cesium/blob/main/Source/Shaders/Builtin/Functions/unpackFloat.glsl
  * @internal
  */
-exports.decodeFloat32 = `
-float decodeFloat32(vec4 packedFloat) {
-  float sign = 1.0 - step(128.0, packedFloat[3]) * 2.0;
-  float exponent = 2.0 * mod(packedFloat[3], 128.0) + step(128.0, packedFloat[2]) - 127.0;
-  if (exponent == -127.0)
-    return 0.0;
-
-  float mantissa = mod(packedFloat[2], 128.0) * 65536.0 + packedFloat[1] * 256.0 + packedFloat[0] + float(0x800000);
-  float result = sign * exp2(exponent - 23.0) * mantissa;
-  return result;
-}
+exports.decodeFloat32 = `
+float decodeFloat32(vec4 packedFloat) {
+  float sign = 1.0 - step(128.0, packedFloat[3]) * 2.0;
+  float exponent = 2.0 * mod(packedFloat[3], 128.0) + step(128.0, packedFloat[2]) - 127.0;
+  if (exponent == -127.0)
+    return 0.0;
+
+  float mantissa = mod(packedFloat[2], 128.0) * 65536.0 + packedFloat[1] * 256.0 + packedFloat[0] + float(0x800000);
+  float result = sign * exp2(exponent - 23.0) * mantissa;
+  return result;
+}
 `;
-exports.decode3Float32 = `
-// This expects an array of 4 vec3s, where each vec4 contains a slice of all 3 of the packed floats in .xyz
-// pf0 is in [0].x, pf1 is in [0].y, and pf2 in [0].z
-// e.g.: packedFloat[0] = vec3(pf0.x, pf1.x, pf2.x)
-// likewise .y info is in [1], .z in [2], and .w in [3]
-vec3 decode3Float32(vec3 packedFloat[4]) {
-  vec3 sign = 1.0 - step(128.0, packedFloat[3].xyz) * 2.0;
-  vec3 exponent = 2.0 * mod(packedFloat[3].xyz, 128.0) + step(128.0, packedFloat[2].xyz) - 127.0;
-  vec3 zeroFlag = vec3(notEqual(vec3(-127.0), exponent));
-  vec3 mantissa = mod(packedFloat[2].xyz, 128.0) * 65536.0 + packedFloat[1].xyz * 256.0 + packedFloat[0].xyz + float(0x800000);
-  vec3 result = sign * exp2(exponent - 23.0) * mantissa * zeroFlag;
-  return result;
-}
+exports.decode3Float32 = `
+// This expects an array of 4 vec3s, where each vec4 contains a slice of all 3 of the packed floats in .xyz
+// pf0 is in [0].x, pf1 is in [0].y, and pf2 in [0].z
+// e.g.: packedFloat[0] = vec3(pf0.x, pf1.x, pf2.x)
+// likewise .y info is in [1], .z in [2], and .w in [3]
+vec3 decode3Float32(vec3 packedFloat[4]) {
+  vec3 sign = 1.0 - step(128.0, packedFloat[3].xyz) * 2.0;
+  vec3 exponent = 2.0 * mod(packedFloat[3].xyz, 128.0) + step(128.0, packedFloat[2].xyz) - 127.0;
+  vec3 zeroFlag = vec3(notEqual(vec3(-127.0), exponent));
+  vec3 mantissa = mod(packedFloat[2].xyz, 128.0) * 65536.0 + packedFloat[1].xyz * 256.0 + packedFloat[0].xyz + float(0x800000);
+  vec3 result = sign * exp2(exponent - 23.0) * mantissa * zeroFlag;
+  return result;
+}
 `;
 //# sourceMappingURL=Decode.js.map

package/lib/cjs/render/webgl/glsl/Decode.js.map

@@ -1 +1 @@
-{"version":3,"file":"Decode.js","sourceRoot":"","sources":["../../../../../src/render/webgl/glsl/Decode.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAIH,gBAAgB;AACH,QAAA,YAAY,GAAG;;;;CAI3B,CAAC;AAEF,gBAAgB;AACH,QAAA,YAAY,GAAG;;;;CAI3B,CAAC;AAEF,gBAAgB;AACH,QAAA,YAAY,GAAG;;CAE3B,CAAC;AAEF,gBAAgB;AACH,QAAA,YAAY,GAAG;;;CAG3B,CAAC;AAEF,gBAAgB;AACH,QAAA,cAAc,GAAG;;CAE7B,CAAC;AAEF,gBAAgB;AACH,QAAA,cAAc,GAAG;;;;;;;;;;CAU7B,CAAC;AAEF;;GAEG;AACU,QAAA,UAAU,GAAG;;;;CAIzB,CAAC;AAEF;;GAEG;AACU,QAAA,YAAY,GAAG;;;;;;;;CAQ3B,CAAC;AAEF,gBAAgB;AACH,QAAA,wBAAwB,GAAG;;;;CAIvC,CAAC;AAEF,gBAAgB;AAChB,SAAgB,2BAA2B,CAAC,OAAsB;IAChE,OAAO,CAAC,WAAW,CAAC,oBAAY,CAAC,CAAC;IAClC,OAAO,CAAC,WAAW,CAAC,gCAAwB,CAAC,CAAC;AAChD,CAAC;AAHD,kEAGC;AAED;;;;GAIG;AACU,QAAA,aAAa,GAAG;;;;;;;;;;;CAW5B,CAAC;AAEW,QAAA,cAAc,GAAG;;;;;;;;;;;;;CAa7B,CAAC","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module WebGL\r\n */\r\n\r\nimport { ShaderBuilder } from \"../ShaderBuilder\";\r\n\r\n/** @internal */\r\nexport const decodeUint16 = `\r\nfloat decodeUInt16(vec2 v) {\r\n  return dot(v, vec2(1.0, 256.0)); // v.x | (v.y << 8)\r\n}\r\n`;\r\n\r\n/** @internal */\r\nexport const decodeUint24 = `\r\nfloat decodeUInt24(vec3 v) {\r\n  return dot(v, vec3(1.0, 256.0, 256.0*256.0)); // v.x | (v.y << 8) | (v.z << 16)\r\n}\r\n`;\r\n\r\n/** @internal */\r\nexport const unquantize3d = `\r\nvec3 unquantize3d(vec3 qpos, vec3 origin, vec3 scale) { return origin + scale * qpos; }\r\n`;\r\n\r\n/** @internal */\r\nexport const unquantize2d = `\r\n// params.xy = origin. params.zw = scale.\r\nvec2 unquantize2d(vec2 qpos, vec4 params) { return params.xy + params.zw * qpos; }\r\n`;\r\n\r\n/** @internal */\r\nexport const decodeDepthRgb = `\r\nfloat decodeDepthRgb(vec3 rgb) { return dot(rgb, vec3(1.0, 1.0 / 255.0, 1.0 / 65025.0)); }\r\n`;\r\n\r\n/** @internal */\r\nexport const encodeDepthRgb = `\r\nvec3 encodeDepthRgb(float depth) {\r\n  // 1.0 must be reduced slightly; otherwise decoding will produce zero. It's the far plane, so we don't care (and decoding produces 1.0 anyway).\r\n  depth = min(depth, 16777215.0/16777216.0);\r\n\r\n  vec3 enc = vec3(1.0, 255.0, 65025.0) * depth;\r\n  enc = fract(enc);\r\n  enc.xy -= enc.yz / 255.0;\r\n  return enc;\r\n}\r\n`;\r\n\r\n/** Pack 2 floats in the integer range [0..255] into a single float equal to v.x | (v.y << 8)\r\n * @internal\r\n */\r\nexport const pack2Bytes = `\r\nfloat pack2Bytes(vec2 v) {\r\n  return v.x + (v.y * 256.0);\r\n}\r\n`;\r\n\r\n/** Unpack a float in the integer range [0..0xffff] into a vec2 containing 2 integers in the range [0..255]\r\n * @internal\r\n */\r\nexport const unpack2Bytes = `\r\nvec2 unpack2Bytes(float f) {\r\n  f = floor(f + 0.5);\r\n  vec2 v;\r\n  v.y = floor(f / 256.0);\r\n  v.x = floor(f - v.y * 256.0);\r\n  return v;\r\n}\r\n`;\r\n\r\n/** @internal */\r\nexport const unpackAndNormalize2Bytes = `\r\nvec2 unpackAndNormalize2Bytes(float f) {\r\n  return unpack2Bytes(f) / 255.0;\r\n}\r\n`;\r\n\r\n/** @internal */\r\nexport function addUnpackAndNormalize2Bytes(builder: ShaderBuilder): void {\r\n  builder.addFunction(unpack2Bytes);\r\n  builder.addFunction(unpackAndNormalize2Bytes);\r\n}\r\n\r\n/** Given an IEEE 32-bit float stuffed into a RGBA unsigned byte texture, extract the float.\r\n * The input vec4 components are in the integer range [0..255].\r\n * From https://github.com/CesiumGS/cesium/blob/main/Source/Shaders/Builtin/Functions/unpackFloat.glsl\r\n * @internal\r\n */\r\nexport const decodeFloat32 = `\r\nfloat decodeFloat32(vec4 packedFloat) {\r\n  float sign = 1.0 - step(128.0, packedFloat[3]) * 2.0;\r\n  float exponent = 2.0 * mod(packedFloat[3], 128.0) + step(128.0, packedFloat[2]) - 127.0;\r\n  if (exponent == -127.0)\r\n    return 0.0;\r\n\r\n  float mantissa = mod(packedFloat[2], 128.0) * 65536.0 + packedFloat[1] * 256.0 + packedFloat[0] + float(0x800000);\r\n  float result = sign * exp2(exponent - 23.0) * mantissa;\r\n  return result;\r\n}\r\n`;\r\n\r\nexport const decode3Float32 = `\r\n// This expects an array of 4 vec3s, where each vec4 contains a slice of all 3 of the packed floats in .xyz\r\n// pf0 is in [0].x, pf1 is in [0].y, and pf2 in [0].z\r\n// e.g.: packedFloat[0] = vec3(pf0.x, pf1.x, pf2.x)\r\n// likewise .y info is in [1], .z in [2], and .w in [3]\r\nvec3 decode3Float32(vec3 packedFloat[4]) {\r\n  vec3 sign = 1.0 - step(128.0, packedFloat[3].xyz) * 2.0;\r\n  vec3 exponent = 2.0 * mod(packedFloat[3].xyz, 128.0) + step(128.0, packedFloat[2].xyz) - 127.0;\r\n  vec3 zeroFlag = vec3(notEqual(vec3(-127.0), exponent));\r\n  vec3 mantissa = mod(packedFloat[2].xyz, 128.0) * 65536.0 + packedFloat[1].xyz * 256.0 + packedFloat[0].xyz + float(0x800000);\r\n  vec3 result = sign * exp2(exponent - 23.0) * mantissa * zeroFlag;\r\n  return result;\r\n}\r\n`;\r\n"]}
+{"version":3,"file":"Decode.js","sourceRoot":"","sources":["../../../../../src/render/webgl/glsl/Decode.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAIH,gBAAgB;AACH,QAAA,YAAY,GAAG;;;;CAI3B,CAAC;AAEF,gBAAgB;AACH,QAAA,YAAY,GAAG;;;;CAI3B,CAAC;AAEF,gBAAgB;AACH,QAAA,YAAY,GAAG;;CAE3B,CAAC;AAEF,gBAAgB;AACH,QAAA,YAAY,GAAG;;;CAG3B,CAAC;AAEF,gBAAgB;AACH,QAAA,cAAc,GAAG;;CAE7B,CAAC;AAEF,gBAAgB;AACH,QAAA,cAAc,GAAG;;;;;;;;;;CAU7B,CAAC;AAEF;;GAEG;AACU,QAAA,UAAU,GAAG;;;;CAIzB,CAAC;AAEF;;GAEG;AACU,QAAA,YAAY,GAAG;;;;;;;;CAQ3B,CAAC;AAEF,gBAAgB;AACH,QAAA,wBAAwB,GAAG;;;;CAIvC,CAAC;AAEF,gBAAgB;AAChB,SAAgB,2BAA2B,CAAC,OAAsB;IAChE,OAAO,CAAC,WAAW,CAAC,oBAAY,CAAC,CAAC;IAClC,OAAO,CAAC,WAAW,CAAC,gCAAwB,CAAC,CAAC;AAChD,CAAC;AAHD,kEAGC;AAED;;;;GAIG;AACU,QAAA,aAAa,GAAG;;;;;;;;;;;CAW5B,CAAC;AAEW,QAAA,cAAc,GAAG;;;;;;;;;;;;;CAa7B,CAAC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n/** @packageDocumentation\n * @module WebGL\n */\n\nimport { ShaderBuilder } from \"../ShaderBuilder\";\n\n/** @internal */\nexport const decodeUint16 = `\nfloat decodeUInt16(vec2 v) {\n  return dot(v, vec2(1.0, 256.0)); // v.x | (v.y << 8)\n}\n`;\n\n/** @internal */\nexport const decodeUint24 = `\nfloat decodeUInt24(vec3 v) {\n  return dot(v, vec3(1.0, 256.0, 256.0*256.0)); // v.x | (v.y << 8) | (v.z << 16)\n}\n`;\n\n/** @internal */\nexport const unquantize3d = `\nvec3 unquantize3d(vec3 qpos, vec3 origin, vec3 scale) { return origin + scale * qpos; }\n`;\n\n/** @internal */\nexport const unquantize2d = `\n// params.xy = origin. params.zw = scale.\nvec2 unquantize2d(vec2 qpos, vec4 params) { return params.xy + params.zw * qpos; }\n`;\n\n/** @internal */\nexport const decodeDepthRgb = `\nfloat decodeDepthRgb(vec3 rgb) { return dot(rgb, vec3(1.0, 1.0 / 255.0, 1.0 / 65025.0)); }\n`;\n\n/** @internal */\nexport const encodeDepthRgb = `\nvec3 encodeDepthRgb(float depth) {\n  // 1.0 must be reduced slightly; otherwise decoding will produce zero. It's the far plane, so we don't care (and decoding produces 1.0 anyway).\n  depth = min(depth, 16777215.0/16777216.0);\n\n  vec3 enc = vec3(1.0, 255.0, 65025.0) * depth;\n  enc = fract(enc);\n  enc.xy -= enc.yz / 255.0;\n  return enc;\n}\n`;\n\n/** Pack 2 floats in the integer range [0..255] into a single float equal to v.x | (v.y << 8)\n * @internal\n */\nexport const pack2Bytes = `\nfloat pack2Bytes(vec2 v) {\n  return v.x + (v.y * 256.0);\n}\n`;\n\n/** Unpack a float in the integer range [0..0xffff] into a vec2 containing 2 integers in the range [0..255]\n * @internal\n */\nexport const unpack2Bytes = `\nvec2 unpack2Bytes(float f) {\n  f = floor(f + 0.5);\n  vec2 v;\n  v.y = floor(f / 256.0);\n  v.x = floor(f - v.y * 256.0);\n  return v;\n}\n`;\n\n/** @internal */\nexport const unpackAndNormalize2Bytes = `\nvec2 unpackAndNormalize2Bytes(float f) {\n  return unpack2Bytes(f) / 255.0;\n}\n`;\n\n/** @internal */\nexport function addUnpackAndNormalize2Bytes(builder: ShaderBuilder): void {\n  builder.addFunction(unpack2Bytes);\n  builder.addFunction(unpackAndNormalize2Bytes);\n}\n\n/** Given an IEEE 32-bit float stuffed into a RGBA unsigned byte texture, extract the float.\n * The input vec4 components are in the integer range [0..255].\n * From https://github.com/CesiumGS/cesium/blob/main/Source/Shaders/Builtin/Functions/unpackFloat.glsl\n * @internal\n */\nexport const decodeFloat32 = `\nfloat decodeFloat32(vec4 packedFloat) {\n  float sign = 1.0 - step(128.0, packedFloat[3]) * 2.0;\n  float exponent = 2.0 * mod(packedFloat[3], 128.0) + step(128.0, packedFloat[2]) - 127.0;\n  if (exponent == -127.0)\n    return 0.0;\n\n  float mantissa = mod(packedFloat[2], 128.0) * 65536.0 + packedFloat[1] * 256.0 + packedFloat[0] + float(0x800000);\n  float result = sign * exp2(exponent - 23.0) * mantissa;\n  return result;\n}\n`;\n\nexport const decode3Float32 = `\n// This expects an array of 4 vec3s, where each vec4 contains a slice of all 3 of the packed floats in .xyz\n// pf0 is in [0].x, pf1 is in [0].y, and pf2 in [0].z\n// e.g.: packedFloat[0] = vec3(pf0.x, pf1.x, pf2.x)\n// likewise .y info is in [1], .z in [2], and .w in [3]\nvec3 decode3Float32(vec3 packedFloat[4]) {\n  vec3 sign = 1.0 - step(128.0, packedFloat[3].xyz) * 2.0;\n  vec3 exponent = 2.0 * mod(packedFloat[3].xyz, 128.0) + step(128.0, packedFloat[2].xyz) - 127.0;\n  vec3 zeroFlag = vec3(notEqual(vec3(-127.0), exponent));\n  vec3 mantissa = mod(packedFloat[2].xyz, 128.0) * 65536.0 + packedFloat[1].xyz * 256.0 + packedFloat[0].xyz + float(0x800000);\n  vec3 result = sign * exp2(exponent - 23.0) * mantissa * zeroFlag;\n  return result;\n}\n`;\n"]}

package/lib/cjs/render/webgl/glsl/EDL.js

@@ -13,35 +13,35 @@ const Texture_1 = require("../Texture");
 const Fragment_1 = require("./Fragment");
 const ViewportQuad_1 = require("./ViewportQuad");
 // This shader calculates a more basic version of EDL, and only for the original size, so single pass
-const calcBasicEDL = `
-    float strength = u_pointCloudEDL1.x;
-    float scaleFactor = u_pointCloudEDL1.z;
-    float pixRadius = u_pointCloudEDL1.y;
-    vec2 invTexSize = u_texInfo.xy;
-    float is3d = u_pointCloudEDL1.w;
-
-    vec4 color = TEXTURE(u_colorTexture, v_texCoord);
-    if (color.a == 0.0)
-        discard;
-    else {
-        const vec2 neighbors[8] = vec2[8] (  //neighbor relative position
-            vec2( 1.0, 0.0), vec2( 0.70710678,  0.70710678), vec2(0.0,  1.0), vec2(-0.70710678,  0.70710678),
-            vec2(-1.0, 0.0), vec2(-0.70710678, -0.70710678), vec2(0.0, -1.0), vec2( 0.70710678, -0.70710678));
-        float depth = TEXTURE(u_depthTexture, v_texCoord).r;
-        float sum = 0.0;
-        vec2 posScale = pixRadius * invTexSize;
-        // contribution of each neighbor
-        // NOTE: this is currently using neighbor depths regardless of if they were written by point cloud
-        for (int c = 0; c < 8; c++) {
-            vec2 nRelPos = posScale * neighbors[c];
-            vec2 nPos = v_texCoord + nRelPos;
-            float zN = TEXTURE(u_depthTexture, nPos).r;  // neighbor depth
-            sum += max(0.0, (is3d > 0.5) ? depth - zN : log (depth/zN));
-        }
-        float f = sum / 8.0;
-        f = exp(-f * 33.5 * strength * scaleFactor); // 33.5 factor to aim for a typical (unfactored) strength of 5
-        return vec4(f * color.rgb, 1.0);
-    }
+const calcBasicEDL = `
+    float strength = u_pointCloudEDL1.x;
+    float scaleFactor = u_pointCloudEDL1.z;
+    float pixRadius = u_pointCloudEDL1.y;
+    vec2 invTexSize = u_texInfo.xy;
+    float is3d = u_pointCloudEDL1.w;
+
+    vec4 color = TEXTURE(u_colorTexture, v_texCoord);
+    if (color.a == 0.0)
+        discard;
+    else {
+        const vec2 neighbors[8] = vec2[8] (  //neighbor relative position
+            vec2( 1.0, 0.0), vec2( 0.70710678,  0.70710678), vec2(0.0,  1.0), vec2(-0.70710678,  0.70710678),
+            vec2(-1.0, 0.0), vec2(-0.70710678, -0.70710678), vec2(0.0, -1.0), vec2( 0.70710678, -0.70710678));
+        float depth = TEXTURE(u_depthTexture, v_texCoord).r;
+        float sum = 0.0;
+        vec2 posScale = pixRadius * invTexSize;
+        // contribution of each neighbor
+        // NOTE: this is currently using neighbor depths regardless of if they were written by point cloud
+        for (int c = 0; c < 8; c++) {
+            vec2 nRelPos = posScale * neighbors[c];
+            vec2 nPos = v_texCoord + nRelPos;
+            float zN = TEXTURE(u_depthTexture, nPos).r;  // neighbor depth
+            sum += max(0.0, (is3d > 0.5) ? depth - zN : log (depth/zN));
+        }
+        float f = sum / 8.0;
+        f = exp(-f * 33.5 * strength * scaleFactor); // 33.5 factor to aim for a typical (unfactored) strength of 5
+        return vec4(f * color.rgb, 1.0);
+    }
 `;
 /** @internal */
 function createEDLCalcBasicProgram(context) {
@@ -79,36 +79,36 @@ function createEDLCalcBasicProgram(context) {
 }
 exports.createEDLCalcBasicProgram = createEDLCalcBasicProgram;
 // This shader calculates the full version of EDL, and can be run at full, 1/2 and 1/4 scale
-const calcFullEDL = `
-    float strength = u_pointCloudEDL1.x;
-    float scaleFactor = u_pointCloudEDL1.z;
-    float pixRadius = u_pointCloudEDL1.y;
-    float scale = u_texInfo.z;  // 1, 2, 4
-    vec2 invTexSize = u_texInfo.xy;
-    float is3d = u_pointCloudEDL1.w;
-
-    vec4 color = TEXTURE(u_colorTexture, v_texCoord);
-    if (color.a == 0.0)
-        return color;
-    else {
-        const vec2 neighbors[8] = vec2[8] (  //neighbor relative position
-            vec2( 1.0, 0.0), vec2( 0.70710678,  0.70710678), vec2(0.0,  1.0), vec2(-0.70710678,  0.70710678),
-            vec2(-1.0, 0.0), vec2(-0.70710678, -0.70710678), vec2(0.0, -1.0), vec2( 0.70710678, -0.70710678));
-        float depth = TEXTURE(u_depthTexture, v_texCoord).r;
-        float sum = 0.0;
-        vec2 posScale = pixRadius * invTexSize;
-        // contribution of each neighbor
-        // NOTE: this is currently using neighbor depths regardless of if they were written by point cloud
-        for (int c = 0; c < 8; c++) {
-            vec2 nRelPos = posScale * neighbors[c];
-            vec2 nPos = v_texCoord + nRelPos;
-            float zN = TEXTURE(u_depthTexture, nPos).r;  // neighbor depth
-            sum += max(0.0, (is3d > 0.5) ? depth - zN : log (depth/zN)) / scale;
-        }
-        float f = sum / 8.0;
-        f = exp(-f * 33.5 * strength * scaleFactor); // 33.5 factor to aim for a typical (unfactored) strength of 5
-        return vec4(f * color.rgb, 1.0);
-    }
+const calcFullEDL = `
+    float strength = u_pointCloudEDL1.x;
+    float scaleFactor = u_pointCloudEDL1.z;
+    float pixRadius = u_pointCloudEDL1.y;
+    float scale = u_texInfo.z;  // 1, 2, 4
+    vec2 invTexSize = u_texInfo.xy;
+    float is3d = u_pointCloudEDL1.w;
+
+    vec4 color = TEXTURE(u_colorTexture, v_texCoord);
+    if (color.a == 0.0)
+        return color;
+    else {
+        const vec2 neighbors[8] = vec2[8] (  //neighbor relative position
+            vec2( 1.0, 0.0), vec2( 0.70710678,  0.70710678), vec2(0.0,  1.0), vec2(-0.70710678,  0.70710678),
+            vec2(-1.0, 0.0), vec2(-0.70710678, -0.70710678), vec2(0.0, -1.0), vec2( 0.70710678, -0.70710678));
+        float depth = TEXTURE(u_depthTexture, v_texCoord).r;
+        float sum = 0.0;
+        vec2 posScale = pixRadius * invTexSize;
+        // contribution of each neighbor
+        // NOTE: this is currently using neighbor depths regardless of if they were written by point cloud
+        for (int c = 0; c < 8; c++) {
+            vec2 nRelPos = posScale * neighbors[c];
+            vec2 nPos = v_texCoord + nRelPos;
+            float zN = TEXTURE(u_depthTexture, nPos).r;  // neighbor depth
+            sum += max(0.0, (is3d > 0.5) ? depth - zN : log (depth/zN)) / scale;
+        }
+        float f = sum / 8.0;
+        f = exp(-f * 33.5 * strength * scaleFactor); // 33.5 factor to aim for a typical (unfactored) strength of 5
+        return vec4(f * color.rgb, 1.0);
+    }
 `;
 /** @internal */
 function createEDLCalcFullProgram(context) {
@@ -146,41 +146,41 @@ function createEDLCalcFullProgram(context) {
 }
 exports.createEDLCalcFullProgram = createEDLCalcFullProgram;
 // This shader filters the EDL image, and can be run at 1/2 and 1/4 scale
-const filterEDL = `
-    // NB: this bilateral filter hardcodes spatialSigma to 2.0 and depthSigma to 0.4, with halfSize = 2
-    float distCoefs[] = float[] (
-        1.0, 0.9692332344763441, 0.8824969025845955, 0.9692332344763441, 0.9394130628134758,
-        0.8553453273074225, 0.8824969025845955, 0.8553453273074225, 0.8553453273074225, 0.7788007830714049);
-    const float depthSigma = 0.4;
-    vec2 invTexSize = u_texInfo.xy;
-
-    float depth = TEXTURE(u_depthTexture, v_texCoord).r;
-    float wsum = 0.0;  // sum of all weights
-    vec3  csum = vec3(0.0);  // sum of all contributions
-    vec2  coordi = vec2(0.0, 0.0);  // ith neighbor position x,y
-
-    for (int c = -2; c <= 2; c++) {
-        coordi.x = float(c) * invTexSize.x;
-        int cabs = (c < 0) ? -c : c;
-
-        for (int d = -2; d <= 2; d++) {
-            coordi.y = float(d) * invTexSize.y;
-            vec4 ci = TEXTURE(u_colorTexture, v_texCoord + coordi); // neighbor color
-
-            //pixel distance based damping
-            int dabs = (d < 0) ? -d : d;
-            float fi = distCoefs[cabs * 3 + dabs];
-
-            //pixel depth difference based damping
-            float zi = TEXTURE(u_depthTexture, v_texCoord + coordi).r; // neighbor depth
-            float dz = (depth - zi) / depthSigma;
-            fi *= exp(-dz * dz / 2.0);
-
-            csum += ci.rgb * fi;
-            wsum += fi;
-        }
-    }
-    return vec4(csum / wsum, 1.0);
+const filterEDL = `
+    // NB: this bilateral filter hardcodes spatialSigma to 2.0 and depthSigma to 0.4, with halfSize = 2
+    float distCoefs[] = float[] (
+        1.0, 0.9692332344763441, 0.8824969025845955, 0.9692332344763441, 0.9394130628134758,
+        0.8553453273074225, 0.8824969025845955, 0.8553453273074225, 0.8553453273074225, 0.7788007830714049);
+    const float depthSigma = 0.4;
+    vec2 invTexSize = u_texInfo.xy;
+
+    float depth = TEXTURE(u_depthTexture, v_texCoord).r;
+    float wsum = 0.0;  // sum of all weights
+    vec3  csum = vec3(0.0);  // sum of all contributions
+    vec2  coordi = vec2(0.0, 0.0);  // ith neighbor position x,y
+
+    for (int c = -2; c <= 2; c++) {
+        coordi.x = float(c) * invTexSize.x;
+        int cabs = (c < 0) ? -c : c;
+
+        for (int d = -2; d <= 2; d++) {
+            coordi.y = float(d) * invTexSize.y;
+            vec4 ci = TEXTURE(u_colorTexture, v_texCoord + coordi); // neighbor color
+
+            //pixel distance based damping
+            int dabs = (d < 0) ? -d : d;
+            float fi = distCoefs[cabs * 3 + dabs];
+
+            //pixel depth difference based damping
+            float zi = TEXTURE(u_depthTexture, v_texCoord + coordi).r; // neighbor depth
+            float dz = (depth - zi) / depthSigma;
+            fi *= exp(-dz * dz / 2.0);
+
+            csum += ci.rgb * fi;
+            wsum += fi;
+        }
+    }
+    return vec4(csum / wsum, 1.0);
 `;
 /** @internal */
 function createEDLFilterProgram(context) {
@@ -212,15 +212,15 @@ function createEDLFilterProgram(context) {
 }
 exports.createEDLFilterProgram = createEDLFilterProgram;
 // This shader mixes the 3 EDL images into the final image
-const mixEDL = `
-  vec4 col1 = TEXTURE(u_colorTexture1, v_texCoord);
-  if (col1.a == 0.0)
-      discard;
-  else {
-      vec3 col2 = TEXTURE(u_colorTexture2, v_texCoord).rgb;
-      vec3 col4 = TEXTURE(u_colorTexture4, v_texCoord).rgb;
-      return vec4 ((u_weights.x * col1.rgb + u_weights.y * col2 + u_weights.z * col4) / (u_weights.x + u_weights.y + u_weights.z), 1.0);
-  }
+const mixEDL = `
+  vec4 col1 = TEXTURE(u_colorTexture1, v_texCoord);
+  if (col1.a == 0.0)
+      discard;
+  else {
+      vec3 col2 = TEXTURE(u_colorTexture2, v_texCoord).rgb;
+      vec3 col4 = TEXTURE(u_colorTexture4, v_texCoord).rgb;
+      return vec4 ((u_weights.x * col1.rgb + u_weights.y * col2 + u_weights.z * col4) / (u_weights.x + u_weights.y + u_weights.z), 1.0);
+  }
 `;
 /** @internal */
 function createEDLMixProgram(context) {

package/lib/cjs/render/webgl/glsl/EDL.js.map

@@ -1 +1 @@
-{"version":3,"file":"EDL.js","sourceRoot":"","sources":["../../../../../src/render/webgl/glsl/EDL.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module WebGL\r\n */\r\n\r\nimport { EDLCalcBasicGeometry, EDLCalcFullGeometry, EDLFilterGeometry, EDLMixGeometry } from \"../CachedGeometry\";\r\nimport { TextureUnit } from \"../RenderFlags\";\r\nimport { FragmentShaderComponent, VariableType } from \"../ShaderBuilder\";\r\nimport { ShaderProgram } from \"../ShaderProgram\";\r\nimport { Texture2DHandle } from \"../Texture\";\r\nimport { assignFragColor } from \"./Fragment\";\r\nimport { createViewportQuadBuilder } from \"./ViewportQuad\";\r\n\r\n// This shader calculates a more basic version of EDL, and only for the original size, so single pass\r\nconst calcBasicEDL = `\r\n    float strength = u_pointCloudEDL1.x;\r\n    float scaleFactor = u_pointCloudEDL1.z;\r\n    float pixRadius = u_pointCloudEDL1.y;\r\n    vec2 invTexSize = u_texInfo.xy;\r\n    float is3d = u_pointCloudEDL1.w;\r\n\r\n    vec4 color = TEXTURE(u_colorTexture, v_texCoord);\r\n    if (color.a == 0.0)\r\n        discard;\r\n    else {\r\n        const vec2 neighbors[8] = vec2[8] (  //neighbor relative position\r\n            vec2( 1.0, 0.0), vec2( 0.70710678,  0.70710678), vec2(0.0,  1.0), vec2(-0.70710678,  0.70710678),\r\n            vec2(-1.0, 0.0), vec2(-0.70710678, -0.70710678), vec2(0.0, -1.0), vec2( 0.70710678, -0.70710678));\r\n        float depth = TEXTURE(u_depthTexture, v_texCoord).r;\r\n        float sum = 0.0;\r\n        vec2 posScale = pixRadius * invTexSize;\r\n        // contribution of each neighbor\r\n        // NOTE: this is currently using neighbor depths regardless of if they were written by point cloud\r\n        for (int c = 0; c < 8; c++) {\r\n            vec2 nRelPos = posScale * neighbors[c];\r\n            vec2 nPos = v_texCoord + nRelPos;\r\n            float zN = TEXTURE(u_depthTexture, nPos).r;  // neighbor depth\r\n            sum += max(0.0, (is3d > 0.5) ? depth - zN : log (depth/zN));\r\n        }\r\n        float f = sum / 8.0;\r\n        f = exp(-f * 33.5 * strength * scaleFactor); // 33.5 factor to aim for a typical (unfactored) strength of 5\r\n        return vec4(f * color.rgb, 1.0);\r\n    }\r\n`;\r\n\r\n/** @internal */\r\nexport function createEDLCalcBasicProgram(context: WebGL2RenderingContext): ShaderProgram {\r\n  const builder = createViewportQuadBuilder(true);\r\n  const frag = builder.frag;\r\n\r\n  frag.set(FragmentShaderComponent.ComputeBaseColor, calcBasicEDL);\r\n  frag.set(FragmentShaderComponent.AssignFragData, assignFragColor);\r\n\r\n  frag.addUniform(\"u_texInfo\", VariableType.Vec3, (prog) => {\r\n    prog.addGraphicUniform(\"u_texInfo\", (uniform, params) => {\r\n      const geom = params.geometry as EDLCalcBasicGeometry;\r\n      uniform.setUniform3fv(geom.texInfo);\r\n    });\r\n  });\r\n\r\n  frag.addUniform(\"u_colorTexture\", VariableType.Sampler2D, (prog) => {\r\n    prog.addGraphicUniform(\"u_colorTexture\", (uniform, params) => {\r\n      const geom = params.geometry as EDLCalcBasicGeometry;\r\n      Texture2DHandle.bindSampler(uniform, geom.colorTexture, TextureUnit.Zero);\r\n    });\r\n  });\r\n\r\n  frag.addUniform(\"u_depthTexture\", VariableType.Sampler2D, (prog) => {\r\n    prog.addGraphicUniform(\"u_depthTexture\", (uniform, params) => {\r\n      const geom = params.geometry as EDLCalcBasicGeometry;\r\n      Texture2DHandle.bindSampler(uniform, geom.depthTexture, TextureUnit.One);\r\n    });\r\n  });\r\n\r\n  // Uniforms based on the PointCloudDisplaySettings.\r\n  frag.addUniform(\"u_pointCloudEDL1\", VariableType.Vec4, (prog) => {\r\n    prog.addGraphicUniform(\"u_pointCloudEDL1\", (uniform, params) => {\r\n      params.target.uniforms.realityModel.pointCloud.bindEDL1(uniform);\r\n    });\r\n  });\r\n\r\n  builder.vert.headerComment = \"//!V! EDLCalcBasic\";\r\n  builder.frag.headerComment = \"//!F! EDLCalcBasic\";\r\n\r\n  return builder.buildProgram(context);\r\n}\r\n\r\n// This shader calculates the full version of EDL, and can be run at full, 1/2 and 1/4 scale\r\nconst calcFullEDL = `\r\n    float strength = u_pointCloudEDL1.x;\r\n    float scaleFactor = u_pointCloudEDL1.z;\r\n    float pixRadius = u_pointCloudEDL1.y;\r\n    float scale = u_texInfo.z;  // 1, 2, 4\r\n    vec2 invTexSize = u_texInfo.xy;\r\n    float is3d = u_pointCloudEDL1.w;\r\n\r\n    vec4 color = TEXTURE(u_colorTexture, v_texCoord);\r\n    if (color.a == 0.0)\r\n        return color;\r\n    else {\r\n        const vec2 neighbors[8] = vec2[8] (  //neighbor relative position\r\n            vec2( 1.0, 0.0), vec2( 0.70710678,  0.70710678), vec2(0.0,  1.0), vec2(-0.70710678,  0.70710678),\r\n            vec2(-1.0, 0.0), vec2(-0.70710678, -0.70710678), vec2(0.0, -1.0), vec2( 0.70710678, -0.70710678));\r\n        float depth = TEXTURE(u_depthTexture, v_texCoord).r;\r\n        float sum = 0.0;\r\n        vec2 posScale = pixRadius * invTexSize;\r\n        // contribution of each neighbor\r\n        // NOTE: this is currently using neighbor depths regardless of if they were written by point cloud\r\n        for (int c = 0; c < 8; c++) {\r\n            vec2 nRelPos = posScale * neighbors[c];\r\n            vec2 nPos = v_texCoord + nRelPos;\r\n            float zN = TEXTURE(u_depthTexture, nPos).r;  // neighbor depth\r\n            sum += max(0.0, (is3d > 0.5) ? depth - zN : log (depth/zN)) / scale;\r\n        }\r\n        float f = sum / 8.0;\r\n        f = exp(-f * 33.5 * strength * scaleFactor); // 33.5 factor to aim for a typical (unfactored) strength of 5\r\n        return vec4(f * color.rgb, 1.0);\r\n    }\r\n`;\r\n\r\n/** @internal */\r\nexport function createEDLCalcFullProgram(context: WebGL2RenderingContext): ShaderProgram {\r\n  const builder = createViewportQuadBuilder(true);\r\n  const frag = builder.frag;\r\n\r\n  frag.set(FragmentShaderComponent.ComputeBaseColor, calcFullEDL);\r\n  frag.set(FragmentShaderComponent.AssignFragData, assignFragColor);\r\n\r\n  frag.addUniform(\"u_texInfo\", VariableType.Vec3, (prog) => {\r\n    prog.addGraphicUniform(\"u_texInfo\", (uniform, params) => {\r\n      const geom = params.geometry as EDLCalcFullGeometry;\r\n      uniform.setUniform3fv(geom.texInfo);\r\n    });\r\n  });\r\n\r\n  frag.addUniform(\"u_colorTexture\", VariableType.Sampler2D, (prog) => {\r\n    prog.addGraphicUniform(\"u_colorTexture\", (uniform, params) => {\r\n      const geom = params.geometry as EDLCalcFullGeometry;\r\n      Texture2DHandle.bindSampler(uniform, geom.colorTexture, TextureUnit.Zero);\r\n    });\r\n  });\r\n\r\n  frag.addUniform(\"u_depthTexture\", VariableType.Sampler2D, (prog) => {\r\n    prog.addGraphicUniform(\"u_depthTexture\", (uniform, params) => {\r\n      const geom = params.geometry as EDLCalcFullGeometry;\r\n      Texture2DHandle.bindSampler(uniform, geom.depthTexture, TextureUnit.One);\r\n    });\r\n  });\r\n\r\n  // Uniforms based on the PointCloudDisplaySettings.\r\n  frag.addUniform(\"u_pointCloudEDL1\", VariableType.Vec4, (prog) => {\r\n    prog.addGraphicUniform(\"u_pointCloudEDL1\", (uniform, params) => {\r\n      params.target.uniforms.realityModel.pointCloud.bindEDL1(uniform);\r\n    });\r\n  });\r\n\r\n  builder.vert.headerComment = \"//!V! EDLCalcFull\";\r\n  builder.frag.headerComment = \"//!F! EDLCalcFull\";\r\n\r\n  return builder.buildProgram(context);\r\n}\r\n\r\n// This shader filters the EDL image, and can be run at 1/2 and 1/4 scale\r\nconst filterEDL = `\r\n    // NB: this bilateral filter hardcodes spatialSigma to 2.0 and depthSigma to 0.4, with halfSize = 2\r\n    float distCoefs[] = float[] (\r\n        1.0, 0.9692332344763441, 0.8824969025845955, 0.9692332344763441, 0.9394130628134758,\r\n        0.8553453273074225, 0.8824969025845955, 0.8553453273074225, 0.8553453273074225, 0.7788007830714049);\r\n    const float depthSigma = 0.4;\r\n    vec2 invTexSize = u_texInfo.xy;\r\n\r\n    float depth = TEXTURE(u_depthTexture, v_texCoord).r;\r\n    float wsum = 0.0;  // sum of all weights\r\n    vec3  csum = vec3(0.0);  // sum of all contributions\r\n    vec2  coordi = vec2(0.0, 0.0);  // ith neighbor position x,y\r\n\r\n    for (int c = -2; c <= 2; c++) {\r\n        coordi.x = float(c) * invTexSize.x;\r\n        int cabs = (c < 0) ? -c : c;\r\n\r\n        for (int d = -2; d <= 2; d++) {\r\n            coordi.y = float(d) * invTexSize.y;\r\n            vec4 ci = TEXTURE(u_colorTexture, v_texCoord + coordi); // neighbor color\r\n\r\n            //pixel distance based damping\r\n            int dabs = (d < 0) ? -d : d;\r\n            float fi = distCoefs[cabs * 3 + dabs];\r\n\r\n            //pixel depth difference based damping\r\n            float zi = TEXTURE(u_depthTexture, v_texCoord + coordi).r; // neighbor depth\r\n            float dz = (depth - zi) / depthSigma;\r\n            fi *= exp(-dz * dz / 2.0);\r\n\r\n            csum += ci.rgb * fi;\r\n            wsum += fi;\r\n        }\r\n    }\r\n    return vec4(csum / wsum, 1.0);\r\n`;\r\n\r\n/** @internal */\r\nexport function createEDLFilterProgram(context: WebGL2RenderingContext): ShaderProgram {\r\n  const builder = createViewportQuadBuilder(true);\r\n  const frag = builder.frag;\r\n\r\n  frag.set(FragmentShaderComponent.ComputeBaseColor, filterEDL);\r\n  frag.set(FragmentShaderComponent.AssignFragData, assignFragColor);\r\n\r\n  frag.addUniform(\"u_texInfo\", VariableType.Vec3, (prog) => {\r\n    prog.addGraphicUniform(\"u_texInfo\", (uniform, params) => {\r\n      const geom = params.geometry as EDLFilterGeometry;\r\n      uniform.setUniform3fv(geom.texInfo);\r\n    });\r\n  });\r\n\r\n  frag.addUniform(\"u_colorTexture\", VariableType.Sampler2D, (prog) => {\r\n    prog.addGraphicUniform(\"u_colorTexture\", (uniform, params) => {\r\n      const geom = params.geometry as EDLFilterGeometry;\r\n      Texture2DHandle.bindSampler(uniform, geom.colorTexture, TextureUnit.Zero);\r\n    });\r\n  });\r\n\r\n  frag.addUniform(\"u_depthTexture\", VariableType.Sampler2D, (prog) => {\r\n    prog.addGraphicUniform(\"u_depthTexture\", (uniform, params) => {\r\n      const geom = params.geometry as EDLFilterGeometry;\r\n      Texture2DHandle.bindSampler(uniform, geom.depthTexture, TextureUnit.One);\r\n    });\r\n  });\r\n\r\n  builder.vert.headerComment = \"//!V! EDLFilter\";\r\n  builder.frag.headerComment = \"//!F! EDLFilter\";\r\n\r\n  return builder.buildProgram(context);\r\n}\r\n\r\n// This shader mixes the 3 EDL images into the final image\r\nconst mixEDL = `\r\n  vec4 col1 = TEXTURE(u_colorTexture1, v_texCoord);\r\n  if (col1.a == 0.0)\r\n      discard;\r\n  else {\r\n      vec3 col2 = TEXTURE(u_colorTexture2, v_texCoord).rgb;\r\n      vec3 col4 = TEXTURE(u_colorTexture4, v_texCoord).rgb;\r\n      return vec4 ((u_weights.x * col1.rgb + u_weights.y * col2 + u_weights.z * col4) / (u_weights.x + u_weights.y + u_weights.z), 1.0);\r\n  }\r\n`;\r\n\r\n/** @internal */\r\nexport function createEDLMixProgram(context: WebGL2RenderingContext): ShaderProgram {\r\n  const builder = createViewportQuadBuilder(true);\r\n  const frag = builder.frag;\r\n\r\n  frag.set(FragmentShaderComponent.ComputeBaseColor, mixEDL);\r\n  frag.set(FragmentShaderComponent.AssignFragData, assignFragColor);\r\n\r\n  frag.addUniform(\"u_colorTexture1\", VariableType.Sampler2D, (prog) => {\r\n    prog.addGraphicUniform(\"u_colorTexture1\", (uniform, params) => {\r\n      const geom = params.geometry as EDLMixGeometry;\r\n      Texture2DHandle.bindSampler(uniform, geom.colorTexture1, TextureUnit.Zero);\r\n    });\r\n  });\r\n\r\n  frag.addUniform(\"u_colorTexture2\", VariableType.Sampler2D, (prog) => {\r\n    prog.addGraphicUniform(\"u_colorTexture2\", (uniform, params) => {\r\n      const geom = params.geometry as EDLMixGeometry;\r\n      Texture2DHandle.bindSampler(uniform, geom.colorTexture2, TextureUnit.One);\r\n    });\r\n  });\r\n\r\n  frag.addUniform(\"u_colorTexture4\", VariableType.Sampler2D, (prog) => {\r\n    prog.addGraphicUniform(\"u_colorTexture4\", (uniform, params) => {\r\n      const geom = params.geometry as EDLMixGeometry;\r\n      Texture2DHandle.bindSampler(uniform, geom.colorTexture4, TextureUnit.Two);\r\n    });\r\n  });\r\n\r\n  // Uniforms based on the PointCloudDisplaySettings.\r\n  frag.addUniform(\"u_weights\", VariableType.Vec4, (prog) => {\r\n    prog.addGraphicUniform(\"u_weights\", (uniform, params) => {\r\n      params.target.uniforms.realityModel.pointCloud.bindEDL2(uniform);\r\n    });\r\n  });\r\n\r\n  builder.vert.headerComment = \"//!V! EDLMix\";\r\n  builder.frag.headerComment = \"//!F! EDLMix\";\r\n\r\n  return builder.buildProgram(context);\r\n}\r\n"]}
+{"version":3,"file":"EDL.js","sourceRoot":"","sources":["../../../../../src/render/webgl/glsl/EDL.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n/** @packageDocumentation\n * @module WebGL\n */\n\nimport { EDLCalcBasicGeometry, EDLCalcFullGeometry, EDLFilterGeometry, EDLMixGeometry } from \"../CachedGeometry\";\nimport { TextureUnit } from \"../RenderFlags\";\nimport { FragmentShaderComponent, VariableType } from \"../ShaderBuilder\";\nimport { ShaderProgram } from \"../ShaderProgram\";\nimport { Texture2DHandle } from \"../Texture\";\nimport { assignFragColor } from \"./Fragment\";\nimport { createViewportQuadBuilder } from \"./ViewportQuad\";\n\n// This shader calculates a more basic version of EDL, and only for the original size, so single pass\nconst calcBasicEDL = `\n    float strength = u_pointCloudEDL1.x;\n    float scaleFactor = u_pointCloudEDL1.z;\n    float pixRadius = u_pointCloudEDL1.y;\n    vec2 invTexSize = u_texInfo.xy;\n    float is3d = u_pointCloudEDL1.w;\n\n    vec4 color = TEXTURE(u_colorTexture, v_texCoord);\n    if (color.a == 0.0)\n        discard;\n    else {\n        const vec2 neighbors[8] = vec2[8] (  //neighbor relative position\n            vec2( 1.0, 0.0), vec2( 0.70710678,  0.70710678), vec2(0.0,  1.0), vec2(-0.70710678,  0.70710678),\n            vec2(-1.0, 0.0), vec2(-0.70710678, -0.70710678), vec2(0.0, -1.0), vec2( 0.70710678, -0.70710678));\n        float depth = TEXTURE(u_depthTexture, v_texCoord).r;\n        float sum = 0.0;\n        vec2 posScale = pixRadius * invTexSize;\n        // contribution of each neighbor\n        // NOTE: this is currently using neighbor depths regardless of if they were written by point cloud\n        for (int c = 0; c < 8; c++) {\n            vec2 nRelPos = posScale * neighbors[c];\n            vec2 nPos = v_texCoord + nRelPos;\n            float zN = TEXTURE(u_depthTexture, nPos).r;  // neighbor depth\n            sum += max(0.0, (is3d > 0.5) ? depth - zN : log (depth/zN));\n        }\n        float f = sum / 8.0;\n        f = exp(-f * 33.5 * strength * scaleFactor); // 33.5 factor to aim for a typical (unfactored) strength of 5\n        return vec4(f * color.rgb, 1.0);\n    }\n`;\n\n/** @internal */\nexport function createEDLCalcBasicProgram(context: WebGL2RenderingContext): ShaderProgram {\n  const builder = createViewportQuadBuilder(true);\n  const frag = builder.frag;\n\n  frag.set(FragmentShaderComponent.ComputeBaseColor, calcBasicEDL);\n  frag.set(FragmentShaderComponent.AssignFragData, assignFragColor);\n\n  frag.addUniform(\"u_texInfo\", VariableType.Vec3, (prog) => {\n    prog.addGraphicUniform(\"u_texInfo\", (uniform, params) => {\n      const geom = params.geometry as EDLCalcBasicGeometry;\n      uniform.setUniform3fv(geom.texInfo);\n    });\n  });\n\n  frag.addUniform(\"u_colorTexture\", VariableType.Sampler2D, (prog) => {\n    prog.addGraphicUniform(\"u_colorTexture\", (uniform, params) => {\n      const geom = params.geometry as EDLCalcBasicGeometry;\n      Texture2DHandle.bindSampler(uniform, geom.colorTexture, TextureUnit.Zero);\n    });\n  });\n\n  frag.addUniform(\"u_depthTexture\", VariableType.Sampler2D, (prog) => {\n    prog.addGraphicUniform(\"u_depthTexture\", (uniform, params) => {\n      const geom = params.geometry as EDLCalcBasicGeometry;\n      Texture2DHandle.bindSampler(uniform, geom.depthTexture, TextureUnit.One);\n    });\n  });\n\n  // Uniforms based on the PointCloudDisplaySettings.\n  frag.addUniform(\"u_pointCloudEDL1\", VariableType.Vec4, (prog) => {\n    prog.addGraphicUniform(\"u_pointCloudEDL1\", (uniform, params) => {\n      params.target.uniforms.realityModel.pointCloud.bindEDL1(uniform);\n    });\n  });\n\n  builder.vert.headerComment = \"//!V! EDLCalcBasic\";\n  builder.frag.headerComment = \"//!F! EDLCalcBasic\";\n\n  return builder.buildProgram(context);\n}\n\n// This shader calculates the full version of EDL, and can be run at full, 1/2 and 1/4 scale\nconst calcFullEDL = `\n    float strength = u_pointCloudEDL1.x;\n    float scaleFactor = u_pointCloudEDL1.z;\n    float pixRadius = u_pointCloudEDL1.y;\n    float scale = u_texInfo.z;  // 1, 2, 4\n    vec2 invTexSize = u_texInfo.xy;\n    float is3d = u_pointCloudEDL1.w;\n\n    vec4 color = TEXTURE(u_colorTexture, v_texCoord);\n    if (color.a == 0.0)\n        return color;\n    else {\n        const vec2 neighbors[8] = vec2[8] (  //neighbor relative position\n            vec2( 1.0, 0.0), vec2( 0.70710678,  0.70710678), vec2(0.0,  1.0), vec2(-0.70710678,  0.70710678),\n            vec2(-1.0, 0.0), vec2(-0.70710678, -0.70710678), vec2(0.0, -1.0), vec2( 0.70710678, -0.70710678));\n        float depth = TEXTURE(u_depthTexture, v_texCoord).r;\n        float sum = 0.0;\n        vec2 posScale = pixRadius * invTexSize;\n        // contribution of each neighbor\n        // NOTE: this is currently using neighbor depths regardless of if they were written by point cloud\n        for (int c = 0; c < 8; c++) {\n            vec2 nRelPos = posScale * neighbors[c];\n            vec2 nPos = v_texCoord + nRelPos;\n            float zN = TEXTURE(u_depthTexture, nPos).r;  // neighbor depth\n            sum += max(0.0, (is3d > 0.5) ? depth - zN : log (depth/zN)) / scale;\n        }\n        float f = sum / 8.0;\n        f = exp(-f * 33.5 * strength * scaleFactor); // 33.5 factor to aim for a typical (unfactored) strength of 5\n        return vec4(f * color.rgb, 1.0);\n    }\n`;\n\n/** @internal */\nexport function createEDLCalcFullProgram(context: WebGL2RenderingContext): ShaderProgram {\n  const builder = createViewportQuadBuilder(true);\n  const frag = builder.frag;\n\n  frag.set(FragmentShaderComponent.ComputeBaseColor, calcFullEDL);\n  frag.set(FragmentShaderComponent.AssignFragData, assignFragColor);\n\n  frag.addUniform(\"u_texInfo\", VariableType.Vec3, (prog) => {\n    prog.addGraphicUniform(\"u_texInfo\", (uniform, params) => {\n      const geom = params.geometry as EDLCalcFullGeometry;\n      uniform.setUniform3fv(geom.texInfo);\n    });\n  });\n\n  frag.addUniform(\"u_colorTexture\", VariableType.Sampler2D, (prog) => {\n    prog.addGraphicUniform(\"u_colorTexture\", (uniform, params) => {\n      const geom = params.geometry as EDLCalcFullGeometry;\n      Texture2DHandle.bindSampler(uniform, geom.colorTexture, TextureUnit.Zero);\n    });\n  });\n\n  frag.addUniform(\"u_depthTexture\", VariableType.Sampler2D, (prog) => {\n    prog.addGraphicUniform(\"u_depthTexture\", (uniform, params) => {\n      const geom = params.geometry as EDLCalcFullGeometry;\n      Texture2DHandle.bindSampler(uniform, geom.depthTexture, TextureUnit.One);\n    });\n  });\n\n  // Uniforms based on the PointCloudDisplaySettings.\n  frag.addUniform(\"u_pointCloudEDL1\", VariableType.Vec4, (prog) => {\n    prog.addGraphicUniform(\"u_pointCloudEDL1\", (uniform, params) => {\n      params.target.uniforms.realityModel.pointCloud.bindEDL1(uniform);\n    });\n  });\n\n  builder.vert.headerComment = \"//!V! EDLCalcFull\";\n  builder.frag.headerComment = \"//!F! EDLCalcFull\";\n\n  return builder.buildProgram(context);\n}\n\n// This shader filters the EDL image, and can be run at 1/2 and 1/4 scale\nconst filterEDL = `\n    // NB: this bilateral filter hardcodes spatialSigma to 2.0 and depthSigma to 0.4, with halfSize = 2\n    float distCoefs[] = float[] (\n        1.0, 0.9692332344763441, 0.8824969025845955, 0.9692332344763441, 0.9394130628134758,\n        0.8553453273074225, 0.8824969025845955, 0.8553453273074225, 0.8553453273074225, 0.7788007830714049);\n    const float depthSigma = 0.4;\n    vec2 invTexSize = u_texInfo.xy;\n\n    float depth = TEXTURE(u_depthTexture, v_texCoord).r;\n    float wsum = 0.0;  // sum of all weights\n    vec3  csum = vec3(0.0);  // sum of all contributions\n    vec2  coordi = vec2(0.0, 0.0);  // ith neighbor position x,y\n\n    for (int c = -2; c <= 2; c++) {\n        coordi.x = float(c) * invTexSize.x;\n        int cabs = (c < 0) ? -c : c;\n\n        for (int d = -2; d <= 2; d++) {\n            coordi.y = float(d) * invTexSize.y;\n            vec4 ci = TEXTURE(u_colorTexture, v_texCoord + coordi); // neighbor color\n\n            //pixel distance based damping\n            int dabs = (d < 0) ? -d : d;\n            float fi = distCoefs[cabs * 3 + dabs];\n\n            //pixel depth difference based damping\n            float zi = TEXTURE(u_depthTexture, v_texCoord + coordi).r; // neighbor depth\n            float dz = (depth - zi) / depthSigma;\n            fi *= exp(-dz * dz / 2.0);\n\n            csum += ci.rgb * fi;\n            wsum += fi;\n        }\n    }\n    return vec4(csum / wsum, 1.0);\n`;\n\n/** @internal */\nexport function createEDLFilterProgram(context: WebGL2RenderingContext): ShaderProgram {\n  const builder = createViewportQuadBuilder(true);\n  const frag = builder.frag;\n\n  frag.set(FragmentShaderComponent.ComputeBaseColor, filterEDL);\n  frag.set(FragmentShaderComponent.AssignFragData, assignFragColor);\n\n  frag.addUniform(\"u_texInfo\", VariableType.Vec3, (prog) => {\n    prog.addGraphicUniform(\"u_texInfo\", (uniform, params) => {\n      const geom = params.geometry as EDLFilterGeometry;\n      uniform.setUniform3fv(geom.texInfo);\n    });\n  });\n\n  frag.addUniform(\"u_colorTexture\", VariableType.Sampler2D, (prog) => {\n    prog.addGraphicUniform(\"u_colorTexture\", (uniform, params) => {\n      const geom = params.geometry as EDLFilterGeometry;\n      Texture2DHandle.bindSampler(uniform, geom.colorTexture, TextureUnit.Zero);\n    });\n  });\n\n  frag.addUniform(\"u_depthTexture\", VariableType.Sampler2D, (prog) => {\n    prog.addGraphicUniform(\"u_depthTexture\", (uniform, params) => {\n      const geom = params.geometry as EDLFilterGeometry;\n      Texture2DHandle.bindSampler(uniform, geom.depthTexture, TextureUnit.One);\n    });\n  });\n\n  builder.vert.headerComment = \"//!V! EDLFilter\";\n  builder.frag.headerComment = \"//!F! EDLFilter\";\n\n  return builder.buildProgram(context);\n}\n\n// This shader mixes the 3 EDL images into the final image\nconst mixEDL = `\n  vec4 col1 = TEXTURE(u_colorTexture1, v_texCoord);\n  if (col1.a == 0.0)\n      discard;\n  else {\n      vec3 col2 = TEXTURE(u_colorTexture2, v_texCoord).rgb;\n      vec3 col4 = TEXTURE(u_colorTexture4, v_texCoord).rgb;\n      return vec4 ((u_weights.x * col1.rgb + u_weights.y * col2 + u_weights.z * col4) / (u_weights.x + u_weights.y + u_weights.z), 1.0);\n  }\n`;\n\n/** @internal */\nexport function createEDLMixProgram(context: WebGL2RenderingContext): ShaderProgram {\n  const builder = createViewportQuadBuilder(true);\n  const frag = builder.frag;\n\n  frag.set(FragmentShaderComponent.ComputeBaseColor, mixEDL);\n  frag.set(FragmentShaderComponent.AssignFragData, assignFragColor);\n\n  frag.addUniform(\"u_colorTexture1\", VariableType.Sampler2D, (prog) => {\n    prog.addGraphicUniform(\"u_colorTexture1\", (uniform, params) => {\n      const geom = params.geometry as EDLMixGeometry;\n      Texture2DHandle.bindSampler(uniform, geom.colorTexture1, TextureUnit.Zero);\n    });\n  });\n\n  frag.addUniform(\"u_colorTexture2\", VariableType.Sampler2D, (prog) => {\n    prog.addGraphicUniform(\"u_colorTexture2\", (uniform, params) => {\n      const geom = params.geometry as EDLMixGeometry;\n      Texture2DHandle.bindSampler(uniform, geom.colorTexture2, TextureUnit.One);\n    });\n  });\n\n  frag.addUniform(\"u_colorTexture4\", VariableType.Sampler2D, (prog) => {\n    prog.addGraphicUniform(\"u_colorTexture4\", (uniform, params) => {\n      const geom = params.geometry as EDLMixGeometry;\n      Texture2DHandle.bindSampler(uniform, geom.colorTexture4, TextureUnit.Two);\n    });\n  });\n\n  // Uniforms based on the PointCloudDisplaySettings.\n  frag.addUniform(\"u_weights\", VariableType.Vec4, (prog) => {\n    prog.addGraphicUniform(\"u_weights\", (uniform, params) => {\n      params.target.uniforms.realityModel.pointCloud.bindEDL2(uniform);\n    });\n  });\n\n  builder.vert.headerComment = \"//!V! EDLMix\";\n  builder.frag.headerComment = \"//!F! EDLMix\";\n\n  return builder.buildProgram(context);\n}\n"]}

package/lib/cjs/render/webgl/glsl/EVSMFromDepth.js

@@ -18,31 +18,31 @@ const SolarShadowMapping_1 = require("./SolarShadowMapping");
 // Positions are in NDC [-1..1]. Compute UV params in [0..1]
 const computeTexCoord = "v_texCoord = (rawPosition.xy + 1.0) * 0.5;";
 const computePosition = "return rawPos;";
-const computeEVSM = `
-  const float sampleWeight = 0.25;
-  vec4 average = vec4(0.0);
-  vec2 tc = v_texCoord - u_stepSize * 0.5; // v_texCoord starts in between the 4 texels
-
-  float depth = TEXTURE(u_depthTexture, tc).r;
-  vec2 vsmDepth = warpDepth(depth, u_evsmExponent);
-  average += sampleWeight * vec4(vsmDepth.xy, vsmDepth.xy * vsmDepth.xy);
-
-  tc.x += u_stepSize.x;
-  depth = TEXTURE(u_depthTexture, tc).r;
-  vsmDepth = warpDepth(depth, u_evsmExponent);
-  average += sampleWeight * vec4(vsmDepth.xy, vsmDepth.xy * vsmDepth.xy);
-
-  tc.y += u_stepSize.y;
-  depth = TEXTURE(u_depthTexture, tc).r;
-  vsmDepth = warpDepth(depth, u_evsmExponent);
-  average += sampleWeight * vec4(vsmDepth.xy, vsmDepth.xy * vsmDepth.xy);
-
-  tc.x -= u_stepSize.x;
-  depth = TEXTURE(u_depthTexture, tc).r;
-  vsmDepth = warpDepth(depth, u_evsmExponent);
-  average += sampleWeight * vec4(vsmDepth.xy, vsmDepth.xy * vsmDepth.xy);
-
-  return average;
+const computeEVSM = `
+  const float sampleWeight = 0.25;
+  vec4 average = vec4(0.0);
+  vec2 tc = v_texCoord - u_stepSize * 0.5; // v_texCoord starts in between the 4 texels
+
+  float depth = TEXTURE(u_depthTexture, tc).r;
+  vec2 vsmDepth = warpDepth(depth, u_evsmExponent);
+  average += sampleWeight * vec4(vsmDepth.xy, vsmDepth.xy * vsmDepth.xy);
+
+  tc.x += u_stepSize.x;
+  depth = TEXTURE(u_depthTexture, tc).r;
+  vsmDepth = warpDepth(depth, u_evsmExponent);
+  average += sampleWeight * vec4(vsmDepth.xy, vsmDepth.xy * vsmDepth.xy);
+
+  tc.y += u_stepSize.y;
+  depth = TEXTURE(u_depthTexture, tc).r;
+  vsmDepth = warpDepth(depth, u_evsmExponent);
+  average += sampleWeight * vec4(vsmDepth.xy, vsmDepth.xy * vsmDepth.xy);
+
+  tc.x -= u_stepSize.x;
+  depth = TEXTURE(u_depthTexture, tc).r;
+  vsmDepth = warpDepth(depth, u_evsmExponent);
+  average += sampleWeight * vec4(vsmDepth.xy, vsmDepth.xy * vsmDepth.xy);
+
+  return average;
 `;
 /** @internal */
 function createEVSMProgram(context) {

package/lib/cjs/render/webgl/glsl/EVSMFromDepth.js.map

@@ -1 +1 @@
-{"version":3,"file":"EVSMFromDepth.js","sourceRoot":"","sources":["../../../../../src/render/webgl/glsl/EVSMFromDepth.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAEH,kDAA+C;AAE/C,gDAA6C;AAC7C,oDAAmI;AAEnI,wCAA6C;AAC7C,yCAA6C;AAC7C,6DAAkE;AAElE,mGAAmG;AAEnG,4DAA4D;AAC5D,MAAM,eAAe,GAAG,4CAA4C,CAAC;AACrE,MAAM,eAAe,GAAG,gBAAgB,CAAC;AAEzC,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;CAyBnB,CAAC;AAEF,gBAAgB;AAChB,SAAgB,iBAAiB,CAAC,OAA+B;IAC/D,MAAM,OAAO,GAAG,IAAI,8BAAc,CAAC,2BAAY,CAAC,gBAAgB,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC;IACpF,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAC1B,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAE1B,IAAI,CAAC,GAAG,iDAAwC,eAAe,CAAC,CAAC;IACjE,OAAO,CAAC,wBAAwB,CAAC,YAAY,6BAAqB,eAAe,CAAC,CAAC;IAEnF,IAAI,CAAC,UAAU,CAAC,gBAAgB,kCAA0B,CAAC,IAAI,EAAE,EAAE;QACjE,IAAI,CAAC,iBAAiB,CAAC,gBAAgB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC3D,MAAM,IAAI,GAAG,MAAM,CAAC,QAAwB,CAAC;YAC7C,yBAAe,CAAC,WAAW,CAAC,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,yBAAW,CAAC,IAAI,CAAC,CAAC;QAC5E,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,UAAU,CAAC,YAAY,6BAAqB,CAAC,IAAI,EAAE,EAAE;QACxD,IAAI,CAAC,iBAAiB,CAAC,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACvD,MAAM,IAAI,GAAG,MAAM,CAAC,QAAwB,CAAC;YAC7C,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACvC,CAAC,CAAC,CAAC;IACL,CAAC,iCAAyB,CAAC;IAE3B,IAAA,oCAAe,EAAC,IAAI,CAAC,CAAC;IAEtB,IAAI,CAAC,WAAW,CAAC,8BAAS,CAAC,CAAC;IAC5B,IAAI,CAAC,GAAG,mDAA2C,WAAW,CAAC,CAAC;IAChE,IAAI,CAAC,GAAG,kDAAyC,0BAAe,CAAC,CAAC;IAElE,OAAO,CAAC,IAAI,CAAC,aAAa,GAAG,qBAAqB,CAAC;IACnD,OAAO,CAAC,IAAI,CAAC,aAAa,GAAG,qBAAqB,CAAC;IAEnD,OAAO,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;AACvC,CAAC;AAhCD,8CAgCC","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module WebGL\r\n */\r\n\r\nimport { AttributeMap } from \"../AttributeMap\";\r\nimport { EVSMGeometry } from \"../CachedGeometry\";\r\nimport { TextureUnit } from \"../RenderFlags\";\r\nimport { FragmentShaderComponent, ProgramBuilder, VariablePrecision, VariableType, VertexShaderComponent } from \"../ShaderBuilder\";\r\nimport { ShaderProgram } from \"../ShaderProgram\";\r\nimport { Texture2DHandle } from \"../Texture\";\r\nimport { assignFragColor } from \"./Fragment\";\r\nimport { addEvsmExponent, warpDepth } from \"./SolarShadowMapping\";\r\n\r\n// This shader reads the depth texture, converts it to EVSM values, then averages those down 4 to 1\r\n\r\n// Positions are in NDC [-1..1]. Compute UV params in [0..1]\r\nconst computeTexCoord = \"v_texCoord = (rawPosition.xy + 1.0) * 0.5;\";\r\nconst computePosition = \"return rawPos;\";\r\n\r\nconst computeEVSM = `\r\n  const float sampleWeight = 0.25;\r\n  vec4 average = vec4(0.0);\r\n  vec2 tc = v_texCoord - u_stepSize * 0.5; // v_texCoord starts in between the 4 texels\r\n\r\n  float depth = TEXTURE(u_depthTexture, tc).r;\r\n  vec2 vsmDepth = warpDepth(depth, u_evsmExponent);\r\n  average += sampleWeight * vec4(vsmDepth.xy, vsmDepth.xy * vsmDepth.xy);\r\n\r\n  tc.x += u_stepSize.x;\r\n  depth = TEXTURE(u_depthTexture, tc).r;\r\n  vsmDepth = warpDepth(depth, u_evsmExponent);\r\n  average += sampleWeight * vec4(vsmDepth.xy, vsmDepth.xy * vsmDepth.xy);\r\n\r\n  tc.y += u_stepSize.y;\r\n  depth = TEXTURE(u_depthTexture, tc).r;\r\n  vsmDepth = warpDepth(depth, u_evsmExponent);\r\n  average += sampleWeight * vec4(vsmDepth.xy, vsmDepth.xy * vsmDepth.xy);\r\n\r\n  tc.x -= u_stepSize.x;\r\n  depth = TEXTURE(u_depthTexture, tc).r;\r\n  vsmDepth = warpDepth(depth, u_evsmExponent);\r\n  average += sampleWeight * vec4(vsmDepth.xy, vsmDepth.xy * vsmDepth.xy);\r\n\r\n  return average;\r\n`;\r\n\r\n/** @internal */\r\nexport function createEVSMProgram(context: WebGL2RenderingContext): ShaderProgram {\r\n  const builder = new ProgramBuilder(AttributeMap.findAttributeMap(undefined, false));\r\n  const vert = builder.vert;\r\n  const frag = builder.frag;\r\n\r\n  vert.set(VertexShaderComponent.ComputePosition, computePosition);\r\n  builder.addInlineComputedVarying(\"v_texCoord\", VariableType.Vec2, computeTexCoord);\r\n\r\n  frag.addUniform(\"u_depthTexture\", VariableType.Sampler2D, (prog) => {\r\n    prog.addGraphicUniform(\"u_depthTexture\", (uniform, params) => {\r\n      const geom = params.geometry as EVSMGeometry;\r\n      Texture2DHandle.bindSampler(uniform, geom.depthTexture, TextureUnit.Zero);\r\n    });\r\n  });\r\n\r\n  frag.addUniform(\"u_stepSize\", VariableType.Vec2, (prog) => {\r\n    prog.addGraphicUniform(\"u_stepSize\", (uniform, params) => {\r\n      const geom = params.geometry as EVSMGeometry;\r\n      uniform.setUniform2fv(geom.stepSize);\r\n    });\r\n  }, VariablePrecision.High);\r\n\r\n  addEvsmExponent(frag);\r\n\r\n  frag.addFunction(warpDepth);\r\n  frag.set(FragmentShaderComponent.ComputeBaseColor, computeEVSM);\r\n  frag.set(FragmentShaderComponent.AssignFragData, assignFragColor);\r\n\r\n  builder.vert.headerComment = \"//!V! EVSMFromDepth\";\r\n  builder.frag.headerComment = \"//!F! EVSMFromDepth\";\r\n\r\n  return builder.buildProgram(context);\r\n}\r\n"]}
+{"version":3,"file":"EVSMFromDepth.js","sourceRoot":"","sources":["../../../../../src/render/webgl/glsl/EVSMFromDepth.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAEH,kDAA+C;AAE/C,gDAA6C;AAC7C,oDAAmI;AAEnI,wCAA6C;AAC7C,yCAA6C;AAC7C,6DAAkE;AAElE,mGAAmG;AAEnG,4DAA4D;AAC5D,MAAM,eAAe,GAAG,4CAA4C,CAAC;AACrE,MAAM,eAAe,GAAG,gBAAgB,CAAC;AAEzC,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;CAyBnB,CAAC;AAEF,gBAAgB;AAChB,SAAgB,iBAAiB,CAAC,OAA+B;IAC/D,MAAM,OAAO,GAAG,IAAI,8BAAc,CAAC,2BAAY,CAAC,gBAAgB,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC;IACpF,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAC1B,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAE1B,IAAI,CAAC,GAAG,iDAAwC,eAAe,CAAC,CAAC;IACjE,OAAO,CAAC,wBAAwB,CAAC,YAAY,6BAAqB,eAAe,CAAC,CAAC;IAEnF,IAAI,CAAC,UAAU,CAAC,gBAAgB,kCAA0B,CAAC,IAAI,EAAE,EAAE;QACjE,IAAI,CAAC,iBAAiB,CAAC,gBAAgB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC3D,MAAM,IAAI,GAAG,MAAM,CAAC,QAAwB,CAAC;YAC7C,yBAAe,CAAC,WAAW,CAAC,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,yBAAW,CAAC,IAAI,CAAC,CAAC;QAC5E,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,UAAU,CAAC,YAAY,6BAAqB,CAAC,IAAI,EAAE,EAAE;QACxD,IAAI,CAAC,iBAAiB,CAAC,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACvD,MAAM,IAAI,GAAG,MAAM,CAAC,QAAwB,CAAC;YAC7C,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACvC,CAAC,CAAC,CAAC;IACL,CAAC,iCAAyB,CAAC;IAE3B,IAAA,oCAAe,EAAC,IAAI,CAAC,CAAC;IAEtB,IAAI,CAAC,WAAW,CAAC,8BAAS,CAAC,CAAC;IAC5B,IAAI,CAAC,GAAG,mDAA2C,WAAW,CAAC,CAAC;IAChE,IAAI,CAAC,GAAG,kDAAyC,0BAAe,CAAC,CAAC;IAElE,OAAO,CAAC,IAAI,CAAC,aAAa,GAAG,qBAAqB,CAAC;IACnD,OAAO,CAAC,IAAI,CAAC,aAAa,GAAG,qBAAqB,CAAC;IAEnD,OAAO,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;AACvC,CAAC;AAhCD,8CAgCC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n/** @packageDocumentation\n * @module WebGL\n */\n\nimport { AttributeMap } from \"../AttributeMap\";\nimport { EVSMGeometry } from \"../CachedGeometry\";\nimport { TextureUnit } from \"../RenderFlags\";\nimport { FragmentShaderComponent, ProgramBuilder, VariablePrecision, VariableType, VertexShaderComponent } from \"../ShaderBuilder\";\nimport { ShaderProgram } from \"../ShaderProgram\";\nimport { Texture2DHandle } from \"../Texture\";\nimport { assignFragColor } from \"./Fragment\";\nimport { addEvsmExponent, warpDepth } from \"./SolarShadowMapping\";\n\n// This shader reads the depth texture, converts it to EVSM values, then averages those down 4 to 1\n\n// Positions are in NDC [-1..1]. Compute UV params in [0..1]\nconst computeTexCoord = \"v_texCoord = (rawPosition.xy + 1.0) * 0.5;\";\nconst computePosition = \"return rawPos;\";\n\nconst computeEVSM = `\n  const float sampleWeight = 0.25;\n  vec4 average = vec4(0.0);\n  vec2 tc = v_texCoord - u_stepSize * 0.5; // v_texCoord starts in between the 4 texels\n\n  float depth = TEXTURE(u_depthTexture, tc).r;\n  vec2 vsmDepth = warpDepth(depth, u_evsmExponent);\n  average += sampleWeight * vec4(vsmDepth.xy, vsmDepth.xy * vsmDepth.xy);\n\n  tc.x += u_stepSize.x;\n  depth = TEXTURE(u_depthTexture, tc).r;\n  vsmDepth = warpDepth(depth, u_evsmExponent);\n  average += sampleWeight * vec4(vsmDepth.xy, vsmDepth.xy * vsmDepth.xy);\n\n  tc.y += u_stepSize.y;\n  depth = TEXTURE(u_depthTexture, tc).r;\n  vsmDepth = warpDepth(depth, u_evsmExponent);\n  average += sampleWeight * vec4(vsmDepth.xy, vsmDepth.xy * vsmDepth.xy);\n\n  tc.x -= u_stepSize.x;\n  depth = TEXTURE(u_depthTexture, tc).r;\n  vsmDepth = warpDepth(depth, u_evsmExponent);\n  average += sampleWeight * vec4(vsmDepth.xy, vsmDepth.xy * vsmDepth.xy);\n\n  return average;\n`;\n\n/** @internal */\nexport function createEVSMProgram(context: WebGL2RenderingContext): ShaderProgram {\n  const builder = new ProgramBuilder(AttributeMap.findAttributeMap(undefined, false));\n  const vert = builder.vert;\n  const frag = builder.frag;\n\n  vert.set(VertexShaderComponent.ComputePosition, computePosition);\n  builder.addInlineComputedVarying(\"v_texCoord\", VariableType.Vec2, computeTexCoord);\n\n  frag.addUniform(\"u_depthTexture\", VariableType.Sampler2D, (prog) => {\n    prog.addGraphicUniform(\"u_depthTexture\", (uniform, params) => {\n      const geom = params.geometry as EVSMGeometry;\n      Texture2DHandle.bindSampler(uniform, geom.depthTexture, TextureUnit.Zero);\n    });\n  });\n\n  frag.addUniform(\"u_stepSize\", VariableType.Vec2, (prog) => {\n    prog.addGraphicUniform(\"u_stepSize\", (uniform, params) => {\n      const geom = params.geometry as EVSMGeometry;\n      uniform.setUniform2fv(geom.stepSize);\n    });\n  }, VariablePrecision.High);\n\n  addEvsmExponent(frag);\n\n  frag.addFunction(warpDepth);\n  frag.set(FragmentShaderComponent.ComputeBaseColor, computeEVSM);\n  frag.set(FragmentShaderComponent.AssignFragData, assignFragColor);\n\n  builder.vert.headerComment = \"//!V! EVSMFromDepth\";\n  builder.frag.headerComment = \"//!F! EVSMFromDepth\";\n\n  return builder.buildProgram(context);\n}\n"]}