@luma.gl/shadertools 9.0.16 → 9.0.19

package/dist/dist.dev.js

@@ -4909,7 +4909,7 @@ float tan_fp32(float a) {
   };
 
   // src/modules/engine/picking/picking.ts
-  var DEFAULT_HIGHLIGHT_COLOR = new Float32Array([0, 1, 1, 1]);
+  var DEFAULT_HIGHLIGHT_COLOR = [0, 1, 1, 1];
   var vs = glsl`\
 uniform pickingUniforms {
   float isActive;
@@ -5058,7 +5058,7 @@ vec4 picking_filterColor(vec4 color) {
       isAttribute: false,
       isHighlightActive: false,
       useFloatColors: true,
-      highlightedObjectColor: new Float32Array([0, 0, 0]),
+      highlightedObjectColor: [0, 0, 0],
       highlightColor: DEFAULT_HIGHLIGHT_COLOR
     },
     getUniforms
@@ -5112,15 +5112,16 @@ struct DirectionalLight {
 
 uniform lightingUniforms {
   int enabled;
-  int pointLightCount;
+  int lightType;
+
   int directionalLightCount;
+  int pointLightCount;
 
   vec3 ambientColor;
 
-  int lightType;
   vec3 lightColor;
-  vec3 lightDirection;
   vec3 lightPosition;
+  vec3 lightDirection;
   vec3 lightAttenuation;
 
   // AmbientLight ambientLight;
@@ -5160,11 +5161,13 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
     },
     uniformTypes: {
       enabled: "i32",
-      ambientLightColor: "vec3<f32>",
-      numberOfLights: "i32",
-      // , array: MAX_LIGHTS,
       lightType: "i32",
       // , array: MAX_LIGHTS,
+      directionalLightCount: "i32",
+      // , array: MAX_LIGHTS,
+      pointLightCount: "i32",
+      // , array: MAX_LIGHTS,
+      ambientLightColor: "vec3<f32>",
       lightColor: "vec3<f32>",
       // , array: MAX_LIGHTS,
       lightPosition: "vec3<f32>",
@@ -5177,9 +5180,10 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
     },
     defaultUniforms: {
       enabled: 1,
-      ambientLightColor: [0.1, 0.1, 0.1],
-      numberOfLights: 0,
       lightType: 0 /* POINT */,
+      directionalLightCount: 0,
+      pointLightCount: 0,
+      ambientLightColor: [0.1, 0.1, 0.1],
       lightColor: [1, 1, 1],
       lightPosition: [1, 1, 2],
       // TODO - could combine direction and attenuation
@@ -5238,7 +5242,8 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
       lightSourceUniforms.lightDirection = directionalLight.direction;
       currentLight++;
     }
-    lightSourceUniforms.numberOfLights = currentLight;
+    lightSourceUniforms.directionalLightCount = directionalLights.length;
+    lightSourceUniforms.pointLightCount = pointLights.length;
     return lightSourceUniforms;
   }
   function extractLightTypes(lights2) {
@@ -5300,7 +5305,7 @@ vec4 dirlight_filterColor(vec4 color) {
       lightDirection: "vec3<f32>"
     },
     defaultUniforms: {
-      lightDirection: new Float32Array([1, 1, 2])
+      lightDirection: [1, 1, 2]
     },
     getUniforms: getUniforms3
   };
@@ -5314,15 +5319,7 @@ vec4 dirlight_filterColor(vec4 color) {
 
   // src/modules/lighting/gouraud-material/gouraud-shaders-glsl.ts
   var GOURAUD_VS = glsl`\
-uniform materialUniforms {
-  uniform float ambient;
-  uniform float diffuse;
-  uniform float shininess;
-  uniform vec3  specularColor;
-} material;
-`;
-  var GOURAUD_FS = glsl`\
-uniform materialUniforms {
+uniform gouraudMaterialUniforms {
   uniform float ambient;
   uniform float diffuse;
   uniform float shininess;
@@ -5344,39 +5341,41 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_d
 vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
   vec3 lightColor = surfaceColor;
 
-  if (lighting.enabled) {
-    vec3 view_direction = normalize(cameraPosition - position_worldspace);
-    lightColor = material.ambient * surfaceColor * lighting.ambientColor;
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
 
-    if (lighting.lightType == 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);
-    } 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);
+  vec3 view_direction = normalize(cameraPosition - position_worldspace);
+  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
+
+  if (lighting.lightType == 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);
+  } 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);
+  }
 
-    for (int i = 0; i < MAX_LIGHTS; i++) {
-      if (i >= lighting.directionalLightCount) {
-        break;
-      }
-      DirectionalLight directionalLight = lighting.directionalLight[i];
-      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+  for (int i = 0; i < MAX_LIGHTS; i++) {
+    if (i >= lighting.directionalLightCount) {
+      break;
     }
-    */
+    DirectionalLight directionalLight = lighting.directionalLight[i];
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
   }
+  */
   return lightColor;
 }
 
@@ -5384,30 +5383,41 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
   vec3 lightColor = vec3(0, 0, 0);
   vec3 surfaceColor = vec3(0, 0, 0);
 
-  if (lighting.enabled) {
-    vec3 view_direction = normalize(cameraPosition - position_worldspace);
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
 
-    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;
+  vec3 view_direction = normalize(cameraPosition - position_worldspace);
 
-      case 1:
-        DirectionalLight directionalLight = lighting_getDirectionalLight(0);
-        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-        break;
-    }
+  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;
 }
+`;
+  var GOURAUD_FS = glsl`\
+uniform gouraudMaterialUniforms {
+  uniform float ambient;
+  uniform float diffuse;
+  uniform float shininess;
+  uniform vec3  specularColor;
+} material;
 `;
 
   // src/modules/lighting/gouraud-material/gouraud-material.ts
   var gouraudMaterial = {
-    name: "gouraud-lighting",
+    name: "gouraudMaterial",
     // Note these are switched between phong and gouraud
     vs: GOURAUD_VS,
     fs: GOURAUD_FS,
@@ -5508,21 +5518,23 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
   vec3 surfaceColor = vec3(0, 0, 0);
 
   if (lighting.enabled == 0) {
-    vec3 view_direction = normalize(cameraPosition - position_worldspace);
+    return lightColor;
+  }
 
-    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;
+  vec3 view_direction = normalize(cameraPosition - position_worldspace);
 
-      case 1:
-        DirectionalLight directionalLight = lighting_getDirectionalLight(0);
-        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-        break;
-    }
+  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;
 }
@@ -5530,7 +5542,7 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
 
   // src/modules/lighting/phong-material/phong-material.ts
   var phongMaterial = {
-    name: "phong-lighting",
+    name: "phongMaterial",
     // Note these are switched between phong and gouraud
     vs: PHONG_VS,
     fs: PHONG_FS,
@@ -6054,25 +6066,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
       scaleDiffBaseMR: "vec4<f32>",
       scaleFGDSpec: "vec4<f32>"
     },
-    bindings: {
-      baseColorSampler: { type: "texture", location: 8 },
-      // #ifdef HAS_BASECOLORMAP
-      normalSampler: { type: "texture", location: 9 },
-      // #ifdef HAS_NORMALMAP
-      emissiveSampler: { type: "texture", location: 10 },
-      // #ifdef HAS_EMISSIVEMAP
-      metallicRoughnessSampler: { type: "texture", location: 11 },
-      // #ifdef HAS_METALROUGHNESSMAP
-      occlusionSampler: { type: "texture", location: 12 },
-      // #ifdef HAS_OCCLUSIONMAP
-      // IBL Samplers
-      diffuseEnvSampler: { type: "texture", location: 13 },
-      // #ifdef USE_IBL (samplerCube)
-      specularEnvSampler: { type: "texture", location: 14 },
-      // #ifdef USE_IBL (samplerCube)
-      brdfLUT: { type: "texture", location: 15 }
-      // #ifdef USE_IBL
-    },
     dependencies: [lighting]
   };