@onerjs/addons 8.25.3 → 8.25.5

package/atmosphere/atmospherePBRMaterialPlugin.js

@@ -0,0 +1,230 @@
+// Copyright (c) Microsoft Corporation.
+// MIT License
+import { MaterialDefines } from "@onerjs/core/Materials/materialDefines.js";
+import { MaterialPluginBase } from "@onerjs/core/Materials/materialPluginBase.js";
+class AtmospherePBRMaterialDefines extends MaterialDefines {
+    /**
+     * Constructs the {@link AtmospherePBRMaterialDefines}.
+     * @param useAerialPerspectiveLut - Whether to use the aerial perspective LUT.
+     */
+    constructor(useAerialPerspectiveLut) {
+        super();
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        this.APPLY_AERIAL_PERSPECTIVE_INTENSITY = false;
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        this.APPLY_AERIAL_PERSPECTIVE_RADIANCE_BIAS = false;
+        this.USE_AERIAL_PERSPECTIVE_LUT = useAerialPerspectiveLut;
+    }
+}
+const UboArray = [{ name: "inverseViewportSize", size: 2, type: "vec2" }];
+const MakeUniforms = (atmosphere) => ({
+    ubo: UboArray,
+    fragment: "uniform vec2 inverseViewportSize;\n",
+    externalUniforms: atmosphere.uniformBuffer.getUniformNames(),
+});
+const PluginName = "AtmospherePBRMaterialPlugin";
+const PluginPriority = 600;
+/**
+ * Adds shading logic to a PBRMaterial that provides radiance, diffuse sky irradiance, and aerial perspective from the atmosphere.
+ */
+export class AtmospherePBRMaterialPlugin extends MaterialPluginBase {
+    /**
+     * Constructs the {@link AtmospherePBRMaterialPlugin}.
+     * @param material - The material to apply the plugin to.
+     * @param _atmosphere - The atmosphere to use for shading.
+     * @param _isAerialPerspectiveEnabled - Whether to apply aerial perspective.
+     */
+    constructor(material, _atmosphere, _isAerialPerspectiveEnabled = false) {
+        super(material, PluginName, PluginPriority, {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            USE_CUSTOM_REFLECTION: _atmosphere.diffuseSkyIrradianceLut !== null,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            CUSTOM_FRAGMENT_BEFORE_FOG: _isAerialPerspectiveEnabled,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            USE_AERIAL_PERSPECTIVE_LUT: _isAerialPerspectiveEnabled && _atmosphere.isAerialPerspectiveLutEnabled,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            APPLY_AERIAL_PERSPECTIVE_INTENSITY: _isAerialPerspectiveEnabled && _atmosphere.aerialPerspectiveIntensity !== 1.0,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            APPLY_AERIAL_PERSPECTIVE_RADIANCE_BIAS: _isAerialPerspectiveEnabled && _atmosphere.aerialPerspectiveRadianceBias !== 0.0,
+        }, false, // addPluginToList -- false because we need to control when this is added to the list
+        true, // enable
+        true // resolveIncludes
+        );
+        this._atmosphere = _atmosphere;
+        this._isAerialPerspectiveEnabled = _isAerialPerspectiveEnabled;
+        this.doNotSerialize = true;
+        // This calls `getCode` so we need to do this after having initialized the class fields.
+        this._pluginManager._addPlugin(this);
+    }
+    /**
+     * @override
+     */
+    getUniformBuffersNames(_ubos) {
+        const uniformBuffer = this._atmosphere.uniformBuffer;
+        if (uniformBuffer.useUbo) {
+            _ubos.push(uniformBuffer.name);
+        }
+    }
+    /**
+     * @override
+     */
+    getUniforms() {
+        return MakeUniforms(this._atmosphere);
+    }
+    /**
+     * @override
+     */
+    isReadyForSubMesh() {
+        let isReady = true;
+        const atmosphere = this._atmosphere;
+        if (this._isAerialPerspectiveEnabled && atmosphere.isAerialPerspectiveLutEnabled) {
+            const aerialPerspectiveLutRenderTarget = atmosphere.aerialPerspectiveLutRenderTarget;
+            isReady = isReady && !!aerialPerspectiveLutRenderTarget?.isReady();
+        }
+        const transmittanceLutRenderTarget = atmosphere.transmittanceLut?.renderTarget ?? null;
+        isReady = isReady && !!transmittanceLutRenderTarget?.isReady();
+        return isReady;
+    }
+    /**
+     * @override
+     */
+    getActiveTextures(_activeTextures) {
+        const atmosphere = this._atmosphere;
+        if (this._isAerialPerspectiveEnabled && atmosphere.isAerialPerspectiveLutEnabled) {
+            const aerialPerspectiveLutRenderTarget = atmosphere.aerialPerspectiveLutRenderTarget;
+            if (aerialPerspectiveLutRenderTarget) {
+                _activeTextures.push(aerialPerspectiveLutRenderTarget);
+            }
+        }
+        const transmittanceLutRenderTarget = atmosphere.transmittanceLut?.renderTarget ?? null;
+        if (transmittanceLutRenderTarget) {
+            _activeTextures.push(transmittanceLutRenderTarget);
+        }
+    }
+    /**
+     * @override
+     */
+    bindForSubMesh(uniformBuffer) {
+        const atmosphere = this._atmosphere;
+        const engine = atmosphere.scene.getEngine();
+        // Bind the atmosphere's uniform buffer to the effect.
+        const effect = uniformBuffer.currentEffect;
+        if (effect) {
+            this._atmosphere.bindUniformBufferToEffect(effect);
+        }
+        const width = engine.getRenderWidth();
+        const height = engine.getRenderHeight();
+        uniformBuffer.updateFloat2("inverseViewportSize", 1.0 / width, 1.0 / height);
+        if (this._isAerialPerspectiveEnabled && atmosphere.isAerialPerspectiveLutEnabled) {
+            const aerialPerspectiveLutRenderTarget = atmosphere.aerialPerspectiveLutRenderTarget;
+            uniformBuffer.setTexture("aerialPerspectiveLut", aerialPerspectiveLutRenderTarget);
+        }
+        const transmittanceLutRenderTarget = atmosphere.transmittanceLut?.renderTarget ?? null;
+        uniformBuffer.setTexture("transmittanceLut", transmittanceLutRenderTarget);
+    }
+    /**
+     * @override
+     */
+    prepareDefines(defines) {
+        const lastUseAerialPerspectiveLut = defines.USE_AERIAL_PERSPECTIVE_LUT;
+        const lastApplyAerialPerspectiveIntensity = defines.APPLY_AERIAL_PERSPECTIVE_INTENSITY;
+        const lastApplyAerialPerspectiveRadianceBias = defines.APPLY_AERIAL_PERSPECTIVE_RADIANCE_BIAS;
+        defines.USE_AERIAL_PERSPECTIVE_LUT = this._isAerialPerspectiveEnabled && this._atmosphere.isAerialPerspectiveLutEnabled;
+        defines.APPLY_AERIAL_PERSPECTIVE_INTENSITY = this._isAerialPerspectiveEnabled && this._atmosphere.aerialPerspectiveIntensity !== 1.0;
+        defines.APPLY_AERIAL_PERSPECTIVE_RADIANCE_BIAS = this._isAerialPerspectiveEnabled && this._atmosphere.aerialPerspectiveRadianceBias !== 0.0;
+        if (lastUseAerialPerspectiveLut !== defines.USE_AERIAL_PERSPECTIVE_LUT ||
+            lastApplyAerialPerspectiveIntensity !== defines.APPLY_AERIAL_PERSPECTIVE_INTENSITY ||
+            lastApplyAerialPerspectiveRadianceBias !== defines.APPLY_AERIAL_PERSPECTIVE_RADIANCE_BIAS) {
+            defines.markAllAsDirty();
+        }
+    }
+    /**
+     * @override
+     */
+    getSamplers(samplers) {
+        samplers.push("transmittanceLut");
+        if (this._isAerialPerspectiveEnabled && this._atmosphere.isAerialPerspectiveLutEnabled) {
+            samplers.push("aerialPerspectiveLut");
+        }
+    }
+    /**
+     * @override
+     */
+    getCustomCode(shaderType) {
+        // Assumed inputs are light0, vPositionW, normalW.
+        // Only works for directional lights.
+        if (shaderType !== "fragment") {
+            return null;
+        }
+        const useUbo = this._atmosphere.scene.getEngine().supportsUniformBuffers;
+        const directionToLightSnippet = useUbo ? "-light0.vLightData.xyz" : "-vLightData0.xyz";
+        const useAtmosphereUbo = this._atmosphere.uniformBuffer.useUbo;
+        const atmosphereImportSnippet = useAtmosphereUbo ? "#include<atmosphereUboDeclaration>" : "#include<atmosphereFragmentDeclaration>";
+        return {
+            CUSTOM_FRAGMENT_DEFINITIONS: this._isAerialPerspectiveEnabled && this._atmosphere.isAerialPerspectiveLutEnabled
+                ? `uniform sampler2D transmittanceLut;\r\nprecision highp sampler2DArray;\r\nuniform sampler2DArray aerialPerspectiveLut;\r\n${atmosphereImportSnippet}\r\n#include<atmosphereFunctions>`
+                : `uniform sampler2D transmittanceLut;\r\n${atmosphereImportSnippet}\r\n#include<atmosphereFunctions>`,
+            CUSTOM_LIGHT0_COLOR: `
+            {
+                vec3 positionGlobal = 0.001 * vPositionW + vec3(0., planetRadius, 0.);
+                float positionRadius = length(positionGlobal);
+                vec3 geocentricNormal = positionGlobal / positionRadius;
+                vec3 directionToLight = ${directionToLightSnippet};
+                float cosAngleLightToZenith = dot(directionToLight, geocentricNormal);
+                diffuse0 = lightIntensity * sampleTransmittanceLut(transmittanceLut, positionRadius, cosAngleLightToZenith);
+            }
+`,
+            CUSTOM_REFLECTION: `
+            {
+                vec3 positionGlobal =  0.001 * vPositionW + vec3(0., planetRadius, 0.);
+                float positionRadius = length(positionGlobal);
+                vec3 geocentricNormal = positionGlobal / positionRadius;
+
+                vec3 directionToLight = ${directionToLightSnippet};
+                float cosAngleLightToZenith = dot(directionToLight, geocentricNormal);
+
+                vec2 uv = vec2(0.5 + 0.5 * cosAngleLightToZenith, (positionRadius - planetRadius) / atmosphereThickness);
+                float irradianceScaleT = 0.5 * dot(normalW, geocentricNormal) + 0.5;
+                float irradianceScale = ((-0.6652 * irradianceScaleT) + 1.5927) * irradianceScaleT + 0.1023;
+                vec3 environmentIrradiance = lightIntensity * sampleReflection(irradianceSampler, uv).rgb;
+
+                // Add a contribution here to estimate indirect lighting.
+                const float r = 0.2;
+                float indirect = getLuminance(environmentIrradiance) / max(0.00001, 1. - r);
+                environmentIrradiance *= irradianceScale;
+                environmentIrradiance += indirect;
+
+                environmentIrradiance += additionalDiffuseSkyIrradiance;
+
+                const float diffuseBrdf = 1. / PI;
+                environmentIrradiance *= diffuseBrdf * diffuseSkyIrradianceIntensity;
+
+                reflectionOut.environmentIrradiance = environmentIrradiance;
+                reflectionOut.environmentRadiance.rgb = reflectionOut.environmentIrradiance;
+            }
+`,
+            // TODO: Support full ray marching if USE_AERIAL_PERSPECTIVE_LUT is disabled.
+            CUSTOM_FRAGMENT_BEFORE_FOG: `
+            #if USE_AERIAL_PERSPECTIVE_LUT
+            {
+                vec3 positionGlobal = 0.001 * vPositionW + vec3(0., planetRadius, 0.);
+                float distanceFromCamera = distance(positionGlobal, cameraPositionGlobal);
+
+                vec4 aerialPerspective = vec4(0.);
+                if (sampleAerialPerspectiveLut(
+                        gl_FragCoord.xy * inverseViewportSize,
+                        true,
+                        distanceFromCamera,
+                        NumAerialPerspectiveLutLayers,
+                        AerialPerspectiveLutKMPerSlice,
+                        AerialPerspectiveLutRangeKM,
+                        aerialPerspective)) {
+                    finalColor = aerialPerspective + (1. - aerialPerspective.a) * finalColor;
+                }
+            }
+            #endif
+`,
+        };
+    }
+}
+//# sourceMappingURL=atmospherePBRMaterialPlugin.js.map

package/atmosphere/atmospherePBRMaterialPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"atmospherePBRMaterialPlugin.js","sourceRoot":"","sources":["../../../../dev/addons/src/atmosphere/atmospherePBRMaterialPlugin.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) Microsoft Corporation.\r\n// MIT License\r\n\r\nimport type { Atmosphere } from \"./atmosphere\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport type { Material } from \"core/Materials/material\";\r\nimport { MaterialDefines } from \"core/Materials/materialDefines\";\r\nimport { MaterialPluginBase } from \"core/Materials/materialPluginBase\";\r\nimport type { Nullable } from \"core/types\";\r\nimport type { UniformBuffer } from \"core/Materials/uniformBuffer\";\r\n\r\nclass AtmospherePBRMaterialDefines extends MaterialDefines {\r\n    // eslint-disable-next-line @typescript-eslint/naming-convention\r\n    public USE_AERIAL_PERSPECTIVE_LUT: boolean;\r\n    // eslint-disable-next-line @typescript-eslint/naming-convention\r\n    public APPLY_AERIAL_PERSPECTIVE_INTENSITY = false;\r\n    // eslint-disable-next-line @typescript-eslint/naming-convention\r\n    public APPLY_AERIAL_PERSPECTIVE_RADIANCE_BIAS = false;\r\n\r\n    /**\r\n     * Constructs the {@link AtmospherePBRMaterialDefines}.\r\n     * @param useAerialPerspectiveLut - Whether to use the aerial perspective LUT.\r\n     */\r\n    constructor(useAerialPerspectiveLut: boolean) {\r\n        super();\r\n        this.USE_AERIAL_PERSPECTIVE_LUT = useAerialPerspectiveLut;\r\n    }\r\n}\r\n\r\nconst UboArray = [{ name: \"inverseViewportSize\", size: 2, type: \"vec2\" }];\r\nconst MakeUniforms = (atmosphere: Atmosphere) => ({\r\n    ubo: UboArray,\r\n    fragment: \"uniform vec2 inverseViewportSize;\\n\",\r\n    externalUniforms: atmosphere.uniformBuffer.getUniformNames(),\r\n});\r\n\r\nconst PluginName = \"AtmospherePBRMaterialPlugin\";\r\nconst PluginPriority = 600;\r\n\r\n/**\r\n * Adds shading logic to a PBRMaterial that provides radiance, diffuse sky irradiance, and aerial perspective from the atmosphere.\r\n */\r\nexport class AtmospherePBRMaterialPlugin extends MaterialPluginBase {\r\n    /**\r\n     * Constructs the {@link AtmospherePBRMaterialPlugin}.\r\n     * @param material - The material to apply the plugin to.\r\n     * @param _atmosphere - The atmosphere to use for shading.\r\n     * @param _isAerialPerspectiveEnabled - Whether to apply aerial perspective.\r\n     */\r\n    constructor(\r\n        material: Material,\r\n        private readonly _atmosphere: Atmosphere,\r\n        private readonly _isAerialPerspectiveEnabled = false\r\n    ) {\r\n        super(\r\n            material,\r\n            PluginName,\r\n            PluginPriority,\r\n            {\r\n                // eslint-disable-next-line @typescript-eslint/naming-convention\r\n                USE_CUSTOM_REFLECTION: _atmosphere.diffuseSkyIrradianceLut !== null,\r\n                // eslint-disable-next-line @typescript-eslint/naming-convention\r\n                CUSTOM_FRAGMENT_BEFORE_FOG: _isAerialPerspectiveEnabled,\r\n                // eslint-disable-next-line @typescript-eslint/naming-convention\r\n                USE_AERIAL_PERSPECTIVE_LUT: _isAerialPerspectiveEnabled && _atmosphere.isAerialPerspectiveLutEnabled,\r\n                // eslint-disable-next-line @typescript-eslint/naming-convention\r\n                APPLY_AERIAL_PERSPECTIVE_INTENSITY: _isAerialPerspectiveEnabled && _atmosphere.aerialPerspectiveIntensity !== 1.0,\r\n                // eslint-disable-next-line @typescript-eslint/naming-convention\r\n                APPLY_AERIAL_PERSPECTIVE_RADIANCE_BIAS: _isAerialPerspectiveEnabled && _atmosphere.aerialPerspectiveRadianceBias !== 0.0,\r\n            },\r\n            false, // addPluginToList -- false because we need to control when this is added to the list\r\n            true, // enable\r\n            true // resolveIncludes\r\n        );\r\n\r\n        this.doNotSerialize = true;\r\n\r\n        // This calls `getCode` so we need to do this after having initialized the class fields.\r\n        this._pluginManager._addPlugin(this);\r\n    }\r\n\r\n    /**\r\n     * @override\r\n     */\r\n    public override getUniformBuffersNames(_ubos: string[]): void {\r\n        const uniformBuffer = this._atmosphere.uniformBuffer;\r\n        if (uniformBuffer.useUbo) {\r\n            _ubos.push(uniformBuffer.name);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @override\r\n     */\r\n    public override getUniforms() {\r\n        return MakeUniforms(this._atmosphere);\r\n    }\r\n\r\n    /**\r\n     * @override\r\n     */\r\n    public override isReadyForSubMesh(): boolean {\r\n        let isReady = true;\r\n        const atmosphere = this._atmosphere;\r\n        if (this._isAerialPerspectiveEnabled && atmosphere.isAerialPerspectiveLutEnabled) {\r\n            const aerialPerspectiveLutRenderTarget = atmosphere.aerialPerspectiveLutRenderTarget;\r\n            isReady = isReady && !!aerialPerspectiveLutRenderTarget?.isReady();\r\n        }\r\n        const transmittanceLutRenderTarget = atmosphere.transmittanceLut?.renderTarget ?? null;\r\n        isReady = isReady && !!transmittanceLutRenderTarget?.isReady();\r\n        return isReady;\r\n    }\r\n\r\n    /**\r\n     * @override\r\n     */\r\n    public override getActiveTextures(_activeTextures: BaseTexture[]): void {\r\n        const atmosphere = this._atmosphere;\r\n        if (this._isAerialPerspectiveEnabled && atmosphere.isAerialPerspectiveLutEnabled) {\r\n            const aerialPerspectiveLutRenderTarget = atmosphere.aerialPerspectiveLutRenderTarget;\r\n            if (aerialPerspectiveLutRenderTarget) {\r\n                _activeTextures.push(aerialPerspectiveLutRenderTarget);\r\n            }\r\n        }\r\n\r\n        const transmittanceLutRenderTarget = atmosphere.transmittanceLut?.renderTarget ?? null;\r\n        if (transmittanceLutRenderTarget) {\r\n            _activeTextures.push(transmittanceLutRenderTarget);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @override\r\n     */\r\n    public override bindForSubMesh(uniformBuffer: UniformBuffer): void {\r\n        const atmosphere = this._atmosphere;\r\n        const engine = atmosphere.scene.getEngine();\r\n\r\n        // Bind the atmosphere's uniform buffer to the effect.\r\n        const effect = uniformBuffer.currentEffect;\r\n        if (effect) {\r\n            this._atmosphere.bindUniformBufferToEffect(effect);\r\n        }\r\n\r\n        const width = engine.getRenderWidth();\r\n        const height = engine.getRenderHeight();\r\n        uniformBuffer.updateFloat2(\"inverseViewportSize\", 1.0 / width, 1.0 / height);\r\n\r\n        if (this._isAerialPerspectiveEnabled && atmosphere.isAerialPerspectiveLutEnabled) {\r\n            const aerialPerspectiveLutRenderTarget = atmosphere.aerialPerspectiveLutRenderTarget;\r\n            uniformBuffer.setTexture(\"aerialPerspectiveLut\", aerialPerspectiveLutRenderTarget);\r\n        }\r\n        const transmittanceLutRenderTarget = atmosphere.transmittanceLut?.renderTarget ?? null;\r\n        uniformBuffer.setTexture(\"transmittanceLut\", transmittanceLutRenderTarget);\r\n    }\r\n\r\n    /**\r\n     * @override\r\n     */\r\n    public override prepareDefines(defines: AtmospherePBRMaterialDefines): void {\r\n        const lastUseAerialPerspectiveLut = defines.USE_AERIAL_PERSPECTIVE_LUT;\r\n        const lastApplyAerialPerspectiveIntensity = defines.APPLY_AERIAL_PERSPECTIVE_INTENSITY;\r\n        const lastApplyAerialPerspectiveRadianceBias = defines.APPLY_AERIAL_PERSPECTIVE_RADIANCE_BIAS;\r\n        defines.USE_AERIAL_PERSPECTIVE_LUT = this._isAerialPerspectiveEnabled && this._atmosphere.isAerialPerspectiveLutEnabled;\r\n        defines.APPLY_AERIAL_PERSPECTIVE_INTENSITY = this._isAerialPerspectiveEnabled && this._atmosphere.aerialPerspectiveIntensity !== 1.0;\r\n        defines.APPLY_AERIAL_PERSPECTIVE_RADIANCE_BIAS = this._isAerialPerspectiveEnabled && this._atmosphere.aerialPerspectiveRadianceBias !== 0.0;\r\n        if (\r\n            lastUseAerialPerspectiveLut !== defines.USE_AERIAL_PERSPECTIVE_LUT ||\r\n            lastApplyAerialPerspectiveIntensity !== defines.APPLY_AERIAL_PERSPECTIVE_INTENSITY ||\r\n            lastApplyAerialPerspectiveRadianceBias !== defines.APPLY_AERIAL_PERSPECTIVE_RADIANCE_BIAS\r\n        ) {\r\n            defines.markAllAsDirty();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @override\r\n     */\r\n    public override getSamplers(samplers: string[]): void {\r\n        samplers.push(\"transmittanceLut\");\r\n        if (this._isAerialPerspectiveEnabled && this._atmosphere.isAerialPerspectiveLutEnabled) {\r\n            samplers.push(\"aerialPerspectiveLut\");\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @override\r\n     */\r\n    public override getCustomCode(shaderType: string): Nullable<Record<string, string>> {\r\n        // Assumed inputs are light0, vPositionW, normalW.\r\n        // Only works for directional lights.\r\n        if (shaderType !== \"fragment\") {\r\n            return null;\r\n        }\r\n\r\n        const useUbo = this._atmosphere.scene.getEngine().supportsUniformBuffers;\r\n        const directionToLightSnippet = useUbo ? \"-light0.vLightData.xyz\" : \"-vLightData0.xyz\";\r\n\r\n        const useAtmosphereUbo = this._atmosphere.uniformBuffer.useUbo;\r\n        const atmosphereImportSnippet = useAtmosphereUbo ? \"#include<atmosphereUboDeclaration>\" : \"#include<atmosphereFragmentDeclaration>\";\r\n\r\n        return {\r\n            CUSTOM_FRAGMENT_DEFINITIONS:\r\n                this._isAerialPerspectiveEnabled && this._atmosphere.isAerialPerspectiveLutEnabled\r\n                    ? `uniform sampler2D transmittanceLut;\\r\\nprecision highp sampler2DArray;\\r\\nuniform sampler2DArray aerialPerspectiveLut;\\r\\n${atmosphereImportSnippet}\\r\\n#include<atmosphereFunctions>`\r\n                    : `uniform sampler2D transmittanceLut;\\r\\n${atmosphereImportSnippet}\\r\\n#include<atmosphereFunctions>`,\r\n            CUSTOM_LIGHT0_COLOR: `\r\n            {\r\n                vec3 positionGlobal = 0.001 * vPositionW + vec3(0., planetRadius, 0.);\r\n                float positionRadius = length(positionGlobal);\r\n                vec3 geocentricNormal = positionGlobal / positionRadius;\r\n                vec3 directionToLight = ${directionToLightSnippet};\r\n                float cosAngleLightToZenith = dot(directionToLight, geocentricNormal);\r\n                diffuse0 = lightIntensity * sampleTransmittanceLut(transmittanceLut, positionRadius, cosAngleLightToZenith);\r\n            }\r\n`,\r\n            CUSTOM_REFLECTION: `\r\n            {\r\n                vec3 positionGlobal =  0.001 * vPositionW + vec3(0., planetRadius, 0.);\r\n                float positionRadius = length(positionGlobal);\r\n                vec3 geocentricNormal = positionGlobal / positionRadius;\r\n\r\n                vec3 directionToLight = ${directionToLightSnippet};\r\n                float cosAngleLightToZenith = dot(directionToLight, geocentricNormal);\r\n\r\n                vec2 uv = vec2(0.5 + 0.5 * cosAngleLightToZenith, (positionRadius - planetRadius) / atmosphereThickness);\r\n                float irradianceScaleT = 0.5 * dot(normalW, geocentricNormal) + 0.5;\r\n                float irradianceScale = ((-0.6652 * irradianceScaleT) + 1.5927) * irradianceScaleT + 0.1023;\r\n                vec3 environmentIrradiance = lightIntensity * sampleReflection(irradianceSampler, uv).rgb;\r\n\r\n                // Add a contribution here to estimate indirect lighting.\r\n                const float r = 0.2;\r\n                float indirect = getLuminance(environmentIrradiance) / max(0.00001, 1. - r);\r\n                environmentIrradiance *= irradianceScale;\r\n                environmentIrradiance += indirect;\r\n\r\n                environmentIrradiance += additionalDiffuseSkyIrradiance;\r\n\r\n                const float diffuseBrdf = 1. / PI;\r\n                environmentIrradiance *= diffuseBrdf * diffuseSkyIrradianceIntensity;\r\n\r\n                reflectionOut.environmentIrradiance = environmentIrradiance;\r\n                reflectionOut.environmentRadiance.rgb = reflectionOut.environmentIrradiance;\r\n            }\r\n`,\r\n            // TODO: Support full ray marching if USE_AERIAL_PERSPECTIVE_LUT is disabled.\r\n            CUSTOM_FRAGMENT_BEFORE_FOG: `\r\n            #if USE_AERIAL_PERSPECTIVE_LUT\r\n            {\r\n                vec3 positionGlobal = 0.001 * vPositionW + vec3(0., planetRadius, 0.);\r\n                float distanceFromCamera = distance(positionGlobal, cameraPositionGlobal);\r\n\r\n                vec4 aerialPerspective = vec4(0.);\r\n                if (sampleAerialPerspectiveLut(\r\n                        gl_FragCoord.xy * inverseViewportSize,\r\n                        true,\r\n                        distanceFromCamera,\r\n                        NumAerialPerspectiveLutLayers,\r\n                        AerialPerspectiveLutKMPerSlice,\r\n                        AerialPerspectiveLutRangeKM,\r\n                        aerialPerspective)) {\r\n                    finalColor = aerialPerspective + (1. - aerialPerspective.a) * finalColor;\r\n                }\r\n            }\r\n            #endif\r\n`,\r\n        };\r\n    }\r\n}\r\n"]}

package/atmosphere/atmospherePerCameraVariables.d.ts

@@ -0,0 +1,102 @@
+import type { Camera } from "@onerjs/core/Cameras/camera.js";
+import type { IMatrixLike, IVector3Like, IVector4Like } from "@onerjs/core/Maths/math.like.js";
+/**
+ * Variables that are used to render the atmosphere and are computed per-camera.
+ */
+export declare class AtmospherePerCameraVariables {
+    private _inverseViewProjectionMatrixWithoutTranslation;
+    private _directionToLightRelativeToCameraGeocentricNormal;
+    private _cosAngleLightToZenith;
+    private _cameraRadius;
+    private _clampedCameraRadius;
+    private _cameraHeight;
+    private _clampedCameraHeight;
+    private _cameraPositionGlobal;
+    private _clampedCameraPositionGlobal;
+    private _cosCameraHorizonAngleFromZenith;
+    private _sinCameraAtmosphereHorizonAngleFromNadir;
+    private _cameraGeocentricNormal;
+    private _cameraForward;
+    private _cameraNearPlane;
+    private _cameraPosition;
+    private _viewport;
+    private _lastViewMatrix;
+    private _lastProjectionMatrix;
+    private _inverseViewMatrixWithoutTranslation;
+    private _inverseProjectionMatrix;
+    /**
+     * The inverse view projection matrix is used to unproject rays.
+     * To avoid precision issues, the translation part of the matrix has been removed.
+     */
+    get inverseViewProjectionMatrixWithoutTranslation(): IMatrixLike;
+    /**
+     * The direction to the light relative to the geocentric normal under the camera.
+     */
+    get directionToLightRelativeToCameraGeocentricNormal(): IVector3Like;
+    /**
+     * The cosine of the angle between the light direction and zenith.
+     */
+    get cosAngleLightToZenith(): number;
+    /**
+     * The distance from the camera to the planet origin in kilometers.
+     */
+    get cameraRadius(): number;
+    /**
+     * The distance from the camera to the planet origin, clamped to the planet radius offset, in kilometers.
+     */
+    get clampedCameraRadius(): number;
+    /**
+     * The height of the camera above the planet surface in kilometers.
+     */
+    get cameraHeight(): number;
+    /**
+     * The height of the camera above the planet surface, clamped to the planet radius offset, in kilometers.
+     */
+    get clampedCameraHeight(): number;
+    /**
+     * The camera position in global space kilometers.
+     */
+    get cameraPositionGlobal(): IVector3Like;
+    /**
+     * The camera position, clamped to the planet radius offset, in global space kilometers.
+     */
+    get clampedCameraPositionGlobal(): IVector3Like;
+    /**
+     * The cosine of the angle from the zenith to the horizon of the planet, measured from the camera position.
+     */
+    get cosCameraHorizonAngleFromZenith(): number;
+    /**
+     * The sine of the angle from the nadir to the horizon of the atmosphere, measured from the camera position.
+     */
+    get sinCameraAtmosphereHorizonAngleFromNadir(): number;
+    /**
+     * The geocentric normal of the camera in global space i.e., the normalization of {@link cameraPositionGlobal}.
+     */
+    get cameraGeocentricNormal(): IVector3Like;
+    /**
+     * The camera's forward direction in world space.
+     */
+    get cameraForward(): IVector3Like;
+    /**
+     * The distance to the near plane of the camera.
+     */
+    get cameraNearPlane(): number;
+    /**
+     * The camera's position in world space.
+     */
+    get cameraPosition(): IVector3Like;
+    /**
+     * The viewport for the camera.
+     */
+    get viewport(): IVector4Like;
+    /**
+     * Updates the variables.
+     * @param camera - The camera to update the variables for.
+     * @param planetRadius - The radius of the planet in kilometers.
+     * @param planetRadiusWithOffset - The radius of the planet with the offset in kilometers.
+     * @param atmosphereRadius - The radius of the atmosphere in kilometers.
+     * @param directionToLight - The direction to the light in world space.
+     * @param originHeight - The height of the origin (distance from planet's surface) in kilometers.
+     */
+    update(camera: Camera, planetRadius: number, planetRadiusWithOffset: number, atmosphereRadius: number, directionToLight: IVector3Like, originHeight: number): void;
+}

package/atmosphere/atmospherePerCameraVariables.js

@@ -0,0 +1,189 @@
+// Copyright (c) Microsoft Corporation.
+// MIT License
+import { Matrix, Vector3, Vector4 } from "@onerjs/core/Maths/math.vector.js";
+import { Ray } from "@onerjs/core/Culling/ray.core.js";
+import { Vector3Dot } from "@onerjs/core/Maths/math.vector.functions.js";
+const TempRay = new Ray(Vector3.Zero(), Vector3.Zero());
+/**
+ * Variables that are used to render the atmosphere and are computed per-camera.
+ */
+export class AtmospherePerCameraVariables {
+    constructor() {
+        this._inverseViewProjectionMatrixWithoutTranslation = Matrix.Identity();
+        this._directionToLightRelativeToCameraGeocentricNormal = Vector3.Up();
+        this._cosAngleLightToZenith = 0;
+        this._cameraRadius = 0;
+        this._clampedCameraRadius = 0;
+        this._cameraHeight = 0;
+        this._clampedCameraHeight = 0;
+        this._cameraPositionGlobal = new Vector3();
+        this._clampedCameraPositionGlobal = new Vector3();
+        this._cosCameraHorizonAngleFromZenith = 0;
+        this._sinCameraAtmosphereHorizonAngleFromNadir = 0;
+        this._cameraGeocentricNormal = Vector3.Up();
+        this._cameraForward = Vector3.Down();
+        this._cameraNearPlane = 0;
+        this._cameraPosition = new Vector3();
+        this._viewport = new Vector4();
+        this._lastViewMatrix = Matrix.Identity();
+        this._lastProjectionMatrix = Matrix.Identity();
+        this._inverseViewMatrixWithoutTranslation = Matrix.Identity();
+        this._inverseProjectionMatrix = Matrix.Identity();
+    }
+    /**
+     * The inverse view projection matrix is used to unproject rays.
+     * To avoid precision issues, the translation part of the matrix has been removed.
+     */
+    get inverseViewProjectionMatrixWithoutTranslation() {
+        return this._inverseViewProjectionMatrixWithoutTranslation;
+    }
+    /**
+     * The direction to the light relative to the geocentric normal under the camera.
+     */
+    get directionToLightRelativeToCameraGeocentricNormal() {
+        return this._directionToLightRelativeToCameraGeocentricNormal;
+    }
+    /**
+     * The cosine of the angle between the light direction and zenith.
+     */
+    get cosAngleLightToZenith() {
+        return this._cosAngleLightToZenith;
+    }
+    /**
+     * The distance from the camera to the planet origin in kilometers.
+     */
+    get cameraRadius() {
+        return this._cameraRadius;
+    }
+    /**
+     * The distance from the camera to the planet origin, clamped to the planet radius offset, in kilometers.
+     */
+    get clampedCameraRadius() {
+        return this._clampedCameraRadius;
+    }
+    /**
+     * The height of the camera above the planet surface in kilometers.
+     */
+    get cameraHeight() {
+        return this._cameraHeight;
+    }
+    /**
+     * The height of the camera above the planet surface, clamped to the planet radius offset, in kilometers.
+     */
+    get clampedCameraHeight() {
+        return this._clampedCameraHeight;
+    }
+    /**
+     * The camera position in global space kilometers.
+     */
+    get cameraPositionGlobal() {
+        return this._cameraPositionGlobal;
+    }
+    /**
+     * The camera position, clamped to the planet radius offset, in global space kilometers.
+     */
+    get clampedCameraPositionGlobal() {
+        return this._clampedCameraPositionGlobal;
+    }
+    /**
+     * The cosine of the angle from the zenith to the horizon of the planet, measured from the camera position.
+     */
+    get cosCameraHorizonAngleFromZenith() {
+        return this._cosCameraHorizonAngleFromZenith;
+    }
+    /**
+     * The sine of the angle from the nadir to the horizon of the atmosphere, measured from the camera position.
+     */
+    get sinCameraAtmosphereHorizonAngleFromNadir() {
+        return this._sinCameraAtmosphereHorizonAngleFromNadir;
+    }
+    /**
+     * The geocentric normal of the camera in global space i.e., the normalization of {@link cameraPositionGlobal}.
+     */
+    get cameraGeocentricNormal() {
+        return this._cameraGeocentricNormal;
+    }
+    /**
+     * The camera's forward direction in world space.
+     */
+    get cameraForward() {
+        return this._cameraForward;
+    }
+    /**
+     * The distance to the near plane of the camera.
+     */
+    get cameraNearPlane() {
+        return this._cameraNearPlane;
+    }
+    /**
+     * The camera's position in world space.
+     */
+    get cameraPosition() {
+        return this._cameraPosition;
+    }
+    /**
+     * The viewport for the camera.
+     */
+    get viewport() {
+        return this._viewport;
+    }
+    /**
+     * Updates the variables.
+     * @param camera - The camera to update the variables for.
+     * @param planetRadius - The radius of the planet in kilometers.
+     * @param planetRadiusWithOffset - The radius of the planet with the offset in kilometers.
+     * @param atmosphereRadius - The radius of the atmosphere in kilometers.
+     * @param directionToLight - The direction to the light in world space.
+     * @param originHeight - The height of the origin (distance from planet's surface) in kilometers.
+     */
+    update(camera, planetRadius, planetRadiusWithOffset, atmosphereRadius, directionToLight, originHeight) {
+        this._cameraNearPlane = camera.minZ;
+        this._cameraForward.copyFrom(camera.getForwardRayToRef(TempRay, 1).direction);
+        const engine = camera.getScene().getEngine();
+        this._viewport.copyFromFloats(0.0, 0.0, engine.getRenderWidth(), engine.getRenderHeight());
+        // Compute inverse view projection matrix, but remove the translational component to increase precision.
+        const viewMatrix = camera.getViewMatrix();
+        const projectionMatrix = camera.getProjectionMatrix();
+        if (!this._lastViewMatrix.equals(viewMatrix) || !this._lastProjectionMatrix.equals(projectionMatrix)) {
+            this._lastViewMatrix.copyFrom(viewMatrix);
+            this._lastViewMatrix.setTranslation(Vector3.ZeroReadOnly);
+            this._lastViewMatrix.invertToRef(this._inverseViewMatrixWithoutTranslation);
+            this._lastProjectionMatrix.copyFrom(projectionMatrix);
+            this._lastProjectionMatrix.invertToRef(this._inverseProjectionMatrix);
+            this._inverseProjectionMatrix.multiplyToRef(this._inverseViewMatrixWithoutTranslation, this._inverseViewProjectionMatrixWithoutTranslation);
+        }
+        // Compute the global space position of the camera in kilometers.
+        this._cameraPosition.copyFrom(camera.globalPosition);
+        this._cameraPosition.scaleToRef(1.0 / 1000.0, this._cameraPositionGlobal);
+        this._cameraPositionGlobal.y += planetRadius + originHeight;
+        this._cameraHeight = this._cameraPositionGlobal.y - planetRadius;
+        // Clamp the camera parameters.
+        this._cameraRadius = this._cameraPositionGlobal.length();
+        this._clampedCameraRadius = this._cameraRadius;
+        this._cameraPositionGlobal.normalizeToRef(this._cameraGeocentricNormal);
+        if (this._clampedCameraRadius < planetRadiusWithOffset) {
+            this._clampedCameraRadius = planetRadiusWithOffset;
+            this._cameraGeocentricNormal.scaleToRef(planetRadiusWithOffset, this._clampedCameraPositionGlobal);
+        }
+        else {
+            this._clampedCameraPositionGlobal.copyFrom(this._cameraPositionGlobal);
+        }
+        this._cosCameraHorizonAngleFromZenith = ComputeCosHorizonAngleFromZenith(planetRadius, this._clampedCameraRadius);
+        this._sinCameraAtmosphereHorizonAngleFromNadir = Math.min(1.0, atmosphereRadius / this._clampedCameraRadius);
+        this._clampedCameraHeight = this._clampedCameraRadius - planetRadius;
+        // Compute the direction to the light relative to the camera's geocentric normal.
+        {
+            this._cosAngleLightToZenith = Vector3Dot(directionToLight, this._cameraGeocentricNormal);
+            const lightZenithSinAngle = Math.sqrt(Math.max(0.0, 1.0 - this._cosAngleLightToZenith * this._cosAngleLightToZenith));
+            this._directionToLightRelativeToCameraGeocentricNormal.copyFromFloats(lightZenithSinAngle, this._cosAngleLightToZenith, 0.0);
+            this._directionToLightRelativeToCameraGeocentricNormal.normalize();
+        }
+    }
+}
+const ComputeCosHorizonAngleFromZenith = (planetRadius, radius) => {
+    const sinHorizonAngleFromNadir = Math.min(1, planetRadius / radius);
+    const cosHorizonAngleFromNadir = Math.sqrt(1 - sinHorizonAngleFromNadir * sinHorizonAngleFromNadir);
+    const cosHorizonAngleFromZenith = -cosHorizonAngleFromNadir;
+    return cosHorizonAngleFromZenith;
+};
+//# sourceMappingURL=atmospherePerCameraVariables.js.map

package/atmosphere/atmospherePerCameraVariables.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"atmospherePerCameraVariables.js","sourceRoot":"","sources":["../../../../dev/addons/src/atmosphere/atmospherePerCameraVariables.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) Microsoft Corporation.\r\n// MIT License\r\n\r\nimport type { Camera } from \"core/Cameras/camera\";\r\nimport type { IMatrixLike, IVector3Like, IVector4Like } from \"core/Maths/math.like\";\r\nimport { Matrix, Vector3, Vector4 } from \"core/Maths/math.vector\";\r\nimport { Ray } from \"core/Culling/ray.core\";\r\nimport { Vector3Dot } from \"core/Maths/math.vector.functions\";\r\n\r\nconst TempRay = new Ray(Vector3.Zero(), Vector3.Zero());\r\n\r\n/**\r\n * Variables that are used to render the atmosphere and are computed per-camera.\r\n */\r\nexport class AtmospherePerCameraVariables {\r\n    private _inverseViewProjectionMatrixWithoutTranslation = Matrix.Identity();\r\n    private _directionToLightRelativeToCameraGeocentricNormal = Vector3.Up();\r\n    private _cosAngleLightToZenith = 0;\r\n    private _cameraRadius = 0;\r\n    private _clampedCameraRadius = 0;\r\n    private _cameraHeight = 0;\r\n    private _clampedCameraHeight = 0;\r\n    private _cameraPositionGlobal = new Vector3();\r\n    private _clampedCameraPositionGlobal = new Vector3();\r\n    private _cosCameraHorizonAngleFromZenith = 0;\r\n    private _sinCameraAtmosphereHorizonAngleFromNadir = 0;\r\n    private _cameraGeocentricNormal = Vector3.Up();\r\n    private _cameraForward = Vector3.Down();\r\n    private _cameraNearPlane = 0;\r\n    private _cameraPosition = new Vector3();\r\n    private _viewport = new Vector4();\r\n    private _lastViewMatrix = Matrix.Identity();\r\n    private _lastProjectionMatrix = Matrix.Identity();\r\n    private _inverseViewMatrixWithoutTranslation = Matrix.Identity();\r\n    private _inverseProjectionMatrix = Matrix.Identity();\r\n\r\n    /**\r\n     * The inverse view projection matrix is used to unproject rays.\r\n     * To avoid precision issues, the translation part of the matrix has been removed.\r\n     */\r\n    public get inverseViewProjectionMatrixWithoutTranslation(): IMatrixLike {\r\n        return this._inverseViewProjectionMatrixWithoutTranslation;\r\n    }\r\n\r\n    /**\r\n     * The direction to the light relative to the geocentric normal under the camera.\r\n     */\r\n    public get directionToLightRelativeToCameraGeocentricNormal(): IVector3Like {\r\n        return this._directionToLightRelativeToCameraGeocentricNormal;\r\n    }\r\n\r\n    /**\r\n     * The cosine of the angle between the light direction and zenith.\r\n     */\r\n    public get cosAngleLightToZenith(): number {\r\n        return this._cosAngleLightToZenith;\r\n    }\r\n\r\n    /**\r\n     * The distance from the camera to the planet origin in kilometers.\r\n     */\r\n    public get cameraRadius(): number {\r\n        return this._cameraRadius;\r\n    }\r\n\r\n    /**\r\n     * The distance from the camera to the planet origin, clamped to the planet radius offset, in kilometers.\r\n     */\r\n    public get clampedCameraRadius(): number {\r\n        return this._clampedCameraRadius;\r\n    }\r\n\r\n    /**\r\n     * The height of the camera above the planet surface in kilometers.\r\n     */\r\n    public get cameraHeight(): number {\r\n        return this._cameraHeight;\r\n    }\r\n\r\n    /**\r\n     * The height of the camera above the planet surface, clamped to the planet radius offset, in kilometers.\r\n     */\r\n    public get clampedCameraHeight(): number {\r\n        return this._clampedCameraHeight;\r\n    }\r\n\r\n    /**\r\n     * The camera position in global space kilometers.\r\n     */\r\n    public get cameraPositionGlobal(): IVector3Like {\r\n        return this._cameraPositionGlobal;\r\n    }\r\n\r\n    /**\r\n     * The camera position, clamped to the planet radius offset, in global space kilometers.\r\n     */\r\n    public get clampedCameraPositionGlobal(): IVector3Like {\r\n        return this._clampedCameraPositionGlobal;\r\n    }\r\n\r\n    /**\r\n     * The cosine of the angle from the zenith to the horizon of the planet, measured from the camera position.\r\n     */\r\n    public get cosCameraHorizonAngleFromZenith(): number {\r\n        return this._cosCameraHorizonAngleFromZenith;\r\n    }\r\n\r\n    /**\r\n     * The sine of the angle from the nadir to the horizon of the atmosphere, measured from the camera position.\r\n     */\r\n    public get sinCameraAtmosphereHorizonAngleFromNadir(): number {\r\n        return this._sinCameraAtmosphereHorizonAngleFromNadir;\r\n    }\r\n\r\n    /**\r\n     * The geocentric normal of the camera in global space i.e., the normalization of {@link cameraPositionGlobal}.\r\n     */\r\n    public get cameraGeocentricNormal(): IVector3Like {\r\n        return this._cameraGeocentricNormal;\r\n    }\r\n\r\n    /**\r\n     * The camera's forward direction in world space.\r\n     */\r\n    public get cameraForward(): IVector3Like {\r\n        return this._cameraForward;\r\n    }\r\n\r\n    /**\r\n     * The distance to the near plane of the camera.\r\n     */\r\n    public get cameraNearPlane(): number {\r\n        return this._cameraNearPlane;\r\n    }\r\n\r\n    /**\r\n     * The camera's position in world space.\r\n     */\r\n    public get cameraPosition(): IVector3Like {\r\n        return this._cameraPosition;\r\n    }\r\n\r\n    /**\r\n     * The viewport for the camera.\r\n     */\r\n    public get viewport(): IVector4Like {\r\n        return this._viewport;\r\n    }\r\n\r\n    /**\r\n     * Updates the variables.\r\n     * @param camera - The camera to update the variables for.\r\n     * @param planetRadius - The radius of the planet in kilometers.\r\n     * @param planetRadiusWithOffset - The radius of the planet with the offset in kilometers.\r\n     * @param atmosphereRadius - The radius of the atmosphere in kilometers.\r\n     * @param directionToLight - The direction to the light in world space.\r\n     * @param originHeight - The height of the origin (distance from planet's surface) in kilometers.\r\n     */\r\n    public update(camera: Camera, planetRadius: number, planetRadiusWithOffset: number, atmosphereRadius: number, directionToLight: IVector3Like, originHeight: number): void {\r\n        this._cameraNearPlane = camera.minZ;\r\n        this._cameraForward.copyFrom(camera.getForwardRayToRef(TempRay, 1).direction);\r\n\r\n        const engine = camera.getScene().getEngine();\r\n        this._viewport.copyFromFloats(0.0, 0.0, engine.getRenderWidth(), engine.getRenderHeight());\r\n\r\n        // Compute inverse view projection matrix, but remove the translational component to increase precision.\r\n        const viewMatrix = camera.getViewMatrix();\r\n        const projectionMatrix = camera.getProjectionMatrix();\r\n        if (!this._lastViewMatrix.equals(viewMatrix) || !this._lastProjectionMatrix.equals(projectionMatrix)) {\r\n            this._lastViewMatrix.copyFrom(viewMatrix);\r\n            this._lastViewMatrix.setTranslation(Vector3.ZeroReadOnly);\r\n            this._lastViewMatrix.invertToRef(this._inverseViewMatrixWithoutTranslation);\r\n\r\n            this._lastProjectionMatrix.copyFrom(projectionMatrix);\r\n            this._lastProjectionMatrix.invertToRef(this._inverseProjectionMatrix);\r\n            this._inverseProjectionMatrix.multiplyToRef(this._inverseViewMatrixWithoutTranslation, this._inverseViewProjectionMatrixWithoutTranslation);\r\n        }\r\n\r\n        // Compute the global space position of the camera in kilometers.\r\n        this._cameraPosition.copyFrom(camera.globalPosition);\r\n        this._cameraPosition.scaleToRef(1.0 / 1000.0, this._cameraPositionGlobal);\r\n        this._cameraPositionGlobal.y += planetRadius + originHeight;\r\n        this._cameraHeight = this._cameraPositionGlobal.y - planetRadius;\r\n\r\n        // Clamp the camera parameters.\r\n        this._cameraRadius = this._cameraPositionGlobal.length();\r\n        this._clampedCameraRadius = this._cameraRadius;\r\n        this._cameraPositionGlobal.normalizeToRef(this._cameraGeocentricNormal);\r\n        if (this._clampedCameraRadius < planetRadiusWithOffset) {\r\n            this._clampedCameraRadius = planetRadiusWithOffset;\r\n            this._cameraGeocentricNormal.scaleToRef(planetRadiusWithOffset, this._clampedCameraPositionGlobal);\r\n        } else {\r\n            this._clampedCameraPositionGlobal.copyFrom(this._cameraPositionGlobal);\r\n        }\r\n\r\n        this._cosCameraHorizonAngleFromZenith = ComputeCosHorizonAngleFromZenith(planetRadius, this._clampedCameraRadius);\r\n        this._sinCameraAtmosphereHorizonAngleFromNadir = Math.min(1.0, atmosphereRadius / this._clampedCameraRadius);\r\n        this._clampedCameraHeight = this._clampedCameraRadius - planetRadius;\r\n\r\n        // Compute the direction to the light relative to the camera's geocentric normal.\r\n        {\r\n            this._cosAngleLightToZenith = Vector3Dot(directionToLight, this._cameraGeocentricNormal);\r\n            const lightZenithSinAngle = Math.sqrt(Math.max(0.0, 1.0 - this._cosAngleLightToZenith * this._cosAngleLightToZenith));\r\n            this._directionToLightRelativeToCameraGeocentricNormal.copyFromFloats(lightZenithSinAngle, this._cosAngleLightToZenith, 0.0);\r\n            this._directionToLightRelativeToCameraGeocentricNormal.normalize();\r\n        }\r\n    }\r\n}\r\n\r\nconst ComputeCosHorizonAngleFromZenith = (planetRadius: number, radius: number): number => {\r\n    const sinHorizonAngleFromNadir = Math.min(1, planetRadius / radius);\r\n    const cosHorizonAngleFromNadir = Math.sqrt(1 - sinHorizonAngleFromNadir * sinHorizonAngleFromNadir);\r\n    const cosHorizonAngleFromZenith = -cosHorizonAngleFromNadir;\r\n    return cosHorizonAngleFromZenith;\r\n};\r\n"]}