@luma.gl/shadertools 9.1.9 → 9.2.0-alpha.2

package/dist/modules/lighting/pbr-material/pbr-vertex-glsl.d.ts

@@ -1,2 +0,0 @@
-export declare const vs = "out vec3 pbr_vPosition;\nout vec2 pbr_vUV;\n\n#ifdef HAS_NORMALS\n# ifdef HAS_TANGENTS\nout mat3 pbr_vTBN;\n# else\nout vec3 pbr_vNormal;\n# endif\n#endif\n\nvoid pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, vec2 uv)\n{\n  vec4 pos = pbrProjection.modelMatrix * position;\n  pbr_vPosition = vec3(pos.xyz) / pos.w;\n\n#ifdef HAS_NORMALS\n#ifdef HAS_TANGENTS\n  vec3 normalW = normalize(vec3(pbrProjection.normalMatrix * vec4(normal.xyz, 0.0)));\n  vec3 tangentW = normalize(vec3(pbrProjection.modelMatrix * vec4(tangent.xyz, 0.0)));\n  vec3 bitangentW = cross(normalW, tangentW) * tangent.w;\n  pbr_vTBN = mat3(tangentW, bitangentW, normalW);\n#else // HAS_TANGENTS != 1\n  pbr_vNormal = normalize(vec3(pbrProjection.modelMatrix * vec4(normal.xyz, 0.0)));\n#endif\n#endif\n\n#ifdef HAS_UV\n  pbr_vUV = uv;\n#else\n  pbr_vUV = vec2(0.,0.);\n#endif\n}\n";
-//# sourceMappingURL=pbr-vertex-glsl.d.ts.map

package/dist/modules/lighting/pbr-material/pbr-vertex-glsl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pbr-vertex-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/pbr-material/pbr-vertex-glsl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,EAAE,m3BAkCd,CAAC"}

package/dist/modules/lighting/pbr-material/pbr-vertex-glsl.js

@@ -1,39 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-export const vs = /* glsl */ `\
-out vec3 pbr_vPosition;
-out vec2 pbr_vUV;
-
-#ifdef HAS_NORMALS
-# ifdef HAS_TANGENTS
-out mat3 pbr_vTBN;
-# else
-out vec3 pbr_vNormal;
-# endif
-#endif
-
-void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, vec2 uv)
-{
-  vec4 pos = pbrProjection.modelMatrix * position;
-  pbr_vPosition = vec3(pos.xyz) / pos.w;
-
-#ifdef HAS_NORMALS
-#ifdef HAS_TANGENTS
-  vec3 normalW = normalize(vec3(pbrProjection.normalMatrix * vec4(normal.xyz, 0.0)));
-  vec3 tangentW = normalize(vec3(pbrProjection.modelMatrix * vec4(tangent.xyz, 0.0)));
-  vec3 bitangentW = cross(normalW, tangentW) * tangent.w;
-  pbr_vTBN = mat3(tangentW, bitangentW, normalW);
-#else // HAS_TANGENTS != 1
-  pbr_vNormal = normalize(vec3(pbrProjection.modelMatrix * vec4(normal.xyz, 0.0)));
-#endif
-#endif
-
-#ifdef HAS_UV
-  pbr_vUV = uv;
-#else
-  pbr_vUV = vec2(0.,0.);
-#endif
-}
-`;
-//# sourceMappingURL=pbr-vertex-glsl.js.map

package/dist/modules/lighting/pbr-material/pbr-vertex-glsl.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pbr-vertex-glsl.js","sourceRoot":"","sources":["../../../../src/modules/lighting/pbr-material/pbr-vertex-glsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,MAAM,CAAC,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkC5B,CAAC"}

package/dist/modules/module-injectors.d.ts

@@ -1,3 +0,0 @@
-export declare const MODULE_INJECTORS_VS = "#ifdef MODULE_LOGDEPTH\n  logdepth_adjustPosition(gl_Position);\n#endif\n";
-export declare const MODULE_INJECTORS_FS = "#ifdef MODULE_MATERIAL\n  fragColor = material_filterColor(fragColor);\n#endif\n\n#ifdef MODULE_LIGHTING\n  fragColor = lighting_filterColor(fragColor);\n#endif\n\n#ifdef MODULE_FOG\n  fragColor = fog_filterColor(fragColor);\n#endif\n\n#ifdef MODULE_PICKING\n  fragColor = picking_filterHighlightColor(fragColor);\n  fragColor = picking_filterPickingColor(fragColor);\n#endif\n\n#ifdef MODULE_LOGDEPTH\n  logdepth_setFragDepth();\n#endif\n";
-//# sourceMappingURL=module-injectors.d.ts.map

package/dist/modules/module-injectors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"module-injectors.d.ts","sourceRoot":"","sources":["../../src/modules/module-injectors.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,mBAAmB,8EAI/B,CAAC;AAEF,eAAO,MAAM,mBAAmB,4bAqB/B,CAAC"}

package/dist/modules/module-injectors.js

@@ -1,31 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-export const MODULE_INJECTORS_VS = /* glsl */ `\
-#ifdef MODULE_LOGDEPTH
-  logdepth_adjustPosition(gl_Position);
-#endif
-`;
-export const MODULE_INJECTORS_FS = /* glsl */ `\
-#ifdef MODULE_MATERIAL
-  fragColor = material_filterColor(fragColor);
-#endif
-
-#ifdef MODULE_LIGHTING
-  fragColor = lighting_filterColor(fragColor);
-#endif
-
-#ifdef MODULE_FOG
-  fragColor = fog_filterColor(fragColor);
-#endif
-
-#ifdef MODULE_PICKING
-  fragColor = picking_filterHighlightColor(fragColor);
-  fragColor = picking_filterPickingColor(fragColor);
-#endif
-
-#ifdef MODULE_LOGDEPTH
-  logdepth_setFragDepth();
-#endif
-`;
-//# sourceMappingURL=module-injectors.js.map

package/dist/modules/module-injectors.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"module-injectors.js","sourceRoot":"","sources":["../../src/modules/module-injectors.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC;;;;CAI7C,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;CAqB7C,CAAC"}

package/dist/modules-webgl1/geometry/geometry.d.ts

@@ -1,9 +0,0 @@
-/**
- * Geometry varyings
- */
-export declare const geometry: {
-    name: string;
-    vs: string;
-    fs: string;
-};
-//# sourceMappingURL=geometry.d.ts.map

package/dist/modules-webgl1/geometry/geometry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../../src/modules-webgl1/geometry/geometry.ts"],"names":[],"mappings":"AAiCA;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;CAIpB,CAAC"}

package/dist/modules-webgl1/geometry/geometry.js

@@ -1,39 +0,0 @@
-// import {ShaderModule} from '../../types';
-// TODO - reuse normal from geometry module
-const vs = /* glsl */ `\
-varying vec4 geometry_vPosition;
-varying vec3 geometry_vNormal;
-
-void geometry_setNormal(vec3 normal) {
-  geometry_vNormal = normal;
-}
-
-void geometry_setPosition(vec4 position) {
-  geometry_vPosition = position;
-}
-
-void geometry_setPosition(vec3 position) {
-  geometry_vPosition = vec4(position, 1.);
-}
-`;
-const fs = /* glsl */ `\
-varying vec4 geometry_vPosition;
-varying vec3 geometry_vNormal;
-
-vec4 geometry_getPosition() {
-  return geometry_vPosition;
-}
-
-vec3 geometry_getNormal() {
-  return geometry_vNormal;
-}
-`;
-/**
- * Geometry varyings
- */
-export const geometry = {
-    name: 'geometry',
-    vs,
-    fs
-};
-//# sourceMappingURL=geometry.js.map

package/dist/modules-webgl1/geometry/geometry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"geometry.js","sourceRoot":"","sources":["../../../src/modules-webgl1/geometry/geometry.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAE5C,2CAA2C;AAC3C,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;CAerB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;CAWrB,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,IAAI,EAAE,UAAU;IAChB,EAAE;IACF,EAAE;CACH,CAAC"}

package/dist/modules-webgl1/lighting/dirlight/dirlight.d.ts

@@ -1,10 +0,0 @@
-import { ShaderModule } from "../../../lib/shader-module/shader-module.js";
-import type { NumericArray } from "../../../types.js";
-export type DirlightOptions = {
-    lightDirection?: NumericArray;
-};
-/**
- * Cheap lighting - single directional light, single dot product, one uniform
- */
-export declare const dirlight: ShaderModule;
-//# sourceMappingURL=dirlight.d.ts.map

package/dist/modules-webgl1/lighting/dirlight/dirlight.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dirlight.d.ts","sourceRoot":"","sources":["../../../../src/modules-webgl1/lighting/dirlight/dirlight.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAC,oDAAiD;AACtE,OAAO,KAAK,EAAC,YAAY,EAAC,0BAAuB;AAKjD,MAAM,MAAM,eAAe,GAAG;IAC5B,cAAc,CAAC,EAAE,YAAY,CAAC;CAC/B,CAAC;AA4BF;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,YAMtB,CAAC"}

package/dist/modules-webgl1/lighting/dirlight/dirlight.js

@@ -1,38 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-import { project } from "../../project/project.js";
-const DEFAULT_MODULE_OPTIONS = {
-    lightDirection: new Float32Array([1, 1, 2])
-};
-function getUniforms(opts = DEFAULT_MODULE_OPTIONS) {
-    const uniforms = {};
-    if (opts.lightDirection) {
-        // @ts-expect-error TODO add types
-        uniforms.dirlight_uLightDirection = opts.lightDirection;
-    }
-    return uniforms;
-}
-const fs = /* glsl */ `\
-uniform vec3 dirlight_uLightDirection;
-
-/*
- * Returns color attenuated by angle from light source
- */
-vec4 dirlight_filterColor(vec4 color) {
-  vec3 normal = project_getNormal_World();
-  float d = abs(dot(normalize(normal), normalize(dirlight_uLightDirection)));
-  return vec4(color.rgb * d, color.a);
-}
-`;
-/**
- * Cheap lighting - single directional light, single dot product, one uniform
- */
-export const dirlight = {
-    name: 'dirlight',
-    // vs // TODO - reuse normal from geometry module
-    fs,
-    getUniforms,
-    dependencies: [project]
-};
-//# sourceMappingURL=dirlight.js.map

package/dist/modules-webgl1/lighting/dirlight/dirlight.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"dirlight.js","sourceRoot":"","sources":["../../../../src/modules-webgl1/lighting/dirlight/dirlight.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,OAAO,EAAC,OAAO,EAAC,iCAA8B;AAQ9C,MAAM,sBAAsB,GAA8B;IACxD,cAAc,EAAE,IAAI,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAC5C,CAAC;AAEF,SAAS,WAAW,CAAC,OAAwB,sBAAsB;IACjE,MAAM,QAAQ,GAAG,EAAE,CAAC;IACpB,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;QACxB,kCAAkC;QAClC,QAAQ,CAAC,wBAAwB,GAAG,IAAI,CAAC,cAAc,CAAC;IAC1D,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;CAWrB,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAiB;IACpC,IAAI,EAAE,UAAU;IAChB,iDAAiD;IACjD,EAAE;IACF,WAAW;IACX,YAAY,EAAE,CAAC,OAAO,CAAC;CACxB,CAAC"}

package/dist/modules-webgl1/lighting/lights/lights-glsl.d.ts

@@ -1,2 +0,0 @@
-export declare const lightingShader = "#if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))\n\nstruct AmbientLight {\n vec3 color;\n};\n\nstruct PointLight {\n vec3 color;\n vec3 position;\n\n // Constant-Linear-Exponential\n vec3 attenuation;\n};\n\nstruct DirectionalLight {\n  vec3 color;\n  vec3 direction;\n};\n\nuniform AmbientLight lighting_uAmbientLight;\nuniform PointLight lighting_uPointLight[MAX_LIGHTS];\nuniform DirectionalLight lighting_uDirectionalLight[MAX_LIGHTS];\nuniform int lighting_uPointLightCount;\nuniform int lighting_uDirectionalLightCount;\n\nuniform bool lighting_uEnabled;\n\nfloat getPointLightAttenuation(PointLight pointLight, float distance) {\n  return pointLight.attenuation.x\n       + pointLight.attenuation.y * distance\n       + pointLight.attenuation.z * distance * distance;\n}\n\n#endif\n";
-//# sourceMappingURL=lights-glsl.d.ts.map

package/dist/modules-webgl1/lighting/lights/lights-glsl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lights-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules-webgl1/lighting/lights/lights-glsl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc,w2BAmC1B,CAAC"}

package/dist/modules-webgl1/lighting/lights/lights-glsl.js

@@ -1,40 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-export const lightingShader = /* glsl */ `\
-#if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
-
-struct AmbientLight {
- vec3 color;
-};
-
-struct PointLight {
- vec3 color;
- vec3 position;
-
- // Constant-Linear-Exponential
- vec3 attenuation;
-};
-
-struct DirectionalLight {
-  vec3 color;
-  vec3 direction;
-};
-
-uniform AmbientLight lighting_uAmbientLight;
-uniform PointLight lighting_uPointLight[MAX_LIGHTS];
-uniform DirectionalLight lighting_uDirectionalLight[MAX_LIGHTS];
-uniform int lighting_uPointLightCount;
-uniform int lighting_uDirectionalLightCount;
-
-uniform bool lighting_uEnabled;
-
-float getPointLightAttenuation(PointLight pointLight, float distance) {
-  return pointLight.attenuation.x
-       + pointLight.attenuation.y * distance
-       + pointLight.attenuation.z * distance * distance;
-}
-
-#endif
-`;
-//# sourceMappingURL=lights-glsl.js.map

package/dist/modules-webgl1/lighting/lights/lights-glsl.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"lights-glsl.js","sourceRoot":"","sources":["../../../../src/modules-webgl1/lighting/lights/lights-glsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,MAAM,CAAC,MAAM,cAAc,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCxC,CAAC"}

package/dist/modules-webgl1/lighting/lights/lights.d.ts

@@ -1,38 +0,0 @@
-import type { NumberArray } from "../../../types.js";
-type LightSources = {
-    ambientLight?: {
-        color: Readonly<NumberArray>;
-        intensity: number;
-    };
-    pointLights?: {
-        color: Readonly<NumberArray>;
-        intensity: number;
-        position: NumberArray;
-        attenuation: number;
-    }[];
-    directionalLights?: {
-        color: Readonly<NumberArray>;
-        intensity: number;
-        position: NumberArray;
-        direction: NumberArray;
-    }[];
-};
-export type LightsOptions = {
-    lightSources?: LightSources;
-};
-declare function getUniforms(opts?: LightsOptions): Record<string, any>;
-/**
- * An implementation of PBR (Physically-Based Rendering).
- * Physically Based Shading of a microfacet surface defined by a glTF material.
- */
-export declare const lights: {
-    name: string;
-    vs: string;
-    fs: string;
-    getUniforms: typeof getUniforms;
-    defines: {
-        MAX_LIGHTS: number;
-    };
-};
-export {};
-//# sourceMappingURL=lights.d.ts.map

package/dist/modules-webgl1/lighting/lights/lights.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lights.d.ts","sourceRoot":"","sources":["../../../../src/modules-webgl1/lighting/lights/lights.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,WAAW,EAAC,0BAAuB;AAKhD,KAAK,YAAY,GAAG;IAClB,YAAY,CAAC,EAAE;QACb,KAAK,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;QAC7B,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,WAAW,CAAC,EAAE;QACZ,KAAK,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;QAC7B,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,WAAW,CAAC;QACtB,WAAW,EAAE,MAAM,CAAC;KACrB,EAAE,CAAC;IACJ,iBAAiB,CAAC,EAAE;QAClB,KAAK,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;QAC7B,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,WAAW,CAAC;QACtB,SAAS,EAAE,WAAW,CAAC;KACxB,EAAE,CAAC;CACL,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B,CAAC;AAgDF,iBAAS,WAAW,CAAC,IAAI,GAAE,aAAsC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAkDtF;AAED;;;GAGG;AACH,eAAO,MAAM,MAAM;;;;;;;;CAQlB,CAAC"}

package/dist/modules-webgl1/lighting/lights/lights.js

@@ -1,93 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-import { lightingShader } from "./lights-glsl.js";
-const INITIAL_MODULE_OPTIONS = {
-    lightSources: {}
-};
-// Take color 0-255 and intensity as input and output 0.0-1.0 range
-function convertColor(colorDef = {}) {
-    const { color = [0, 0, 0], intensity = 1.0 } = colorDef;
-    return color.map(component => (component * intensity) / 255.0);
-}
-function getLightSourceUniforms({ ambientLight, pointLights = [], directionalLights = [] }) {
-    const lightSourceUniforms = {};
-    if (ambientLight) {
-        lightSourceUniforms['lighting_uAmbientLight.color'] = convertColor(ambientLight);
-    }
-    else {
-        lightSourceUniforms['lighting_uAmbientLight.color'] = [0, 0, 0];
-    }
-    pointLights.forEach((pointLight, index) => {
-        lightSourceUniforms[`lighting_uPointLight[${index}].color`] = convertColor(pointLight);
-        lightSourceUniforms[`lighting_uPointLight[${index}].position`] = pointLight.position;
-        lightSourceUniforms[`lighting_uPointLight[${index}].attenuation`] = pointLight.attenuation || [
-            1, 0, 0
-        ];
-    });
-    lightSourceUniforms.lighting_uPointLightCount = pointLights.length;
-    directionalLights.forEach((directionalLight, index) => {
-        lightSourceUniforms[`lighting_uDirectionalLight[${index}].color`] =
-            convertColor(directionalLight);
-        lightSourceUniforms[`lighting_uDirectionalLight[${index}].direction`] =
-            directionalLight.direction;
-    });
-    lightSourceUniforms.lighting_uDirectionalLightCount = directionalLights.length;
-    return lightSourceUniforms;
-}
-// eslint-disable-next-line complexity
-function getUniforms(opts = INITIAL_MODULE_OPTIONS) {
-    // Specify lights separately
-    if ('lightSources' in opts) {
-        const { ambientLight, pointLights, directionalLights } = opts.lightSources || {};
-        const hasLights = ambientLight ||
-            (pointLights && pointLights.length > 0) ||
-            (directionalLights && directionalLights.length > 0);
-        if (!hasLights) {
-            return { lighting_uEnabled: false };
-        }
-        return Object.assign({}, getLightSourceUniforms({ ambientLight, pointLights, directionalLights }), {
-            lighting_uEnabled: true
-        });
-    }
-    // Support for array of lights. Type of light is detected by type field
-    if ('lights' in opts) {
-        const lightSources = { pointLights: [], directionalLights: [] };
-        // @ts-expect-error
-        for (const light of opts.lights || []) {
-            switch (light.type) {
-                case 'ambient':
-                    // Note: Only uses last ambient light
-                    // TODO - add ambient light sources on CPU?
-                    lightSources.ambientLight = light;
-                    break;
-                case 'directional':
-                    lightSources.directionalLights?.push(light);
-                    break;
-                case 'point':
-                    lightSources.pointLights?.push(light);
-                    break;
-                default:
-                // eslint-disable-next-line
-                // console.warn(light.type);
-            }
-        }
-        // Call the `opts.lightSources`` version
-        return getUniforms({ lightSources });
-    }
-    return {};
-}
-/**
- * An implementation of PBR (Physically-Based Rendering).
- * Physically Based Shading of a microfacet surface defined by a glTF material.
- */
-export const lights = {
-    name: 'lights',
-    vs: lightingShader,
-    fs: lightingShader,
-    getUniforms,
-    defines: {
-        MAX_LIGHTS: 3
-    }
-};
-//# sourceMappingURL=lights.js.map

package/dist/modules-webgl1/lighting/lights/lights.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"lights.js","sourceRoot":"","sources":["../../../../src/modules-webgl1/lighting/lights/lights.ts"],"names":[],"mappings":"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"}

package/dist/modules-webgl1/lighting/pbr/pbr-fragment-glsl.d.ts

@@ -1,2 +0,0 @@
-export declare const fs = "precision highp float;\n\nuniform bool pbr_uUnlit;\n\n#ifdef USE_IBL\nuniform samplerCube u_DiffuseEnvSampler;\nuniform samplerCube u_SpecularEnvSampler;\nuniform sampler2D u_brdfLUT;\nuniform vec2 u_ScaleIBLAmbient;\n#endif\n\n#ifdef HAS_BASECOLORMAP\nuniform sampler2D u_BaseColorSampler;\n#endif\n#ifdef HAS_NORMALMAP\nuniform sampler2D u_NormalSampler;\nuniform float u_NormalScale;\n#endif\n#ifdef HAS_EMISSIVEMAP\nuniform sampler2D u_EmissiveSampler;\nuniform vec3 u_EmissiveFactor;\n#endif\n#ifdef HAS_METALROUGHNESSMAP\nuniform sampler2D u_MetallicRoughnessSampler;\n#endif\n#ifdef HAS_OCCLUSIONMAP\nuniform sampler2D u_OcclusionSampler;\nuniform float u_OcclusionStrength;\n#endif\n\n#ifdef ALPHA_CUTOFF\nuniform float u_AlphaCutoff;\n#endif\n\nuniform vec2 u_MetallicRoughnessValues;\nuniform vec4 u_BaseColorFactor;\n\nuniform vec3 u_Camera;\n\n// debugging flags used for shader output of intermediate PBR variables\n#ifdef PBR_DEBUG\nuniform vec4 u_ScaleDiffBaseMR;\nuniform vec4 u_ScaleFGDSpec;\n#endif\n\nin vec3 pbr_vPosition;\n\nin vec2 pbr_vUV;\n\n#ifdef HAS_NORMALS\n#ifdef HAS_TANGENTS\nin mat3 pbr_vTBN;\n#else\nin vec3 pbr_vNormal;\n#endif\n#endif\n\n// Encapsulate the various inputs used by the various functions in the shading equation\n// We store values in this struct to simplify the integration of alternative implementations\n// of the shading terms, outlined in the Readme.MD Appendix.\nstruct PBRInfo\n{\n  float NdotL;                  // cos angle between normal and light direction\n  float NdotV;                  // cos angle between normal and view direction\n  float NdotH;                  // cos angle between normal and half vector\n  float LdotH;                  // cos angle between light direction and half vector\n  float VdotH;                  // cos angle between view direction and half vector\n  float perceptualRoughness;    // roughness value, as authored by the model creator (input to shader)\n  float metalness;              // metallic value at the surface\n  vec3 reflectance0;            // full reflectance color (normal incidence angle)\n  vec3 reflectance90;           // reflectance color at grazing angle\n  float alphaRoughness;         // roughness mapped to a more linear change in the roughness (proposed by [2])\n  vec3 diffuseColor;            // color contribution from diffuse lighting\n  vec3 specularColor;           // color contribution from specular lighting\n  vec3 n;                       // normal at surface point\n  vec3 v;                       // vector from surface point to camera\n};\n\nconst float M_PI = 3.141592653589793;\nconst float c_MinRoughness = 0.04;\n\nvec4 SRGBtoLINEAR(vec4 srgbIn)\n{\n#ifdef MANUAL_SRGB\n#ifdef SRGB_FAST_APPROXIMATION\n  vec3 linOut = pow(srgbIn.xyz,vec3(2.2));\n#else //SRGB_FAST_APPROXIMATION\n  vec3 bLess = step(vec3(0.04045),srgbIn.xyz);\n  vec3 linOut = mix( srgbIn.xyz/vec3(12.92), pow((srgbIn.xyz+vec3(0.055))/vec3(1.055),vec3(2.4)), bLess );\n#endif //SRGB_FAST_APPROXIMATION\n  return vec4(linOut,srgbIn.w);;\n#else //MANUAL_SRGB\n  return srgbIn;\n#endif //MANUAL_SRGB\n}\n\n// Find the normal for this fragment, pulling either from a predefined normal map\n// or from the interpolated mesh normal and tangent attributes.\nvec3 getNormal()\n{\n  // Retrieve the tangent space matrix\n#ifndef HAS_TANGENTS\n  vec3 pos_dx = dFdx(pbr_vPosition);\n  vec3 pos_dy = dFdy(pbr_vPosition);\n  vec3 tex_dx = dFdx(vec3(pbr_vUV, 0.0));\n  vec3 tex_dy = dFdy(vec3(pbr_vUV, 0.0));\n  vec3 t = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);\n\n#ifdef HAS_NORMALS\n  vec3 ng = normalize(pbr_vNormal);\n#else\n  vec3 ng = cross(pos_dx, pos_dy);\n#endif\n\n  t = normalize(t - ng * dot(ng, t));\n  vec3 b = normalize(cross(ng, t));\n  mat3 tbn = mat3(t, b, ng);\n#else // HAS_TANGENTS\n  mat3 tbn = pbr_vTBN;\n#endif\n\n#ifdef HAS_NORMALMAP\n  vec3 n = texture(u_NormalSampler, pbr_vUV).rgb;\n  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(u_NormalScale, u_NormalScale, 1.0)));\n#else\n  // The tbn matrix is linearly interpolated, so we need to re-normalize\n  vec3 n = normalize(tbn[2].xyz);\n#endif\n\n  return n;\n}\n\n// Calculation of the lighting contribution from an optional Image Based Light source.\n// Precomputed Environment Maps are required uniform inputs and are computed as outlined in [1].\n// See our README.md on Environment Maps [3] for additional discussion.\n#ifdef USE_IBL\nvec3 getIBLContribution(PBRInfo pbrInputs, vec3 n, vec3 reflection)\n{\n  float mipCount = 9.0; // resolution of 512x512\n  float lod = (pbrInputs.perceptualRoughness * mipCount);\n  // retrieve a scale and bias to F0. See [1], Figure 3\n  vec3 brdf = SRGBtoLINEAR(texture(u_brdfLUT,\n    vec2(pbrInputs.NdotV, 1.0 - pbrInputs.perceptualRoughness))).rgb;\n  vec3 diffuseLight = SRGBtoLINEAR(textureCube(u_DiffuseEnvSampler, n)).rgb;\n\n#ifdef USE_TEX_LOD\n  vec3 specularLight = SRGBtoLINEAR(textureCubeLod(u_SpecularEnvSampler, reflection, lod)).rgb;\n#else\n  vec3 specularLight = SRGBtoLINEAR(textureCube(u_SpecularEnvSampler, reflection)).rgb;\n#endif\n\n  vec3 diffuse = diffuseLight * pbrInputs.diffuseColor;\n  vec3 specular = specularLight * (pbrInputs.specularColor * brdf.x + brdf.y);\n\n  // For presentation, this allows us to disable IBL terms\n  diffuse *= u_ScaleIBLAmbient.x;\n  specular *= u_ScaleIBLAmbient.y;\n\n  return diffuse + specular;\n}\n#endif\n\n// Basic Lambertian diffuse\n// Implementation from Lambert's Photometria https://archive.org/details/lambertsphotome00lambgoog\n// See also [1], Equation 1\nvec3 diffuse(PBRInfo pbrInputs)\n{\n  return pbrInputs.diffuseColor / M_PI;\n}\n\n// The following equation models the Fresnel reflectance term of the spec equation (aka F())\n// Implementation of fresnel from [4], Equation 15\nvec3 specularReflection(PBRInfo pbrInputs)\n{\n  return pbrInputs.reflectance0 +\n    (pbrInputs.reflectance90 - pbrInputs.reflectance0) *\n    pow(clamp(1.0 - pbrInputs.VdotH, 0.0, 1.0), 5.0);\n}\n\n// This calculates the specular geometric attenuation (aka G()),\n// where rougher material will reflect less light back to the viewer.\n// This implementation is based on [1] Equation 4, and we adopt their modifications to\n// alphaRoughness as input as originally proposed in [2].\nfloat geometricOcclusion(PBRInfo pbrInputs)\n{\n  float NdotL = pbrInputs.NdotL;\n  float NdotV = pbrInputs.NdotV;\n  float r = pbrInputs.alphaRoughness;\n\n  float attenuationL = 2.0 * NdotL / (NdotL + sqrt(r * r + (1.0 - r * r) * (NdotL * NdotL)));\n  float attenuationV = 2.0 * NdotV / (NdotV + sqrt(r * r + (1.0 - r * r) * (NdotV * NdotV)));\n  return attenuationL * attenuationV;\n}\n\n// The following equation(s) model the distribution of microfacet normals across\n// the area being drawn (aka D())\n// Implementation from \"Average Irregularity Representation of a Roughened Surface\n// for Ray Reflection\" by T. S. Trowbridge, and K. P. Reitz\n// Follows the distribution function recommended in the SIGGRAPH 2013 course notes\n// from EPIC Games [1], Equation 3.\nfloat microfacetDistribution(PBRInfo pbrInputs)\n{\n  float roughnessSq = pbrInputs.alphaRoughness * pbrInputs.alphaRoughness;\n  float f = (pbrInputs.NdotH * roughnessSq - pbrInputs.NdotH) * pbrInputs.NdotH + 1.0;\n  return roughnessSq / (M_PI * f * f);\n}\n\nvoid PBRInfo_setAmbientLight(inout PBRInfo pbrInputs) {\n  pbrInputs.NdotL = 1.0;\n  pbrInputs.NdotH = 0.0;\n  pbrInputs.LdotH = 0.0;\n  pbrInputs.VdotH = 1.0;\n}\n\nvoid PBRInfo_setDirectionalLight(inout PBRInfo pbrInputs, vec3 lightDirection) {\n  vec3 n = pbrInputs.n;\n  vec3 v = pbrInputs.v;\n  vec3 l = normalize(lightDirection);             // Vector from surface point to light\n  vec3 h = normalize(l+v);                        // Half vector between both l and v\n\n  pbrInputs.NdotL = clamp(dot(n, l), 0.001, 1.0);\n  pbrInputs.NdotH = clamp(dot(n, h), 0.0, 1.0);\n  pbrInputs.LdotH = clamp(dot(l, h), 0.0, 1.0);\n  pbrInputs.VdotH = clamp(dot(v, h), 0.0, 1.0);\n}\n\nvoid PBRInfo_setPointLight(inout PBRInfo pbrInputs, PointLight pointLight) {\n  vec3 light_direction = normalize(pointLight.position - pbr_vPosition);\n  PBRInfo_setDirectionalLight(pbrInputs, light_direction);\n}\n\nvec3 calculateFinalColor(PBRInfo pbrInputs, vec3 lightColor) {\n  // Calculate the shading terms for the microfacet specular shading model\n  vec3 F = specularReflection(pbrInputs);\n  float G = geometricOcclusion(pbrInputs);\n  float D = microfacetDistribution(pbrInputs);\n\n  // Calculation of analytical lighting contribution\n  vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInputs);\n  vec3 specContrib = F * G * D / (4.0 * pbrInputs.NdotL * pbrInputs.NdotV);\n  // Obtain final intensity as reflectance (BRDF) scaled by the energy of the light (cosine law)\n  return pbrInputs.NdotL * lightColor * (diffuseContrib + specContrib);\n}\n\nvec4 pbr_filterColor(vec4 colorUnused)\n{\n  // The albedo may be defined from a base texture or a flat color\n#ifdef HAS_BASECOLORMAP\n  vec4 baseColor = SRGBtoLINEAR(texture(u_BaseColorSampler, pbr_vUV)) * u_BaseColorFactor;\n#else\n  vec4 baseColor = u_BaseColorFactor;\n#endif\n\n#ifdef ALPHA_CUTOFF\n  if (baseColor.a < u_AlphaCutoff) {\n    discard;\n  }\n#endif\n\n  vec3 color = vec3(0, 0, 0);\n\n  if(pbr_uUnlit){\n    color.rgb = baseColor.rgb;\n  }\n  else{\n    // Metallic and Roughness material properties are packed together\n    // In glTF, these factors can be specified by fixed scalar values\n    // or from a metallic-roughness map\n    float perceptualRoughness = u_MetallicRoughnessValues.y;\n    float metallic = u_MetallicRoughnessValues.x;\n#ifdef HAS_METALROUGHNESSMAP\n    // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.\n    // This layout intentionally reserves the 'r' channel for (optional) occlusion map data\n    vec4 mrSample = texture(u_MetallicRoughnessSampler, pbr_vUV);\n    perceptualRoughness = mrSample.g * perceptualRoughness;\n    metallic = mrSample.b * metallic;\n#endif\n    perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);\n    metallic = clamp(metallic, 0.0, 1.0);\n    // Roughness is authored as perceptual roughness; as is convention,\n    // convert to material roughness by squaring the perceptual roughness [2].\n    float alphaRoughness = perceptualRoughness * perceptualRoughness;\n\n    vec3 f0 = vec3(0.04);\n    vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - f0);\n    diffuseColor *= 1.0 - metallic;\n    vec3 specularColor = mix(f0, baseColor.rgb, metallic);\n\n    // Compute reflectance.\n    float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);\n\n    // For typical incident reflectance range (between 4% to 100%) set the grazing\n    // reflectance to 100% for typical fresnel effect.\n    // For very low reflectance range on highly diffuse objects (below 4%),\n    // incrementally reduce grazing reflecance to 0%.\n    float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);\n    vec3 specularEnvironmentR0 = specularColor.rgb;\n    vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;\n\n    vec3 n = getNormal();                          // normal at surface point\n    vec3 v = normalize(u_Camera - pbr_vPosition);  // Vector from surface point to camera\n\n    float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);\n    vec3 reflection = -normalize(reflect(v, n));\n\n    PBRInfo pbrInputs = PBRInfo(\n      0.0, // NdotL\n      NdotV,\n      0.0, // NdotH\n      0.0, // LdotH\n      0.0, // VdotH\n      perceptualRoughness,\n      metallic,\n      specularEnvironmentR0,\n      specularEnvironmentR90,\n      alphaRoughness,\n      diffuseColor,\n      specularColor,\n      n,\n      v\n    );\n\n#ifdef USE_LIGHTS\n    // Apply ambient light\n    PBRInfo_setAmbientLight(pbrInputs);\n    color += calculateFinalColor(pbrInputs, lighting_uAmbientLight.color);\n\n    // Apply directional light\n    for(int i = 0; i < lighting_uDirectionalLightCount; i++) {\n      if (i < lighting_uDirectionalLightCount) {\n        PBRInfo_setDirectionalLight(pbrInputs, lighting_uDirectionalLight[i].direction);\n        color += calculateFinalColor(pbrInputs, lighting_uDirectionalLight[i].color);\n      }\n    }\n\n    // Apply point light\n    for(int i = 0; i < lighting_uPointLightCount; i++) {\n      if (i < lighting_uPointLightCount) {\n        PBRInfo_setPointLight(pbrInputs, lighting_uPointLight[i]);\n        float attenuation = getPointLightAttenuation(lighting_uPointLight[i], distance(lighting_uPointLight[i].position, pbr_vPosition));\n        color += calculateFinalColor(pbrInputs, lighting_uPointLight[i].color / attenuation);\n      }\n    }\n#endif\n\n    // Calculate lighting contribution from image based lighting source (IBL)\n#ifdef USE_IBL\n    color += getIBLContribution(pbrInputs, n, reflection);\n#endif\n\n    // Apply optional PBR terms for additional (optional) shading\n#ifdef HAS_OCCLUSIONMAP\n    float ao = texture(u_OcclusionSampler, pbr_vUV).r;\n    color = mix(color, color * ao, u_OcclusionStrength);\n#endif\n\n#ifdef HAS_EMISSIVEMAP\n    vec3 emissive = SRGBtoLINEAR(texture(u_EmissiveSampler, pbr_vUV)).rgb * u_EmissiveFactor;\n    color += emissive;\n#endif\n\n    // This section uses mix to override final color for reference app visualization\n    // of various parameters in the lighting equation.\n#ifdef PBR_DEBUG\n    // TODO: Figure out how to debug multiple lights\n\n    // color = mix(color, F, u_ScaleFGDSpec.x);\n    // color = mix(color, vec3(G), u_ScaleFGDSpec.y);\n    // color = mix(color, vec3(D), u_ScaleFGDSpec.z);\n    // color = mix(color, specContrib, u_ScaleFGDSpec.w);\n\n    // color = mix(color, diffuseContrib, u_ScaleDiffBaseMR.x);\n    color = mix(color, baseColor.rgb, u_ScaleDiffBaseMR.y);\n    color = mix(color, vec3(metallic), u_ScaleDiffBaseMR.z);\n    color = mix(color, vec3(perceptualRoughness), u_ScaleDiffBaseMR.w);\n#endif\n\n  }\n\n  return vec4(pow(color,vec3(1.0/2.2)), baseColor.a);\n}\n";
-//# sourceMappingURL=pbr-fragment-glsl.d.ts.map

package/dist/modules-webgl1/lighting/pbr/pbr-fragment-glsl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pbr-fragment-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules-webgl1/lighting/pbr/pbr-fragment-glsl.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,EAAE,+rbA8Xd,CAAC"}