@luma.gl/shaders 10.0.0-alpha.10 → 10.0.0-alpha.12

package/dist/modules/lighting/pbr-shadow/pbr-shadow.cjs

@@ -0,0 +1,97 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pbr_shadow_exports = {};
+__export(pbr_shadow_exports, {
+  pbrShadow: () => pbrShadow
+});
+module.exports = __toCommonJS(pbr_shadow_exports);
+var import_pbr_material = require("../pbr-material/pbr-material.cjs");
+var import_shadow = require("../shadow/shadow.cjs");
+const pbrShadow = {
+  name: "pbrShadow",
+  dependencies: [import_pbr_material.pbrMaterial, import_shadow.shadow],
+  bindingLayout: [{ name: "pbrShadow", group: 0 }],
+  uniformTypes: { viewMatrix: "mat4x4<f32>", enabled: "i32" },
+  defaultUniforms: {
+    viewMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+    enabled: 1
+  },
+  getUniforms(properties = {}) {
+    return {
+      ...properties.viewMatrix ? { viewMatrix: properties.viewMatrix } : {},
+      ...properties.enabled === void 0 ? {} : { enabled: Number(properties.enabled) }
+    };
+  },
+  source: (
+    /* wgsl */
+    `
+struct PBRShadowUniforms {
+  viewMatrix: mat4x4f,
+  enabled: i32,
+};
+@group(0) @binding(auto) var<uniform> pbrShadow: PBRShadowUniforms;
+fn pbrShadow_filterColorWithDirectionalContact(vertexColor: vec4f, worldPosition: vec3f, worldNormal: vec3f, contactVisibility: f32) -> vec4f {
+  var directionalVisibility = 1.0;
+  var pointVisibility = vec4f(1.0);
+  var spotVisibility = vec4f(1.0);
+  if (pbrShadow.enabled != 0) {
+    let normal = normalize(worldNormal);
+    let viewDepth = -(pbrShadow.viewMatrix * vec4f(worldPosition, 1.0)).z;
+    directionalVisibility = shadow_getDirectionalFactor(worldPosition, normal, viewDepth);
+    for (var index = 0; index < 4; index++) {
+      pointVisibility[index] = shadow_getPointFactor(index, worldPosition, normal);
+      spotVisibility[index] = shadow_getSpotFactor(index, worldPosition, normal);
+    }
+  }
+  return pbr_filterColorWithShadows(vertexColor, min(directionalVisibility, contactVisibility), pointVisibility, spotVisibility);
+}
+fn pbrShadow_filterColor(vertexColor: vec4f, worldPosition: vec3f, worldNormal: vec3f) -> vec4f {
+  return pbrShadow_filterColorWithDirectionalContact(vertexColor, worldPosition, worldNormal, 1.0);
+}`
+  ),
+  fs: (
+    /* glsl */
+    `
+layout(std140) uniform pbrShadowUniforms {
+  mat4 viewMatrix;
+  int enabled;
+} pbrShadow;
+vec4 pbrShadow_filterColorWithDirectionalContact(vec4 vertexColor, vec3 worldPosition, vec3 worldNormal, float contactVisibility) {
+  float directionalVisibility = 1.0;
+  vec4 pointVisibility = vec4(1.0);
+  vec4 spotVisibility = vec4(1.0);
+  if (pbrShadow.enabled != 0) {
+    vec3 normal = normalize(worldNormal);
+    float viewDepth = -(pbrShadow.viewMatrix * vec4(worldPosition, 1.0)).z;
+    directionalVisibility = shadow_getDirectionalFactor(worldPosition, normal, viewDepth);
+    for (int index = 0; index < 4; index++) {
+      pointVisibility[index] = shadow_getPointFactor(index, worldPosition, normal);
+      spotVisibility[index] = shadow_getSpotFactor(index, worldPosition, normal);
+    }
+  }
+  return pbr_filterColorWithShadows(vertexColor, min(directionalVisibility, contactVisibility), pointVisibility, spotVisibility);
+ }
+vec4 pbrShadow_filterColor(vec4 vertexColor, vec3 worldPosition, vec3 worldNormal) {
+  return pbrShadow_filterColorWithDirectionalContact(vertexColor, worldPosition, worldNormal, 1.0);
+}`
+  )
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pbrShadow
+});

package/dist/modules/lighting/pbr-shadow/pbr-shadow.d.ts

@@ -0,0 +1,15 @@
+import type { NumberArray16 } from '@math.gl/core';
+import type { ShaderModule } from "../../../lib/shader-module/shader-module.js";
+export type PBRShadowProps = {
+    /** Receiver camera view matrix, used for directional cascade selection. */
+    viewMatrix?: Readonly<NumberArray16>;
+    /** Toggle receiving while retaining allocated maps and bindings. Defaults to true. */
+    enabled?: boolean;
+};
+export type PBRShadowUniforms = {
+    viewMatrix: Readonly<NumberArray16>;
+    enabled: number;
+};
+/** Applies shadow visibility to matching direct-light slots in the canonical PBR shader. */
+export declare const pbrShadow: ShaderModule<PBRShadowProps, PBRShadowUniforms>;
+//# sourceMappingURL=pbr-shadow.d.ts.map

package/dist/modules/lighting/pbr-shadow/pbr-shadow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbr-shadow.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/pbr-shadow/pbr-shadow.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAC,YAAY,EAAC,oDAAiD;AAI3E,MAAM,MAAM,cAAc,GAAG;IAC3B,2EAA2E;IAC3E,UAAU,CAAC,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAC;IACrC,sFAAsF;IACtF,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,UAAU,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAC;IACpC,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,4FAA4F;AAC5F,eAAO,MAAM,SAAS,EAAE,YAAY,CAAC,cAAc,EAAE,iBAAiB,CA+DrE,CAAC"}

package/dist/modules/lighting/pbr-shadow/pbr-shadow.js

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import { pbrMaterial } from "../pbr-material/pbr-material.js";
+import { shadow } from "../shadow/shadow.js";
+/** Applies shadow visibility to matching direct-light slots in the canonical PBR shader. */
+export const pbrShadow = {
+    name: 'pbrShadow',
+    dependencies: [pbrMaterial, shadow],
+    bindingLayout: [{ name: 'pbrShadow', group: 0 }],
+    uniformTypes: { viewMatrix: 'mat4x4<f32>', enabled: 'i32' },
+    defaultUniforms: {
+        viewMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+        enabled: 1
+    },
+    getUniforms(properties = {}) {
+        return {
+            ...(properties.viewMatrix ? { viewMatrix: properties.viewMatrix } : {}),
+            ...(properties.enabled === undefined ? {} : { enabled: Number(properties.enabled) })
+        };
+    },
+    source: /* wgsl */ `
+struct PBRShadowUniforms {
+  viewMatrix: mat4x4f,
+  enabled: i32,
+};
+@group(0) @binding(auto) var<uniform> pbrShadow: PBRShadowUniforms;
+fn pbrShadow_filterColorWithDirectionalContact(vertexColor: vec4f, worldPosition: vec3f, worldNormal: vec3f, contactVisibility: f32) -> vec4f {
+  var directionalVisibility = 1.0;
+  var pointVisibility = vec4f(1.0);
+  var spotVisibility = vec4f(1.0);
+  if (pbrShadow.enabled != 0) {
+    let normal = normalize(worldNormal);
+    let viewDepth = -(pbrShadow.viewMatrix * vec4f(worldPosition, 1.0)).z;
+    directionalVisibility = shadow_getDirectionalFactor(worldPosition, normal, viewDepth);
+    for (var index = 0; index < 4; index++) {
+      pointVisibility[index] = shadow_getPointFactor(index, worldPosition, normal);
+      spotVisibility[index] = shadow_getSpotFactor(index, worldPosition, normal);
+    }
+  }
+  return pbr_filterColorWithShadows(vertexColor, min(directionalVisibility, contactVisibility), pointVisibility, spotVisibility);
+}
+fn pbrShadow_filterColor(vertexColor: vec4f, worldPosition: vec3f, worldNormal: vec3f) -> vec4f {
+  return pbrShadow_filterColorWithDirectionalContact(vertexColor, worldPosition, worldNormal, 1.0);
+}`,
+    fs: /* glsl */ `
+layout(std140) uniform pbrShadowUniforms {
+  mat4 viewMatrix;
+  int enabled;
+} pbrShadow;
+vec4 pbrShadow_filterColorWithDirectionalContact(vec4 vertexColor, vec3 worldPosition, vec3 worldNormal, float contactVisibility) {
+  float directionalVisibility = 1.0;
+  vec4 pointVisibility = vec4(1.0);
+  vec4 spotVisibility = vec4(1.0);
+  if (pbrShadow.enabled != 0) {
+    vec3 normal = normalize(worldNormal);
+    float viewDepth = -(pbrShadow.viewMatrix * vec4(worldPosition, 1.0)).z;
+    directionalVisibility = shadow_getDirectionalFactor(worldPosition, normal, viewDepth);
+    for (int index = 0; index < 4; index++) {
+      pointVisibility[index] = shadow_getPointFactor(index, worldPosition, normal);
+      spotVisibility[index] = shadow_getSpotFactor(index, worldPosition, normal);
+    }
+  }
+  return pbr_filterColorWithShadows(vertexColor, min(directionalVisibility, contactVisibility), pointVisibility, spotVisibility);
+ }
+vec4 pbrShadow_filterColor(vec4 vertexColor, vec3 worldPosition, vec3 worldNormal) {
+  return pbrShadow_filterColorWithDirectionalContact(vertexColor, worldPosition, worldNormal, 1.0);
+}`
+};
+//# sourceMappingURL=pbr-shadow.js.map

package/dist/modules/lighting/pbr-shadow/pbr-shadow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbr-shadow.js","sourceRoot":"","sources":["../../../../src/modules/lighting/pbr-shadow/pbr-shadow.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,4DAA4D;AAI5D,OAAO,EAAC,WAAW,EAAC,wCAAqC;AACzD,OAAO,EAAC,MAAM,EAAC,4BAAyB;AAcxC,4FAA4F;AAC5F,MAAM,CAAC,MAAM,SAAS,GAAoD;IACxE,IAAI,EAAE,WAAW;IACjB,YAAY,EAAE,CAAC,WAAW,EAAE,MAAM,CAAC;IACnC,aAAa,EAAE,CAAC,EAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,EAAC,CAAC;IAC9C,YAAY,EAAE,EAAC,UAAU,EAAE,aAAa,EAAE,OAAO,EAAE,KAAK,EAAC;IACzD,eAAe,EAAE;QACf,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QAC5D,OAAO,EAAE,CAAC;KACX;IACD,WAAW,CAAC,UAAU,GAAG,EAAE;QACzB,OAAO;YACL,GAAG,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,EAAC,UAAU,EAAE,UAAU,CAAC,UAAU,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YACrE,GAAG,CAAC,UAAU,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAC,OAAO,EAAE,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,EAAC,CAAC;SACnF,CAAC;IACJ,CAAC;IACD,MAAM,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;EAuBnB;IAEA,EAAE,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;EAsBf;CACD,CAAC"}

package/dist/modules/lighting/pbr-surface/pbr-surface.cjs

@@ -0,0 +1,114 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pbr_surface_exports = {};
+__export(pbr_surface_exports, {
+  pbrSurface: () => pbrSurface
+});
+module.exports = __toCommonJS(pbr_surface_exports);
+var import_pbr_material = require("../pbr-material/pbr-material.cjs");
+const pbrSurface = {
+  name: "pbrSurface",
+  dependencies: [import_pbr_material.pbrMaterial],
+  bindingLayout: [{ name: "pbrSurface", group: 0 }],
+  uniformTypes: { viewMatrix: "mat4x4<f32>", useMaterialNormals: "i32" },
+  defaultUniforms: {
+    viewMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+    useMaterialNormals: 0
+  },
+  getUniforms(properties = {}) {
+    return {
+      ...properties.viewMatrix ? { viewMatrix: properties.viewMatrix } : {},
+      ...properties.useMaterialNormals === void 0 ? {} : { useMaterialNormals: Number(properties.useMaterialNormals) }
+    };
+  },
+  source: (
+    /* wgsl */
+    `
+struct PBRSurfaceUniforms {
+  viewMatrix: mat4x4f,
+  useMaterialNormals: i32,
+};
+@group(0) @binding(auto) var<uniform> pbrSurface: PBRSurfaceUniforms;
+fn pbrSurface_getColor() -> vec4f {
+#ifdef HAS_NORMALS
+  var normal = normalize(fragmentInputs.pbr_vNormal);
+#ifdef DOUBLE_SIDED
+  if (!pbr_frontFacing) {normal = -normal;}
+#endif
+#else
+  var normal = normalize(cross(dpdy(fragmentInputs.pbr_vPosition), dpdx(fragmentInputs.pbr_vPosition)));
+#endif
+#ifdef HAS_NORMALMAP
+  if (pbrSurface.useMaterialNormals != 0) {
+    let coordinates = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+    normal = getNormal(getTBN(coordinates), coordinates);
+  }
+#else
+#ifdef HAS_BUMPMAP
+  if (pbrSurface.useMaterialNormals != 0) {
+    let coordinates = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+    normal = getNormal(getTBN(coordinates), coordinates);
+  }
+#endif
+#endif
+  let viewNormal = normalize((pbrSurface.viewMatrix * vec4f(normal, 0.0)).xyz);
+  return vec4f(viewNormal * 0.5 + vec3f(0.5), 1.0);
+}`
+  ),
+  fs: (
+    /* glsl */
+    `
+layout(std140) uniform pbrSurfaceUniforms {
+  mat4 viewMatrix;
+  int useMaterialNormals;
+} pbrSurface;
+vec4 pbrSurface_getColor() {
+#ifdef HAS_NORMALS
+#ifdef HAS_TANGENTS
+  vec3 normal = normalize(pbr_vTBN[2]);
+#else
+  vec3 normal = normalize(pbr_vNormal);
+#endif
+#ifdef DOUBLE_SIDED
+  if (!gl_FrontFacing) normal = -normal;
+#endif
+#else
+  vec3 normal = normalize(cross(dFdx(pbr_vPosition), dFdy(pbr_vPosition)));
+#endif
+#ifdef HAS_NORMALMAP
+  if (pbrSurface.useMaterialNormals != 0) {
+    vec2 coordinates = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+    normal = getNormal(getTBN(coordinates), coordinates);
+  }
+#else
+#ifdef HAS_BUMPMAP
+  if (pbrSurface.useMaterialNormals != 0) {
+    vec2 coordinates = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+    normal = getNormal(getTBN(coordinates), coordinates);
+  }
+#endif
+#endif
+  vec3 viewNormal = normalize((pbrSurface.viewMatrix * vec4(normal, 0.0)).xyz);
+  return vec4(viewNormal * 0.5 + 0.5, 1.0);
+}`
+  )
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pbrSurface
+});

package/dist/modules/lighting/pbr-surface/pbr-surface.d.ts

@@ -0,0 +1,15 @@
+import type { NumberArray16 } from '@math.gl/core';
+import type { ShaderModule } from "../../../lib/shader-module/shader-module.js";
+export type PBRSurfaceProps = {
+    /** Rigid world-to-view camera transform. Defaults to identity. */
+    viewMatrix?: Readonly<NumberArray16>;
+    /** Include canonical normal/bump maps instead of geometric normals. Defaults to false. */
+    useMaterialNormals?: boolean;
+};
+export type PBRSurfaceUniforms = {
+    viewMatrix: Readonly<NumberArray16>;
+    useMaterialNormals: number;
+};
+/** Encodes view-space PBR normals in RGB; alpha one marks covered surface pixels. */
+export declare const pbrSurface: ShaderModule<PBRSurfaceProps, PBRSurfaceUniforms>;
+//# sourceMappingURL=pbr-surface.d.ts.map

package/dist/modules/lighting/pbr-surface/pbr-surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbr-surface.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/pbr-surface/pbr-surface.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAC,YAAY,EAAC,oDAAiD;AAG3E,MAAM,MAAM,eAAe,GAAG;IAC5B,kEAAkE;IAClE,UAAU,CAAC,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAC;IACrC,0FAA0F;IAC1F,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,UAAU,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAC;IACpC,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,qFAAqF;AACrF,eAAO,MAAM,UAAU,EAAE,YAAY,CAAC,eAAe,EAAE,kBAAkB,CAkFxE,CAAC"}

package/dist/modules/lighting/pbr-surface/pbr-surface.js

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import { pbrMaterial } from "../pbr-material/pbr-material.js";
+/** Encodes view-space PBR normals in RGB; alpha one marks covered surface pixels. */
+export const pbrSurface = {
+    name: 'pbrSurface',
+    dependencies: [pbrMaterial],
+    bindingLayout: [{ name: 'pbrSurface', group: 0 }],
+    uniformTypes: { viewMatrix: 'mat4x4<f32>', useMaterialNormals: 'i32' },
+    defaultUniforms: {
+        viewMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+        useMaterialNormals: 0
+    },
+    getUniforms(properties = {}) {
+        return {
+            ...(properties.viewMatrix ? { viewMatrix: properties.viewMatrix } : {}),
+            ...(properties.useMaterialNormals === undefined
+                ? {}
+                : { useMaterialNormals: Number(properties.useMaterialNormals) })
+        };
+    },
+    source: /* wgsl */ `
+struct PBRSurfaceUniforms {
+  viewMatrix: mat4x4f,
+  useMaterialNormals: i32,
+};
+@group(0) @binding(auto) var<uniform> pbrSurface: PBRSurfaceUniforms;
+fn pbrSurface_getColor() -> vec4f {
+#ifdef HAS_NORMALS
+  var normal = normalize(fragmentInputs.pbr_vNormal);
+#ifdef DOUBLE_SIDED
+  if (!pbr_frontFacing) {normal = -normal;}
+#endif
+#else
+  var normal = normalize(cross(dpdy(fragmentInputs.pbr_vPosition), dpdx(fragmentInputs.pbr_vPosition)));
+#endif
+#ifdef HAS_NORMALMAP
+  if (pbrSurface.useMaterialNormals != 0) {
+    let coordinates = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+    normal = getNormal(getTBN(coordinates), coordinates);
+  }
+#else
+#ifdef HAS_BUMPMAP
+  if (pbrSurface.useMaterialNormals != 0) {
+    let coordinates = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+    normal = getNormal(getTBN(coordinates), coordinates);
+  }
+#endif
+#endif
+  let viewNormal = normalize((pbrSurface.viewMatrix * vec4f(normal, 0.0)).xyz);
+  return vec4f(viewNormal * 0.5 + vec3f(0.5), 1.0);
+}`,
+    fs: /* glsl */ `
+layout(std140) uniform pbrSurfaceUniforms {
+  mat4 viewMatrix;
+  int useMaterialNormals;
+} pbrSurface;
+vec4 pbrSurface_getColor() {
+#ifdef HAS_NORMALS
+#ifdef HAS_TANGENTS
+  vec3 normal = normalize(pbr_vTBN[2]);
+#else
+  vec3 normal = normalize(pbr_vNormal);
+#endif
+#ifdef DOUBLE_SIDED
+  if (!gl_FrontFacing) normal = -normal;
+#endif
+#else
+  vec3 normal = normalize(cross(dFdx(pbr_vPosition), dFdy(pbr_vPosition)));
+#endif
+#ifdef HAS_NORMALMAP
+  if (pbrSurface.useMaterialNormals != 0) {
+    vec2 coordinates = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+    normal = getNormal(getTBN(coordinates), coordinates);
+  }
+#else
+#ifdef HAS_BUMPMAP
+  if (pbrSurface.useMaterialNormals != 0) {
+    vec2 coordinates = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+    normal = getNormal(getTBN(coordinates), coordinates);
+  }
+#endif
+#endif
+  vec3 viewNormal = normalize((pbrSurface.viewMatrix * vec4(normal, 0.0)).xyz);
+  return vec4(viewNormal * 0.5 + 0.5, 1.0);
+}`
+};
+//# sourceMappingURL=pbr-surface.js.map

package/dist/modules/lighting/pbr-surface/pbr-surface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbr-surface.js","sourceRoot":"","sources":["../../../../src/modules/lighting/pbr-surface/pbr-surface.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,4DAA4D;AAI5D,OAAO,EAAC,WAAW,EAAC,wCAAqC;AAczD,qFAAqF;AACrF,MAAM,CAAC,MAAM,UAAU,GAAsD;IAC3E,IAAI,EAAE,YAAY;IAClB,YAAY,EAAE,CAAC,WAAW,CAAC;IAC3B,aAAa,EAAE,CAAC,EAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC,EAAC,CAAC;IAC/C,YAAY,EAAE,EAAC,UAAU,EAAE,aAAa,EAAE,kBAAkB,EAAE,KAAK,EAAC;IACpE,eAAe,EAAE;QACf,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QAC5D,kBAAkB,EAAE,CAAC;KACtB;IACD,WAAW,CAAC,UAAU,GAAG,EAAE;QACzB,OAAO;YACL,GAAG,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,EAAC,UAAU,EAAE,UAAU,CAAC,UAAU,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YACrE,GAAG,CAAC,UAAU,CAAC,kBAAkB,KAAK,SAAS;gBAC7C,CAAC,CAAC,EAAE;gBACJ,CAAC,CAAC,EAAC,kBAAkB,EAAE,MAAM,CAAC,UAAU,CAAC,kBAAkB,CAAC,EAAC,CAAC;SACjE,CAAC;IACJ,CAAC;IACD,MAAM,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BnB;IACA,EAAE,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCf;CACD,CAAC"}