@itwin/core-frontend 4.1.0-dev.14 → 4.1.0-dev.15

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

@@ -9,100 +9,100 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addLighting = void 0;
 const Common_1 = require("./Common");
-const computeDirectionalLighting = `
-void computeDirectionalLight (inout float diffuse, inout float specular, vec3 normal, vec3 toEye, vec3 lightDir, float lightIntensity, float specularExponent) {
-  diffuse += lightIntensity * max(dot(normal, lightDir), 0.0);
-  vec3 toReflectedLight = normalize(reflect(lightDir, normal));
-  float specularDot = max(dot(toReflectedLight, toEye), 0.0001);
-  // NB: If specularDot and specularExponent are both zero, 0^0 done below can return NaN.  Must make sure specularDot is larger than zero (hence 0.0001 or greater, as ensured above).
-  specular += lightIntensity * pow(specularDot, specularExponent);
-}
+const computeDirectionalLighting = `
+void computeDirectionalLight (inout float diffuse, inout float specular, vec3 normal, vec3 toEye, vec3 lightDir, float lightIntensity, float specularExponent) {
+  diffuse += lightIntensity * max(dot(normal, lightDir), 0.0);
+  vec3 toReflectedLight = normalize(reflect(lightDir, normal));
+  float specularDot = max(dot(toReflectedLight, toEye), 0.0001);
+  // NB: If specularDot and specularExponent are both zero, 0^0 done below can return NaN.  Must make sure specularDot is larger than zero (hence 0.0001 or greater, as ensured above).
+  specular += lightIntensity * pow(specularDot, specularExponent);
+}
 `;
 // mat_weights: x=diffuse y=specular
-const applyLighting = `
-  if (baseColor.a <= 0.0 || !u_surfaceFlags[kSurfaceBitIndex_ApplyLighting])
-    return baseColor;
-
-  // Extract surface properties
-  vec3 rgb = baseColor.rgb;
-  vec3 toEye = kFrustumType_Perspective == u_frustum.z ? normalize(v_eyeSpace.xyz) : vec3(0.0, 0.0, -1.0);
-
-  // Extract material properties
-  float diffuseWeight = mat_weights.x;
-  float specularWeight = mat_weights.y * u_lightSettings[13];
-  float specularExponent = mat_specular.a;
-  vec3 specularColor = mat_specular.rgb;
-  const float ambientWeight = 1.0; // Ignore MicroStation's ambient weights - usually bogus.
-
-  // Compute directional lights
-  const vec3 portraitDir = vec3(-0.7071, 0.0, 0.7071);
-  float portraitIntensity = u_lightSettings[12];
-  float sunIntensity = u_lightSettings[0];
-
-  float directionalDiffuseIntensity = 0.0;
-  float directionalSpecularIntensity = 0.0;
-  computeDirectionalLight(directionalDiffuseIntensity, directionalSpecularIntensity, g_normal, toEye, u_sunDir, sunIntensity, specularExponent);
-  computeDirectionalLight(directionalDiffuseIntensity, directionalSpecularIntensity, g_normal ,toEye, portraitDir, portraitIntensity, specularExponent);
-
-  const float directionalFudge = 0.92; // leftover from old lighting implementation
-  vec3 diffuseAccum = directionalDiffuseIntensity * diffuseWeight * rgb * directionalFudge; // directional light is white.
-  vec3 specularAccum = directionalSpecularIntensity * specularWeight * specularColor;
-
-  // Compute ambient light
-  float ambientIntensity = u_lightSettings[4];
-  vec3 ambientColor = vec3(u_lightSettings[1], u_lightSettings[2], u_lightSettings[3]);
-  if (ambientColor.r + ambientColor.g + ambientColor.b == 0.0)
-    ambientColor = rgb;
-
-  diffuseAccum += ambientIntensity * ambientWeight * ambientColor;
-
-  // Compute hemisphere lights
-  vec3 ground = vec3(u_lightSettings[5], u_lightSettings[6], u_lightSettings[7]);
-  vec3 sky = vec3(u_lightSettings[8], u_lightSettings[9], u_lightSettings[10]);
-  float hemiIntensity = u_lightSettings[11];
-
-  //  diffuse
-  float hemiDot = dot(g_normal, u_upVector);
-  float hemiDiffuseWeight = 0.5 * hemiDot + 0.5;
-  vec3 hemiColor = mix(ground, sky, hemiDiffuseWeight);
-  diffuseAccum += hemiIntensity * hemiColor * rgb;
-
-  //  sky specular
-  vec3 reflectSky = normalize(reflect(u_upVector, g_normal));
-  float skyDot = max(dot(reflectSky, toEye), 0.0001);
-  float hemiSpecWeight = hemiIntensity * pow(skyDot, specularExponent);
-
-  //  ground specular
-  vec3 reflectGround = normalize(reflect(-u_upVector, g_normal));
-  float groundDot = max(dot(reflectGround, toEye), 0.0001);
-  hemiSpecWeight += hemiIntensity * pow(groundDot, specularExponent);
-
-  specularAccum += hemiSpecWeight * specularColor * hemiColor;
-
-  vec3 litColor = diffuseAccum + specularAccum;
-
-  // Apply fresnel reflection.
-  float fresnelIntensity = u_lightSettings[15];
-  if (0.0 != fresnelIntensity) {
-    float fresnel = -dot(toEye, g_normal);
-    if (fresnelIntensity < 0.0) {
-      fresnelIntensity = abs(fresnelIntensity);
-      fresnel = 1.0 - fresnel;
-    }
-
-    fresnel = clamp(1.0 - fresnel, 0.0, 1.0);
-    litColor = litColor * (1.0 + fresnelIntensity * fresnel);
-  }
-
-  // Clamp while preserving hue.
-  float maxIntensity = max(litColor.r, max(litColor.g, litColor.b));
-  float numCel = u_lightSettings[14];
-  if (numCel > 0.0)
-    baseColor.rgb = baseColor.rgb * ceil(maxIntensity * numCel) / numCel;
-  else
-    baseColor.rgb = litColor / max(1.0, maxIntensity);
-
-  return baseColor;
+const applyLighting = `
+  if (baseColor.a <= 0.0 || !u_surfaceFlags[kSurfaceBitIndex_ApplyLighting])
+    return baseColor;
+
+  // Extract surface properties
+  vec3 rgb = baseColor.rgb;
+  vec3 toEye = kFrustumType_Perspective == u_frustum.z ? normalize(v_eyeSpace.xyz) : vec3(0.0, 0.0, -1.0);
+
+  // Extract material properties
+  float diffuseWeight = mat_weights.x;
+  float specularWeight = mat_weights.y * u_lightSettings[13];
+  float specularExponent = mat_specular.a;
+  vec3 specularColor = mat_specular.rgb;
+  const float ambientWeight = 1.0; // Ignore MicroStation's ambient weights - usually bogus.
+
+  // Compute directional lights
+  const vec3 portraitDir = vec3(-0.7071, 0.0, 0.7071);
+  float portraitIntensity = u_lightSettings[12];
+  float sunIntensity = u_lightSettings[0];
+
+  float directionalDiffuseIntensity = 0.0;
+  float directionalSpecularIntensity = 0.0;
+  computeDirectionalLight(directionalDiffuseIntensity, directionalSpecularIntensity, g_normal, toEye, u_sunDir, sunIntensity, specularExponent);
+  computeDirectionalLight(directionalDiffuseIntensity, directionalSpecularIntensity, g_normal ,toEye, portraitDir, portraitIntensity, specularExponent);
+
+  const float directionalFudge = 0.92; // leftover from old lighting implementation
+  vec3 diffuseAccum = directionalDiffuseIntensity * diffuseWeight * rgb * directionalFudge; // directional light is white.
+  vec3 specularAccum = directionalSpecularIntensity * specularWeight * specularColor;
+
+  // Compute ambient light
+  float ambientIntensity = u_lightSettings[4];
+  vec3 ambientColor = vec3(u_lightSettings[1], u_lightSettings[2], u_lightSettings[3]);
+  if (ambientColor.r + ambientColor.g + ambientColor.b == 0.0)
+    ambientColor = rgb;
+
+  diffuseAccum += ambientIntensity * ambientWeight * ambientColor;
+
+  // Compute hemisphere lights
+  vec3 ground = vec3(u_lightSettings[5], u_lightSettings[6], u_lightSettings[7]);
+  vec3 sky = vec3(u_lightSettings[8], u_lightSettings[9], u_lightSettings[10]);
+  float hemiIntensity = u_lightSettings[11];
+
+  //  diffuse
+  float hemiDot = dot(g_normal, u_upVector);
+  float hemiDiffuseWeight = 0.5 * hemiDot + 0.5;
+  vec3 hemiColor = mix(ground, sky, hemiDiffuseWeight);
+  diffuseAccum += hemiIntensity * hemiColor * rgb;
+
+  //  sky specular
+  vec3 reflectSky = normalize(reflect(u_upVector, g_normal));
+  float skyDot = max(dot(reflectSky, toEye), 0.0001);
+  float hemiSpecWeight = hemiIntensity * pow(skyDot, specularExponent);
+
+  //  ground specular
+  vec3 reflectGround = normalize(reflect(-u_upVector, g_normal));
+  float groundDot = max(dot(reflectGround, toEye), 0.0001);
+  hemiSpecWeight += hemiIntensity * pow(groundDot, specularExponent);
+
+  specularAccum += hemiSpecWeight * specularColor * hemiColor;
+
+  vec3 litColor = diffuseAccum + specularAccum;
+
+  // Apply fresnel reflection.
+  float fresnelIntensity = u_lightSettings[15];
+  if (0.0 != fresnelIntensity) {
+    float fresnel = -dot(toEye, g_normal);
+    if (fresnelIntensity < 0.0) {
+      fresnelIntensity = abs(fresnelIntensity);
+      fresnel = 1.0 - fresnel;
+    }
+
+    fresnel = clamp(1.0 - fresnel, 0.0, 1.0);
+    litColor = litColor * (1.0 + fresnelIntensity * fresnel);
+  }
+
+  // Clamp while preserving hue.
+  float maxIntensity = max(litColor.r, max(litColor.g, litColor.b));
+  float numCel = u_lightSettings[14];
+  if (numCel > 0.0)
+    baseColor.rgb = baseColor.rgb * ceil(maxIntensity * numCel) / numCel;
+  else
+    baseColor.rgb = litColor / max(1.0, maxIntensity);
+
+  return baseColor;
 `;
 /** NB: addMaterial() sets up the mat_* variables used by applyLighting.
  * @internal

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

@@ -1 +1 @@
-{"version":3,"file":"Lighting.js","sourceRoot":"","sources":["../../../../../src/render/webgl/glsl/Lighting.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAGH,qCAAsC;AAEtC,MAAM,0BAA0B,GAAG;;;;;;;;CAQlC,CAAC;AAEF,oCAAoC;AACpC,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoFrB,CAAC;AAEF;;GAEG;AACH,SAAgB,WAAW,CAAC,OAAuB;IACjD,IAAA,mBAAU,EAAC,OAAO,CAAC,CAAC;IAEpB,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAE1B,IAAI,CAAC,WAAW,CAAC,0BAA0B,CAAC,CAAC;IAC7C,IAAI,CAAC,GAAG,gDAAwC,aAAa,CAAC,CAAC;IAE/D,IAAI,CAAC,UAAU,CAAC,UAAU,6BAAqB,CAAC,IAAI,EAAE,EAAE;QACtD,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrD,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;QACnD,CAAC,CAAC,CAAC;IACL,CAAC,iCAAyB,CAAC;IAE3B,IAAI,CAAC,UAAU,CAAC,qBAAqB,8BAAsB,CAAC,IAAI,EAAE,EAAE;QAClE,IAAI,CAAC,iBAAiB,CAAC,oBAAoB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC/D,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC9C,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,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AAzBD,kCAyBC","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 { FragmentShaderComponent, ProgramBuilder, VariablePrecision, VariableType } from \"../ShaderBuilder\";\r\nimport { addFrustum } from \"./Common\";\r\n\r\nconst computeDirectionalLighting = `\r\nvoid computeDirectionalLight (inout float diffuse, inout float specular, vec3 normal, vec3 toEye, vec3 lightDir, float lightIntensity, float specularExponent) {\r\n  diffuse += lightIntensity * max(dot(normal, lightDir), 0.0);\r\n  vec3 toReflectedLight = normalize(reflect(lightDir, normal));\r\n  float specularDot = max(dot(toReflectedLight, toEye), 0.0001);\r\n  // NB: If specularDot and specularExponent are both zero, 0^0 done below can return NaN.  Must make sure specularDot is larger than zero (hence 0.0001 or greater, as ensured above).\r\n  specular += lightIntensity * pow(specularDot, specularExponent);\r\n}\r\n`;\r\n\r\n// mat_weights: x=diffuse y=specular\r\nconst applyLighting = `\r\n  if (baseColor.a <= 0.0 || !u_surfaceFlags[kSurfaceBitIndex_ApplyLighting])\r\n    return baseColor;\r\n\r\n  // Extract surface properties\r\n  vec3 rgb = baseColor.rgb;\r\n  vec3 toEye = kFrustumType_Perspective == u_frustum.z ? normalize(v_eyeSpace.xyz) : vec3(0.0, 0.0, -1.0);\r\n\r\n  // Extract material properties\r\n  float diffuseWeight = mat_weights.x;\r\n  float specularWeight = mat_weights.y * u_lightSettings[13];\r\n  float specularExponent = mat_specular.a;\r\n  vec3 specularColor = mat_specular.rgb;\r\n  const float ambientWeight = 1.0; // Ignore MicroStation's ambient weights - usually bogus.\r\n\r\n  // Compute directional lights\r\n  const vec3 portraitDir = vec3(-0.7071, 0.0, 0.7071);\r\n  float portraitIntensity = u_lightSettings[12];\r\n  float sunIntensity = u_lightSettings[0];\r\n\r\n  float directionalDiffuseIntensity = 0.0;\r\n  float directionalSpecularIntensity = 0.0;\r\n  computeDirectionalLight(directionalDiffuseIntensity, directionalSpecularIntensity, g_normal, toEye, u_sunDir, sunIntensity, specularExponent);\r\n  computeDirectionalLight(directionalDiffuseIntensity, directionalSpecularIntensity, g_normal ,toEye, portraitDir, portraitIntensity, specularExponent);\r\n\r\n  const float directionalFudge = 0.92; // leftover from old lighting implementation\r\n  vec3 diffuseAccum = directionalDiffuseIntensity * diffuseWeight * rgb * directionalFudge; // directional light is white.\r\n  vec3 specularAccum = directionalSpecularIntensity * specularWeight * specularColor;\r\n\r\n  // Compute ambient light\r\n  float ambientIntensity = u_lightSettings[4];\r\n  vec3 ambientColor = vec3(u_lightSettings[1], u_lightSettings[2], u_lightSettings[3]);\r\n  if (ambientColor.r + ambientColor.g + ambientColor.b == 0.0)\r\n    ambientColor = rgb;\r\n\r\n  diffuseAccum += ambientIntensity * ambientWeight * ambientColor;\r\n\r\n  // Compute hemisphere lights\r\n  vec3 ground = vec3(u_lightSettings[5], u_lightSettings[6], u_lightSettings[7]);\r\n  vec3 sky = vec3(u_lightSettings[8], u_lightSettings[9], u_lightSettings[10]);\r\n  float hemiIntensity = u_lightSettings[11];\r\n\r\n  //  diffuse\r\n  float hemiDot = dot(g_normal, u_upVector);\r\n  float hemiDiffuseWeight = 0.5 * hemiDot + 0.5;\r\n  vec3 hemiColor = mix(ground, sky, hemiDiffuseWeight);\r\n  diffuseAccum += hemiIntensity * hemiColor * rgb;\r\n\r\n  //  sky specular\r\n  vec3 reflectSky = normalize(reflect(u_upVector, g_normal));\r\n  float skyDot = max(dot(reflectSky, toEye), 0.0001);\r\n  float hemiSpecWeight = hemiIntensity * pow(skyDot, specularExponent);\r\n\r\n  //  ground specular\r\n  vec3 reflectGround = normalize(reflect(-u_upVector, g_normal));\r\n  float groundDot = max(dot(reflectGround, toEye), 0.0001);\r\n  hemiSpecWeight += hemiIntensity * pow(groundDot, specularExponent);\r\n\r\n  specularAccum += hemiSpecWeight * specularColor * hemiColor;\r\n\r\n  vec3 litColor = diffuseAccum + specularAccum;\r\n\r\n  // Apply fresnel reflection.\r\n  float fresnelIntensity = u_lightSettings[15];\r\n  if (0.0 != fresnelIntensity) {\r\n    float fresnel = -dot(toEye, g_normal);\r\n    if (fresnelIntensity < 0.0) {\r\n      fresnelIntensity = abs(fresnelIntensity);\r\n      fresnel = 1.0 - fresnel;\r\n    }\r\n\r\n    fresnel = clamp(1.0 - fresnel, 0.0, 1.0);\r\n    litColor = litColor * (1.0 + fresnelIntensity * fresnel);\r\n  }\r\n\r\n  // Clamp while preserving hue.\r\n  float maxIntensity = max(litColor.r, max(litColor.g, litColor.b));\r\n  float numCel = u_lightSettings[14];\r\n  if (numCel > 0.0)\r\n    baseColor.rgb = baseColor.rgb * ceil(maxIntensity * numCel) / numCel;\r\n  else\r\n    baseColor.rgb = litColor / max(1.0, maxIntensity);\r\n\r\n  return baseColor;\r\n`;\r\n\r\n/** NB: addMaterial() sets up the mat_* variables used by applyLighting.\r\n * @internal\r\n */\r\nexport function addLighting(builder: ProgramBuilder) {\r\n  addFrustum(builder);\r\n\r\n  const frag = builder.frag;\r\n\r\n  frag.addFunction(computeDirectionalLighting);\r\n  frag.set(FragmentShaderComponent.ApplyLighting, applyLighting);\r\n\r\n  frag.addUniform(\"u_sunDir\", VariableType.Vec3, (prog) => {\r\n    prog.addProgramUniform(\"u_sunDir\", (uniform, params) => {\r\n      params.target.uniforms.bindSunDirection(uniform);\r\n    });\r\n  }, VariablePrecision.High);\r\n\r\n  frag.addUniform(\"u_lightSettings[16]\", VariableType.Float, (prog) => {\r\n    prog.addProgramUniform(\"u_lightSettings[0]\", (uniform, params) => {\r\n      params.target.uniforms.lights.bind(uniform);\r\n    });\r\n  });\r\n\r\n  frag.addUniform(\"u_upVector\", VariableType.Vec3, (prog) => {\r\n    prog.addProgramUniform(\"u_upVector\", (uniform, params) => {\r\n      params.target.uniforms.frustum.bindUpVector(uniform);\r\n    });\r\n  });\r\n}\r\n"]}
+{"version":3,"file":"Lighting.js","sourceRoot":"","sources":["../../../../../src/render/webgl/glsl/Lighting.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAGH,qCAAsC;AAEtC,MAAM,0BAA0B,GAAG;;;;;;;;CAQlC,CAAC;AAEF,oCAAoC;AACpC,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoFrB,CAAC;AAEF;;GAEG;AACH,SAAgB,WAAW,CAAC,OAAuB;IACjD,IAAA,mBAAU,EAAC,OAAO,CAAC,CAAC;IAEpB,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAE1B,IAAI,CAAC,WAAW,CAAC,0BAA0B,CAAC,CAAC;IAC7C,IAAI,CAAC,GAAG,gDAAwC,aAAa,CAAC,CAAC;IAE/D,IAAI,CAAC,UAAU,CAAC,UAAU,6BAAqB,CAAC,IAAI,EAAE,EAAE;QACtD,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrD,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;QACnD,CAAC,CAAC,CAAC;IACL,CAAC,iCAAyB,CAAC;IAE3B,IAAI,CAAC,UAAU,CAAC,qBAAqB,8BAAsB,CAAC,IAAI,EAAE,EAAE;QAClE,IAAI,CAAC,iBAAiB,CAAC,oBAAoB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC/D,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC9C,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,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AAzBD,kCAyBC","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 { FragmentShaderComponent, ProgramBuilder, VariablePrecision, VariableType } from \"../ShaderBuilder\";\nimport { addFrustum } from \"./Common\";\n\nconst computeDirectionalLighting = `\nvoid computeDirectionalLight (inout float diffuse, inout float specular, vec3 normal, vec3 toEye, vec3 lightDir, float lightIntensity, float specularExponent) {\n  diffuse += lightIntensity * max(dot(normal, lightDir), 0.0);\n  vec3 toReflectedLight = normalize(reflect(lightDir, normal));\n  float specularDot = max(dot(toReflectedLight, toEye), 0.0001);\n  // NB: If specularDot and specularExponent are both zero, 0^0 done below can return NaN.  Must make sure specularDot is larger than zero (hence 0.0001 or greater, as ensured above).\n  specular += lightIntensity * pow(specularDot, specularExponent);\n}\n`;\n\n// mat_weights: x=diffuse y=specular\nconst applyLighting = `\n  if (baseColor.a <= 0.0 || !u_surfaceFlags[kSurfaceBitIndex_ApplyLighting])\n    return baseColor;\n\n  // Extract surface properties\n  vec3 rgb = baseColor.rgb;\n  vec3 toEye = kFrustumType_Perspective == u_frustum.z ? normalize(v_eyeSpace.xyz) : vec3(0.0, 0.0, -1.0);\n\n  // Extract material properties\n  float diffuseWeight = mat_weights.x;\n  float specularWeight = mat_weights.y * u_lightSettings[13];\n  float specularExponent = mat_specular.a;\n  vec3 specularColor = mat_specular.rgb;\n  const float ambientWeight = 1.0; // Ignore MicroStation's ambient weights - usually bogus.\n\n  // Compute directional lights\n  const vec3 portraitDir = vec3(-0.7071, 0.0, 0.7071);\n  float portraitIntensity = u_lightSettings[12];\n  float sunIntensity = u_lightSettings[0];\n\n  float directionalDiffuseIntensity = 0.0;\n  float directionalSpecularIntensity = 0.0;\n  computeDirectionalLight(directionalDiffuseIntensity, directionalSpecularIntensity, g_normal, toEye, u_sunDir, sunIntensity, specularExponent);\n  computeDirectionalLight(directionalDiffuseIntensity, directionalSpecularIntensity, g_normal ,toEye, portraitDir, portraitIntensity, specularExponent);\n\n  const float directionalFudge = 0.92; // leftover from old lighting implementation\n  vec3 diffuseAccum = directionalDiffuseIntensity * diffuseWeight * rgb * directionalFudge; // directional light is white.\n  vec3 specularAccum = directionalSpecularIntensity * specularWeight * specularColor;\n\n  // Compute ambient light\n  float ambientIntensity = u_lightSettings[4];\n  vec3 ambientColor = vec3(u_lightSettings[1], u_lightSettings[2], u_lightSettings[3]);\n  if (ambientColor.r + ambientColor.g + ambientColor.b == 0.0)\n    ambientColor = rgb;\n\n  diffuseAccum += ambientIntensity * ambientWeight * ambientColor;\n\n  // Compute hemisphere lights\n  vec3 ground = vec3(u_lightSettings[5], u_lightSettings[6], u_lightSettings[7]);\n  vec3 sky = vec3(u_lightSettings[8], u_lightSettings[9], u_lightSettings[10]);\n  float hemiIntensity = u_lightSettings[11];\n\n  //  diffuse\n  float hemiDot = dot(g_normal, u_upVector);\n  float hemiDiffuseWeight = 0.5 * hemiDot + 0.5;\n  vec3 hemiColor = mix(ground, sky, hemiDiffuseWeight);\n  diffuseAccum += hemiIntensity * hemiColor * rgb;\n\n  //  sky specular\n  vec3 reflectSky = normalize(reflect(u_upVector, g_normal));\n  float skyDot = max(dot(reflectSky, toEye), 0.0001);\n  float hemiSpecWeight = hemiIntensity * pow(skyDot, specularExponent);\n\n  //  ground specular\n  vec3 reflectGround = normalize(reflect(-u_upVector, g_normal));\n  float groundDot = max(dot(reflectGround, toEye), 0.0001);\n  hemiSpecWeight += hemiIntensity * pow(groundDot, specularExponent);\n\n  specularAccum += hemiSpecWeight * specularColor * hemiColor;\n\n  vec3 litColor = diffuseAccum + specularAccum;\n\n  // Apply fresnel reflection.\n  float fresnelIntensity = u_lightSettings[15];\n  if (0.0 != fresnelIntensity) {\n    float fresnel = -dot(toEye, g_normal);\n    if (fresnelIntensity < 0.0) {\n      fresnelIntensity = abs(fresnelIntensity);\n      fresnel = 1.0 - fresnel;\n    }\n\n    fresnel = clamp(1.0 - fresnel, 0.0, 1.0);\n    litColor = litColor * (1.0 + fresnelIntensity * fresnel);\n  }\n\n  // Clamp while preserving hue.\n  float maxIntensity = max(litColor.r, max(litColor.g, litColor.b));\n  float numCel = u_lightSettings[14];\n  if (numCel > 0.0)\n    baseColor.rgb = baseColor.rgb * ceil(maxIntensity * numCel) / numCel;\n  else\n    baseColor.rgb = litColor / max(1.0, maxIntensity);\n\n  return baseColor;\n`;\n\n/** NB: addMaterial() sets up the mat_* variables used by applyLighting.\n * @internal\n */\nexport function addLighting(builder: ProgramBuilder) {\n  addFrustum(builder);\n\n  const frag = builder.frag;\n\n  frag.addFunction(computeDirectionalLighting);\n  frag.set(FragmentShaderComponent.ApplyLighting, applyLighting);\n\n  frag.addUniform(\"u_sunDir\", VariableType.Vec3, (prog) => {\n    prog.addProgramUniform(\"u_sunDir\", (uniform, params) => {\n      params.target.uniforms.bindSunDirection(uniform);\n    });\n  }, VariablePrecision.High);\n\n  frag.addUniform(\"u_lightSettings[16]\", VariableType.Float, (prog) => {\n    prog.addProgramUniform(\"u_lightSettings[0]\", (uniform, params) => {\n      params.target.uniforms.lights.bind(uniform);\n    });\n  });\n\n  frag.addUniform(\"u_upVector\", VariableType.Vec3, (prog) => {\n    prog.addProgramUniform(\"u_upVector\", (uniform, params) => {\n      params.target.uniforms.frustum.bindUpVector(uniform);\n    });\n  });\n}\n"]}

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

@@ -1 +1 @@
-{"version":3,"file":"LogarithmicDepthBuffer.js","sourceRoot":"","sources":["../../../../../src/render/webgl/glsl/LogarithmicDepthBuffer.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAEH,sDAA6C;AAE7C,sCAAmC;AACnC,qCAAuC;AAEvC,6DAA6D;AAC7D,wJAAwJ;AACxJ,qFAAqF;AACrF,MAAM,aAAa,GAAG,+FAA+F,CAAC;AAEtH,gBAAgB;AAChB,SAAgB,WAAW,CAAC,OAAuB;IACjD,IAAA,qBAAM,EAAC,eAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC;IAE3C,IAAA,oBAAW,EAAC,OAAO,CAAC,CAAC;IAErB,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAC1B,IAAI,CAAC,UAAU,CAAC,QAAQ,6BAAqB,CAAC,IAAI,EAAE,EAAE;QACpD,IAAI,CAAC,iBAAiB,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACnD,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC7D,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,GAAG,iDAAwC,aAAa,CAAC,CAAC;AACjE,CAAC;AAbD,kCAaC","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 { assert } from \"@itwin/core-bentley\";\r\nimport { FragmentShaderComponent, ProgramBuilder, VariableType } from \"../ShaderBuilder\";\r\nimport { System } from \"../System\";\r\nimport { addEyeSpace } from \"./Common\";\r\n\r\n// Based on http://tulrich.com/geekstuff/log_depth_buffer.txt\r\n// Previously attempted to adjust z in vertex shader along the lines of https://outerra.blogspot.com/2013/07/logarithmic-depth-buffer-optimizations.html\r\n// - but interpolation along triangles intersecting the near plane was far too wonky.\r\nconst finalizeDepth = \"return 0.0 == u_logZ.x ? -v_eyeSpace.z / u_logZ.y : log(-v_eyeSpace.z * u_logZ.x) / u_logZ.y;\";\r\n\r\n/** @internal */\r\nexport function addLogDepth(builder: ProgramBuilder): void {\r\n  assert(System.instance.supportsLogZBuffer);\r\n\r\n  addEyeSpace(builder);\r\n\r\n  const frag = builder.frag;\r\n  frag.addUniform(\"u_logZ\", VariableType.Vec2, (prog) => {\r\n    prog.addProgramUniform(\"u_logZ\", (uniform, params) => {\r\n      uniform.setUniform2fv(params.target.uniforms.frustum.logZ);\r\n    });\r\n  });\r\n\r\n  frag.set(FragmentShaderComponent.FinalizeDepth, finalizeDepth);\r\n}\r\n"]}
+{"version":3,"file":"LogarithmicDepthBuffer.js","sourceRoot":"","sources":["../../../../../src/render/webgl/glsl/LogarithmicDepthBuffer.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAEH,sDAA6C;AAE7C,sCAAmC;AACnC,qCAAuC;AAEvC,6DAA6D;AAC7D,wJAAwJ;AACxJ,qFAAqF;AACrF,MAAM,aAAa,GAAG,+FAA+F,CAAC;AAEtH,gBAAgB;AAChB,SAAgB,WAAW,CAAC,OAAuB;IACjD,IAAA,qBAAM,EAAC,eAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC;IAE3C,IAAA,oBAAW,EAAC,OAAO,CAAC,CAAC;IAErB,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAC1B,IAAI,CAAC,UAAU,CAAC,QAAQ,6BAAqB,CAAC,IAAI,EAAE,EAAE;QACpD,IAAI,CAAC,iBAAiB,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACnD,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC7D,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,GAAG,iDAAwC,aAAa,CAAC,CAAC;AACjE,CAAC;AAbD,kCAaC","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 { assert } from \"@itwin/core-bentley\";\nimport { FragmentShaderComponent, ProgramBuilder, VariableType } from \"../ShaderBuilder\";\nimport { System } from \"../System\";\nimport { addEyeSpace } from \"./Common\";\n\n// Based on http://tulrich.com/geekstuff/log_depth_buffer.txt\n// Previously attempted to adjust z in vertex shader along the lines of https://outerra.blogspot.com/2013/07/logarithmic-depth-buffer-optimizations.html\n// - but interpolation along triangles intersecting the near plane was far too wonky.\nconst finalizeDepth = \"return 0.0 == u_logZ.x ? -v_eyeSpace.z / u_logZ.y : log(-v_eyeSpace.z * u_logZ.x) / u_logZ.y;\";\n\n/** @internal */\nexport function addLogDepth(builder: ProgramBuilder): void {\n  assert(System.instance.supportsLogZBuffer);\n\n  addEyeSpace(builder);\n\n  const frag = builder.frag;\n  frag.addUniform(\"u_logZ\", VariableType.Vec2, (prog) => {\n    prog.addProgramUniform(\"u_logZ\", (uniform, params) => {\n      uniform.setUniform2fv(params.target.uniforms.frustum.logZ);\n    });\n  });\n\n  frag.set(FragmentShaderComponent.FinalizeDepth, finalizeDepth);\n}\n"]}

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

@@ -8,27 +8,27 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addLookupTable = void 0;
-const computeLUTCoords = `
-vec2 computeLUTCoords(float index, vec2 dimensions, vec2 center, float mult) {
-  float baseIndex = index*mult;
-
-  // Fix precision issues wherein mod(x,y) => y instead of 0 when x is multiple of y...
-  float epsilon = 0.5 / dimensions.x;
-  float yId = floor(baseIndex / dimensions.x + epsilon);
-  float xId = baseIndex - dimensions.x * yId; // replaces mod()...
-
-  return center + vec2(xId/dimensions.x, yId/dimensions.y);
-}
+const computeLUTCoords = `
+vec2 computeLUTCoords(float index, vec2 dimensions, vec2 center, float mult) {
+  float baseIndex = index*mult;
+
+  // Fix precision issues wherein mod(x,y) => y instead of 0 when x is multiple of y...
+  float epsilon = 0.5 / dimensions.x;
+  float yId = floor(baseIndex / dimensions.x + epsilon);
+  float xId = baseIndex - dimensions.x * yId; // replaces mod()...
+
+  return center + vec2(xId/dimensions.x, yId/dimensions.y);
+}
 `;
-const computeCoordsTemplate = `
-vec2 compute_{LUTNAME}_coords(float index) {
-  return computeLUTCoords(index, u_{LUTNAME}Params.xy, g_{LUTNAME}_center, {MULT});
-}
+const computeCoordsTemplate = `
+vec2 compute_{LUTNAME}_coords(float index) {
+  return computeLUTCoords(index, u_{LUTNAME}Params.xy, g_{LUTNAME}_center, {MULT});
+}
 `;
-const initializerTemplate = `
-  {LUTSTEPX} = 1.0 / {LUTPARAMS}.x;
-  float {LUTSTEPY} = 1.0 / {LUTPARAMS}.y;
-  {LUTCENTER} = vec2(0.5*{LUTSTEPX}, 0.5*{LUTSTEPY});
+const initializerTemplate = `
+  {LUTSTEPX} = 1.0 / {LUTPARAMS}.x;
+  float {LUTSTEPY} = 1.0 / {LUTPARAMS}.y;
+  {LUTCENTER} = vec2(0.5*{LUTSTEPX}, 0.5*{LUTSTEPY});
 `;
 /** Add support for a lookup table to the vertex shader. Returns the code used to initialize the global variables.
  * @internal

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

@@ -1 +1 @@
-{"version":3,"file":"LookupTable.js","sourceRoot":"","sources":["../../../../../src/render/webgl/glsl/LookupTable.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAIH,MAAM,gBAAgB,GAAG;;;;;;;;;;;CAWxB,CAAC;AAEF,MAAM,qBAAqB,GAAG;;;;CAI7B,CAAC;AAEF,MAAM,mBAAmB,GAAG;;;;CAI3B,CAAC;AAEF;;GAEG;AACH,SAAgB,cAAc,CAAC,EAAuB,EAAE,OAAe,EAAE,OAAe,KAAK,EAAE,cAAc,GAAG,IAAI;IAClH,EAAE,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC;IAEjC,MAAM,QAAQ,GAAG,KAAK,OAAO,QAAQ,CAAC;IACtC,MAAM,QAAQ,GAAG,GAAG,OAAO,QAAQ,CAAC;IACpC,MAAM,SAAS,GAAG,KAAK,OAAO,SAAS,CAAC;IACxC,MAAM,SAAS,GAAG,KAAK,OAAO,QAAQ,CAAC;IAEvC,EAAE,CAAC,SAAS,CAAC,QAAQ,6BAAqB,CAAC;IAC3C,EAAE,CAAC,SAAS,CAAC,SAAS,4BAAoB,CAAC;IAE3C,IAAI,mBAAmB,GAAG,mBAAmB,CAAC;IAC9C,mBAAmB,GAAG,mBAAmB,CAAC,OAAO,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;IAC3E,mBAAmB,GAAG,mBAAmB,CAAC,OAAO,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;IAC3E,mBAAmB,GAAG,mBAAmB,CAAC,OAAO,CAAC,cAAc,EAAE,SAAS,CAAC,CAAC;IAC7E,mBAAmB,GAAG,mBAAmB,CAAC,OAAO,CAAC,cAAc,EAAE,SAAS,CAAC,CAAC;IAC7E,IAAI,cAAc;QAChB,EAAE,CAAC,cAAc,CAAC,mBAAmB,CAAC,CAAC;IAEzC,IAAI,qBAAqB,GAAG,qBAAqB,CAAC;IAClD,qBAAqB,GAAG,qBAAqB,CAAC,OAAO,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;IAC7E,qBAAqB,GAAG,qBAAqB,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IACvE,EAAE,CAAC,WAAW,CAAC,qBAAqB,CAAC,CAAC;IAEtC,OAAO,mBAAmB,CAAC;AAC7B,CAAC;AAzBD,wCAyBC","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 { VariableType, VertexShaderBuilder } from \"../ShaderBuilder\";\r\n\r\nconst computeLUTCoords = `\r\nvec2 computeLUTCoords(float index, vec2 dimensions, vec2 center, float mult) {\r\n  float baseIndex = index*mult;\r\n\r\n  // Fix precision issues wherein mod(x,y) => y instead of 0 when x is multiple of y...\r\n  float epsilon = 0.5 / dimensions.x;\r\n  float yId = floor(baseIndex / dimensions.x + epsilon);\r\n  float xId = baseIndex - dimensions.x * yId; // replaces mod()...\r\n\r\n  return center + vec2(xId/dimensions.x, yId/dimensions.y);\r\n}\r\n`;\r\n\r\nconst computeCoordsTemplate = `\r\nvec2 compute_{LUTNAME}_coords(float index) {\r\n  return computeLUTCoords(index, u_{LUTNAME}Params.xy, g_{LUTNAME}_center, {MULT});\r\n}\r\n`;\r\n\r\nconst initializerTemplate = `\r\n  {LUTSTEPX} = 1.0 / {LUTPARAMS}.x;\r\n  float {LUTSTEPY} = 1.0 / {LUTPARAMS}.y;\r\n  {LUTCENTER} = vec2(0.5*{LUTSTEPX}, 0.5*{LUTSTEPY});\r\n`;\r\n\r\n/** Add support for a lookup table to the vertex shader. Returns the code used to initialize the global variables.\r\n * @internal\r\n */\r\nexport function addLookupTable(sb: VertexShaderBuilder, lutName: string, mult: string = \"1.0\", addInitializer = true): string {\r\n  sb.addFunction(computeLUTCoords);\r\n\r\n  const lutStepX = `g_${lutName}_stepX`;\r\n  const lutStepY = `${lutName}_stepY`;\r\n  const lutCenter = `g_${lutName}_center`;\r\n  const lutParams = `u_${lutName}Params`;\r\n\r\n  sb.addGlobal(lutStepX, VariableType.Float);\r\n  sb.addGlobal(lutCenter, VariableType.Vec2);\r\n\r\n  let initializerSpecific = initializerTemplate;\r\n  initializerSpecific = initializerSpecific.replace(/{LUTSTEPX}/g, lutStepX);\r\n  initializerSpecific = initializerSpecific.replace(/{LUTSTEPY}/g, lutStepY);\r\n  initializerSpecific = initializerSpecific.replace(/{LUTCENTER}/g, lutCenter);\r\n  initializerSpecific = initializerSpecific.replace(/{LUTPARAMS}/g, lutParams);\r\n  if (addInitializer)\r\n    sb.addInitializer(initializerSpecific);\r\n\r\n  let computeCoordsSpecific = computeCoordsTemplate;\r\n  computeCoordsSpecific = computeCoordsSpecific.replace(/{LUTNAME}/g, lutName);\r\n  computeCoordsSpecific = computeCoordsSpecific.replace(/{MULT}/g, mult);\r\n  sb.addFunction(computeCoordsSpecific);\r\n\r\n  return initializerSpecific;\r\n}\r\n"]}
+{"version":3,"file":"LookupTable.js","sourceRoot":"","sources":["../../../../../src/render/webgl/glsl/LookupTable.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAIH,MAAM,gBAAgB,GAAG;;;;;;;;;;;CAWxB,CAAC;AAEF,MAAM,qBAAqB,GAAG;;;;CAI7B,CAAC;AAEF,MAAM,mBAAmB,GAAG;;;;CAI3B,CAAC;AAEF;;GAEG;AACH,SAAgB,cAAc,CAAC,EAAuB,EAAE,OAAe,EAAE,OAAe,KAAK,EAAE,cAAc,GAAG,IAAI;IAClH,EAAE,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC;IAEjC,MAAM,QAAQ,GAAG,KAAK,OAAO,QAAQ,CAAC;IACtC,MAAM,QAAQ,GAAG,GAAG,OAAO,QAAQ,CAAC;IACpC,MAAM,SAAS,GAAG,KAAK,OAAO,SAAS,CAAC;IACxC,MAAM,SAAS,GAAG,KAAK,OAAO,QAAQ,CAAC;IAEvC,EAAE,CAAC,SAAS,CAAC,QAAQ,6BAAqB,CAAC;IAC3C,EAAE,CAAC,SAAS,CAAC,SAAS,4BAAoB,CAAC;IAE3C,IAAI,mBAAmB,GAAG,mBAAmB,CAAC;IAC9C,mBAAmB,GAAG,mBAAmB,CAAC,OAAO,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;IAC3E,mBAAmB,GAAG,mBAAmB,CAAC,OAAO,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;IAC3E,mBAAmB,GAAG,mBAAmB,CAAC,OAAO,CAAC,cAAc,EAAE,SAAS,CAAC,CAAC;IAC7E,mBAAmB,GAAG,mBAAmB,CAAC,OAAO,CAAC,cAAc,EAAE,SAAS,CAAC,CAAC;IAC7E,IAAI,cAAc;QAChB,EAAE,CAAC,cAAc,CAAC,mBAAmB,CAAC,CAAC;IAEzC,IAAI,qBAAqB,GAAG,qBAAqB,CAAC;IAClD,qBAAqB,GAAG,qBAAqB,CAAC,OAAO,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;IAC7E,qBAAqB,GAAG,qBAAqB,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IACvE,EAAE,CAAC,WAAW,CAAC,qBAAqB,CAAC,CAAC;IAEtC,OAAO,mBAAmB,CAAC;AAC7B,CAAC;AAzBD,wCAyBC","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 { VariableType, VertexShaderBuilder } from \"../ShaderBuilder\";\n\nconst computeLUTCoords = `\nvec2 computeLUTCoords(float index, vec2 dimensions, vec2 center, float mult) {\n  float baseIndex = index*mult;\n\n  // Fix precision issues wherein mod(x,y) => y instead of 0 when x is multiple of y...\n  float epsilon = 0.5 / dimensions.x;\n  float yId = floor(baseIndex / dimensions.x + epsilon);\n  float xId = baseIndex - dimensions.x * yId; // replaces mod()...\n\n  return center + vec2(xId/dimensions.x, yId/dimensions.y);\n}\n`;\n\nconst computeCoordsTemplate = `\nvec2 compute_{LUTNAME}_coords(float index) {\n  return computeLUTCoords(index, u_{LUTNAME}Params.xy, g_{LUTNAME}_center, {MULT});\n}\n`;\n\nconst initializerTemplate = `\n  {LUTSTEPX} = 1.0 / {LUTPARAMS}.x;\n  float {LUTSTEPY} = 1.0 / {LUTPARAMS}.y;\n  {LUTCENTER} = vec2(0.5*{LUTSTEPX}, 0.5*{LUTSTEPY});\n`;\n\n/** Add support for a lookup table to the vertex shader. Returns the code used to initialize the global variables.\n * @internal\n */\nexport function addLookupTable(sb: VertexShaderBuilder, lutName: string, mult: string = \"1.0\", addInitializer = true): string {\n  sb.addFunction(computeLUTCoords);\n\n  const lutStepX = `g_${lutName}_stepX`;\n  const lutStepY = `${lutName}_stepY`;\n  const lutCenter = `g_${lutName}_center`;\n  const lutParams = `u_${lutName}Params`;\n\n  sb.addGlobal(lutStepX, VariableType.Float);\n  sb.addGlobal(lutCenter, VariableType.Vec2);\n\n  let initializerSpecific = initializerTemplate;\n  initializerSpecific = initializerSpecific.replace(/{LUTSTEPX}/g, lutStepX);\n  initializerSpecific = initializerSpecific.replace(/{LUTSTEPY}/g, lutStepY);\n  initializerSpecific = initializerSpecific.replace(/{LUTCENTER}/g, lutCenter);\n  initializerSpecific = initializerSpecific.replace(/{LUTPARAMS}/g, lutParams);\n  if (addInitializer)\n    sb.addInitializer(initializerSpecific);\n\n  let computeCoordsSpecific = computeCoordsTemplate;\n  computeCoordsSpecific = computeCoordsSpecific.replace(/{LUTNAME}/g, lutName);\n  computeCoordsSpecific = computeCoordsSpecific.replace(/{MULT}/g, mult);\n  sb.addFunction(computeCoordsSpecific);\n\n  return initializerSpecific;\n}\n"]}

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

@@ -9,20 +9,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addSurfaceMonochrome = exports.addUnlitMonochrome = void 0;
 const core_common_1 = require("@itwin/core-common");
-const applyUnlitMonochromeColor = `
-  vec4 monoColor = vec4(u_monoRgb, baseColor.a);
-  return u_shaderFlags[kShaderBit_Monochrome] ? monoColor : baseColor;
+const applyUnlitMonochromeColor = `
+  vec4 monoColor = vec4(u_monoRgb, baseColor.a);
+  return u_shaderFlags[kShaderBit_Monochrome] ? monoColor : baseColor;
 `;
-const applySurfaceMonochromeColor = `
-  vec4 monoColor = vec4(u_monoRgb, baseColor.a);
-  if (1.0 == u_mixMonoColor) {
-    vec3 rgb = baseColor.rgb;
-    rgb = vec3(dot(rgb, vec3(.222, .707, .071)));
-    rgb *= u_monoRgb;
-    monoColor.rgb = rgb;
-  }
-
-  return u_shaderFlags[kShaderBit_Monochrome] ? monoColor : baseColor;
+const applySurfaceMonochromeColor = `
+  vec4 monoColor = vec4(u_monoRgb, baseColor.a);
+  if (1.0 == u_mixMonoColor) {
+    vec3 rgb = baseColor.rgb;
+    rgb = vec3(dot(rgb, vec3(.222, .707, .071)));
+    rgb *= u_monoRgb;
+    monoColor.rgb = rgb;
+  }
+
+  return u_shaderFlags[kShaderBit_Monochrome] ? monoColor : baseColor;
 `;
 function addMonoRgb(frag) {
     frag.addUniform("u_monoRgb", 4 /* VariableType.Vec3 */, (prog) => {

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

@@ -1 +1 @@
-{"version":3,"file":"Monochrome.js","sourceRoot":"","sources":["../../../../../src/render/webgl/glsl/Monochrome.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAEH,oDAAoD;AAGpD,MAAM,yBAAyB,GAAG;;;CAGjC,CAAC;AAEF,MAAM,2BAA2B,GAAG;;;;;;;;;;CAUnC,CAAC;AAEF,SAAS,UAAU,CAAC,IAA2B;IAC7C,IAAI,CAAC,UAAU,CAAC,WAAW,6BAAqB,CAAC,IAAI,EAAE,EAAE;QACvD,IAAI,CAAC,iBAAiB,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACtD,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;QAC1D,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AAED,gBAAgB;AAChB,SAAgB,kBAAkB,CAAC,IAA2B;IAC5D,UAAU,CAAC,IAAI,CAAC,CAAC;IACjB,IAAI,CAAC,GAAG,kDAA0C,yBAAyB,CAAC,CAAC;AAC/E,CAAC;AAHD,gDAGC;AAED,gBAAgB;AAChB,SAAgB,oBAAoB,CAAC,IAA2B;IAC9D,UAAU,CAAC,IAAI,CAAC,CAAC;IACjB,IAAI,CAAC,UAAU,CAAC,gBAAgB,8BAAsB,CAAC,IAAI,EAAE,EAAE;QAC7D,IAAI,CAAC,iBAAiB,CAAC,gBAAgB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC3D,OAAO,CAAC,YAAY,CAAC,4BAAc,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,IAAI,MAAM,CAAC,QAAQ,CAAC,sBAAsB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACzJ,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,GAAG,kDAA0C,2BAA2B,CAAC,CAAC;AACjF,CAAC;AATD,oDASC","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 { MonochromeMode } from \"@itwin/core-common\";\r\nimport { FragmentShaderBuilder, FragmentShaderComponent, VariableType } from \"../ShaderBuilder\";\r\n\r\nconst applyUnlitMonochromeColor = `\r\n  vec4 monoColor = vec4(u_monoRgb, baseColor.a);\r\n  return u_shaderFlags[kShaderBit_Monochrome] ? monoColor : baseColor;\r\n`;\r\n\r\nconst applySurfaceMonochromeColor = `\r\n  vec4 monoColor = vec4(u_monoRgb, baseColor.a);\r\n  if (1.0 == u_mixMonoColor) {\r\n    vec3 rgb = baseColor.rgb;\r\n    rgb = vec3(dot(rgb, vec3(.222, .707, .071)));\r\n    rgb *= u_monoRgb;\r\n    monoColor.rgb = rgb;\r\n  }\r\n\r\n  return u_shaderFlags[kShaderBit_Monochrome] ? monoColor : baseColor;\r\n`;\r\n\r\nfunction addMonoRgb(frag: FragmentShaderBuilder): void {\r\n  frag.addUniform(\"u_monoRgb\", VariableType.Vec3, (prog) => {\r\n    prog.addProgramUniform(\"u_monoRgb\", (uniform, params) => {\r\n      params.target.uniforms.style.bindMonochromeRgb(uniform);\r\n    });\r\n  });\r\n}\r\n\r\n/** @internal */\r\nexport function addUnlitMonochrome(frag: FragmentShaderBuilder): void {\r\n  addMonoRgb(frag);\r\n  frag.set(FragmentShaderComponent.ApplyMonochrome, applyUnlitMonochromeColor);\r\n}\r\n\r\n/** @internal */\r\nexport function addSurfaceMonochrome(frag: FragmentShaderBuilder): void {\r\n  addMonoRgb(frag);\r\n  frag.addUniform(\"u_mixMonoColor\", VariableType.Float, (prog) => {\r\n    prog.addGraphicUniform(\"u_mixMonoColor\", (uniform, params) => {\r\n      uniform.setUniform1f(MonochromeMode.Scaled === params.target.plan.monochromeMode && params.geometry.wantMixMonochromeColor(params.target) ? 1.0 : 0.0);\r\n    });\r\n  });\r\n\r\n  frag.set(FragmentShaderComponent.ApplyMonochrome, applySurfaceMonochromeColor);\r\n}\r\n"]}
+{"version":3,"file":"Monochrome.js","sourceRoot":"","sources":["../../../../../src/render/webgl/glsl/Monochrome.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAEH,oDAAoD;AAGpD,MAAM,yBAAyB,GAAG;;;CAGjC,CAAC;AAEF,MAAM,2BAA2B,GAAG;;;;;;;;;;CAUnC,CAAC;AAEF,SAAS,UAAU,CAAC,IAA2B;IAC7C,IAAI,CAAC,UAAU,CAAC,WAAW,6BAAqB,CAAC,IAAI,EAAE,EAAE;QACvD,IAAI,CAAC,iBAAiB,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACtD,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;QAC1D,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AAED,gBAAgB;AAChB,SAAgB,kBAAkB,CAAC,IAA2B;IAC5D,UAAU,CAAC,IAAI,CAAC,CAAC;IACjB,IAAI,CAAC,GAAG,kDAA0C,yBAAyB,CAAC,CAAC;AAC/E,CAAC;AAHD,gDAGC;AAED,gBAAgB;AAChB,SAAgB,oBAAoB,CAAC,IAA2B;IAC9D,UAAU,CAAC,IAAI,CAAC,CAAC;IACjB,IAAI,CAAC,UAAU,CAAC,gBAAgB,8BAAsB,CAAC,IAAI,EAAE,EAAE;QAC7D,IAAI,CAAC,iBAAiB,CAAC,gBAAgB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC3D,OAAO,CAAC,YAAY,CAAC,4BAAc,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,IAAI,MAAM,CAAC,QAAQ,CAAC,sBAAsB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACzJ,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,GAAG,kDAA0C,2BAA2B,CAAC,CAAC;AACjF,CAAC;AATD,oDASC","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 { MonochromeMode } from \"@itwin/core-common\";\nimport { FragmentShaderBuilder, FragmentShaderComponent, VariableType } from \"../ShaderBuilder\";\n\nconst applyUnlitMonochromeColor = `\n  vec4 monoColor = vec4(u_monoRgb, baseColor.a);\n  return u_shaderFlags[kShaderBit_Monochrome] ? monoColor : baseColor;\n`;\n\nconst applySurfaceMonochromeColor = `\n  vec4 monoColor = vec4(u_monoRgb, baseColor.a);\n  if (1.0 == u_mixMonoColor) {\n    vec3 rgb = baseColor.rgb;\n    rgb = vec3(dot(rgb, vec3(.222, .707, .071)));\n    rgb *= u_monoRgb;\n    monoColor.rgb = rgb;\n  }\n\n  return u_shaderFlags[kShaderBit_Monochrome] ? monoColor : baseColor;\n`;\n\nfunction addMonoRgb(frag: FragmentShaderBuilder): void {\n  frag.addUniform(\"u_monoRgb\", VariableType.Vec3, (prog) => {\n    prog.addProgramUniform(\"u_monoRgb\", (uniform, params) => {\n      params.target.uniforms.style.bindMonochromeRgb(uniform);\n    });\n  });\n}\n\n/** @internal */\nexport function addUnlitMonochrome(frag: FragmentShaderBuilder): void {\n  addMonoRgb(frag);\n  frag.set(FragmentShaderComponent.ApplyMonochrome, applyUnlitMonochromeColor);\n}\n\n/** @internal */\nexport function addSurfaceMonochrome(frag: FragmentShaderBuilder): void {\n  addMonoRgb(frag);\n  frag.addUniform(\"u_mixMonoColor\", VariableType.Float, (prog) => {\n    prog.addGraphicUniform(\"u_mixMonoColor\", (uniform, params) => {\n      uniform.setUniform1f(MonochromeMode.Scaled === params.target.plan.monochromeMode && params.geometry.wantMixMonochromeColor(params.target) ? 1.0 : 0.0);\n    });\n  });\n\n  frag.set(FragmentShaderComponent.ApplyMonochrome, applySurfaceMonochromeColor);\n}\n"]}