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

package/src/modules/lighting/no-material/dirlight.ts

@@ -0,0 +1,101 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {NumberArray3} from '@math.gl/core';
+import {ShaderModule} from '../../../lib/shader-module/shader-module';
+
+export type DirlightProps = {
+  lightDirection?: NumberArray3;
+};
+
+export type DirlightUniforms = DirlightProps;
+
+// TODO
+export const SOURCE_WGSL = /* WGSL */ `\
+struct dirlightUniforms {
+  lightDirection: vec3<f32>,
+};
+
+alias DirlightNormal = vec3<f32>;
+
+struct DirlightInputs {
+  normal: DirlightNormal,
+};
+
+@group(2) @binding(auto) var<uniform> dirlight : dirlightUniforms;
+
+// For vertex
+fn dirlight_setNormal(normal: vec3<f32>) -> DirlightNormal {
+  return normalize(normal);
+}
+
+// Returns color attenuated by angle from light source
+fn dirlight_filterColor(color: vec4<f32>, inputs: DirlightInputs) -> vec4<f32> {
+  // TODO - fix default light direction
+  // let lightDirection = dirlight.lightDirection;
+  let lightDirection = vec3<f32>(1, 1, 1);
+  let d: f32 = abs(dot(inputs.normal, normalize(lightDirection)));
+  return vec4<f32>(color.rgb * d, color.a);
+}
+`;
+
+const VS_GLSL = /* glsl */ `\
+out vec3 dirlight_vNormal;
+
+void dirlight_setNormal(vec3 normal) {
+  dirlight_vNormal = normalize(normal);
+}
+`;
+
+const FS_GLSL = /* glsl */ `\
+layout(std140) uniform dirlightUniforms {
+  vec3 lightDirection;
+} dirlight;
+
+in vec3 dirlight_vNormal;
+
+// Returns color attenuated by angle from light source
+vec4 dirlight_filterColor(vec4 color) {
+  float d = abs(dot(dirlight_vNormal, normalize(dirlight.lightDirection)));
+  return vec4(color.rgb * d, color.a);
+}
+`;
+
+/**
+ * Cheap lighting - single directional light, single dot product, one uniform
+ */
+export const dirlight = {
+  props: {} as DirlightProps,
+  uniforms: {} as DirlightUniforms,
+
+  name: 'dirlight',
+  bindingLayout: [{name: 'dirlight', group: 2}],
+  firstBindingSlot: 16,
+  dependencies: [],
+  source: SOURCE_WGSL,
+  vs: VS_GLSL,
+  fs: FS_GLSL,
+
+  // fragmentInputs: [
+  //   {
+  //     name: 'dirlight_vNormal',
+  //     type: 'vec3<f32>'
+  //   }
+  // ],
+  uniformTypes: {
+    lightDirection: 'vec3<f32>'
+  },
+  defaultUniforms: {
+    lightDirection: [1, 1, 2]
+  },
+  getUniforms
+} as const satisfies ShaderModule<DirlightProps, DirlightUniforms>;
+
+function getUniforms(opts: DirlightProps = dirlight.defaultUniforms): DirlightUniforms {
+  const uniforms: DirlightUniforms = {};
+  if (opts.lightDirection) {
+    uniforms.lightDirection = opts.lightDirection;
+  }
+  return uniforms;
+}

package/src/modules/lighting/pbr-ambient-occlusion/pbr-ambient-occlusion.ts

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {NumberArray4} from '@math.gl/core';
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {pbrMaterial} from '../pbr-material/pbr-material';
+
+export type PBRAmbientOcclusionProps<TextureT = unknown> = {
+  ambientOcclusionTexture?: TextureT;
+  /** Origin and dimensions of the receiver viewport, in physical pixels. */
+  viewport?: Readonly<NumberArray4>;
+  strength?: number;
+  enabled?: boolean;
+};
+type AmbientUniforms = {viewport: Readonly<NumberArray4>; strength: number; enabled: number};
+type AmbientBindings<TextureT = unknown> = {ambientOcclusionTexture?: TextureT};
+
+/** Sets ambient visibility for the canonical PBR material; direct lighting and emission remain independent. */
+export const pbrAmbientOcclusion: ShaderModule<
+  PBRAmbientOcclusionProps,
+  AmbientUniforms,
+  AmbientBindings
+> = {
+  name: 'pbrAmbientOcclusion',
+  dependencies: [pbrMaterial],
+  bindingLayout: [
+    {name: 'pbrAmbientOcclusion', group: 0},
+    {name: 'ambientOcclusionTexture', group: 2}
+  ],
+  uniformTypes: {viewport: 'vec4<f32>', strength: 'f32', enabled: 'i32'},
+  defaultUniforms: {viewport: [0, 0, 1, 1], strength: 1, enabled: 1},
+  getUniforms(properties = {}) {
+    return {
+      ...(properties.viewport ? {viewport: properties.viewport} : {}),
+      ...(properties.strength === undefined ? {} : {strength: properties.strength}),
+      ...(properties.enabled === undefined ? {} : {enabled: Number(properties.enabled)}),
+      ...(properties.ambientOcclusionTexture
+        ? {ambientOcclusionTexture: properties.ambientOcclusionTexture}
+        : {})
+    };
+  },
+  source: /* wgsl */ `
+struct PBRAmbientOcclusionUniforms {
+  viewport: vec4f,
+  strength: f32,
+  enabled: i32,
+};
+@group(0) @binding(auto) var<uniform> pbrAmbientOcclusion: PBRAmbientOcclusionUniforms;
+@group(2) @binding(auto) var ambientOcclusionTexture: texture_2d<f32>;
+@group(2) @binding(auto) var ambientOcclusionTextureSampler: sampler;
+fn pbrAmbientOcclusion_getFactor(pixelPosition:vec2f)->f32 {
+  if(pbrAmbientOcclusion.enabled==0){return 1.0;}
+  let coordinates=(pixelPosition-pbrAmbientOcclusion.viewport.xy)/pbrAmbientOcclusion.viewport.zw;
+  if(any(coordinates<vec2f(0.0))||any(coordinates>vec2f(1.0))){return 1.0;}
+  let visibility=textureSampleLevel(ambientOcclusionTexture,ambientOcclusionTextureSampler,coordinates,0.0).r;
+  return mix(1.0,clamp(visibility,0.0,1.0),clamp(pbrAmbientOcclusion.strength,0.0,1.0));
+}
+fn pbrAmbientOcclusion_setFactor(pixelPosition:vec2f) {
+  pbr_ambientVisibility = pbrAmbientOcclusion_getFactor(pixelPosition);
+}`,
+  fs: /* glsl */ `
+layout(std140) uniform pbrAmbientOcclusionUniforms {
+  vec4 viewport;
+  float strength;
+  int enabled;
+} pbrAmbientOcclusion;
+uniform sampler2D ambientOcclusionTexture;
+float pbrAmbientOcclusion_getFactor(vec2 pixelPosition) {
+  if(pbrAmbientOcclusion.enabled==0)return 1.0;
+  vec2 coordinates=(pixelPosition-pbrAmbientOcclusion.viewport.xy)/pbrAmbientOcclusion.viewport.zw;
+  if(any(lessThan(coordinates,vec2(0.0)))||any(greaterThan(coordinates,vec2(1.0))))return 1.0;
+  float visibility=texture(ambientOcclusionTexture,coordinates).r;
+  return mix(1.0,clamp(visibility,0.0,1.0),clamp(pbrAmbientOcclusion.strength,0.0,1.0));
+}
+void pbrAmbientOcclusion_setFactor(vec2 pixelPosition) {
+  pbr_ambientVisibility = pbrAmbientOcclusion_getFactor(pixelPosition);
+}`
+};

package/src/modules/lighting/pbr-contact-shadow/pbr-contact-shadow.ts

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {NumberArray4} from '@math.gl/core';
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {pbrMaterial} from '../pbr-material/pbr-material';
+
+export type PBRContactShadowProps<TextureT = unknown> = {
+  contactShadowTexture?: TextureT;
+  /** Origin and dimensions of the receiver viewport, in physical pixels. */
+  viewport?: Readonly<NumberArray4>;
+  strength?: number;
+  enabled?: boolean;
+};
+type ContactUniforms = {viewport: Readonly<NumberArray4>; strength: number; enabled: number};
+type ContactBindings<TextureT = unknown> = {contactShadowTexture?: TextureT};
+
+/** Applies a screen-space visibility mask to the first directional light only. */
+export const pbrContactShadow: ShaderModule<
+  PBRContactShadowProps,
+  ContactUniforms,
+  ContactBindings
+> = {
+  name: 'pbrContactShadow',
+  dependencies: [pbrMaterial],
+  bindingLayout: [
+    {name: 'pbrContactShadow', group: 0},
+    {name: 'contactShadowTexture', group: 2}
+  ],
+  uniformTypes: {viewport: 'vec4<f32>', strength: 'f32', enabled: 'i32'},
+  defaultUniforms: {viewport: [0, 0, 1, 1], strength: 1, enabled: 1},
+  getUniforms(properties = {}) {
+    return {
+      ...(properties.viewport ? {viewport: properties.viewport} : {}),
+      ...(properties.strength === undefined ? {} : {strength: properties.strength}),
+      ...(properties.enabled === undefined ? {} : {enabled: Number(properties.enabled)}),
+      ...(properties.contactShadowTexture
+        ? {contactShadowTexture: properties.contactShadowTexture}
+        : {})
+    };
+  },
+  source: /* wgsl */ `
+struct PBRContactShadowUniforms {
+  viewport: vec4f,
+  strength: f32,
+  enabled: i32,
+};
+@group(0) @binding(auto) var<uniform> pbrContactShadow: PBRContactShadowUniforms;
+@group(2) @binding(auto) var contactShadowTexture: texture_2d<f32>;
+@group(2) @binding(auto) var contactShadowTextureSampler: sampler;
+fn pbrContactShadow_getFactor(pixelPosition:vec2f)->f32 {
+  if(pbrContactShadow.enabled==0){return 1.0;}
+  let coordinates=(pixelPosition-pbrContactShadow.viewport.xy)/pbrContactShadow.viewport.zw;
+  if(any(coordinates<vec2f(0.0))||any(coordinates>vec2f(1.0))){return 1.0;}
+  let visibility=textureSampleLevel(contactShadowTexture,contactShadowTextureSampler,coordinates,0.0).r;
+  return mix(1.0,clamp(visibility,0.0,1.0),clamp(pbrContactShadow.strength,0.0,1.0));
+}
+fn pbrContactShadow_filterColor(vertexColor:vec4f,pixelPosition:vec2f)->vec4f {
+  return pbr_filterColorWithShadows(vertexColor,pbrContactShadow_getFactor(pixelPosition),vec4f(1.0),vec4f(1.0));
+}`,
+  fs: /* glsl */ `
+layout(std140) uniform pbrContactShadowUniforms {
+  vec4 viewport;
+  float strength;
+  int enabled;
+} pbrContactShadow;
+uniform sampler2D contactShadowTexture;
+float pbrContactShadow_getFactor(vec2 pixelPosition) {
+  if(pbrContactShadow.enabled==0)return 1.0;
+  vec2 coordinates=(pixelPosition-pbrContactShadow.viewport.xy)/pbrContactShadow.viewport.zw;
+  if(any(lessThan(coordinates,vec2(0.0)))||any(greaterThan(coordinates,vec2(1.0))))return 1.0;
+  float visibility=texture(contactShadowTexture,coordinates).r;
+  return mix(1.0,clamp(visibility,0.0,1.0),clamp(pbrContactShadow.strength,0.0,1.0));
+}
+vec4 pbrContactShadow_filterColor(vec4 vertexColor,vec2 pixelPosition) {
+  return pbr_filterColorWithShadows(vertexColor,pbrContactShadow_getFactor(pixelPosition),vec4(1.0),vec4(1.0));
+}`
+};