@tangram.gl/tangram-renderer 0.0.0-stage → 0.0.0

package/src/lights/lighting-wgsl.ts

@@ -0,0 +1,116 @@
+// Tangram
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2013-2016 Brett Camper and Mapzen
+// Copyright (c) 2026 vis.gl contributors
+
+import {MAX_PORTABLE_LIGHTS} from './lighting-uniforms';
+import {buildNativeFalloff} from './native-falloff';
+
+/** Specialize Tangram's constant-material equations to the bounded active scene light count. */
+export function buildLightingWGSL(lightCount = MAX_PORTABLE_LIGHTS): string {
+    if (!Number.isInteger(lightCount) || lightCount < 0 || lightCount > MAX_PORTABLE_LIGHTS) {
+        throw new Error(`Portable lighting supports 0 to ${MAX_PORTABLE_LIGHTS} visible lights`);
+    }
+    return `
+${buildNativeFalloff('wgsl')}
+struct TangramSurfaceLight {
+    ambient: vec4<f32>, diffuse: vec4<f32>, specular: vec4<f32>,
+    position: vec4<f32>, direction: vec4<f32>, falloff: vec4<f32>,
+    cone: vec4<f32>, coefficients: vec4<f32>,
+};
+fn tangramSurfaceLight(index: i32) -> TangramSurfaceLight {
+    switch index {
+${Array.from({length: lightCount}, (_, index) => `
+        case ${index}: { return TangramSurfaceLight(${['ambient', 'diffuse', 'specular', 'position', 'direction', 'falloff', 'cone', 'coefficients'].map(field => `TangramLighting.u_light_${index}_${field}`).join(', ')}); }`).join('')}
+        default: { return TangramSurfaceLight(vec4<f32>(0.0), vec4<f32>(0.0), vec4<f32>(0.0), vec4<f32>(0.0), vec4<f32>(0.0), vec4<f32>(0.0), vec4<f32>(0.0), vec4<f32>(0.0)); }
+    }
+}
+fn tangramDistanceFalloff(distance: f32, light: TangramSurfaceLight) -> f32 {
+    let exponent = light.falloff.x;
+    let inner = light.falloff.y;
+    let outer = light.falloff.z;
+    var attenuation = 1.0;
+    if (exponent != 0.0) {
+        let radius = select(1.0, inner, inner >= 0.0);
+        if (outer >= 0.0) {
+            let d = clamp(max(0.0, distance - radius) / max(outer - radius, 0.0001), 0.0, 1.0);
+            attenuation = 1.0 - pow(d, exponent);
+        } else {
+            let d = max(0.0, distance - radius) / max(radius, 0.0001) + 1.0;
+            attenuation = clamp(1.0 / pow(d, exponent), 0.0, 1.0);
+        }
+    } else if (inner >= 0.0) {
+        if (outer >= 0.0) {
+            let d = clamp(max(0.0, distance - inner) / max(outer - inner, 0.0001), 0.0, 1.0);
+            attenuation = 1.0 - d * d;
+        } else {
+            let d = max(0.0, distance - inner) / max(inner, 0.0001) + 1.0;
+            attenuation = clamp(1.0 / d, 0.0, 1.0);
+        }
+    } else if (outer >= 0.0) {
+        let d = clamp(distance / max(outer, 0.0001), 0.0, 1.0);
+        attenuation = 1.0 - d * d;
+    }
+    if (light.coefficients.w > 0.5) {
+        attenuation /= tangramNativeDistanceDenominator(light.coefficients.xyz, distance);
+    }
+    return attenuation;
+}
+fn tangramCalculateLighting(eye_to_point: vec3<f32>, normal: vec3<f32>, base_color: vec4<f32>) -> vec4<f32> {
+    var ambient = vec3<f32>(0.0);
+    var diffuse = vec3<f32>(0.0);
+    var specular = vec3<f32>(0.0);
+    let eye_direction = eye_to_point / max(length(eye_to_point), 0.0001);
+    for (var index = 0; index < ${lightCount}; index++) {
+        if (index >= TangramLighting.u_light_count) { break; }
+        let light = tangramSurfaceLight(index);
+        let kind = i32(light.position.w);
+        var direction = -light.direction.xyz;
+        var attenuation = 1.0;
+        if (kind >= 2) {
+            let offset = light.position.xyz - eye_to_point;
+            let distance = length(offset);
+            direction = offset / max(distance, 0.0001);
+            attenuation = tangramDistanceFalloff(distance, light);
+            if (kind == 3) {
+                let cosine = clamp(dot(-direction, light.direction.xyz), 0.0, 1.0);
+                var cone_factor = select(0.0, pow(cosine, light.falloff.w), cosine >= light.cone.z);
+                if (light.coefficients.w > 0.5) {
+                    cone_factor = tangramNativeConeFactor(light.cone.xy, cosine) * pow(cosine, light.falloff.w);
+                }
+                attenuation *= cone_factor;
+            }
+        }
+        ambient += light.ambient.rgb * attenuation;
+        if (kind > 0) {
+            let lambert = clamp(dot(normal, direction), 0.0, 1.0);
+            diffuse += light.diffuse.rgb * lambert * attenuation;
+            if (lambert > 0.0 && TangramMaterial.u_material_flags.w != 0) {
+                let reflected = reflect(-direction, normal);
+                // Preserve Tangram's directional versus positional eye-vector convention.
+                let eye = select(-eye_direction, eye_direction, kind == 1);
+                let power = pow(max(dot(eye, reflected), 0.0), TangramMaterial.u_material_shininess);
+                specular += light.specular.rgb * power * attenuation;
+            }
+        }
+    }
+    var color = vec4<f32>(0.0, 0.0, 0.0, base_color.a);
+    let flags = TangramMaterial.u_material_flags;
+    if (flags.x != 0) {
+        color = vec4<f32>(TangramMaterial.u_material_emission.rgb, color.a * TangramMaterial.u_material_emission.a);
+    }
+    if (flags.y != 0) {
+        color = vec4<f32>(color.rgb + ambient * base_color.rgb * TangramMaterial.u_material_ambient.rgb, color.a * TangramMaterial.u_material_ambient.a);
+    } else if (flags.z != 0) {
+        color = vec4<f32>(color.rgb + ambient * base_color.rgb * TangramMaterial.u_material_diffuse.rgb, color.a);
+    }
+    if (flags.z != 0) {
+        color = vec4<f32>(color.rgb + diffuse * base_color.rgb * TangramMaterial.u_material_diffuse.rgb, color.a * TangramMaterial.u_material_diffuse.a);
+    }
+    if (flags.w != 0) {
+        color = vec4<f32>(color.rgb + specular * TangramMaterial.u_material_specular.rgb, color.a * TangramMaterial.u_material_specular.a);
+    }
+    return clamp(color, vec4<f32>(0.0), vec4<f32>(1.0));
+}
+`;
+}

package/src/lights/material.glsl

@@ -0,0 +1,237 @@
+// Tangram
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2013-2016 Brett Camper and Mapzen
+
+/*
+
+Defines globals:
+material
+light_accumulator_*
+
+*/
+
+
+// MATERIALS
+//
+struct Material {
+    #ifdef TANGRAM_MATERIAL_EMISSION
+        vec4 emission;
+        #ifdef TANGRAM_MATERIAL_EMISSION_TEXTURE
+            vec3 emissionScale;
+        #endif
+    #endif
+
+    #ifdef TANGRAM_MATERIAL_AMBIENT
+        vec4 ambient;
+        #ifdef TANGRAM_MATERIAL_AMBIENT_TEXTURE
+            vec3 ambientScale;
+        #endif
+    #endif
+
+    #ifdef TANGRAM_MATERIAL_DIFFUSE
+        vec4 diffuse;
+        #ifdef TANGRAM_MATERIAL_DIFFUSE_TEXTURE
+            vec3 diffuseScale;
+        #endif
+    #endif
+
+    #ifdef TANGRAM_MATERIAL_SPECULAR
+        vec4 specular;
+        float shininess;
+        #ifdef TANGRAM_MATERIAL_SPECULAR_TEXTURE
+            vec3 specularScale;
+        #endif
+    #endif
+
+
+    #ifdef TANGRAM_MATERIAL_NORMAL_TEXTURE
+        vec3 normalScale;
+        float normalAmount;
+    #endif
+};
+
+// Note: uniform is copied to a global instance to allow modification
+uniform Material u_material;
+Material material;
+
+#ifdef TANGRAM_MATERIAL_EMISSION_TEXTURE
+uniform sampler2D u_material_emission_texture;
+#endif
+
+#ifdef TANGRAM_MATERIAL_AMBIENT_TEXTURE
+uniform sampler2D u_material_ambient_texture;
+#endif
+
+#ifdef TANGRAM_MATERIAL_DIFFUSE_TEXTURE
+uniform sampler2D u_material_diffuse_texture;
+#endif
+
+#ifdef TANGRAM_MATERIAL_SPECULAR_TEXTURE
+uniform sampler2D u_material_specular_texture;
+#endif
+
+#ifdef TANGRAM_MATERIAL_NORMAL_TEXTURE
+uniform sampler2D u_material_normal_texture;
+#endif
+
+// Global light accumulators for each property
+vec4 light_accumulator_ambient = vec4(vec3(0.0), 1.);
+vec4 light_accumulator_diffuse = vec4(vec3(0.0), 1.);
+#ifdef TANGRAM_MATERIAL_SPECULAR
+    vec4 light_accumulator_specular = vec4(vec3(0.0), 1.);
+#endif
+
+
+#ifdef TANGRAM_MATERIAL_TEXTURE_SPHEREMAP
+vec4 getSphereMap (in sampler2D _tex, in vec3 _eyeToPoint, in vec3 _normal, in vec2 _skew) {
+    // Normalized vector from camera to surface
+    vec3 eye = normalize(_eyeToPoint);
+
+    // Adjust for camera skew
+    eye.xy -= _skew;
+    eye = normalize(eye);
+
+    // Reflection of eye off of surface normal
+    vec3 r = reflect(eye, _normal);
+
+    // Map reflected vector onto the surface of a sphere
+    r.z += 1.0;
+    float m = 2. * length(r);
+
+    // Adjust xy to account for spherical shape, and center in middle of texture
+    vec2 uv = r.xy / m + .5;
+
+    // Sample the environment map
+    return texture2D(_tex, uv);
+}
+#endif
+
+
+#ifdef TANGRAM_MATERIAL_TEXTURE_TRIPLANAR
+vec3 getTriPlanarBlend (in vec3 _normal) {
+    vec3 blending = abs(_normal);
+    blending = normalize(max(blending, 0.00001));
+    float b = (blending.x + blending.y + blending.z);
+    return blending / b;
+}
+
+vec4 getTriPlanar (in sampler2D _tex, in vec3 _pos, in vec3 _normal, in vec3 _scale) {
+    vec3 blending = getTriPlanarBlend(_normal);
+    vec4 xaxis = texture2D(_tex, fract(_pos.yz * _scale.x));
+    vec4 yaxis = texture2D(_tex, fract(_pos.xz * _scale.y));
+    vec4 zaxis = texture2D(_tex, fract(_pos.xy * _scale.z));
+    return  xaxis * blending.x + yaxis * blending.y + zaxis * blending.z;
+}
+#endif
+
+
+#ifdef TANGRAM_MATERIAL_TEXTURE_PLANAR
+vec4 getPlanar (in sampler2D _tex, in vec3 _pos, in vec2 _scale) {
+    return texture2D( _tex, fract(_pos.xy * _scale.x) );
+}
+#endif
+
+
+#ifdef TANGRAM_MATERIAL_NORMAL_TEXTURE
+void calculateNormal (inout vec3 _normal) {
+    // Get NORMALMAP
+    //------------------------------------------------
+    #ifdef TANGRAM_MATERIAL_NORMAL_TEXTURE_UV
+    _normal += texture2D(u_material_normal_texture, fract(v_texcoord*material.normalScale.xy)).rgb*2.0-1.0;
+    #endif
+
+    #ifdef TANGRAM_MATERIAL_NORMAL_TEXTURE_PLANAR
+    vec3 normalTex = getPlanar(u_material_normal_texture, v_world_position.xyz, material.normalScale.xy).rgb*2.0-1.0;
+    _normal += normalTex;
+    #endif
+
+    #ifdef TANGRAM_MATERIAL_NORMAL_TEXTURE_TRIPLANAR
+    vec3 normalTex = getTriPlanar(u_material_normal_texture, v_world_position.xyz, _normal, material.normalScale).rgb*2.0-1.0;
+    _normal += normalTex;
+    #endif
+
+    _normal = normalize(_normal);
+}
+#endif
+
+void calculateMaterial (in vec3 _eyeToPoint, inout vec3 _normal) {
+    // get EMISSION TEXTUREMAP
+    //------------------------------------------------
+    #ifdef TANGRAM_MATERIAL_EMISSION_TEXTURE
+        #ifdef TANGRAM_MATERIAL_EMISSION_TEXTURE_UV
+        material.emission *= texture2D(u_material_emission_texture,v_texcoord);
+        #endif
+
+        #ifdef TANGRAM_MATERIAL_EMISSION_TEXTURE_PLANAR
+        material.emission *= getPlanar(u_material_emission_texture, v_world_position.xyz, material.emissionScale.xy);
+        #endif
+
+        #ifdef TANGRAM_MATERIAL_EMISSION_TEXTURE_TRIPLANAR
+        material.emission *= getTriPlanar(u_material_emission_texture, v_world_position.xyz, _normal, material.emissionScale);
+        #endif
+
+        #ifdef TANGRAM_MATERIAL_EMISSION_TEXTURE_SPHEREMAP
+        material.emission *= getSphereMap(u_material_emission_texture, _eyeToPoint, _normal, u_vanishing_point);
+        #endif
+    #endif
+
+    // get AMBIENT TEXTUREMAP
+    //------------------------------------------------
+    #ifdef TANGRAM_MATERIAL_AMBIENT_TEXTURE
+        #ifdef TANGRAM_MATERIAL_AMBIENT_TEXTURE_UV
+        material.ambient *= texture2D(u_material_ambient_texture,v_texcoord);
+        #endif
+
+        #ifdef TANGRAM_MATERIAL_AMBIENT_TEXTURE_PLANAR
+        material.ambient *= getPlanar(u_material_ambient_texture, v_world_position.xyz, material.ambientScale.xy);
+        #endif
+
+        #ifdef TANGRAM_MATERIAL_AMBIENT_TEXTURE_TRIPLANAR
+        material.ambient *= getTriPlanar(u_material_ambient_texture, v_world_position.xyz, _normal, material.ambientScale);
+        #endif
+
+        #ifdef TANGRAM_MATERIAL_AMBIENT_TEXTURE_SPHEREMAP
+        material.ambient *= getSphereMap(u_material_ambient_texture, _eyeToPoint, _normal, u_vanishing_point);
+        #endif
+    #endif
+
+    // get DIFFUSE TEXTUREMAP
+    //------------------------------------------------
+    #ifdef TANGRAM_MATERIAL_DIFFUSE_TEXTURE
+        #ifdef TANGRAM_MATERIAL_DIFFUSE_TEXTURE_UV
+        material.diffuse *= texture2D(u_material_diffuse_texture,v_texcoord);
+        #endif
+
+        #ifdef TANGRAM_MATERIAL_DIFFUSE_TEXTURE_PLANAR
+        material.diffuse *= getPlanar(u_material_diffuse_texture, v_world_position.xyz, material.diffuseScale.xy);
+        #endif
+
+        #ifdef TANGRAM_MATERIAL_DIFFUSE_TEXTURE_TRIPLANAR
+        material.diffuse *= getTriPlanar(u_material_diffuse_texture, v_world_position.xyz, _normal, material.diffuseScale);
+        #endif
+
+        #ifdef TANGRAM_MATERIAL_DIFFUSE_TEXTURE_SPHEREMAP
+        material.diffuse *= getSphereMap(u_material_diffuse_texture, _eyeToPoint, _normal, u_vanishing_point);
+        #endif
+    #endif
+
+    // get SPECULAR TEXTUREMAP
+    //------------------------------------------------
+    #ifdef TANGRAM_MATERIAL_SPECULAR_TEXTURE
+        #ifdef TANGRAM_MATERIAL_SPECULAR_TEXTURE_UV
+        material.specular *= texture2D(u_material_specular_texture,v_texcoord);
+        #endif
+
+        #ifdef TANGRAM_MATERIAL_SPECULAR_TEXTURE_PLANAR
+        material.specular *= getPlanar(u_material_specular_texture, v_world_position.xyz, material.specularScale.xy);
+        #endif
+
+        #ifdef TANGRAM_MATERIAL_SPECULAR_TEXTURE_TRIPLANAR
+        material.specular *= getTriPlanar(u_material_specular_texture, v_world_position.xyz, _normal, material.specularScale);
+        #endif
+
+        #ifdef TANGRAM_MATERIAL_SPECULAR_TEXTURE_SPHEREMAP
+        material.specular *= getSphereMap(u_material_specular_texture, _eyeToPoint, _normal, u_vanishing_point);
+        #endif
+    #endif
+}

package/src/lights/material.ts

@@ -0,0 +1,145 @@
+// Tangram
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2013-2016 Brett Camper and Mapzen
+// Copyright (c) 2026 vis.gl contributors
+
+import GLSL from '../gl/glsl';
+import StyleParser from '../styles/style_parser';
+
+import material_source from './material.glsl';
+import type {PortableMaterial} from './lighting-uniforms';
+
+const material_props = ['emission', 'ambient', 'diffuse', 'specular'];
+
+export default class Material {
+    [key: string]: any;
+    /** Normalized constant/texture channels created from authored material definitions. */
+    declare emission: PortableMaterial['emission'];
+    declare ambient: PortableMaterial['ambient'];
+    declare diffuse: PortableMaterial['diffuse'];
+    declare specular: PortableMaterial['specular'];
+    declare normal: {texture?: unknown; mapping: string; scale: number[] | undefined; amount: number} | undefined;
+    static block: string;
+
+    constructor (config: any) {
+
+        config = config || {};
+
+        // These properties all have the same defaults, so they can be set in bulk
+        material_props.forEach(prop => {
+            const value = config[prop];
+            if (value != null) {
+                if (value.texture) {
+                    this[prop] = {
+                        texture: value.texture,
+                        mapping: value.mapping || 'spheremap',
+                        scale: GLSL.expandVec3(value.scale != null ? value.scale : 1),
+                        amount: GLSL.expandVec4(value.amount != null ? value.amount : 1)
+                    };
+                }
+                else if (typeof value === 'number' || Array.isArray(value)) {
+                    this[prop] = { amount: GLSL.expandVec4(value) };
+                }
+                else if (typeof value === 'string') {
+                    this[prop] = { amount: (StyleParser as any).parseColor(value) };
+                }
+                else {
+                    this[prop] = value;
+                }
+            }
+        });
+
+        // Extra specular props
+        if (this.specular) {
+            this.specular.shininess = config.shininess ? parseFloat(config.shininess) : 0.2;
+        }
+
+        // Normal mapping
+        if (config.normal != null) {
+            this.normal = {
+                texture: config.normal.texture,
+                mapping: config.normal.mapping || 'triplanar',
+                scale: GLSL.expandVec3(config.normal.scale != null ? config.normal.scale : 1),
+                amount: config.normal.amount != null ? config.normal.amount : 1
+            };
+        }
+    }
+
+    // Determine if a material config block has sufficient properties to create a material
+    static isValid (config: any): boolean {
+        if (config == null) {
+            return false;
+        }
+
+        if (config.emission == null &&
+            config.ambient == null &&
+            config.diffuse == null &&
+            config.specular == null) {
+            return false;
+        }
+
+        return true;
+    }
+
+    inject (style: any): void {
+        // For each property, sets defines to configure texture mapping, with a pattern like:
+        //   TANGRAM_MATERIAL_DIFFUSE, TANGRAM_MATERIAL_DIFFUSE_TEXTURE, TANGRAM_MATERIAL_DIFFUSE_TEXTURE_SPHEREMAP
+        // Also sets flags to keep track of each unique mapping type being used, e.g.:
+        //   TANGRAM_MATERIAL_TEXTURE_SPHEREMAP
+        // Enables texture coordinates if needed and not already on
+        material_props.forEach(prop => {
+            let def = `TANGRAM_MATERIAL_${prop.toUpperCase()}`;
+            let texdef = def + '_TEXTURE';
+            style.defines[def] = (this[prop] != null);
+            if (this[prop] && this[prop].texture) {
+                style.defines[texdef] = true;
+                style.defines[texdef + '_' + this[prop].mapping.toUpperCase()] = true;
+                style.defines[`TANGRAM_MATERIAL_TEXTURE_${this[prop].mapping.toUpperCase()}`] = true;
+                style.texcoords = style.texcoords || (this[prop].mapping === 'uv');
+            }
+        });
+
+        // Normal mapping
+        // As anove, sets flags to keep track of each unique mapping type being used, e.g.:
+        //   TANGRAM_MATERIAL_TEXTURE_SPHEREMAP
+        if (this.normal && this.normal.texture) {
+            style.defines['TANGRAM_MATERIAL_NORMAL_TEXTURE'] = true;
+            style.defines['TANGRAM_MATERIAL_NORMAL_TEXTURE_' + this.normal.mapping.toUpperCase()] = true;
+            style.defines[`TANGRAM_MATERIAL_TEXTURE_${this.normal.mapping.toUpperCase()}`] = true;
+            style.texcoords = style.texcoords || (this.normal.mapping === 'uv');
+        }
+
+        style.replaceShaderBlock(Material.block, material_source, 'Material');
+        style.addShaderBlock('setup', '\nmaterial = u_material;\n', 'Material');
+    }
+
+    setupProgram (_program: any): void {
+        // For each property, sets uniforms in the pattern:
+        // u_material.diffuse, u_material.diffuseScale u_material_diffuse_texture
+        material_props.forEach(prop => {
+            if (this[prop]) {
+                if (this[prop].texture) {
+                    _program.setTextureUniform(`u_material_${prop}_texture`, this[prop].texture);
+                    _program.uniform('3fv', `u_material.${prop}Scale`, this[prop].scale);
+                    _program.uniform('4fv', `u_material.${prop}`, this[prop].amount);
+                } else if (this[prop].amount) {
+                    _program.uniform('4fv', `u_material.${prop}`, this[prop].amount);
+                }
+            }
+        });
+
+        // Extra specular props
+        if (this.specular) {
+            _program.uniform('1f', 'u_material.shininess', this.specular.shininess);
+        }
+
+        // Normal mapping
+        if (this.normal && this.normal.texture) {
+            _program.setTextureUniform('u_material_normal_texture', this.normal.texture);
+            _program.uniform('3fv', 'u_material.normalScale', this.normal.scale);
+            _program.uniform('1f', 'u_material.normalAmount', this.normal.amount);
+        }
+    }
+}
+
+Material.block = 'material';

package/src/lights/native-falloff.ts

@@ -0,0 +1,37 @@
+// tangram-layers
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/** Polynomial attenuation shared by GLSL/WGSL, matching luma.gl's native point-light denominator. */
+const DISTANCE_DENOMINATOR = 'coefficients.x + coefficients.y * distance + coefficients.z * distance * distance';
+
+/** Shared native cone transition; Tangram defines the otherwise undefined equal-cone limit explicitly. */
+const CONE_TRANSITION = 'smoothstep(cone.y, cone.x, cosine)';
+
+/**
+ * Native light calculations, independent of Tangram's color/material accumulators.
+ * The 0.0001 floor and outside-cone contribution retain the existing luma-compatible behavior.
+ * Legacy radius/exponent falloff remains a separate multiplier, not a substitute for native attenuation.
+ */
+export function buildNativeFalloff(language: 'glsl' | 'wgsl'): string {
+    if (language === 'glsl') return `
+float tangramNativeDistanceDenominator(vec3 coefficients, float distance) {
+    return max(${DISTANCE_DENOMINATOR}, 0.0001);
+}
+float tangramNativeConeFactor(vec2 cone, float cosine) {
+    float factor = cone.x == cone.y ? step(cone.y, cosine) : ${CONE_TRANSITION};
+    return max(factor, 0.0001);
+}
+`;
+    return `
+fn tangramNativeDistanceDenominator(coefficients: vec3<f32>, distance: f32) -> f32 {
+    return max(${DISTANCE_DENOMINATOR}, 0.0001);
+}
+fn tangramNativeConeFactor(cone: vec2<f32>, cosine: f32) -> f32 {
+    var factor: f32;
+    if (cone.x == cone.y) { factor = step(cone.y, cosine); }
+    else { factor = ${CONE_TRANSITION}; }
+    return max(factor, 0.0001);
+}
+`;
+}

package/src/lights/point_light.glsl

@@ -0,0 +1,96 @@
+// Tangram
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2013-2016 Brett Camper and Mapzen
+// Copyright (c) 2026 vis.gl contributors
+
+/*
+
+Expected globals:
+material
+light_accumulator_*
+
+*/
+
+struct PointLight {
+    vec3 ambient;
+    vec3 diffuse;
+    vec3 specular;
+    vec4 position;
+    float useLumaAttenuation;
+    vec3 attenuationCoefficients;
+
+    float attenuationExponent;
+    float innerRadius;
+    float outerRadius;
+};
+
+void calculateLight(in PointLight _light, in vec3 _eyeToPoint, in vec3 _normal) {
+
+    float dist = length(_light.position.xyz - _eyeToPoint);
+
+    // Compute vector from surface to light position
+    vec3 VP = (_light.position.xyz - _eyeToPoint) / dist;
+
+    // Normalize the vector from surface to light position
+    float nDotVP = clamp(dot(VP, _normal), 0.0, 1.0);
+
+    // Attenuation defaults
+    float attenuation = 1.0;
+    if (_light.attenuationExponent != 0.0) {
+        float Rin = _light.innerRadius >= 0.0 ? _light.innerRadius : 1.0;
+        float e = _light.attenuationExponent;
+        if (_light.outerRadius >= 0.0) {
+            float Rdiff = _light.outerRadius-Rin;
+            float d = clamp(max(0.0,dist-Rin)/Rdiff, 0.0, 1.0);
+            attenuation = 1.0-(pow(d,e));
+        } else {
+            // If no outer is provide behaves like:
+            // https://imdoingitwrong.wordpress.com/2011/01/31/light-attenuation/
+            float d = max(0.0,dist-Rin)/Rin+1.0;
+            attenuation = clamp(1.0/(pow(d,e)), 0.0, 1.0);
+        }
+    } else {
+        float Rin = max(_light.innerRadius, 0.0);
+        if (_light.innerRadius >= 0.0) {
+            if (_light.outerRadius >= 0.0) {
+                float Rdiff = _light.outerRadius-Rin;
+                float d = clamp(max(0.0,dist-Rin)/Rdiff, 0.0, 1.0);
+                attenuation = 1.0-d*d;
+            } else {
+                // If no outer is provide behaves like:
+                // https://imdoingitwrong.wordpress.com/2011/01/31/light-attenuation/
+                float d = max(0.0,dist-Rin)/Rin+1.0;
+                attenuation = clamp(1.0/d, 0.0, 1.0);
+            }
+        } else {
+            if (_light.outerRadius >= 0.0) {
+                float d = clamp(dist/_light.outerRadius, 0.0, 1.0);
+                attenuation = 1.0-d*d;
+            } else {
+                attenuation = 1.0;
+            }
+        }
+    }
+
+    if (_light.useLumaAttenuation > 0.5) {
+        attenuation /= tangramNativeDistanceDenominator(_light.attenuationCoefficients, dist);
+    }
+
+    // Computer accumulators
+    light_accumulator_ambient.rgb += _light.ambient * attenuation;
+
+    #ifdef TANGRAM_MATERIAL_DIFFUSE
+        light_accumulator_diffuse.rgb += _light.diffuse * nDotVP * attenuation;
+    #endif
+
+    #ifdef TANGRAM_MATERIAL_SPECULAR
+        float pf = 0.0; // power factor for shiny speculars
+        if (nDotVP > 0.0) {
+            vec3 reflectVector = reflect(-VP, _normal);
+            float eyeDotR = max(0.0, dot(-normalize(_eyeToPoint), reflectVector));
+            pf = pow(eyeDotR, material.shininess);
+        }
+
+        light_accumulator_specular.rgb += _light.specular * pf * attenuation;
+    #endif
+}