@rings-webgpu/core 1.0.30 → 1.0.32

package/dist/rings.es.max.js

@@ -42146,7 +42146,7 @@ class PostProcessingComponent extends ComponentBase {
   }
 }
 
-const version = "1.0.29";
+const version = "1.0.31";
 
 class Engine3D {
   /**
@@ -61147,6 +61147,711 @@ class KHR_lights_punctual {
 class KHR_materials_ior {
 }
 
+class LASUtils {
+  /**
+   * Split array into chunks of specified size
+   */
+  static chunk(arr, size) {
+    const overall = [];
+    let index = 0;
+    while (index < arr.length) {
+      overall.push(arr.slice(index, index + size));
+      index += size;
+    }
+    return overall;
+  }
+  /**
+   * Remove comments from text (lines starting with #)
+   */
+  static removeComment(str) {
+    return str.split("\n").filter((f) => !(f.trim().charAt(0) === "#")).join("\n");
+  }
+  /**
+   * Convert string to number or string
+   * Returns number if string represents a valid number, otherwise returns string
+   */
+  static convertToValue(s) {
+    return Boolean(+s) || /^0|0$/.test(s) ? +s : s;
+  }
+  /**
+   * Parse a LAS section from text
+   * @param text Full LAS file text
+   * @param sectionName Section name (e.g., 'VERSION', 'WELL', 'CURVE')
+   * @returns Section content as string
+   */
+  static parseSection(text, sectionName) {
+    const regex = new RegExp(`~${sectionName}(?:\\w*\\s*)*\\n\\s*`, "i");
+    const parts = text.split(regex);
+    if (parts.length > 1) {
+      return parts[1].split(/~/)[0];
+    }
+    return "";
+  }
+  /**
+   * Parse a parameter line from LAS file
+   * Format: MNEM.UNIT  VALUE  :DESCRIPTION
+   * @param line Parameter line text
+   * @returns Parsed parameter object
+   */
+  static parseParameterLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      return { mnemonic: "", unit: "", value: "", description: "" };
+    }
+    const colonIndex = trimmed.indexOf(":");
+    const beforeColon = colonIndex >= 0 ? trimmed.substring(0, colonIndex).trim() : trimmed;
+    const description = colonIndex >= 0 ? trimmed.substring(colonIndex + 1).trim() : "none";
+    const parts = beforeColon.split(/\s{2,}|\s+/);
+    const mnemonicPart = parts[0] || "";
+    const dotIndex = mnemonicPart.indexOf(".");
+    let mnemonic = "";
+    let unit = "none";
+    if (dotIndex >= 0) {
+      mnemonic = mnemonicPart.substring(0, dotIndex).trim();
+      unit = mnemonicPart.substring(dotIndex + 1).trim() || "none";
+    } else {
+      mnemonic = mnemonicPart.trim();
+    }
+    const value = parts.length > 1 ? parts[parts.length - 1].trim() : "";
+    return {
+      mnemonic: mnemonic.toUpperCase(),
+      unit,
+      value,
+      description: description || "none"
+    };
+  }
+}
+
+class LASLoader {
+  /**
+   * Parse LAS file (supports both ASCII text and binary buffer)
+   * @param input LAS file content as string or ArrayBuffer
+   * @returns Parsed LAS data (ASCII or Binary)
+   */
+  async parse(input) {
+    if (input instanceof ArrayBuffer) {
+      const dataView = new DataView(input);
+      const magic = readMagicBytes(dataView);
+      if (magic === "LASF") {
+        return await this.parseBinary(input);
+      } else {
+        const decoder = new TextDecoder("utf-8", { fatal: false });
+        const text = decoder.decode(input);
+        return await this.parseText(text);
+      }
+    } else {
+      return await this.parseText(input);
+    }
+  }
+  /**
+   * Parse ASCII LAS (Log ASCII Standard) format
+   * @param text LAS file content as string
+   * @returns Parsed ASCII LAS data
+   */
+  async parseText(text) {
+    const metadata = this.parseMetadata(text);
+    const wellParams = this.parseWellParams(text);
+    const curveParams = this.parseCurveParams(text);
+    const headers = this.parseHeaders(text);
+    const nullValue = wellParams.NULL?.value;
+    const nullValueNum = typeof nullValue === "string" ? +nullValue : nullValue;
+    const data = this.parseData(text, headers, nullValueNum || -999.25);
+    return {
+      headers,
+      data,
+      wellParams,
+      curveParams,
+      metadata,
+      nullValue: nullValueNum || -999.25
+    };
+  }
+  /**
+   * Parse binary LAS (LIDAR Point Cloud) format
+   * @param buffer LAS file content as ArrayBuffer
+   * @returns Parsed binary LAS data
+   */
+  async parseBinary(buffer) {
+    const dataView = new DataView(buffer);
+    const magic = readMagicBytes(dataView);
+    if (magic !== "LASF") {
+      throw new Error(`LASLoader: Invalid binary LAS file, expected 'LASF' magic bytes, got '${magic}'`);
+    }
+    const versionMinor = dataView.getUint8(24);
+    const versionMajor = dataView.getUint8(25);
+    const version = versionMajor + versionMinor / 10;
+    const pointDataFormat = dataView.getUint8(104);
+    const numPoints = dataView.getUint32(107, true);
+    const xScale = dataView.getFloat64(131, true);
+    const yScale = dataView.getFloat64(139, true);
+    const zScale = dataView.getFloat64(147, true);
+    const xOffset = dataView.getFloat64(155, true);
+    const yOffset = dataView.getFloat64(163, true);
+    const zOffset = dataView.getFloat64(171, true);
+    const xMin = dataView.getFloat64(187, true);
+    const xMax = dataView.getFloat64(195, true);
+    const yMin = dataView.getFloat64(203, true);
+    const yMax = dataView.getFloat64(211, true);
+    const zMin = dataView.getFloat64(219, true);
+    const zMax = dataView.getFloat64(227, true);
+    const offsetToPointData = dataView.getUint32(96, true);
+    const numVLRs = dataView.getUint32(100, true);
+    let pointDataOffset = offsetToPointData;
+    for (let i = 0; i < numVLRs; i++) {
+      const vlrDataLength = dataView.getUint16(pointDataOffset + 54, true);
+      pointDataOffset += 54 + vlrDataLength;
+    }
+    const pointRecordLengths = [20, 28, 26, 34, 57, 63, 30, 36, 38, 59, 67];
+    const pointRecordLength = pointRecordLengths[pointDataFormat] || 20;
+    if (pointDataFormat > 10) {
+      throw new Error(`LASLoader: Unsupported point data format ${pointDataFormat}`);
+    }
+    const positions = new Float32Array(numPoints * 3);
+    const colors = new Uint8Array(numPoints * 4);
+    let baseOffset = pointDataOffset;
+    for (let i = 0; i < numPoints; i++) {
+      const offset = baseOffset + i * pointRecordLength;
+      let xInt, yInt, zInt;
+      if (pointDataFormat >= 6) {
+        xInt = Number(dataView.getBigInt64(offset, true));
+        yInt = Number(dataView.getBigInt64(offset + 8, true));
+        zInt = Number(dataView.getBigInt64(offset + 16, true));
+      } else {
+        xInt = dataView.getInt32(offset, true);
+        yInt = dataView.getInt32(offset + 4, true);
+        zInt = dataView.getInt32(offset + 8, true);
+      }
+      const x = xInt * xScale + xOffset;
+      const y = yInt * yScale + yOffset;
+      const z = zInt * zScale + zOffset;
+      positions[i * 3 + 0] = x;
+      positions[i * 3 + 1] = y;
+      positions[i * 3 + 2] = z;
+      let intensityOffset;
+      if (pointDataFormat >= 6) {
+        intensityOffset = offset + 24;
+      } else {
+        intensityOffset = offset + 12;
+      }
+      const intensity = dataView.getUint16(intensityOffset, true);
+      if ([2, 3, 5, 7, 8, 9, 10].includes(pointDataFormat)) {
+        let rgbOffset;
+        const recordEnd = offset + pointRecordLength;
+        if (pointDataFormat === 5) {
+          rgbOffset = offset + 28;
+        } else if (pointDataFormat === 10) {
+          rgbOffset = offset + 59;
+        } else {
+          rgbOffset = recordEnd - 6;
+        }
+        if (rgbOffset >= offset && rgbOffset + 6 <= recordEnd && rgbOffset + 6 <= buffer.byteLength) {
+          try {
+            const r = dataView.getUint16(rgbOffset, true);
+            const g = dataView.getUint16(rgbOffset + 2, true);
+            const b = dataView.getUint16(rgbOffset + 4, true);
+            colors[i * 4 + 0] = r < 256 ? r : r >> 8;
+            colors[i * 4 + 1] = g < 256 ? g : g >> 8;
+            colors[i * 4 + 2] = b < 256 ? b : b >> 8;
+            colors[i * 4 + 3] = 255;
+          } catch (e) {
+            console.warn(`LASLoader: Failed to read RGB at offset ${rgbOffset} (format ${pointDataFormat}, record length ${pointRecordLength}), using intensity instead. Error: ${e}`);
+            const intensityNorm = Math.min(intensity / 65535, 1);
+            colors[i * 4 + 0] = Math.floor(intensityNorm * 255);
+            colors[i * 4 + 1] = Math.floor(intensityNorm * 255);
+            colors[i * 4 + 2] = Math.floor(intensityNorm * 255);
+            colors[i * 4 + 3] = 255;
+          }
+        } else {
+          console.warn(`LASLoader: RGB offset ${rgbOffset} out of bounds (offset: ${offset}, record end: ${recordEnd}, buffer size: ${buffer.byteLength}, format: ${pointDataFormat}), using intensity instead`);
+          const intensityNorm = Math.min(intensity / 65535, 1);
+          colors[i * 4 + 0] = Math.floor(intensityNorm * 255);
+          colors[i * 4 + 1] = Math.floor(intensityNorm * 255);
+          colors[i * 4 + 2] = Math.floor(intensityNorm * 255);
+          colors[i * 4 + 3] = 255;
+        }
+      } else {
+        const intensityNorm = Math.min(intensity / 65535, 1);
+        colors[i * 4 + 0] = Math.floor(intensityNorm * 255);
+        colors[i * 4 + 1] = Math.floor(intensityNorm * 255);
+        colors[i * 4 + 2] = Math.floor(intensityNorm * 255);
+        colors[i * 4 + 3] = 255;
+      }
+    }
+    return {
+      format: "binary",
+      version,
+      pointDataFormat,
+      numPoints,
+      positions,
+      colors,
+      bbox: { xMin, xMax, yMin, yMax, zMin, zMax },
+      scale: { x: xScale, y: yScale, z: zScale },
+      offset: { x: xOffset, y: yOffset, z: zOffset }
+    };
+  }
+  /**
+   * Parse version information section (~VERSION)
+   */
+  parseMetadata(text) {
+    const versionSection = LASUtils.parseSection(text, "V");
+    if (!versionSection) {
+      throw new Error("LASLoader: ~VERSION section not found");
+    }
+    const cleaned = LASUtils.removeComment(versionSection);
+    const lines = cleaned.split("\n").filter(Boolean);
+    let version = 2;
+    let wrap = false;
+    for (const line of lines) {
+      const parts = line.split(/\s{2,}|\s*:/).filter(Boolean);
+      if (parts.length >= 2) {
+        const key = parts[0].trim().toUpperCase();
+        const value = parts[1].trim().toUpperCase();
+        if (key === "VERS" || key === "VERSION") {
+          const versionMatch = value.match(/(\d+\.?\d*)/);
+          if (versionMatch) {
+            version = +versionMatch[1];
+          }
+        } else if (key === "WRAP" || key === "WRAP.") {
+          wrap = value === "YES" || value === "Y";
+        }
+      }
+    }
+    return { version, wrap };
+  }
+  /**
+   * Parse well information section (~WELL)
+   */
+  parseWellParams(text) {
+    const wellSection = LASUtils.parseSection(text, "W");
+    if (!wellSection) {
+      return {};
+    }
+    const cleaned = LASUtils.removeComment(wellSection);
+    const lines = cleaned.split("\n").filter(Boolean);
+    const params = {};
+    for (const line of lines) {
+      const parsed = LASUtils.parseParameterLine(line);
+      if (parsed.mnemonic) {
+        params[parsed.mnemonic] = {
+          unit: parsed.unit,
+          value: LASUtils.convertToValue(parsed.value),
+          description: parsed.description
+        };
+      }
+    }
+    return params;
+  }
+  /**
+   * Parse curve information section (~CURVE)
+   */
+  parseCurveParams(text) {
+    const curveSection = LASUtils.parseSection(text, "C");
+    if (!curveSection) {
+      return {};
+    }
+    const cleaned = LASUtils.removeComment(curveSection);
+    const lines = cleaned.split("\n").filter(Boolean);
+    const params = {};
+    for (const line of lines) {
+      const parsed = LASUtils.parseParameterLine(line);
+      if (parsed.mnemonic) {
+        params[parsed.mnemonic] = {
+          unit: parsed.unit,
+          value: parsed.value,
+          description: parsed.description
+        };
+      }
+    }
+    return params;
+  }
+  /**
+   * Parse headers (column names) from curve section
+   */
+  parseHeaders(text) {
+    const curveSection = LASUtils.parseSection(text, "C");
+    if (!curveSection) {
+      throw new Error("LASLoader: ~CURVE section not found");
+    }
+    const cleaned = LASUtils.removeComment(curveSection);
+    const lines = cleaned.split("\n").filter(Boolean);
+    const headers = [];
+    for (const line of lines) {
+      const parsed = LASUtils.parseParameterLine(line);
+      if (parsed.mnemonic) {
+        headers.push(parsed.mnemonic);
+      }
+    }
+    if (headers.length === 0) {
+      throw new Error("LASLoader: No headers found in ~CURVE section");
+    }
+    return headers;
+  }
+  /**
+   * Parse ASCII data section (~A)
+   */
+  parseData(text, headers, nullValue) {
+    const dataMatch = text.match(/~A(?:[\x20-\x7E])*(?:\r\n|\r|\n)([\s\S]*?)(?=~|$)/);
+    if (!dataMatch || !dataMatch[1]) {
+      throw new Error("LASLoader: ~A data section not found");
+    }
+    const dataSection = dataMatch[1].trim();
+    if (!dataSection) {
+      throw new Error("LASLoader: Data section is empty");
+    }
+    const values = dataSection.split(/\s+/).filter((v) => v.trim().length > 0).map((m) => LASUtils.convertToValue(m.trim()));
+    if (values.length === 0) {
+      throw new Error("LASLoader: No data values found");
+    }
+    const rowCount = Math.floor(values.length / headers.length);
+    if (rowCount === 0) {
+      throw new Error("LASLoader: Insufficient data values");
+    }
+    const data = [];
+    for (let i = 0; i < rowCount; i++) {
+      const row = [];
+      for (let j = 0; j < headers.length; j++) {
+        const idx = i * headers.length + j;
+        if (idx < values.length) {
+          row.push(values[idx]);
+        }
+      }
+      if (row.length === headers.length) {
+        data.push(row);
+      }
+    }
+    return data;
+  }
+}
+
+var LASVisualizationMode = /* @__PURE__ */ ((LASVisualizationMode2) => {
+  LASVisualizationMode2["PointCloud"] = "pointcloud";
+  LASVisualizationMode2["Curve"] = "curve";
+  LASVisualizationMode2["WellTrajectory"] = "trajectory";
+  return LASVisualizationMode2;
+})(LASVisualizationMode || {});
+
+var __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor;
+var __decorateClass$4 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(result)) || result;
+  return result;
+};
+let FatLineShader = class extends Shader {
+  constructor() {
+    super();
+    const colorShader = new RenderShaderPass("FatLine_VS", "FatLine_FS");
+    colorShader.setShaderEntry(`VertMain`, `FragMain`);
+    this.addRenderPass(colorShader);
+    const shaderState = colorShader.shaderState;
+    shaderState.acceptShadow = false;
+    shaderState.castShadow = false;
+    shaderState.receiveEnv = false;
+    shaderState.acceptGI = false;
+    shaderState.useLight = false;
+    shaderState.cullMode = GPUCullMode.none;
+    shaderState.depthWriteEnabled = true;
+    this.setDefault();
+  }
+  /**
+   * Set default uniform values
+   */
+  setDefault() {
+    this.setUniformColor(`baseColor`, new Color(1, 1, 1, 1));
+    this.setUniformFloat(`lineWidth`, 1);
+    this.setUniformFloat(`opacity`, 1);
+    this.setUniformVector2(`resolution`, new Vector2(1920, 1080));
+    const identityMatrix = new Matrix4();
+    const pass = this.getDefaultColorShader();
+    pass.setUniform(`modelMatrix`, identityMatrix.rawData);
+  }
+};
+FatLineShader = __decorateClass$4([
+  RegisterShader(FatLineShader, "FatLineShader")
+], FatLineShader);
+
+class FatLineMaterial extends Material {
+  constructor() {
+    super();
+    this.shader = new FatLineShader();
+    this.transparent = true;
+  }
+  /**
+   * Set instance buffer for line segments
+   * This should be called after setting the geometry
+   */
+  setInstanceBuffer(buffer) {
+    this.shader.setStorageBuffer("instances", buffer);
+  }
+  /**
+   * Set model matrix for transforming line segments
+   * This should be updated each frame if the object moves
+   */
+  setModelMatrix(matrix) {
+    const pass = this.shader.getDefaultColorShader();
+    pass.setUniform("modelMatrix", matrix.rawData);
+  }
+  /**
+   * Set base color (tint color)
+   */
+  set baseColor(color) {
+    this.shader.setUniformColor(`baseColor`, color);
+  }
+  /**
+   * Get base color (tint color)
+   */
+  get baseColor() {
+    return this.shader.getUniformColor("baseColor");
+  }
+  /**
+   * Set line width in pixels
+   */
+  set lineWidth(value) {
+    this.shader.setUniformFloat(`lineWidth`, value);
+  }
+  /**
+   * Get line width in pixels
+   */
+  get lineWidth() {
+    return this.shader.getUniformFloat("lineWidth");
+  }
+  /**
+   * Set opacity (0-1)
+   */
+  set opacity(value) {
+    this.shader.setUniformFloat(`opacity`, value);
+  }
+  /**
+   * Get opacity (0-1)
+   */
+  get opacity() {
+    return this.shader.getUniformFloat("opacity");
+  }
+  /**
+   * Set viewport resolution for correct pixel-space calculations
+   * This should be set automatically by the renderer
+   */
+  set resolution(value) {
+    this.shader.setUniformVector2(`resolution`, value);
+  }
+  /**
+   * Get viewport resolution
+   */
+  get resolution() {
+    return this.shader.getUniformVector2("resolution");
+  }
+}
+
+class LASParser extends ParserBase {
+  static format = ParserFormat.BIN;
+  // Can handle both binary and text
+  visualizationMode = LASVisualizationMode.PointCloud;
+  async parseBuffer(buffer) {
+    const loader = new LASLoader();
+    const parsedData = await loader.parse(buffer);
+    await this.createVisualization(parsedData);
+  }
+  /**
+   * Create visualization from parsed LAS data
+   */
+  async createVisualization(parsedData) {
+    if ("format" in parsedData && parsedData.format === "binary") {
+      this.data = this.createBinaryPointCloudVisualization(parsedData);
+    } else {
+      const asciiData = parsedData;
+      let result;
+      switch (this.visualizationMode) {
+        case LASVisualizationMode.PointCloud:
+          result = this.createPointCloudVisualization(asciiData);
+          break;
+        case LASVisualizationMode.Curve:
+          result = this.createCurveVisualization(asciiData);
+          break;
+        case LASVisualizationMode.WellTrajectory:
+          result = this.createWellTrajectoryVisualization(asciiData);
+          break;
+        default:
+          result = this.createPointCloudVisualization(asciiData);
+      }
+      result["lasData"] = asciiData;
+      result["wellParams"] = asciiData.wellParams;
+      result["curveParams"] = asciiData.curveParams;
+      this.data = result;
+    }
+  }
+  /**
+   * Create point cloud visualization from binary LAS data
+   */
+  createBinaryPointCloudVisualization(binaryData) {
+    const pointCloudObj = new Object3D();
+    pointCloudObj.name = "LASPointCloud";
+    const pointCloudObjRoot = new Object3D();
+    pointCloudObjRoot.name = "LASPointCloudRoot";
+    pointCloudObj.addChild(pointCloudObjRoot);
+    const renderer = pointCloudObjRoot.addComponent(PointCloudRenderer);
+    renderer.initFromData(binaryData.positions, binaryData.colors, binaryData.numPoints);
+    renderer.setPointShape("circle");
+    renderer.setPointSize(4);
+    pointCloudObj["lasFormat"] = "binary";
+    pointCloudObj["lasVersion"] = binaryData.version;
+    pointCloudObj["numPoints"] = binaryData.numPoints;
+    pointCloudObj["pointDataFormat"] = binaryData.pointDataFormat;
+    pointCloudObj["bbox"] = binaryData.bbox;
+    return pointCloudObj;
+  }
+  verification() {
+    if (this.data) {
+      return true;
+    }
+    throw new Error("LASParser: Parse failed");
+  }
+  /**
+   * Create point cloud visualization from LAS data
+   * Depth as Z axis, curve values as X/Y axes
+   */
+  createPointCloudVisualization(lasData) {
+    const { headers, data, nullValue } = lasData;
+    const depthIndex = headers.findIndex(
+      (h) => h.toUpperCase() === "DEPTH" || h.toUpperCase() === "DEPT"
+    );
+    if (depthIndex < 0) {
+      throw new Error("LASParser: DEPTH column not found");
+    }
+    const curveIndices = headers.map((_, i) => i).filter((i) => i !== depthIndex).slice(0, 2);
+    const validData = data.filter(
+      (row) => !row.some((val) => val === nullValue || val === +nullValue)
+    );
+    if (validData.length === 0) {
+      throw new Error("LASParser: No valid data points after filtering");
+    }
+    const pointCount = validData.length;
+    const positions = new Float32Array(pointCount * 3);
+    const colors = new Uint8Array(pointCount * 4);
+    let minX = Infinity, maxX = -Infinity;
+    let minY = Infinity, maxY = -Infinity;
+    if (curveIndices.length > 0) {
+      const xValues = validData.map((row) => +row[curveIndices[0]]).filter((v) => !isNaN(v));
+      minX = Math.min(...xValues);
+      maxX = Math.max(...xValues);
+      if (curveIndices.length > 1) {
+        const yValues = validData.map((row) => +row[curveIndices[1]]).filter((v) => !isNaN(v));
+        minY = Math.min(...yValues);
+        maxY = Math.max(...yValues);
+      }
+    }
+    for (let i = 0; i < validData.length; i++) {
+      const row = validData[i];
+      const idx = i * 3;
+      const colorIdx = i * 4;
+      positions[idx + 2] = +row[depthIndex];
+      if (curveIndices.length > 0) {
+        const xValue = +row[curveIndices[0]];
+        const normalizedX = maxX !== minX ? (xValue - minX) / (maxX - minX) : 0;
+        positions[idx + 0] = normalizedX * 10;
+        if (curveIndices.length > 1) {
+          const yValue = +row[curveIndices[1]];
+          const normalizedY = maxY !== minY ? (yValue - minY) / (maxY - minY) : 0;
+          positions[idx + 1] = normalizedY * 10;
+        } else {
+          positions[idx + 1] = 0;
+        }
+      } else {
+        positions[idx + 0] = 0;
+        positions[idx + 1] = 0;
+      }
+      if (curveIndices.length > 0) {
+        const curveValue = +row[curveIndices[0]];
+        const normalizedValue = maxX !== minX ? (curveValue - minX) / (maxX - minX) : 0;
+        this.mapValueToColor(normalizedValue, colors, colorIdx);
+      } else {
+        colors[colorIdx + 0] = 255;
+        colors[colorIdx + 1] = 255;
+        colors[colorIdx + 2] = 255;
+        colors[colorIdx + 3] = 255;
+      }
+    }
+    const pointCloudObj = new Object3D();
+    pointCloudObj.name = "LASPointCloud";
+    const renderer = pointCloudObj.addComponent(PointCloudRenderer);
+    renderer.initFromData(positions, colors, pointCount);
+    renderer.setPointShape("circle");
+    renderer.setPointSize(4);
+    return pointCloudObj;
+  }
+  /**
+   * Create curve visualization using FatLineRenderer
+   * Depth as Z axis, normalized curve value as X axis
+   */
+  createCurveVisualization(lasData) {
+    const { headers, data, nullValue } = lasData;
+    const depthIndex = headers.findIndex(
+      (h) => h.toUpperCase() === "DEPTH" || h.toUpperCase() === "DEPT"
+    );
+    if (depthIndex < 0) {
+      throw new Error("LASParser: DEPTH column not found");
+    }
+    const curveIndex = headers.map((_, i) => i).find((i) => i !== depthIndex);
+    if (curveIndex === void 0) {
+      throw new Error("LASParser: No curve column found");
+    }
+    const validData = data.filter((row) => {
+      const depth = +row[depthIndex];
+      const curveValue = +row[curveIndex];
+      return !isNaN(depth) && !isNaN(curveValue) && curveValue !== nullValue && curveValue !== +nullValue;
+    });
+    if (validData.length === 0) {
+      throw new Error("LASParser: No valid data points");
+    }
+    const curveValues = validData.map((row) => +row[curveIndex]);
+    const minCurve = Math.min(...curveValues);
+    const maxCurve = Math.max(...curveValues);
+    const curveRange = maxCurve - minCurve;
+    const positions = new Float32Array(validData.length * 3);
+    for (let i = 0; i < validData.length; i++) {
+      const row = validData[i];
+      const idx = i * 3;
+      const depth = +row[depthIndex];
+      const curveValue = +row[curveIndex];
+      positions[idx + 2] = depth;
+      const normalizedCurve = curveRange > 0 ? (curveValue - minCurve) / curveRange : 0;
+      positions[idx + 0] = normalizedCurve * 10;
+      positions[idx + 1] = 0;
+    }
+    const geometry = new FatLineGeometry();
+    geometry.setPositions(positions);
+    const material = new FatLineMaterial();
+    material.baseColor = new Color(1, 0, 0, 1);
+    material.lineWidth = 2;
+    const curveObj = new Object3D();
+    curveObj.name = `LASCurve_${headers[curveIndex]}`;
+    const renderer = curveObj.addComponent(FatLineRenderer);
+    renderer.geometry = geometry;
+    renderer.material = material;
+    return curveObj;
+  }
+  /**
+   * Create well trajectory visualization
+   * TODO: Implement when well trajectory data is available
+   */
+  createWellTrajectoryVisualization(lasData) {
+    throw new Error("LASParser: Well trajectory visualization not yet implemented");
+  }
+  normalizeValue(value, data, columnIndex) {
+    const values = data.map((row) => +row[columnIndex]).filter((v) => !isNaN(v));
+    const min = Math.min(...values);
+    const max = Math.max(...values);
+    return max !== min ? (value - min) / (max - min) : 0;
+  }
+  mapValueToColor(normalizedValue, colors, index) {
+    const r = Math.floor(normalizedValue * 255);
+    const b = Math.floor((1 - normalizedValue) * 255);
+    colors[index + 0] = r;
+    colors[index + 1] = 0;
+    colors[index + 2] = b;
+    colors[index + 3] = 255;
+  }
+}
+
 class PlyParser extends ParserBase {
   static format = ParserFormat.BIN;
   async parseBuffer(buffer) {
@@ -62498,9 +63203,9 @@ class PrefabTextureParser extends ParserBase {
   }
 }
 
-var __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor;
-var __decorateClass$4 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key) : target;
+var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
+var __decorateClass$3 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -62619,13 +63324,13 @@ let LitSSSShader = class extends Shader {
     }
   }
 };
-LitSSSShader = __decorateClass$4([
+LitSSSShader = __decorateClass$3([
   RegisterShader(LitSSSShader, "LitSSSShader")
 ], LitSSSShader);
 
-var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
-var __decorateClass$3 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target;
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -62721,7 +63426,7 @@ let LitShader = class extends Shader {
     }
   }
 };
-LitShader = __decorateClass$3([
+LitShader = __decorateClass$2([
   RegisterShader(LitShader, "LitShader")
 ], LitShader);
 
@@ -62880,47 +63585,6 @@ class PrefabStringUtil {
   }
 }
 
-var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
-var __decorateClass$2 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (decorator(result)) || result;
-  return result;
-};
-let FatLineShader = class extends Shader {
-  constructor() {
-    super();
-    const colorShader = new RenderShaderPass("FatLine_VS", "FatLine_FS");
-    colorShader.setShaderEntry(`VertMain`, `FragMain`);
-    this.addRenderPass(colorShader);
-    const shaderState = colorShader.shaderState;
-    shaderState.acceptShadow = false;
-    shaderState.castShadow = false;
-    shaderState.receiveEnv = false;
-    shaderState.acceptGI = false;
-    shaderState.useLight = false;
-    shaderState.cullMode = GPUCullMode.none;
-    shaderState.depthWriteEnabled = true;
-    this.setDefault();
-  }
-  /**
-   * Set default uniform values
-   */
-  setDefault() {
-    this.setUniformColor(`baseColor`, new Color(1, 1, 1, 1));
-    this.setUniformFloat(`lineWidth`, 1);
-    this.setUniformFloat(`opacity`, 1);
-    this.setUniformVector2(`resolution`, new Vector2(1920, 1080));
-    const identityMatrix = new Matrix4();
-    const pass = this.getDefaultColorShader();
-    pass.setUniform(`modelMatrix`, identityMatrix.rawData);
-  }
-};
-FatLineShader = __decorateClass$2([
-  RegisterShader(FatLineShader, "FatLineShader")
-], FatLineShader);
-
 var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
 var __decorateClass$1 = (decorators, target, key, kind) => {
   var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
@@ -64200,6 +64864,8 @@ class TilesRenderer {
   _root = null;
   // Active and visible tiles set
   _activeTiles = /* @__PURE__ */ new Set();
+  // Tiles that should be hidden but are delayed due to children loading
+  _delayedHideTiles = /* @__PURE__ */ new Set();
   // Rings-specific: Scene group
   group;
   // Rings-specific: Camera management
@@ -64316,6 +64982,7 @@ class TilesRenderer {
     _usedSet.forEach((tile) => lruCache.markUnused(tile));
     _usedSet.clear();
     this.updateCameraInfo();
+    this._checkDelayedHideTiles();
     markUsedTiles(root, this);
     markUsedSetLeaves(root, this);
     markVisibleTiles(root, this);
@@ -64785,6 +65452,9 @@ class TilesRenderer {
   setTileActive(tile, active) {
     if (active) {
       this._activeTiles.add(tile);
+      if (this._delayedHideTiles.has(tile)) {
+        this._delayedHideTiles.delete(tile);
+      }
     } else {
       this._activeTiles.delete(tile);
     }
@@ -64804,7 +65474,42 @@ class TilesRenderer {
       }
       scene.transform.enable = true;
     } else {
-      scene.transform.enable = false;
+      if (!this._delayedHideTiles.has(tile)) {
+        this._delayedHideTiles.add(tile);
+      }
+    }
+  }
+  /**
+   * Get children tiles that are loading and will be active
+   * Check if child is used in current frame (will be displayed) but not yet loaded
+   */
+  _getLoadingChildrenThatWillBeActive(tile) {
+    const loadingChildren = [];
+    const children = tile.children;
+    for (let i = 0, l = children.length; i < l; i++) {
+      const child = children[i];
+      if (child.loadingState !== LOADED && child.loadingState !== FAILED) {
+        loadingChildren.push(child);
+      }
+      if (child.children && child.children.length > 0) {
+        loadingChildren.push(...this._getLoadingChildrenThatWillBeActive(child));
+      }
+    }
+    return loadingChildren;
+  }
+  /**
+   * Check and process delayed hide tiles when a child finishes loading
+   */
+  _checkDelayedHideTiles() {
+    for (const tile of this._delayedHideTiles) {
+      const stillLoading = this._getLoadingChildrenThatWillBeActive(tile);
+      if (stillLoading.length === 0) {
+        this._delayedHideTiles.delete(tile);
+        const scene = tile.cached.scene;
+        if (scene) {
+          scene.transform.enable = false;
+        }
+      }
     }
   }
   /**
@@ -64813,6 +65518,9 @@ class TilesRenderer {
   setTileVisible(tile, visible) {
     if (visible) {
       this._visibleTiles.add(tile);
+      if (this._delayedHideTiles.has(tile)) {
+        this._delayedHideTiles.delete(tile);
+      }
     } else {
       this._visibleTiles.delete(tile);
     }
@@ -64820,7 +65528,13 @@ class TilesRenderer {
     if (!scene) {
       return;
     }
-    scene.transform.enable = visible;
+    if (visible) {
+      scene.transform.enable = true;
+    } else {
+      if (!this._delayedHideTiles.has(tile)) {
+        this._delayedHideTiles.add(tile);
+      }
+    }
   }
   /**
    * Add tile to download queue
@@ -65294,78 +66008,6 @@ class ColorLitMaterial extends Material {
   }
 }
 
-class FatLineMaterial extends Material {
-  constructor() {
-    super();
-    this.shader = new FatLineShader();
-    this.transparent = true;
-  }
-  /**
-   * Set instance buffer for line segments
-   * This should be called after setting the geometry
-   */
-  setInstanceBuffer(buffer) {
-    this.shader.setStorageBuffer("instances", buffer);
-  }
-  /**
-   * Set model matrix for transforming line segments
-   * This should be updated each frame if the object moves
-   */
-  setModelMatrix(matrix) {
-    const pass = this.shader.getDefaultColorShader();
-    pass.setUniform("modelMatrix", matrix.rawData);
-  }
-  /**
-   * Set base color (tint color)
-   */
-  set baseColor(color) {
-    this.shader.setUniformColor(`baseColor`, color);
-  }
-  /**
-   * Get base color (tint color)
-   */
-  get baseColor() {
-    return this.shader.getUniformColor("baseColor");
-  }
-  /**
-   * Set line width in pixels
-   */
-  set lineWidth(value) {
-    this.shader.setUniformFloat(`lineWidth`, value);
-  }
-  /**
-   * Get line width in pixels
-   */
-  get lineWidth() {
-    return this.shader.getUniformFloat("lineWidth");
-  }
-  /**
-   * Set opacity (0-1)
-   */
-  set opacity(value) {
-    this.shader.setUniformFloat(`opacity`, value);
-  }
-  /**
-   * Get opacity (0-1)
-   */
-  get opacity() {
-    return this.shader.getUniformFloat("opacity");
-  }
-  /**
-   * Set viewport resolution for correct pixel-space calculations
-   * This should be set automatically by the renderer
-   */
-  set resolution(value) {
-    this.shader.setUniformVector2(`resolution`, value);
-  }
-  /**
-   * Get viewport resolution
-   */
-  get resolution() {
-    return this.shader.getUniformVector2("resolution");
-  }
-}
-
 class LambertMaterial extends Material {
   /**
    * @constructor
@@ -71082,4 +71724,4 @@ const __viteBrowserExternal = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.def
   __proto__: null
 }, Symbol.toStringTag, { value: 'Module' }));
 
-export { AccelerateDecelerateInterpolator, AccelerateInterpolator, AnimationCurve, AnimationCurveT, AnimationMonitor, AnimatorComponent, AnimatorEventKeyframe, AnticipateInterpolator, AnticipateOvershootInterpolator, ArrayHas, ArrayItemIndex, AtlasParser, AtmosphericComponent, AtmosphericScatteringSky, AtmosphericScatteringSkySetting, AtmosphericScatteringSky_shader, AttributeAnimCurve, AxisObject, B3DMLoader, B3DMLoaderBase, B3DMParseUtil, B3DMParser, BRDFLUT, BRDFLUTGenerate, BRDF_frag, BatchTable, BiMap, BillboardComponent, BillboardType, BitUtil, BitmapTexture2D, BitmapTexture2DArray, BitmapTextureCube, Blend, BlendFactor, BlendMode, BlendShapeData, BlendShapePropertyData, BloomPost, BlurEffectCreatorBlur_cs, BlurEffectCreatorSample_cs, BlurTexture2DBufferCreator, BounceInterpolator, BoundUtil, BoundingBox, BoundingSphere, BoundingVolume, BoxColliderShape, BoxGeometry, BrdfLut_frag, BsDF_frag, BxDF_frag, BxdfDebug_frag, BytesArray, CEvent, CEventDispatcher, CEventListener, CResizeEvent, CSM, Camera3D, CameraControllerBase, CameraType, CameraUtil, CapsuleColliderShape, CastPointShadowMaterialPass, CastShadowMaterialPass, Clearcoat_frag, ClusterBoundsSource_cs, ClusterConfig, ClusterDebug_frag, ClusterLight, ClusterLightingBuffer, ClusterLightingRender, ClusterLighting_cs, CollectInfo, ColliderComponent, ColliderShape, ColliderShapeType, Color, ColorGradient, ColorLitMaterial, ColorLitShader, ColorPassFragmentOutput, ColorPassRenderer, ColorUtil, ComData, Combine_cs, Common_frag, Common_vert, ComponentBase, ComponentCollect, ComputeGPUBuffer, ComputeShader, Context3D, CubeCamera, CubeMapFaceEnum, CubeSky_Shader, CubicBezierCurve, CubicBezierPath, CubicBezierType, CycleInterpolator, CylinderGeometry, DDGIIrradianceComputePass, DDGIIrradianceGPUBufferReader, DDGIIrradianceVolume, DDGIIrradiance_shader, DDGILightingPass, DDGILighting_shader, DDGIMultiBouncePass, DDGIProbeRenderer, DEGREES_TO_RADIANS, DRACO_DECODER_GLTF_JS, DecelerateInterpolator, Denoising_cs, Depth2DTextureArray, DepthCubeArrayTexture, DepthMaterialPass, DepthOfFieldPost, DepthOfView_cs, DirectLight, DoubleArray, EditorInspector, Engine3D, Entity, EntityBatchCollect, EntityCollect, EnvMap_frag, ErpImage2CubeMap, ErpImage2CubeMapCreateCube_cs, ErpImage2CubeMapRgbe2rgba_cs, ExtrudeGeometry, FAILED, FASTFLOOR, FXAAPost, FXAAShader, FastMathShader, FatLineGeometry, FatLineMaterial, FatLineRenderer, FatLineShader, FatLine_FS, FatLine_VS, FeatureTable, FileLoader, FirstPersonCameraController, Float16ArrayTexture, Float32ArrayTexture, FlyCameraController, FontChar, FontInfo, FontPage, FontParser, ForwardRenderJob, FragmentOutput, FragmentVarying, FrameCache, Frustum, FrustumCSM, FrustumCulling_cs, FullQuad_vert_wgsl, GBufferFrame, GBufferPass, GBufferPost, GBufferStand, GBuffer_pass, GILighting, GIProbeMaterial, GIProbeMaterialType, GIProbeShader, GIRenderCompleteEvent, GIRenderStartEvent, GLBChunk, GLBHeader, GLBParser, GLSLLexer, GLSLLexerToken, GLSLPreprocessor, GLSLSyntax, GLTFBinaryExtension, GLTFMaterial, GLTFParser, GLTFSubParser, GLTFSubParserCamera, GLTFSubParserConverter, GLTFSubParserMaterial, GLTFSubParserMesh, GLTFSubParserSkeleton, GLTFSubParserSkin, GLTFType, GLTF_Accessors, GLTF_Info, GLTF_Light, GLTF_Mesh, GLTF_Node, GLTF_Primitives, GLTF_Scene, GPUAddressMode, GPUBlendFactor, GPUBufferBase, GPUBufferType, GPUCompareFunction, GPUContext, GPUCullMode, GPUFilterMode, GPUPrimitiveTopology, GPUTextureFormat, GPUVertexFormat, GPUVertexStepMode, GSplatFormat, GSplatGeometry, GSplatMaterial, GSplatRenderer, GSplatShader, GSplat_FS, GSplat_VS, GTAOPost, GTAO_cs, GUIAtlasTexture, GUICanvas, GUIConfig, GUIGeometry, GUIGeometryRebuild, GUIMaterial, GUIPassRenderer, GUIPick, GUIPickHelper, GUIQuad, GUIQuadAttrEnum, GUIRenderer, GUIShader, GUISpace, GUISprite, GUITexture, GaussianSplatParser, GenerayRandomDir, GeoJsonParser, GeoJsonUtil, GeoType, GeometryBase, GeometryIndicesBuffer, GeometryUtil, GeometryVertexBuffer, GeometryVertexType, GetComponentClass, GetCountInstanceID, GetRepeat, GetShader, GlassShader, GlobalBindGroup, GlobalBindGroupLayout, GlobalFog, GlobalFog_shader, GlobalIlluminationComponent, GlobalUniform, GlobalUniformGroup, GodRayPost, GodRay_cs, GridObject, HDRTexture, HDRTextureCube, Hair_frag, Hair_shader_op, Hair_shader_tr, HaltonSeq, Horizontal, HoverCameraController, I3DMLoader, I3DMLoaderBase, I3DMParser, IBLEnvMapCreator, IBLEnvMapCreator_cs, IESProfiles, IESProfiles_frag, IKDTreeUserData, ImageType, IndicesGPUBuffer, Inline_vert, InputSystem, InstanceDrawComponent, InstanceUniform, InstancedMesh, Interpolator, InterpolatorEnum, IrradianceDataReaderCompleteEvent, IrradianceVolumeData_frag, Irradiance_frag, IsEditorInspector, IsNonSerialize, Joint, JointPose, JumperInterpolator, KDTreeEntity, KDTreeNode, KDTreeRange, KDTreeSpace, KDTreeUUID, KHR_draco_mesh_compression, KHR_lights_punctual, KHR_materials_clearcoat, KHR_materials_emissive_strength, KHR_materials_ior, KHR_materials_unlit, KMZParser, KV, KelvinUtil, KeyCode, KeyEvent, Keyframe, KeyframeT, LDRTextureCube, LOADED, LOADING, LRUCache, LambertMaterial, Lambert_shader, Light, LightBase, LightData, LightEntries, LightType, LightingFunction_frag, Line, LineClassification, LinearInterpolator, LitMaterial, LitSSSShader, LitShader, Lit_shader, LoaderBase, LoaderEvent, LoaderManager, MAX_VALUE, MIN_VALUE, Material, MaterialDataUniformGPUBuffer, MaterialUtilities, MathShader, MathUtil, Matrix3, Matrix4, MatrixBindGroup, MatrixGPUBuffer, MatrixShader, MemoryDO, MemoryInfo, MergeRGBACreator, MergeRGBA_cs, MeshColliderShape, MeshFilter, MeshRenderer, MinMaxAnimationCurves, MinMaxCurve, MinMaxCurveState, MinMaxPolyCurves, MorePassParser, MorePassShader, MorphTargetBlender, MorphTargetData, MorphTargetFrame, MorphTargetTransformKey, MorphTarget_shader, MouseCode, MultiBouncePass_cs, Navi3DAstar, Navi3DConst, Navi3DEdge, Navi3DFunnel, Navi3DMaskType, Navi3DMesh, Navi3DPoint, Navi3DPoint2D, Navi3DPointFat, Navi3DRouter, Navi3DTriangle, NonSerialize, NormalMap_frag, OAnimationEvent, OBJParser, Object3D, Object3DEvent, Object3DTransformTools, Object3DUtil, ObjectAnimClip, OcclusionSystem, Octree, OctreeEntity, OrbitController, OrderMap, Orientation3D, OutLineBlendColor_cs, OutlineCalcOutline_cs, OutlinePass, OutlinePost, OutlinePostData, OutlinePostManager, OutlinePostSlot, Outline_cs, OvershootInterpolator, PARSING, PBRLItShader, PBRLitSSSShader, PLUGIN_REGISTERED, PNTSLoader, PNTSLoaderBase, PNTSParser, ParserBase, ParserFormat, ParticleSystemCurveEvalMode, ParticleSystemRandomnessIds, PassGenerate, PassShader, PassType, PhysicMaterialUniform_frag, PickCompute, PickFire, PickGUIEvent3D, PickResult, Picker_cs, PingPong, PipelinePool, Plane3D, PlaneClassification, PlaneGeometry, PlyMode, PlyParser, PointClassification, PointCloudGeometry, PointCloudMaterial, PointCloudRenderer, PointCloudShader, PointCloud_FS, PointCloud_VS, PointLight, PointLightShadowRenderer, PointShadowCubeCamera, PointerEvent3D, Polynomial, PolynomialCurve, Polynomials, PoolNode, PostBase, PostProcessingComponent, PostRenderer, PreDepthPassRenderer, PreFilteredEnvironment_cs, PreFilteredEnvironment_cs2, PreIntegratedLut, PreIntegratedLutCompute, PrefabAvatarData, PrefabAvatarParser, PrefabBoneData, PrefabMaterialParser, PrefabMeshData, PrefabMeshParser, PrefabNode, PrefabParser, PrefabStringUtil, PrefabTextureData, PrefabTextureParser, Preprocessor, PriorityQueue, Probe, ProbeEntries, ProbeGBufferFrame, ProfilerUtil, PropertyAnimClip, PropertyAnimTag, PropertyAnimation, PropertyAnimationClip, PropertyAnimationClipState, PropertyAnimationEvent, PropertyHelp, QuadAABB, QuadGlsl_fs, QuadGlsl_vs, QuadRoot, QuadShader, QuadTree, QuadTreeCell, Quad_depth2dArray_frag_wgsl, Quad_depth2d_frag_wgsl, Quad_depthCube_frag_wgsl, Quad_frag_wgsl, Quad_vert_wgsl, Quaternion, R32UintTexture, RADIANS_TO_DEGREES, RGBEErrorCode, RGBEHeader, RGBEParser, RTDescriptor, RTFrame, RTResourceConfig, RTResourceMap, Rand, RandomSeed, Ray, RayCastMeshDetail, Reader, Rect, Reference, Reflection, ReflectionCG, ReflectionEntries, ReflectionMaterial, ReflectionRenderer, ReflectionShader, ReflectionShader_shader, RegisterComponent, RegisterShader, RenderContext, RenderLayer, RenderLayerUtil, RenderNode, RenderShaderCollect, RenderShaderCompute, RenderShaderPass, RenderTexture, RendererBase, RendererJob, RendererMap, RendererMask, RendererMaskUtil, RendererPassState, RepeatSE, Res, RotationControlComponents, SHCommon_frag, SN_ArrayConstant, SN_BinaryOperation, SN_Break, SN_CodeBlock, SN_Constant, SN_Continue, SN_Declaration, SN_Discard, SN_DoWhileLoop, SN_Expression, SN_ForLoop, SN_Function, SN_FunctionArgs, SN_FunctionCall, SN_IFBranch, SN_Identifier, SN_IndexOperation, SN_Layout, SN_ParenExpression, SN_Precision, SN_Return, SN_SelectOperation, SN_Struct, SN_TernaryOperation, SN_UnaryOperation, SN_WhileLoop, SSAO_cs, SSGI2_cs, SSGIPost, SSRPost, SSR_BlendColor_cs, SSR_IS_Kernel, SSR_IS_cs, SSR_RayTrace_cs, ScaleControlComponents, Scene3D, Shader, ShaderAttributeInfo, ShaderConverter, ShaderConverterResult, ShaderLib, ShaderPassBase, ShaderReflection, ShaderStage, ShaderState, ShaderUniformInfo, ShaderUtil, ShadingInput, ShadowLightsCollect, ShadowMapPassRenderer, ShadowMapping_frag, Skeleton, SkeletonAnimationClip, SkeletonAnimationClipState, SkeletonAnimationComponent, SkeletonAnimationCompute, SkeletonAnimation_shader, SkeletonBlendComputeArgs, SkeletonPose, SkeletonTransformComputeArgs, SkinnedMeshRenderer, SkinnedMeshRenderer2, SkyGBufferPass, SkyGBuffer_pass, SkyMaterial, SkyRenderer, SkyShader, SolidColorSky, SphereColliderShape, SphereGeometry, SphereReflection, SpotLight, StandShader, StatementNode, StorageGPUBuffer, StringUtil, Struct, StructStorageGPUBuffer, SubGeometry, TAACopyTex_cs, TAAPost, TAASharpTex_cs, TAA_cs, TestComputeLoadBuffer, TextAnchor, TextFieldLayout, TextFieldLine, Texture, TextureCube, TextureCubeFaceData, TextureCubeStdCreator, TextureCubeUtils, TextureMipmapCompute, TextureMipmapGenerator, TextureScaleCompute, ThirdPersonCameraController, Tile, TileSet, TileSetChild, TileSetChildContent, TileSetChildContentMetaData, TileSetRoot, TilesRenderer, Time, TokenType, TorusGeometry, TouchData, TrailGeometry, Transform, TransformAxisEnum, TransformControllerBaseComponent, TransformMode, TransformSpaceMode, TranslationControlComponents, TranslatorContext, TriGeometry, Triangle, UIButton, UIButtonTransition, UIComponentBase, UIEvent, UIImage, UIImageGroup, UIInteractive, UIInteractiveStyle, UIPanel, UIRenderAble, UIShadow, UITextField, UITransform, UNLOADED, UUID, UV, Uint32ArrayTexture, Uint8ArrayTexture, UnLit, UnLitMaterial, UnLitMaterialUniform_frag, UnLitShader, UnLitTexArrayMaterial, UnLitTexArrayShader, UnLitTextureArray, UnLit_frag, UniformGPUBuffer, UniformNode, UniformType, ValueEnumType, ValueOp, ValueParser, ValueSpread, Vector2, Vector3, Vector3Ex, Vector4, VertexAttribute, VertexAttributeIndexShader, VertexAttributeName, VertexAttributeSize, VertexAttributeStride, VertexAttributes_vert, VertexBufferLayout, VertexFormat, VertexGPUBuffer, Vertical, VideoUniform_frag, View3D, ViewPanel, ViewQuad, VirtualTexture, WGS84_FLATTENING, WGS84_HEIGHT, WGS84_RADIUS, WGSLTranslator, WayLines3D, WayPoint3D, WebGPUDescriptorCreator, WorldMatrixUniform, WorldPanel, WrapMode, WrapTimeMode, ZCullingCompute, ZPassShader_cs, ZPassShader_fs, ZPassShader_vs, ZSorterUtil, append, arrayToString, blendComponent, buildCurves, byteSizeOfType, calculateCurveRangesValue, calculateMinMax, castPointShadowMap_vert, clamp, clampRepeat, computeAABBFromPositions, cos, crossProduct, cubicPolynomialRoot, cubicPolynomialRootsGeneric, curvesSupportProcedural, deg2Rad, detectGSplatFormat, directionShadowCastMap_frag, dot, doubleIntegrateSegment, downSample, fastInvSqrt, floorfToIntPos, fonts, generateRandom, generateRandom3, getFloatFromInt, getGLTypeFromTypedArray, getGLTypeFromTypedArrayType, getGlobalRandomSeed, getTypedArray, getTypedArrayTypeFromGLType, grad1, grad2, grad3, grad4, inferSHOrder, integrateSegment, irradianceDataReader, kPI, lerp, lerpByte, lerpColor, lerpVector3, lruPriorityCallback, magnitude, makeAloneSprite, makeGUISprite, makeMatrix44, markUsedSetLeaves, markUsedTiles, markVisibleTiles, matrixMultiply, matrixRotate, matrixRotateY, mergeFunctions, multiplyMatrices4x4REF, normal_distribution, normalizeFast, normalizeSafe, normalizedToByte, normalizedToWord, outlinePostData, outlinePostManager, parsePlyGaussianSplat, parsePlyHeader, parsePlyMesh, parsePlyPointCloud, perm, post, priorityCallback, quadraticPolynomialRootsGeneric, rad2Deg, random01, randomBarycentricCoord, randomPointBetweenEllipsoid, randomPointBetweenSphere, randomPointInsideCube, randomPointInsideEllipsoid, randomPointInsideUnitCircle, randomPointInsideUnitSphere, randomQuaternion, randomQuaternionUniformDistribution, randomSeed, randomUnitVector, randomUnitVector2, rangedRandomFloat, rangedRandomInt, readByType, readMagicBytes, registerMaterial, repeat, rotMatrix, rotateVectorByQuat, roundfToIntPos, scale, shadowCastMap_frag, shadowCastMap_vert, simplex, sin, snoise1, snoise2, snoise3, snoise4, splatColorProperties, splatProperties, sqrMagnitude, sqrtImpl, stencilStateFace, swap, textureCompress, threshold, throttle, toHalfFloat, toggleTiles, traverseAncestors, traverseSet, tw, uniform_real_distribution, uniform_real_distribution2, upSample$1 as upSample, webGPUContext, zSorterUtil };
+export { AccelerateDecelerateInterpolator, AccelerateInterpolator, AnimationCurve, AnimationCurveT, AnimationMonitor, AnimatorComponent, AnimatorEventKeyframe, AnticipateInterpolator, AnticipateOvershootInterpolator, ArrayHas, ArrayItemIndex, AtlasParser, AtmosphericComponent, AtmosphericScatteringSky, AtmosphericScatteringSkySetting, AtmosphericScatteringSky_shader, AttributeAnimCurve, AxisObject, B3DMLoader, B3DMLoaderBase, B3DMParseUtil, B3DMParser, BRDFLUT, BRDFLUTGenerate, BRDF_frag, BatchTable, BiMap, BillboardComponent, BillboardType, BitUtil, BitmapTexture2D, BitmapTexture2DArray, BitmapTextureCube, Blend, BlendFactor, BlendMode, BlendShapeData, BlendShapePropertyData, BloomPost, BlurEffectCreatorBlur_cs, BlurEffectCreatorSample_cs, BlurTexture2DBufferCreator, BounceInterpolator, BoundUtil, BoundingBox, BoundingSphere, BoundingVolume, BoxColliderShape, BoxGeometry, BrdfLut_frag, BsDF_frag, BxDF_frag, BxdfDebug_frag, BytesArray, CEvent, CEventDispatcher, CEventListener, CResizeEvent, CSM, Camera3D, CameraControllerBase, CameraType, CameraUtil, CapsuleColliderShape, CastPointShadowMaterialPass, CastShadowMaterialPass, Clearcoat_frag, ClusterBoundsSource_cs, ClusterConfig, ClusterDebug_frag, ClusterLight, ClusterLightingBuffer, ClusterLightingRender, ClusterLighting_cs, CollectInfo, ColliderComponent, ColliderShape, ColliderShapeType, Color, ColorGradient, ColorLitMaterial, ColorLitShader, ColorPassFragmentOutput, ColorPassRenderer, ColorUtil, ComData, Combine_cs, Common_frag, Common_vert, ComponentBase, ComponentCollect, ComputeGPUBuffer, ComputeShader, Context3D, CubeCamera, CubeMapFaceEnum, CubeSky_Shader, CubicBezierCurve, CubicBezierPath, CubicBezierType, CycleInterpolator, CylinderGeometry, DDGIIrradianceComputePass, DDGIIrradianceGPUBufferReader, DDGIIrradianceVolume, DDGIIrradiance_shader, DDGILightingPass, DDGILighting_shader, DDGIMultiBouncePass, DDGIProbeRenderer, DEGREES_TO_RADIANS, DRACO_DECODER_GLTF_JS, DecelerateInterpolator, Denoising_cs, Depth2DTextureArray, DepthCubeArrayTexture, DepthMaterialPass, DepthOfFieldPost, DepthOfView_cs, DirectLight, DoubleArray, EditorInspector, Engine3D, Entity, EntityBatchCollect, EntityCollect, EnvMap_frag, ErpImage2CubeMap, ErpImage2CubeMapCreateCube_cs, ErpImage2CubeMapRgbe2rgba_cs, ExtrudeGeometry, FAILED, FASTFLOOR, FXAAPost, FXAAShader, FastMathShader, FatLineGeometry, FatLineMaterial, FatLineRenderer, FatLineShader, FatLine_FS, FatLine_VS, FeatureTable, FileLoader, FirstPersonCameraController, Float16ArrayTexture, Float32ArrayTexture, FlyCameraController, FontChar, FontInfo, FontPage, FontParser, ForwardRenderJob, FragmentOutput, FragmentVarying, FrameCache, Frustum, FrustumCSM, FrustumCulling_cs, FullQuad_vert_wgsl, GBufferFrame, GBufferPass, GBufferPost, GBufferStand, GBuffer_pass, GILighting, GIProbeMaterial, GIProbeMaterialType, GIProbeShader, GIRenderCompleteEvent, GIRenderStartEvent, GLBChunk, GLBHeader, GLBParser, GLSLLexer, GLSLLexerToken, GLSLPreprocessor, GLSLSyntax, GLTFBinaryExtension, GLTFMaterial, GLTFParser, GLTFSubParser, GLTFSubParserCamera, GLTFSubParserConverter, GLTFSubParserMaterial, GLTFSubParserMesh, GLTFSubParserSkeleton, GLTFSubParserSkin, GLTFType, GLTF_Accessors, GLTF_Info, GLTF_Light, GLTF_Mesh, GLTF_Node, GLTF_Primitives, GLTF_Scene, GPUAddressMode, GPUBlendFactor, GPUBufferBase, GPUBufferType, GPUCompareFunction, GPUContext, GPUCullMode, GPUFilterMode, GPUPrimitiveTopology, GPUTextureFormat, GPUVertexFormat, GPUVertexStepMode, GSplatFormat, GSplatGeometry, GSplatMaterial, GSplatRenderer, GSplatShader, GSplat_FS, GSplat_VS, GTAOPost, GTAO_cs, GUIAtlasTexture, GUICanvas, GUIConfig, GUIGeometry, GUIGeometryRebuild, GUIMaterial, GUIPassRenderer, GUIPick, GUIPickHelper, GUIQuad, GUIQuadAttrEnum, GUIRenderer, GUIShader, GUISpace, GUISprite, GUITexture, GaussianSplatParser, GenerayRandomDir, GeoJsonParser, GeoJsonUtil, GeoType, GeometryBase, GeometryIndicesBuffer, GeometryUtil, GeometryVertexBuffer, GeometryVertexType, GetComponentClass, GetCountInstanceID, GetRepeat, GetShader, GlassShader, GlobalBindGroup, GlobalBindGroupLayout, GlobalFog, GlobalFog_shader, GlobalIlluminationComponent, GlobalUniform, GlobalUniformGroup, GodRayPost, GodRay_cs, GridObject, HDRTexture, HDRTextureCube, Hair_frag, Hair_shader_op, Hair_shader_tr, HaltonSeq, Horizontal, HoverCameraController, I3DMLoader, I3DMLoaderBase, I3DMParser, IBLEnvMapCreator, IBLEnvMapCreator_cs, IESProfiles, IESProfiles_frag, IKDTreeUserData, ImageType, IndicesGPUBuffer, Inline_vert, InputSystem, InstanceDrawComponent, InstanceUniform, InstancedMesh, Interpolator, InterpolatorEnum, IrradianceDataReaderCompleteEvent, IrradianceVolumeData_frag, Irradiance_frag, IsEditorInspector, IsNonSerialize, Joint, JointPose, JumperInterpolator, KDTreeEntity, KDTreeNode, KDTreeRange, KDTreeSpace, KDTreeUUID, KHR_draco_mesh_compression, KHR_lights_punctual, KHR_materials_clearcoat, KHR_materials_emissive_strength, KHR_materials_ior, KHR_materials_unlit, KMZParser, KV, KelvinUtil, KeyCode, KeyEvent, Keyframe, KeyframeT, LASLoader, LASParser, LASUtils, LASVisualizationMode, LDRTextureCube, LOADED, LOADING, LRUCache, LambertMaterial, Lambert_shader, Light, LightBase, LightData, LightEntries, LightType, LightingFunction_frag, Line, LineClassification, LinearInterpolator, LitMaterial, LitSSSShader, LitShader, Lit_shader, LoaderBase, LoaderEvent, LoaderManager, MAX_VALUE, MIN_VALUE, Material, MaterialDataUniformGPUBuffer, MaterialUtilities, MathShader, MathUtil, Matrix3, Matrix4, MatrixBindGroup, MatrixGPUBuffer, MatrixShader, MemoryDO, MemoryInfo, MergeRGBACreator, MergeRGBA_cs, MeshColliderShape, MeshFilter, MeshRenderer, MinMaxAnimationCurves, MinMaxCurve, MinMaxCurveState, MinMaxPolyCurves, MorePassParser, MorePassShader, MorphTargetBlender, MorphTargetData, MorphTargetFrame, MorphTargetTransformKey, MorphTarget_shader, MouseCode, MultiBouncePass_cs, Navi3DAstar, Navi3DConst, Navi3DEdge, Navi3DFunnel, Navi3DMaskType, Navi3DMesh, Navi3DPoint, Navi3DPoint2D, Navi3DPointFat, Navi3DRouter, Navi3DTriangle, NonSerialize, NormalMap_frag, OAnimationEvent, OBJParser, Object3D, Object3DEvent, Object3DTransformTools, Object3DUtil, ObjectAnimClip, OcclusionSystem, Octree, OctreeEntity, OrbitController, OrderMap, Orientation3D, OutLineBlendColor_cs, OutlineCalcOutline_cs, OutlinePass, OutlinePost, OutlinePostData, OutlinePostManager, OutlinePostSlot, Outline_cs, OvershootInterpolator, PARSING, PBRLItShader, PBRLitSSSShader, PLUGIN_REGISTERED, PNTSLoader, PNTSLoaderBase, PNTSParser, ParserBase, ParserFormat, ParticleSystemCurveEvalMode, ParticleSystemRandomnessIds, PassGenerate, PassShader, PassType, PhysicMaterialUniform_frag, PickCompute, PickFire, PickGUIEvent3D, PickResult, Picker_cs, PingPong, PipelinePool, Plane3D, PlaneClassification, PlaneGeometry, PlyMode, PlyParser, PointClassification, PointCloudGeometry, PointCloudMaterial, PointCloudRenderer, PointCloudShader, PointCloud_FS, PointCloud_VS, PointLight, PointLightShadowRenderer, PointShadowCubeCamera, PointerEvent3D, Polynomial, PolynomialCurve, Polynomials, PoolNode, PostBase, PostProcessingComponent, PostRenderer, PreDepthPassRenderer, PreFilteredEnvironment_cs, PreFilteredEnvironment_cs2, PreIntegratedLut, PreIntegratedLutCompute, PrefabAvatarData, PrefabAvatarParser, PrefabBoneData, PrefabMaterialParser, PrefabMeshData, PrefabMeshParser, PrefabNode, PrefabParser, PrefabStringUtil, PrefabTextureData, PrefabTextureParser, Preprocessor, PriorityQueue, Probe, ProbeEntries, ProbeGBufferFrame, ProfilerUtil, PropertyAnimClip, PropertyAnimTag, PropertyAnimation, PropertyAnimationClip, PropertyAnimationClipState, PropertyAnimationEvent, PropertyHelp, QuadAABB, QuadGlsl_fs, QuadGlsl_vs, QuadRoot, QuadShader, QuadTree, QuadTreeCell, Quad_depth2dArray_frag_wgsl, Quad_depth2d_frag_wgsl, Quad_depthCube_frag_wgsl, Quad_frag_wgsl, Quad_vert_wgsl, Quaternion, R32UintTexture, RADIANS_TO_DEGREES, RGBEErrorCode, RGBEHeader, RGBEParser, RTDescriptor, RTFrame, RTResourceConfig, RTResourceMap, Rand, RandomSeed, Ray, RayCastMeshDetail, Reader, Rect, Reference, Reflection, ReflectionCG, ReflectionEntries, ReflectionMaterial, ReflectionRenderer, ReflectionShader, ReflectionShader_shader, RegisterComponent, RegisterShader, RenderContext, RenderLayer, RenderLayerUtil, RenderNode, RenderShaderCollect, RenderShaderCompute, RenderShaderPass, RenderTexture, RendererBase, RendererJob, RendererMap, RendererMask, RendererMaskUtil, RendererPassState, RepeatSE, Res, RotationControlComponents, SHCommon_frag, SN_ArrayConstant, SN_BinaryOperation, SN_Break, SN_CodeBlock, SN_Constant, SN_Continue, SN_Declaration, SN_Discard, SN_DoWhileLoop, SN_Expression, SN_ForLoop, SN_Function, SN_FunctionArgs, SN_FunctionCall, SN_IFBranch, SN_Identifier, SN_IndexOperation, SN_Layout, SN_ParenExpression, SN_Precision, SN_Return, SN_SelectOperation, SN_Struct, SN_TernaryOperation, SN_UnaryOperation, SN_WhileLoop, SSAO_cs, SSGI2_cs, SSGIPost, SSRPost, SSR_BlendColor_cs, SSR_IS_Kernel, SSR_IS_cs, SSR_RayTrace_cs, ScaleControlComponents, Scene3D, Shader, ShaderAttributeInfo, ShaderConverter, ShaderConverterResult, ShaderLib, ShaderPassBase, ShaderReflection, ShaderStage, ShaderState, ShaderUniformInfo, ShaderUtil, ShadingInput, ShadowLightsCollect, ShadowMapPassRenderer, ShadowMapping_frag, Skeleton, SkeletonAnimationClip, SkeletonAnimationClipState, SkeletonAnimationComponent, SkeletonAnimationCompute, SkeletonAnimation_shader, SkeletonBlendComputeArgs, SkeletonPose, SkeletonTransformComputeArgs, SkinnedMeshRenderer, SkinnedMeshRenderer2, SkyGBufferPass, SkyGBuffer_pass, SkyMaterial, SkyRenderer, SkyShader, SolidColorSky, SphereColliderShape, SphereGeometry, SphereReflection, SpotLight, StandShader, StatementNode, StorageGPUBuffer, StringUtil, Struct, StructStorageGPUBuffer, SubGeometry, TAACopyTex_cs, TAAPost, TAASharpTex_cs, TAA_cs, TestComputeLoadBuffer, TextAnchor, TextFieldLayout, TextFieldLine, Texture, TextureCube, TextureCubeFaceData, TextureCubeStdCreator, TextureCubeUtils, TextureMipmapCompute, TextureMipmapGenerator, TextureScaleCompute, ThirdPersonCameraController, Tile, TileSet, TileSetChild, TileSetChildContent, TileSetChildContentMetaData, TileSetRoot, TilesRenderer, Time, TokenType, TorusGeometry, TouchData, TrailGeometry, Transform, TransformAxisEnum, TransformControllerBaseComponent, TransformMode, TransformSpaceMode, TranslationControlComponents, TranslatorContext, TriGeometry, Triangle, UIButton, UIButtonTransition, UIComponentBase, UIEvent, UIImage, UIImageGroup, UIInteractive, UIInteractiveStyle, UIPanel, UIRenderAble, UIShadow, UITextField, UITransform, UNLOADED, UUID, UV, Uint32ArrayTexture, Uint8ArrayTexture, UnLit, UnLitMaterial, UnLitMaterialUniform_frag, UnLitShader, UnLitTexArrayMaterial, UnLitTexArrayShader, UnLitTextureArray, UnLit_frag, UniformGPUBuffer, UniformNode, UniformType, ValueEnumType, ValueOp, ValueParser, ValueSpread, Vector2, Vector3, Vector3Ex, Vector4, VertexAttribute, VertexAttributeIndexShader, VertexAttributeName, VertexAttributeSize, VertexAttributeStride, VertexAttributes_vert, VertexBufferLayout, VertexFormat, VertexGPUBuffer, Vertical, VideoUniform_frag, View3D, ViewPanel, ViewQuad, VirtualTexture, WGS84_FLATTENING, WGS84_HEIGHT, WGS84_RADIUS, WGSLTranslator, WayLines3D, WayPoint3D, WebGPUDescriptorCreator, WorldMatrixUniform, WorldPanel, WrapMode, WrapTimeMode, ZCullingCompute, ZPassShader_cs, ZPassShader_fs, ZPassShader_vs, ZSorterUtil, append, arrayToString, blendComponent, buildCurves, byteSizeOfType, calculateCurveRangesValue, calculateMinMax, castPointShadowMap_vert, clamp, clampRepeat, computeAABBFromPositions, cos, crossProduct, cubicPolynomialRoot, cubicPolynomialRootsGeneric, curvesSupportProcedural, deg2Rad, detectGSplatFormat, directionShadowCastMap_frag, dot, doubleIntegrateSegment, downSample, fastInvSqrt, floorfToIntPos, fonts, generateRandom, generateRandom3, getFloatFromInt, getGLTypeFromTypedArray, getGLTypeFromTypedArrayType, getGlobalRandomSeed, getTypedArray, getTypedArrayTypeFromGLType, grad1, grad2, grad3, grad4, inferSHOrder, integrateSegment, irradianceDataReader, kPI, lerp, lerpByte, lerpColor, lerpVector3, lruPriorityCallback, magnitude, makeAloneSprite, makeGUISprite, makeMatrix44, markUsedSetLeaves, markUsedTiles, markVisibleTiles, matrixMultiply, matrixRotate, matrixRotateY, mergeFunctions, multiplyMatrices4x4REF, normal_distribution, normalizeFast, normalizeSafe, normalizedToByte, normalizedToWord, outlinePostData, outlinePostManager, parsePlyGaussianSplat, parsePlyHeader, parsePlyMesh, parsePlyPointCloud, perm, post, priorityCallback, quadraticPolynomialRootsGeneric, rad2Deg, random01, randomBarycentricCoord, randomPointBetweenEllipsoid, randomPointBetweenSphere, randomPointInsideCube, randomPointInsideEllipsoid, randomPointInsideUnitCircle, randomPointInsideUnitSphere, randomQuaternion, randomQuaternionUniformDistribution, randomSeed, randomUnitVector, randomUnitVector2, rangedRandomFloat, rangedRandomInt, readByType, readMagicBytes, registerMaterial, repeat, rotMatrix, rotateVectorByQuat, roundfToIntPos, scale, shadowCastMap_frag, shadowCastMap_vert, simplex, sin, snoise1, snoise2, snoise3, snoise4, splatColorProperties, splatProperties, sqrMagnitude, sqrtImpl, stencilStateFace, swap, textureCompress, threshold, throttle, toHalfFloat, toggleTiles, traverseAncestors, traverseSet, tw, uniform_real_distribution, uniform_real_distribution2, upSample$1 as upSample, webGPUContext, zSorterUtil };