@luma.gl/shadertools 9.1.0-alpha.16 → 9.1.0-alpha.18

package/src/modules/lighting/pbr-material/pbr-projection.ts

@@ -0,0 +1,39 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/* eslint-disable camelcase */
+
+import type {NumberArray3, NumberArray16} from '@math.gl/core';
+
+import {ShaderModule} from '../../../lib/shader-module/shader-module';
+
+const uniformBlock = /* glsl */ `\
+uniform pbrProjectionUniforms {
+  mat4 modelViewProjectionMatrix;
+  mat4 modelMatrix;
+  mat4 normalMatrix;
+  vec3 camera;
+} pbrProjection;
+`;
+
+export type PBRProjectionProps = {
+  modelViewProjectionMatrix: NumberArray16;
+  modelMatrix: NumberArray16;
+  normalMatrix: NumberArray16;
+  camera: NumberArray3;
+};
+
+export const pbrProjection: ShaderModule<PBRProjectionProps> = {
+  name: 'pbrProjection',
+  vs: uniformBlock,
+  fs: uniformBlock,
+  // TODO why is this needed?
+  getUniforms: props => props,
+  uniformTypes: {
+    modelViewProjectionMatrix: 'mat4x4<f32>',
+    modelMatrix: 'mat4x4<f32>',
+    normalMatrix: 'mat4x4<f32>',
+    camera: 'vec3<i32>'
+  }
+};

package/src/modules/lighting/pbr-material/pbr-vertex-glsl.ts

@@ -3,38 +3,30 @@
 // Copyright (c) vis.gl contributors
 
 export const vs = /* glsl */ `\
-uniform projection {
-  mat4 u_MVPMatrix;
-  mat4 u_ModelMatrix;
-  mat4 u_NormalMatrix;
-  // Projection
-  vec3 u_Camera;
-}
-
-varying vec3 pbr_vPosition;
-varying vec2 pbr_vUV;
+out vec3 pbr_vPosition;
+out vec2 pbr_vUV;
 
 #ifdef HAS_NORMALS
 # ifdef HAS_TANGENTS
-varying mat3 pbr_vTBN;
+out mat3 pbr_vTBN;
 # else
-varying vec3 pbr_vNormal;
+out vec3 pbr_vNormal;
 # endif
 #endif
 
 void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, vec2 uv)
 {
-  vec4 pos = u_ModelMatrix * position;
+  vec4 pos = pbrProjection.modelMatrix * position;
   pbr_vPosition = vec3(pos.xyz) / pos.w;
 
 #ifdef HAS_NORMALS
 #ifdef HAS_TANGENTS
-  vec3 normalW = normalize(vec3(u_NormalMatrix * vec4(normal.xyz, 0.0)));
-  vec3 tangentW = normalize(vec3(u_ModelMatrix * vec4(tangent.xyz, 0.0)));
+  vec3 normalW = normalize(vec3(pbrProjection.normalMatrix * vec4(normal.xyz, 0.0)));
+  vec3 tangentW = normalize(vec3(pbrProjection.modelMatrix * vec4(tangent.xyz, 0.0)));
   vec3 bitangentW = cross(normalW, tangentW) * tangent.w;
   pbr_vTBN = mat3(tangentW, bitangentW, normalW);
 #else // HAS_TANGENTS != 1
-  pbr_vNormal = normalize(vec3(u_ModelMatrix * vec4(normal.xyz, 0.0)));
+  pbr_vNormal = normalize(vec3(pbrProjection.modelMatrix * vec4(normal.xyz, 0.0)));
 #endif
 #endif
 

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

@@ -2,27 +2,23 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import {NumberArray3} from '@math.gl/types';
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
 import {lighting} from '../lights/lighting';
 import {PHONG_WGSL} from './phong-shaders-wgsl';
 import {PHONG_VS, PHONG_FS} from './phong-shaders-glsl';
 
-export type PhongMaterialProps = PhongMaterialUniforms;
-
-export type PhongMaterialUniforms = {
+export type PhongMaterialProps = {
   ambient?: number;
   diffuse?: number;
   /** Specularity exponent */
   shininess?: number;
-  specularColor?: [number, number, number];
+  specularColor?: NumberArray3;
 };
 
 /** In Phong shading, the normal vector is linearly interpolated across the surface of the polygon from the polygon's vertex normals. */
-export const phongMaterial = {
-  props: {} as PhongMaterialProps,
-  uniforms: {} as PhongMaterialUniforms,
-
-  name: 'phong-lighting',
+export const phongMaterial: ShaderModule<PhongMaterialProps> = {
+  name: 'phongMaterial',
   dependencies: [lighting],
   // Note these are switched between phong and gouraud
   source: PHONG_WGSL,
@@ -43,7 +39,11 @@ export const phongMaterial = {
     shininess: 32,
     specularColor: [0.15, 0.15, 0.15]
   },
-  getUniforms(props?: PhongMaterialProps): PhongMaterialUniforms {
-    return {...phongMaterial.defaultUniforms, ...props};
+  getUniforms(props?: PhongMaterialProps) {
+    const uniforms = {...props};
+    if (uniforms.specularColor) {
+      uniforms.specularColor = uniforms.specularColor.map(x => x / 255) as NumberArray3;
+    }
+    return {...phongMaterial.defaultUniforms, ...uniforms};
   }
-} as const satisfies ShaderModule<PhongMaterialProps, PhongMaterialUniforms>;
+};

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

@@ -41,100 +41,20 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 positio
   vec3 view_direction = normalize(cameraPosition - position_worldspace);
   lightColor = material.ambient * surfaceColor * lighting.ambientColor;
 
-  if (lighting.lightType == 0) {
-    PointLight pointLight = lighting_getPointLight(0);
+  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);
-    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-  } else if (lighting.lightType == 1) {
-    DirectionalLight directionalLight = lighting_getDirectionalLight(0);
-    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-  }
-  
-  /*
-  for (int i = 0; i < MAX_LIGHTS; i++) {
-    if (i >= lighting.pointLightCount) {
-      break;
-    }
-    PointLight pointLight = lighting.pointLight[i];
-    vec3 light_position_worldspace = pointLight.position;
-    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+    float light_attenuation = getPointLightAttenuation(pointLight, distance(light_position_worldspace, position_worldspace));
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color / light_attenuation);
   }
 
-  for (int i = 0; i < MAX_LIGHTS; i++) {
-    if (i >= lighting.directionalLightCount) {
-      break;
-    }
-    DirectionalLight directionalLight = lighting.directionalLight[i];
+  int totalLights = min(MAX_LIGHTS, lighting.pointLightCount + lighting.directionalLightCount);
+  for (int i = lighting.pointLightCount; i < totalLights; i++) {
+    DirectionalLight directionalLight = lighting_getDirectionalLight(i);
     lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
   }
-  */
-  return lightColor;
-}
-
-vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
-  vec3 lightColor = vec3(0, 0, 0);
-  vec3 surfaceColor = vec3(0, 0, 0);
-
-  if (lighting.enabled == 0) {
-    vec3 view_direction = normalize(cameraPosition - position_worldspace);
-
-    switch (lighting.lightType) {
-      case 0:
-        PointLight pointLight = lighting_getPointLight(0);
-        vec3 light_position_worldspace = pointLight.position;
-        vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-        break;
-
-      case 1:
-        DirectionalLight directionalLight = lighting_getDirectionalLight(0);
-        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-        break;
-    }
-  }
+  
   return lightColor;
 }
 `;
-
-// TODO - handle multiple lights
-/**
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting.pointLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting_getPointLight(i);
-      vec3 light_position_worldspace = pointLight.position;
-      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-    }
-
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting.directionalLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting_getDirectionalLight(i);
-      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-    }
-  }
-    /**
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting.pointLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting_getPointLight(i);
-      vec3 light_position_worldspace = pointLight.position;
-      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-    }
-
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting.directionalLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting_getDirectionalLight(i);
-      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-    }
-  }
-  */

package/src/modules-webgl1/project/project.ts

@@ -2,19 +2,20 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {Matrix4} from '@math.gl/core';
+import {Vector3, Matrix4} from '@math.gl/core';
 import {ShaderModule} from '../../lib/shader-module/shader-module';
+import type {NumberArray3, NumberArray16} from '@math.gl/core';
 
 type ProjectionProps = {
-  modelMatrix?: readonly number[];
-  viewMatrix?: readonly number[];
-  projectionMatrix?: readonly number[];
-  cameraPositionWorld?: readonly number[];
+  modelMatrix?: Readonly<Matrix4 | NumberArray16>;
+  viewMatrix?: Readonly<Matrix4 | NumberArray16>;
+  projectionMatrix?: Readonly<Matrix4 | NumberArray16>;
+  cameraPositionWorld?: Readonly<Vector3 | NumberArray3>;
 };
 
-const IDENTITY_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+const IDENTITY_MATRIX: NumberArray16 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
 
-const DEFAULT_MODULE_OPTIONS = {
+const DEFAULT_MODULE_OPTIONS: ProjectionProps = {
   modelMatrix: IDENTITY_MATRIX,
   viewMatrix: IDENTITY_MATRIX,
   projectionMatrix: IDENTITY_MATRIX,

package/src/passes/postprocessing/fxaa/fxaa.ts

@@ -97,7 +97,7 @@ import {ShaderPass} from '../../../lib/shader-module/shader-pass';
 // _  = the highest digit is directly related to style
 //
 
-const fs = `
+const fs = /* glsl */ `
 #define FXAA_QUALITY_PRESET 29
 
 #if (FXAA_QUALITY_PRESET == 10)
@@ -691,4 +691,4 @@ export const fxaa = {
   fs,
   passes: [{sampler: true}],
   getUniforms: props => props
-} as const satisfies ShaderPass<FXAAProps, FXAAUniforms>;
+} as const satisfies ShaderPass<FXAAProps, FXAAUniforms, {}>;

package/src/passes/postprocessing/image-adjust-filters/brightnesscontrast.ts

@@ -60,7 +60,6 @@ export type BrightnessContrastUniforms = BrightnessContrastProps;
  */
 export const brightnessContrast = {
   props: {} as BrightnessContrastProps,
-  uniforms: {} as BrightnessContrastUniforms,
 
   name: 'brightnessContrast',
   uniformTypes: {

package/src/passes/postprocessing/image-adjust-filters/huesaturation.ts

@@ -62,7 +62,6 @@ export type HueSaturationUniforms = HueSaturationProps;
  */
 export const hueSaturation = {
   props: {} as HueSaturationProps,
-  uniforms: {} as HueSaturationUniforms,
 
   name: 'hueSaturation',
   fs,

package/src/passes/postprocessing/image-adjust-filters/vibrance.ts

@@ -37,6 +37,9 @@ export const vibrance = {
   props: {} as VibranceProps,
   uniforms: {} as VibranceUniforms,
   name: 'vibrance',
+  uniformTypes: {
+    amount: 'f32'
+  },
   propTypes: {
     amount: {value: 0, min: -1, max: 1}
   },

package/src/passes/postprocessing/image-blur-filters/tiltshift.ts

@@ -57,9 +57,9 @@ vec4 tiltShift_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
  */
 export type TiltShiftProps = {
   /** The x,y coordinate of the start of the line segment. */
-  start?: number[];
+  start?: [number, number];
   /** The xm y coordinate of the end of the line segment. */
-  end?: number[];
+  end?: [number, number];
   /** The maximum radius of the pyramid blur. */
   blurRadius?: number;
   /** The distance from the line at which the maximum blur radius is reached. */

package/src/passes/postprocessing/image-blur-filters/triangleblur.ts

@@ -51,7 +51,7 @@ export type TriangleBlurProps = {
   /** The radius of the pyramid convolved with the image. */
   radius?: number;
   /** @deprecated internal property */
-  delta?: number[];
+  delta?: [number, number];
 };
 
 export type TriangleBlurUniforms = TriangleBlurProps;

package/src/passes/postprocessing/image-blur-filters/zoomblur.ts

@@ -45,7 +45,7 @@ vec4 zoomBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
  */
 export type ZoomBlurProps = {
   /** - The x, y coordinate of the blur origin. */
-  center?: number[];
+  center?: [number, number];
   /** - The strength of the blur. Values in the range 0 to 1 are usually sufficient, where 0 doesn't change the image and 1 creates a highly blurred image. */
   strength?: number;
 };

package/src/passes/postprocessing/image-fun-filters/colorhalftone.ts

@@ -50,7 +50,7 @@ vec4 colorHalftone_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
  */
 export type ColorHalftoneProps = {
   /** The x,y coordinate of the pattern origin. */
-  center?: number[];
+  center?: [number, number];
   /** The rotation of the pattern in radians. */
   angle?: number;
   /** The diameter of a dot in pixels. */

package/src/passes/postprocessing/image-fun-filters/dotscreen.ts

@@ -36,7 +36,7 @@ vec4 dotScreen_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
  */
 export type DotScreenProps = {
   /** The x, y coordinate of the pattern origin. */
-  center?: number[];
+  center?: [number, number];
   /** The rotation of the pattern in radians. */
   angle?: number;
   /** The diameter of a dot in pixels. */

package/src/passes/postprocessing/image-fun-filters/edgework.ts

@@ -8,11 +8,11 @@ import {random} from '../../../modules/math/random/random';
 const fs = /* glsl */ `\
 uniform edgeWorkUniforms {
   float radius;
-  vec2 delta;
+  int mode;
 } edgeWork;
 
-vec4 edgeWork_sampleColor1(sampler2D source, vec2 texSize, vec2 texCoord) {
-  vec2 relativeDelta = edgeWork.radius * edgeWork.delta / texSize;
+vec4 edgeWork_sampleColorRGB(sampler2D source, vec2 texSize, vec2 texCoord, vec2 delta) {
+  vec2 relativeDelta = edgeWork.radius * delta / texSize;
 
   vec2 color = vec2(0.0);
   vec2 total = vec2(0.0);
@@ -36,8 +36,8 @@ vec4 edgeWork_sampleColor1(sampler2D source, vec2 texSize, vec2 texCoord) {
   return vec4(color / total, 0.0, 1.0);
 }
 
-vec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {
-  vec2 relativeDelta = edgeWork.radius * edgeWork.delta / texSize;
+vec4 edgeWork_sampleColorXY(sampler2D source, vec2 texSize, vec2 texCoord, vec2 delta) {
+  vec2 relativeDelta = edgeWork.radius * delta / texSize;
 
   vec2 color = vec2(0.0);
   vec2 total = vec2(0.0);
@@ -60,6 +60,16 @@ vec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {
   float c = clamp(10000.0 * (color.y / total.y - color.x / total.x) + 0.5, 0.0, 1.0);
   return vec4(c, c, c, 1.0);
 }
+
+vec4 edgeWork_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  switch (edgeWork.mode) {
+    case 0: 
+    return edgeWork_sampleColorRGB(source, texSize, texCoord, vec2(1., 0.));
+    case 1: 
+    default:
+      return edgeWork_sampleColorXY(source, texSize, texCoord, vec2(0., 1.));
+  }
+}
 `;
 
 /**
@@ -70,8 +80,8 @@ vec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {
 export type EdgeWorkProps = {
   /** radius The radius of the effect in pixels. */
   radius?: number;
-  /** @deprecated internal */
-  delta?: number;
+  /** @deprecated xy or RGB */
+  mode?: 0 | 1;
 };
 
 export type EdgeWorkUniforms = EdgeWorkProps;
@@ -88,22 +98,23 @@ export const edgeWork = {
   name: 'edgeWork',
   dependencies: [random],
   fs,
-
+  uniformTypes: {
+    radius: 'f32',
+    mode: 'i32'
+  },
   propTypes: {
     radius: {value: 2, min: 1, softMax: 50},
-    delta: {value: [1, 0], private: true}
+    mode: {value: 0, private: true}
   },
 
   passes: [
     {
-      // @ts-expect-error
-      sampler: 'edgeWork_sampleColor1',
-      propTypes: {delta: [1, 0]}
+      sampler: true,
+      uniforms: {mode: 0}
     },
     {
-      // @ts-expect-error
-      sampler: 'edgeWork_sampleColor2',
-      propTypes: {delta: [0, 1]}
+      sampler: true,
+      uniforms: {mode: 1}
     }
   ]
 } as const satisfies ShaderPass<EdgeWorkProps, EdgeWorkProps>;

package/src/passes/postprocessing/image-fun-filters/hexagonalpixelate.ts

@@ -56,7 +56,7 @@ vec4 hexagonalPixelate_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord
  */
 export type HexagonalPixelateProps = {
   /** The [x, y] coordinates of the pattern center. */
-  center?: number[];
+  center?: [number, number];
   /** The width of an individual tile, in pixels. */
   scale?: number;
 };

package/src/passes/postprocessing/image-fun-filters/magnify.ts

@@ -32,7 +32,7 @@ vec4 magnify_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
  */
 export type MagnifyProps = {
   /** x, y position in screen coords, both x and y is normalized and in range `[0, 1]`. `[0, 0]` is the up left corner, `[1, 1]` is the bottom right corner. Default value is `[0, 0]`. */
-  screenXY?: number[];
+  screenXY?: [number, number];
   /** effect radius in pixels. Default value is `100`. */
   radiusPixels?: number;
   /** magnify level. Default value is `2`. */
@@ -40,7 +40,7 @@ export type MagnifyProps = {
   /** border width of the effect circle, will not show border if value <= 0.0. Default value is `0`. */
   borderWidthPixels?: number;
   /** border color of the effect circle. Default value is `[255, 255, 255, 255]`. */
-  borderColor?: number[];
+  borderColor?: [number, number, number, number];
 };
 
 export type MagnifyUniforms = MagnifyProps;

package/src/passes/postprocessing/image-warp-filters/bulgepinch.ts

@@ -38,7 +38,7 @@ vec4 bulgePinch_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
 /** Bulges or pinches the image in a circle. */
 export type BulgePinchProps = {
   /** The [x, y] coordinates of the center of the circle of effect. */
-  center?: number[];
+  center?: [number, number];
   /** The radius of the circle of effect. */
   radius?: number;
   /** strength -1 to 1 (-1 is strong pinch, 0 is no effect, 1 is strong bulge) */

package/dist/modules/lighting/gouraud-material/gouraud-shaders-glsl.d.ts

@@ -1,42 +0,0 @@
-export declare const GOURAUD_VS = "uniform materialUniforms {\n  uniform float ambient;\n  uniform float diffuse;\n  uniform float shininess;\n  uniform vec3  specularColor;\n} material;\n";
-export declare const GOURAUD_FS = "uniform materialUniforms {\n  uniform float ambient;\n  uniform float diffuse;\n  uniform float shininess;\n  uniform vec3  specularColor;\n} material;\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {\n  vec3 halfway_direction = normalize(light_direction + view_direction);\n  float lambertian = dot(light_direction, normal_worldspace);\n  float specular = 0.0;\n  if (lambertian > 0.0) {\n    float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);\n    specular = pow(specular_angle, material.shininess);\n  }\n  lambertian = max(lambertian, 0.0);\n  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;\n}\n\nvec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = surfaceColor;\n\n  if (lighting.enabled) {\n    vec3 view_direction = normalize(cameraPosition - position_worldspace);\n    lightColor = material.ambient * surfaceColor * lighting.ambientColor;\n\n    if (lighting.lightType == 0) {\n      PointLight pointLight = lighting_getPointLight(0);\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    } else if (lighting.lightType == 1) {\n      DirectionalLight directionalLight = lighting_getDirectionalLight(0);\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n    /*\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.pointLightCount) {\n        break;\n      }\n      PointLight pointLight = lighting.pointLight[i];\n      vec3 light_position_worldspace = pointLight.position;\n      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n    }\n\n    for (int i = 0; i < MAX_LIGHTS; i++) {\n      if (i >= lighting.directionalLightCount) {\n        break;\n      }\n      DirectionalLight directionalLight = lighting.directionalLight[i];\n      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n    }\n    */\n  }\n  return lightColor;\n}\n\nvec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {\n  vec3 lightColor = vec3(0, 0, 0);\n  vec3 surfaceColor = vec3(0, 0, 0);\n\n  if (lighting.enabled) {\n    vec3 view_direction = normalize(cameraPosition - position_worldspace);\n\n    switch (lighting.lightType) {\n      case 0:\n        PointLight pointLight = lighting_getPointLight(0);\n        vec3 light_position_worldspace = pointLight.position;\n        vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n        break;\n\n      case 1:\n        DirectionalLight directionalLight = lighting_getDirectionalLight(0);\n        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n        break;\n    }\n  }\n  return lightColor;\n}\n";
-/**
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting.pointLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting_getPointLight(i);
-      vec3 light_position_worldspace = pointLight.position;
-      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-    }
-
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting.directionalLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting_getDirectionalLight(i);
-      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-    }
-  }
-    /**
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting.pointLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting_getPointLight(i);
-      vec3 light_position_worldspace = pointLight.position;
-      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-    }
-
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting.directionalLightCount) {
-        break;
-      }
-      PointLight pointLight = lighting_getDirectionalLight(i);
-      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-    }
-  }
-  */
-//# sourceMappingURL=gouraud-shaders-glsl.d.ts.map

package/dist/modules/lighting/gouraud-material/gouraud-shaders-glsl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gouraud-shaders-glsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/gouraud-material/gouraud-shaders-glsl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,UAAU,8JAOtB,CAAC;AAEF,eAAO,MAAM,UAAU,ihHAkFtB,CAAC;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsCI"}