@luma.gl/gltf 9.0.0-alpha.50 → 9.0.0-alpha.51

package/dist/dist.dev.js

@@ -1356,26 +1356,172 @@ var __exports__ = (() => {
   __publicField(Texture, "STORAGE_BINDING", 8);
   __publicField(Texture, "RENDER_ATTACHMENT", 16);
 
+  // ../core/src/lib/compiler-log/format-compiler-log.ts
+  function formatCompilerLog(shaderLog, source, options) {
+    let formattedLog = "";
+    const lines = source.split(/\r?\n/);
+    const log3 = shaderLog.slice().sort((a, b) => a.lineNum - b.lineNum);
+    switch (options?.showSourceCode || "no") {
+      case "all":
+        let currentMessage = 0;
+        for (let lineNum = 1; lineNum <= lines.length; lineNum++) {
+          formattedLog += getNumberedLine(lines[lineNum - 1], lineNum, options);
+          while (log3.length > currentMessage && log3[currentMessage].lineNum === lineNum) {
+            const message2 = log3[currentMessage++];
+            formattedLog += formatCompilerMessage(message2, lines, message2.lineNum, {
+              ...options,
+              inlineSource: false
+            });
+          }
+        }
+        return formattedLog;
+      case "issues":
+      case "no":
+        for (const message2 of shaderLog) {
+          formattedLog += formatCompilerMessage(message2, lines, message2.lineNum, {
+            inlineSource: options?.showSourceCode !== "no"
+          });
+        }
+        return formattedLog;
+    }
+  }
+  function formatCompilerMessage(message2, lines, lineNum, options) {
+    if (options?.inlineSource) {
+      const numberedLines = getNumberedLines(lines, lineNum);
+      const positionIndicator = message2.linePos > 0 ? `${" ".repeat(message2.linePos + 5)}^^^
+` : "";
+      return `
+${numberedLines}${positionIndicator}${message2.type.toUpperCase()}: ${message2.message}
+
+`;
+    }
+    return options?.html ? `<div class='luma-compiler-log-error' style="color:red;"><b> ${message2.type.toUpperCase()}: ${message2.message}</b></div>` : `${message2.type.toUpperCase()}: ${message2.message}`;
+  }
+  function getNumberedLines(lines, lineNum, options) {
+    let numberedLines = "";
+    for (let lineIndex = lineNum - 2; lineIndex <= lineNum; lineIndex++) {
+      const sourceLine = lines[lineIndex - 1];
+      if (sourceLine !== void 0) {
+        numberedLines += getNumberedLine(sourceLine, lineNum, options);
+      }
+    }
+    return numberedLines;
+  }
+  function getNumberedLine(line, lineNum, options) {
+    return `${padLeft(String(lineNum), 4)}: ${line}${options?.html ? "<br/>" : "\n"}`;
+  }
+  function padLeft(string, paddedLength) {
+    let result = "";
+    for (let i = string.length; i < paddedLength; ++i) {
+      result += " ";
+    }
+    return result + string;
+  }
+
+  // ../core/src/lib/compiler-log/get-shader-info.ts
+  function getShaderInfo(source, defaultName) {
+    return {
+      name: getShaderName(source, defaultName),
+      language: "glsl",
+      version: getShaderVersion(source)
+    };
+  }
+  function getShaderName(shader, defaultName = "unnamed") {
+    const SHADER_NAME_REGEXP = /#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/;
+    const match = SHADER_NAME_REGEXP.exec(shader);
+    return match ? match[1] : defaultName;
+  }
+  function getShaderVersion(source) {
+    let version = 100;
+    const words = source.match(/[^\s]+/g);
+    if (words && words.length >= 2 && words[0] === "#version") {
+      const v = parseInt(words[1], 10);
+      if (Number.isFinite(v)) {
+        version = v;
+      }
+    }
+    return version;
+  }
+
   // ../core/src/adapter/resources/shader.ts
   var _Shader = class extends Resource {
     get [Symbol.toStringTag]() {
       return "Shader";
     }
+    compilationStatus = "pending";
     constructor(device, props) {
-      super(device, props, _Shader.defaultProps);
+      super(device, {
+        id: getShaderIdFromProps(props),
+        ...props
+      }, _Shader.defaultProps);
       this.stage = this.props.stage;
       this.source = this.props.source;
     }
+    getCompilationInfoSync() {
+      return null;
+    }
+    async debugShader() {
+      switch (this.props.debug) {
+        case "never":
+          return;
+        case "errors":
+          if (this.compilationStatus === "success") {
+            return;
+          }
+          break;
+        case "warnings":
+        case "always":
+          break;
+      }
+      const messages = await this.getCompilationInfo();
+      if (this.props.debug === "warnings" && messages?.length === 0) {
+        return;
+      }
+      this._displayShaderLog(messages);
+    }
+    _displayShaderLog(messages) {
+      if (typeof document === "undefined" || !document?.createElement) {
+        return;
+      }
+      const shaderName = getShaderInfo(this.source).name;
+      const shaderTitle = `${this.stage} ${shaderName}`;
+      const htmlLog = formatCompilerLog(messages, this.source, {
+        showSourceCode: "all",
+        html: true
+      });
+      const button = document.createElement("Button");
+      button.innerHTML = `
+<h1>Shader Compilation Error in ${shaderTitle}</h1><br /><br />
+<code style="user-select:text;"><pre>
+${htmlLog}
+</pre></code>`;
+      button.style.top = "10px";
+      button.style.left = "10px";
+      button.style.position = "absolute";
+      button.style.zIndex = "9999";
+      button.style.width = "100%";
+      button.style.textAlign = "left";
+      document.body.appendChild(button);
+      document.getElementsByClassName("luma-compiler-log-error")[0]?.scrollIntoView();
+      button.onclick = () => {
+        const dataURI = `data:text/plain,${encodeURIComponent(this.source)}`;
+        navigator.clipboard.writeText(dataURI);
+      };
+    }
   };
   var Shader = _Shader;
   __publicField(Shader, "defaultProps", {
     ...Resource.defaultProps,
+    language: "auto",
     stage: "vertex",
     source: "",
     sourceMap: null,
-    language: "auto",
-    shaderType: 0
+    entryPoint: "main",
+    debug: "errors"
   });
+  function getShaderIdFromProps(props) {
+    return getShaderInfo(props.source).name || props.id || uid(`unnamed ${props.stage}-shader`);
+  }
 
   // ../core/src/adapter/resources/sampler.ts
   var _Sampler = class extends Resource {
@@ -2408,46 +2554,6 @@ var __exports__ = (() => {
     return `${dataType}x${components}`;
   }
 
-  // ../core/src/lib/compiler-log/format-compiler-log.ts
-  function formatCompilerLog(shaderLog, source, options) {
-    const lines = source.split(/\r?\n/);
-    let formattedLog = "";
-    for (const message2 of shaderLog) {
-      formattedLog += formatCompilerMessage(message2, lines, message2.lineNum, options);
-    }
-    return formattedLog;
-  }
-  function formatCompilerMessage(message2, lines, lineNum, options) {
-    if (options?.showSourceCode) {
-      const positionIndicator = message2.linePos > 0 ? `${" ".repeat(message2.linePos + 5)}^^^
-` : "";
-      const numberedLines = getNumberedLines(lines, lineNum);
-      return `${numberedLines}${positionIndicator}${message2.type.toUpperCase()}: ${message2.message}
-
-`;
-    }
-    return `${message2.type.toUpperCase()}: ${message2.message}
-`;
-  }
-  function getNumberedLines(lines, lineNum) {
-    let numberedLines = "";
-    for (let line = lineNum - 2; line <= lineNum; line++) {
-      const sourceLine = lines[line];
-      if (sourceLine !== void 0) {
-        numberedLines += `${padLeft(String(line), 4)}: ${sourceLine}
-`;
-      }
-    }
-    return numberedLines;
-  }
-  function padLeft(string, paddedLength) {
-    let result = "";
-    for (let i = string.length; i < paddedLength; ++i) {
-      result += " ";
-    }
-    return result + string;
-  }
-
   // ../core/src/lib/utils/cast.ts
   function cast(value) {
     return value;
@@ -3337,19 +3443,19 @@ ${moduleSource}
   }
 
   // ../shadertools/src/lib/glsl-utils/get-shader-info.ts
-  function getShaderInfo(source, defaultName) {
+  function getShaderInfo2(source, defaultName) {
     return {
-      name: getShaderName(source, defaultName),
+      name: getShaderName2(source, defaultName),
       language: "glsl",
-      version: getShaderVersion(source)
+      version: getShaderVersion2(source)
     };
   }
-  function getShaderName(shader, defaultName = "unnamed") {
+  function getShaderName2(shader, defaultName = "unnamed") {
     const SHADER_NAME_REGEXP = /#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/;
     const match = SHADER_NAME_REGEXP.exec(shader);
     return match ? match[1] : defaultName;
   }
-  function getShaderVersion(source) {
+  function getShaderVersion2(source) {
     let version = 100;
     const words = source.match(/[^\s]+/g);
     if (words && words.length >= 2 && words[0] === "#version") {
@@ -3498,7 +3604,7 @@ precision highp float;
       log: log3
     } = options;
     assert3(typeof source === "string", "shader source must be a string");
-    const sourceVersion = language === "glsl" ? getShaderInfo(source).version : -1;
+    const sourceVersion = language === "glsl" ? getShaderInfo2(source).version : -1;
     const targetVersion = platformInfo.shaderLanguageVersion;
     const sourceVersionDirective = sourceVersion === 100 ? "#version 100" : "#version 300 es";
     const sourceLines = source.split("\n");
@@ -6410,14 +6516,14 @@ uniform mat4 u_MVPMatrix;
 uniform mat4 u_ModelMatrix;
 uniform mat4 u_NormalMatrix;
 
-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
 
@@ -6509,15 +6615,15 @@ uniform vec4 u_ScaleDiffBaseMR;
 uniform vec4 u_ScaleFGDSpec;
 #endif
 
-varying vec3 pbr_vPosition;
+in vec3 pbr_vPosition;
 
-varying vec2 pbr_vUV;
+in vec2 pbr_vUV;
 
 #ifdef HAS_NORMALS
 #ifdef HAS_TANGENTS
-varying mat3 pbr_vTBN;
+in mat3 pbr_vTBN;
 #else
-varying vec3 pbr_vNormal;
+in vec3 pbr_vNormal;
 #endif
 #endif
 
@@ -6586,7 +6692,7 @@ vec3 getNormal()
 #endif
 
 #ifdef HAS_NORMALMAP
-  vec3 n = texture2D(u_NormalSampler, pbr_vUV).rgb;
+  vec3 n = texture(u_NormalSampler, pbr_vUV).rgb;
   n = normalize(tbn * ((2.0 * n - 1.0) * vec3(u_NormalScale, u_NormalScale, 1.0)));
 #else
   // The tbn matrix is linearly interpolated, so we need to re-normalize
@@ -6605,7 +6711,7 @@ vec3 getIBLContribution(PBRInfo pbrInputs, vec3 n, vec3 reflection)
   float mipCount = 9.0; // resolution of 512x512
   float lod = (pbrInputs.perceptualRoughness * mipCount);
   // retrieve a scale and bias to F0. See [1], Figure 3
-  vec3 brdf = SRGBtoLINEAR(texture2D(u_brdfLUT,
+  vec3 brdf = SRGBtoLINEAR(texture(u_brdfLUT,
     vec2(pbrInputs.NdotV, 1.0 - pbrInputs.perceptualRoughness))).rgb;
   vec3 diffuseLight = SRGBtoLINEAR(textureCube(u_DiffuseEnvSampler, n)).rgb;
 
@@ -6712,7 +6818,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
 {
   // The albedo may be defined from a base texture or a flat color
 #ifdef HAS_BASECOLORMAP
-  vec4 baseColor = SRGBtoLINEAR(texture2D(u_BaseColorSampler, pbr_vUV)) * u_BaseColorFactor;
+  vec4 baseColor = SRGBtoLINEAR(texture(u_BaseColorSampler, pbr_vUV)) * u_BaseColorFactor;
 #else
   vec4 baseColor = u_BaseColorFactor;
 #endif
@@ -6737,7 +6843,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
 #ifdef HAS_METALROUGHNESSMAP
     // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
     // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
-    vec4 mrSample = texture2D(u_MetallicRoughnessSampler, pbr_vUV);
+    vec4 mrSample = texture(u_MetallicRoughnessSampler, pbr_vUV);
     perceptualRoughness = mrSample.g * perceptualRoughness;
     metallic = mrSample.b * metallic;
 #endif
@@ -6816,12 +6922,12 @@ vec4 pbr_filterColor(vec4 colorUnused)
 
     // Apply optional PBR terms for additional (optional) shading
 #ifdef HAS_OCCLUSIONMAP
-    float ao = texture2D(u_OcclusionSampler, pbr_vUV).r;
+    float ao = texture(u_OcclusionSampler, pbr_vUV).r;
     color = mix(color, color * ao, u_OcclusionStrength);
 #endif
 
 #ifdef HAS_EMISSIVEMAP
-    vec3 emissive = SRGBtoLINEAR(texture2D(u_EmissiveSampler, pbr_vUV)).rgb * u_EmissiveFactor;
+    vec3 emissive = SRGBtoLINEAR(texture(u_EmissiveSampler, pbr_vUV)).rgb * u_EmissiveFactor;
     color += emissive;
 #endif
 
@@ -12555,31 +12661,6 @@ void main(void) {}`;
     }
   }
 
-  // ../webgl/src/adapter/helpers/get-shader-info.ts
-  function getShaderInfo2(source, defaultName) {
-    return {
-      name: getShaderName2(source, defaultName),
-      language: "glsl",
-      version: getShaderVersion2(source)
-    };
-  }
-  function getShaderName2(shader, defaultName = "unnamed") {
-    const SHADER_NAME_REGEXP = /#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/;
-    const match = SHADER_NAME_REGEXP.exec(shader);
-    return match ? match[1] : defaultName;
-  }
-  function getShaderVersion2(source) {
-    let version = 100;
-    const words = source.match(/[^\s]+/g);
-    if (words && words.length >= 2 && words[0] === "#version") {
-      const v = parseInt(words[1], 10);
-      if (Number.isFinite(v)) {
-        version = v;
-      }
-    }
-    return version;
-  }
-
   // ../webgl/src/adapter/helpers/parse-shader-compiler-log.ts
   function parseShaderCompilerLog(errLog) {
     const lines = errLog.split(/\r?\n/);
@@ -12626,10 +12707,7 @@ void main(void) {}`;
   // ../webgl/src/adapter/resources/webgl-shader.ts
   var WEBGLShader = class extends Shader {
     constructor(device, props) {
-      super(device, {
-        id: getShaderIdFromProps(props),
-        ...props
-      });
+      super(device, props);
       this.device = device;
       switch (this.props.stage) {
         case "vertex":
@@ -12650,9 +12728,12 @@ void main(void) {}`;
         this.destroyed = true;
       }
     }
-    async compilationInfo() {
+    async getCompilationInfo() {
+      return this.getCompilationInfoSync();
+    }
+    getCompilationInfoSync() {
       const log3 = this.device.gl.getShaderInfoLog(this.handle);
-      return log3 ? parseShaderCompilerLog(log3) : [];
+      return parseShaderCompilerLog(log3);
     }
     _compile(source) {
       const addGLSLVersion = (source2) => source2.startsWith("#version ") ? source2 : `#version 100
@@ -12663,25 +12744,13 @@ ${source2}`;
       } = this.device;
       gl.shaderSource(this.handle, source);
       gl.compileShader(this.handle);
-      const compileStatus = gl.getShaderParameter(this.handle, GLEnum2.COMPILE_STATUS);
-      if (!compileStatus) {
-        const shaderLog = gl.getShaderInfoLog(this.handle);
-        const parsedLog = shaderLog ? parseShaderCompilerLog(shaderLog) : [];
-        const messages = parsedLog.filter((message2) => message2.type === "error");
-        const formattedLog = formatCompilerLog(messages, source, {
-          showSourceCode: true
-        });
-        const shaderName = getShaderInfo2(source).name;
-        const shaderDescription = `${this.stage} shader ${shaderName}`;
-        log.error(`GLSL compilation errors in ${shaderDescription}
-${formattedLog}`)();
-        throw new Error(`GLSL compilation errors in ${shaderName}`);
+      this.compilationStatus = gl.getShaderParameter(this.handle, GLEnum2.COMPILE_STATUS) ? "success" : "error";
+      this.debugShader();
+      if (this.compilationStatus === "error") {
+        throw new Error(`GLSL compilation errors in ${this.props.stage} shader ${this.props.id}`);
       }
     }
   };
-  function getShaderIdFromProps(props) {
-    return getShaderInfo2(props.source).name || props.id || uid(`unnamed ${props.stage}-shader`);
-  }
 
   // ../webgl/src/adapter/resources/webgl-render-pass.ts
   var GL_DEPTH_BUFFER_BIT = 256;