@luma.gl/shaders 0.0.0-stage → 10.0.0-alpha.6

package/src/modules/lighting/height-fog/height-fog.ts

@@ -0,0 +1,96 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {heightFogFunctions} from './height-fog-functions';
+
+export type HeightFogUniforms = {
+  color: [number, number, number];
+  density: number;
+  baseHeight: number;
+  heightFalloff: number;
+  /** Spatial density variation, from uniform (0) to wispy (1). */
+  variation: number;
+  /** Horizontal size of fog banks in metres. */
+  wispScale: number;
+  /** Fog advection in metres per second in the same frame as the positions. */
+  velocity: [number, number, number];
+  time: number;
+  /** Rate of internal wisp deformation; zero keeps a rigidly advected field. */
+  evolutionSpeed: number;
+};
+export type HeightFogProps = Partial<HeightFogUniforms>;
+
+/** Analytic extinction through a height-dependent atmosphere. All distances are metres. */
+export const heightFog = {
+  name: 'heightFog',
+  dependencies: [heightFogFunctions],
+  bindingLayout: [{name: 'heightFog', group: 3}],
+  uniformTypes: {
+    color: 'vec3<f32>',
+    density: 'f32',
+    baseHeight: 'f32',
+    heightFalloff: 'f32',
+    variation: 'f32',
+    wispScale: 'f32',
+    velocity: 'vec3<f32>',
+    time: 'f32',
+    evolutionSpeed: 'f32'
+  },
+  defaultUniforms: {
+    color: [0.65, 0.72, 0.78],
+    density: 0,
+    baseHeight: 0,
+    heightFalloff: 0.01,
+    variation: 0,
+    wispScale: 160,
+    velocity: [0, 0, 0],
+    time: 0,
+    evolutionSpeed: 0
+  },
+  getUniforms(props: HeightFogProps = {}) {
+    return props;
+  },
+  fs: /* glsl */ `
+layout(std140) uniform heightFogUniforms {
+  vec3 color;
+  float density;
+  float baseHeight;
+  float heightFalloff;
+  float variation;
+  float wispScale;
+  vec3 velocity;
+  float time;
+  float evolutionSpeed;
+} heightFog;
+float heightFog_getTransmittance(vec3 position, vec3 cameraPosition) {
+  return heightFog_getSpatialTransmittance(cameraPosition, position, vec3(0.0, 0.0, 1.0),
+    heightFog.density, heightFog.baseHeight, heightFog.heightFalloff, heightFog.variation, heightFog.wispScale, heightFog.time, heightFog.velocity, heightFog.evolutionSpeed);
+}
+vec4 heightFog_getColor(vec4 color, vec3 position, vec3 cameraPosition) {
+  return vec4(mix(heightFog.color, color.rgb, heightFog_getTransmittance(position, cameraPosition)), color.a);
+}
+`,
+  source: /* wgsl */ `
+struct heightFogUniforms {
+  color: vec3<f32>,
+  density: f32,
+  baseHeight: f32,
+  heightFalloff: f32,
+  variation: f32,
+  wispScale: f32,
+  velocity: vec3<f32>,
+  time: f32,
+  evolutionSpeed: f32,
+};
+@group(3) @binding(auto) var<uniform> heightFog: heightFogUniforms;
+fn heightFog_getTransmittance(position: vec3<f32>, cameraPosition: vec3<f32>) -> f32 {
+  return heightFog_getSpatialTransmittance(cameraPosition, position, vec3<f32>(0.0, 0.0, 1.0),
+    heightFog.density, heightFog.baseHeight, heightFog.heightFalloff, heightFog.variation, heightFog.wispScale, heightFog.time, heightFog.velocity, heightFog.evolutionSpeed);
+}
+fn heightFog_getColor(color: vec4<f32>, position: vec3<f32>, cameraPosition: vec3<f32>) -> vec4<f32> {
+  return vec4<f32>(mix(heightFog.color, color.rgb, heightFog_getTransmittance(position, cameraPosition)), color.a);
+}
+`
+} as const satisfies ShaderModule<HeightFogProps, HeightFogUniforms>;

package/src/modules/lighting/ibl/ibl.ts

@@ -0,0 +1,43 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {ShaderModule} from '../../../lib/shader-module/shader-module';
+
+export type IBLBindings<TextureT = unknown> = {
+  pbr_diffuseEnvSampler?: TextureT | null;
+  pbr_specularEnvSampler?: TextureT | null;
+  pbr_brdfLUT?: TextureT | null;
+};
+
+export const iblWGSL = /* wgsl */ `\
+#ifdef USE_IBL
+@group(2) @binding(auto) var pbr_diffuseEnvSampler: texture_cube<f32>;
+@group(2) @binding(auto) var pbr_diffuseEnvSamplerSampler: sampler;
+@group(2) @binding(auto) var pbr_specularEnvSampler: texture_cube<f32>;
+@group(2) @binding(auto) var pbr_specularEnvSamplerSampler: sampler;
+@group(2) @binding(auto) var pbr_brdfLUT: texture_2d<f32>;
+@group(2) @binding(auto) var pbr_brdfLUTSampler: sampler;
+#endif
+`;
+
+export const iblGLSL = /* glsl */ `\
+#ifdef USE_IBL
+uniform samplerCube pbr_diffuseEnvSampler;
+uniform samplerCube pbr_specularEnvSampler;
+uniform sampler2D pbr_brdfLUT;
+#endif
+`;
+
+export const ibl = {
+  name: 'ibl',
+  firstBindingSlot: 32,
+  bindingLayout: [
+    {name: 'pbr_diffuseEnvSampler', group: 2},
+    {name: 'pbr_specularEnvSampler', group: 2},
+    {name: 'pbr_brdfLUT', group: 2}
+  ],
+  source: iblWGSL,
+  vs: iblGLSL,
+  fs: iblGLSL
+} as const satisfies ShaderModule<IBLBindings, {}, IBLBindings>;

package/src/modules/lighting/lambert-material/lambert-material.ts

@@ -0,0 +1,42 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {lighting} from '../lights/lighting';
+import {LAMBERT_WGSL} from './lambert-shaders-wgsl';
+import {LAMBERT_VS, LAMBERT_FS} from './lambert-shaders-glsl';
+
+/** Uniform props for the built-in diffuse-only Lambert material model. */
+export type LambertMaterialProps = {
+  unlit?: boolean;
+  ambient?: number;
+  diffuse?: number;
+};
+
+/** A matte material model that applies diffuse-only Lambert lighting per fragment. */
+export const lambertMaterial: ShaderModule<LambertMaterialProps> = {
+  name: 'lambertMaterial',
+  firstBindingSlot: 0,
+  bindingLayout: [{name: 'lambertMaterial', group: 3}],
+  dependencies: [lighting],
+  source: LAMBERT_WGSL,
+  vs: LAMBERT_VS,
+  fs: LAMBERT_FS,
+  defines: {
+    LIGHTING_FRAGMENT: true
+  },
+  uniformTypes: {
+    unlit: 'i32',
+    ambient: 'f32',
+    diffuse: 'f32'
+  },
+  defaultUniforms: {
+    unlit: false,
+    ambient: 0.35,
+    diffuse: 0.6
+  },
+  getUniforms(props?: LambertMaterialProps) {
+    return {...lambertMaterial.defaultUniforms, ...props};
+  }
+};

package/src/modules/lighting/lambert-material/lambert-shaders-glsl.ts

@@ -0,0 +1,61 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export const LAMBERT_VS = /* glsl */ `\
+layout(std140) uniform lambertMaterialUniforms {
+  uniform bool unlit;
+  uniform float ambient;
+  uniform float diffuse;
+} material;
+`;
+
+export const LAMBERT_FS = /* glsl */ `\
+layout(std140) uniform lambertMaterialUniforms {
+  uniform bool unlit;
+  uniform float ambient;
+  uniform float diffuse;
+} material;
+
+vec3 lambert_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 normal_worldspace, vec3 color) {
+  float lambertian = max(dot(light_direction, normal_worldspace), 0.0);
+  return lambertian * material.diffuse * surfaceColor * color;
+}
+
+vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
+  vec3 lightColor = surfaceColor;
+
+  if (material.unlit) {
+    return surfaceColor;
+  }
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
+
+  for (int i = 0; i < lighting.pointLightCount; i++) {
+    PointLight pointLight = lighting_getPointLight(i);
+    vec3 light_position_worldspace = pointLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    float light_attenuation = getPointLightAttenuation(pointLight, distance(light_position_worldspace, position_worldspace));
+    lightColor += lambert_getLightColor(surfaceColor, light_direction, normal_worldspace, pointLight.color / light_attenuation);
+  }
+
+  for (int i = 0; i < lighting.spotLightCount; i++) {
+    SpotLight spotLight = lighting_getSpotLight(i);
+    vec3 light_position_worldspace = spotLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    float light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    lightColor += lambert_getLightColor(surfaceColor, light_direction, normal_worldspace, spotLight.color / light_attenuation);
+  }
+
+  for (int i = 0; i < lighting.directionalLightCount; i++) {
+    DirectionalLight directionalLight = lighting_getDirectionalLight(i);
+    lightColor += lambert_getLightColor(surfaceColor, -directionalLight.direction, normal_worldspace, directionalLight.color);
+  }
+
+  return lightColor;
+}
+`;

package/src/modules/lighting/lambert-material/lambert-shaders-wgsl.ts

@@ -0,0 +1,73 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export const LAMBERT_WGSL = /* wgsl */ `\
+struct lambertMaterialUniforms {
+  unlit: u32,
+  ambient: f32,
+  diffuse: f32,
+};
+
+@group(3) @binding(auto) var<uniform> lambertMaterial : lambertMaterialUniforms;
+
+fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {
+  let lambertian: f32 = max(dot(light_direction, normal_worldspace), 0.0);
+  return lambertian * lambertMaterial.diffuse * surfaceColor * color;
+}
+
+fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {
+  var lightColor: vec3<f32> = surfaceColor;
+
+  if (lambertMaterial.unlit != 0u) {
+    return surfaceColor;
+  }
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  lightColor = lambertMaterial.ambient * surfaceColor * lighting.ambientColor;
+
+  for (var i: i32 = 0; i < lighting.pointLightCount; i++) {
+    let pointLight: PointLight = lighting_getPointLight(i);
+    let light_position_worldspace: vec3<f32> = pointLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    let light_attenuation = getPointLightAttenuation(
+      pointLight,
+      distance(light_position_worldspace, position_worldspace)
+    );
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      light_direction,
+      normal_worldspace,
+      pointLight.color / light_attenuation
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.spotLightCount; i++) {
+    let spotLight: SpotLight = lighting_getSpotLight(i);
+    let light_position_worldspace: vec3<f32> = spotLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    let light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      light_direction,
+      normal_worldspace,
+      spotLight.color / light_attenuation
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {
+    let directionalLight: DirectionalLight = lighting_getDirectionalLight(i);
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      -directionalLight.direction,
+      normal_worldspace,
+      directionalLight.color
+    );
+  }
+
+  return lightColor;
+}
+`;

package/src/modules/lighting/lights/lighting-glsl.ts

@@ -0,0 +1,92 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export const lightingUniformsGLSL = /* glsl */ `\
+precision highp int;
+
+// #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;
+  vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential
+};
+
+struct SpotLight {
+  vec3 color;
+  vec3 position;
+  vec3 direction;
+  vec3 attenuation;
+  vec2 coneCos;
+};
+
+struct DirectionalLight {
+  vec3 color;
+  vec3 direction;
+};
+
+struct UniformLight {
+  vec3 color;
+  vec3 position;
+  vec3 direction;
+  vec3 attenuation;
+  vec2 coneCos;
+};
+
+struct AreaLightUniform {
+  vec3 color; vec3 position; vec3 halfAxisX; vec3 halfAxisY; vec3 normal; int disk;
+};
+
+layout(std140) uniform lightingUniforms {
+  int enabled;
+  int directionalLightCount;
+  int pointLightCount;
+  int spotLightCount;
+  vec3 ambientColor;
+  UniformLight lights[5];
+  int areaLightCount;
+  AreaLightUniform areaLights[4];
+} lighting;
+
+PointLight lighting_getPointLight(int index) {
+  UniformLight light = lighting.lights[index];
+  return PointLight(light.color, light.position, light.attenuation);
+}
+
+SpotLight lighting_getSpotLight(int index) {
+  UniformLight light = lighting.lights[lighting.pointLightCount + index];
+  return SpotLight(light.color, light.position, light.direction, light.attenuation, light.coneCos);
+}
+
+DirectionalLight lighting_getDirectionalLight(int index) {
+  UniformLight light =
+    lighting.lights[lighting.pointLightCount + lighting.spotLightCount + index];
+  return DirectionalLight(light.color, light.direction);
+}
+
+float getPointLightAttenuation(PointLight pointLight, float distance) {
+  return pointLight.attenuation.x
+       + pointLight.attenuation.y * distance
+       + pointLight.attenuation.z * distance * distance;
+}
+
+float getSpotLightAttenuation(SpotLight spotLight, vec3 positionWorldspace) {
+  vec3 light_direction = normalize(positionWorldspace - spotLight.position);
+  float coneFactor = smoothstep(
+    spotLight.coneCos.y,
+    spotLight.coneCos.x,
+    dot(normalize(spotLight.direction), light_direction)
+  );
+  float distanceAttenuation = getPointLightAttenuation(
+    PointLight(spotLight.color, spotLight.position, spotLight.attenuation),
+    distance(spotLight.position, positionWorldspace)
+  );
+  return distanceAttenuation / max(coneFactor, 0.0001);
+}
+
+// #endif
+`;

package/src/modules/lighting/lights/lighting-wgsl.ts

@@ -0,0 +1,91 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export const lightingUniformsWGSL = /* wgsl */ `\
+// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
+const MAX_LIGHTS: i32 = 5;
+
+struct AmbientLight {
+  color: vec3<f32>,
+};
+
+struct PointLight {
+  color: vec3<f32>,
+  position: vec3<f32>,
+  attenuation: vec3<f32>, // 2nd order x:Constant-y:Linear-z:Exponential
+};
+
+struct SpotLight {
+  color: vec3<f32>,
+  position: vec3<f32>,
+  direction: vec3<f32>,
+  attenuation: vec3<f32>,
+  coneCos: vec2<f32>,
+};
+
+struct DirectionalLight {
+  color: vec3<f32>,
+  direction: vec3<f32>,
+};
+
+struct UniformLight {
+  color: vec3<f32>,
+  position: vec3<f32>,
+  direction: vec3<f32>,
+  attenuation: vec3<f32>,
+  coneCos: vec2<f32>,
+};
+
+struct AreaLightUniform {
+  color: vec3f, position: vec3f, halfAxisX: vec3f, halfAxisY: vec3f, normal: vec3f, disk: i32,
+};
+
+struct lightingUniforms {
+  enabled: i32,
+  directionalLightCount: i32,
+  pointLightCount: i32,
+  spotLightCount: i32,
+  ambientColor: vec3<f32>,
+  lights: array<UniformLight, 5>,
+  areaLightCount: i32,
+  areaLights: array<AreaLightUniform, 4>,
+};
+
+@group(2) @binding(auto) var<uniform> lighting : lightingUniforms;
+
+fn lighting_getPointLight(index: i32) -> PointLight {
+  let light = lighting.lights[index];
+  return PointLight(light.color, light.position, light.attenuation);
+}
+
+fn lighting_getSpotLight(index: i32) -> SpotLight {
+  let light = lighting.lights[lighting.pointLightCount + index];
+  return SpotLight(light.color, light.position, light.direction, light.attenuation, light.coneCos);
+}
+
+fn lighting_getDirectionalLight(index: i32) -> DirectionalLight {
+  let light = lighting.lights[lighting.pointLightCount + lighting.spotLightCount + index];
+  return DirectionalLight(light.color, light.direction);
+}
+
+fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
+  return pointLight.attenuation.x
+       + pointLight.attenuation.y * distance
+       + pointLight.attenuation.z * distance * distance;
+}
+
+fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>) -> f32 {
+  let lightDirection = normalize(positionWorldspace - spotLight.position);
+  let coneFactor = smoothstep(
+    spotLight.coneCos.y,
+    spotLight.coneCos.x,
+    dot(normalize(spotLight.direction), lightDirection)
+  );
+  let distanceAttenuation = getPointLightAttenuation(
+    PointLight(spotLight.color, spotLight.position, spotLight.attenuation),
+    distance(spotLight.position, positionWorldspace)
+  );
+  return distanceAttenuation / max(coneFactor, 0.0001);
+}
+`;