@rings-webgpu/core 1.0.30 → 1.0.32

package/dist/rings.umd.max.js

@@ -42153,7 +42153,7 @@ else if (typeof exports === 'object')
     }
   }
 
-  const version = "1.0.29";
+  const version = "1.0.31";
 
   class Engine3D {
     /**
@@ -61154,6 +61154,711 @@ fn frag(){
   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;
+  };
+  exports.FatLineShader = class FatLineShader 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);
+    }
+  };
+  exports.FatLineShader = __decorateClass$4([
+    RegisterShader(exports.FatLineShader, "FatLineShader")
+  ], exports.FatLineShader);
+
+  class FatLineMaterial extends Material {
+    constructor() {
+      super();
+      this.shader = new exports.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 exports.Object3D();
+      pointCloudObj.name = "LASPointCloud";
+      const pointCloudObjRoot = new exports.Object3D();
+      pointCloudObjRoot.name = "LASPointCloudRoot";
+      pointCloudObj.addChild(pointCloudObjRoot);
+      const renderer = pointCloudObjRoot.addComponent(exports.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 exports.Object3D();
+      pointCloudObj.name = "LASPointCloud";
+      const renderer = pointCloudObj.addComponent(exports.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 exports.Object3D();
+      curveObj.name = `LASCurve_${headers[curveIndex]}`;
+      const renderer = curveObj.addComponent(exports.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) {
@@ -62505,9 +63210,9 @@ fn frag(){
     }
   }
 
-  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;
@@ -62626,13 +63331,13 @@ fn frag(){
       }
     }
   };
-  exports.LitSSSShader = __decorateClass$4([
+  exports.LitSSSShader = __decorateClass$3([
     RegisterShader(exports.LitSSSShader, "LitSSSShader")
   ], exports.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;
@@ -62728,7 +63433,7 @@ fn frag(){
       }
     }
   };
-  exports.LitShader = __decorateClass$3([
+  exports.LitShader = __decorateClass$2([
     RegisterShader(exports.LitShader, "LitShader")
   ], exports.LitShader);
 
@@ -62887,47 +63592,6 @@ fn frag(){
     }
   }
 
-  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;
-  };
-  exports.FatLineShader = class FatLineShader 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);
-    }
-  };
-  exports.FatLineShader = __decorateClass$2([
-    RegisterShader(exports.FatLineShader, "FatLineShader")
-  ], exports.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;
@@ -64207,6 +64871,8 @@ fn frag(){
     _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
@@ -64323,6 +64989,7 @@ fn frag(){
       _usedSet.forEach((tile) => lruCache.markUnused(tile));
       _usedSet.clear();
       this.updateCameraInfo();
+      this._checkDelayedHideTiles();
       markUsedTiles(root, this);
       markUsedSetLeaves(root, this);
       markVisibleTiles(root, this);
@@ -64792,6 +65459,9 @@ fn frag(){
     setTileActive(tile, active) {
       if (active) {
         this._activeTiles.add(tile);
+        if (this._delayedHideTiles.has(tile)) {
+          this._delayedHideTiles.delete(tile);
+        }
       } else {
         this._activeTiles.delete(tile);
       }
@@ -64811,7 +65481,42 @@ fn frag(){
         }
         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;
+          }
+        }
       }
     }
     /**
@@ -64820,6 +65525,9 @@ fn frag(){
     setTileVisible(tile, visible) {
       if (visible) {
         this._visibleTiles.add(tile);
+        if (this._delayedHideTiles.has(tile)) {
+          this._delayedHideTiles.delete(tile);
+        }
       } else {
         this._visibleTiles.delete(tile);
       }
@@ -64827,7 +65535,13 @@ fn frag(){
       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
@@ -65301,78 +66015,6 @@ fn frag(){
     }
   }
 
-  class FatLineMaterial extends Material {
-    constructor() {
-      super();
-      this.shader = new exports.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
@@ -71392,6 +72034,10 @@ fn frag(){
   exports.KeyEvent = KeyEvent;
   exports.Keyframe = Keyframe;
   exports.KeyframeT = KeyframeT;
+  exports.LASLoader = LASLoader;
+  exports.LASParser = LASParser;
+  exports.LASUtils = LASUtils;
+  exports.LASVisualizationMode = LASVisualizationMode;
   exports.LDRTextureCube = LDRTextureCube;
   exports.LOADED = LOADED;
   exports.LOADING = LOADING;