@luma.gl/engine 9.0.0-alpha.3 → 9.0.0-alpha.30

package/dist/index.cjs

@@ -0,0 +1,2574 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AnimationLoop: () => AnimationLoop,
+  AnimationLoopTemplate: () => AnimationLoopTemplate,
+  ClipSpace: () => ClipSpace,
+  ConeGeometry: () => ConeGeometry,
+  CubeGeometry: () => CubeGeometry,
+  CylinderGeometry: () => CylinderGeometry,
+  Geometry: () => Geometry,
+  GroupNode: () => GroupNode,
+  IcoSphereGeometry: () => IcoSphereGeometry,
+  KeyFrames: () => KeyFrames,
+  Model: () => Model,
+  ModelNode: () => ModelNode,
+  PipelineFactory: () => PipelineFactory,
+  PlaneGeometry: () => PlaneGeometry,
+  ScenegraphNode: () => ScenegraphNode,
+  SphereGeometry: () => SphereGeometry,
+  Timeline: () => Timeline,
+  Transform: () => Transform,
+  TruncatedConeGeometry: () => TruncatedConeGeometry,
+  makeAnimationLoop: () => makeAnimationLoop
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/animation/timeline.ts
+var channelHandles = 1;
+var animationHandles = 1;
+var Timeline = class {
+  constructor() {
+    this.time = 0;
+    this.channels = /* @__PURE__ */ new Map();
+    this.animations = /* @__PURE__ */ new Map();
+    this.playing = false;
+    this.lastEngineTime = -1;
+  }
+  addChannel(props) {
+    const { delay = 0, duration = Number.POSITIVE_INFINITY, rate = 1, repeat = 1 } = props;
+    const handle = channelHandles++;
+    const channel = {
+      time: 0,
+      delay,
+      duration,
+      rate,
+      repeat
+    };
+    this._setChannelTime(channel, this.time);
+    this.channels.set(handle, channel);
+    return handle;
+  }
+  removeChannel(handle) {
+    this.channels.delete(handle);
+    for (const [animationHandle, animation] of this.animations) {
+      if (animation.channel === handle) {
+        this.detachAnimation(animationHandle);
+      }
+    }
+  }
+  isFinished(handle) {
+    const channel = this.channels.get(handle);
+    if (channel === void 0) {
+      return false;
+    }
+    return this.time >= channel.delay + channel.duration * channel.repeat;
+  }
+  getTime(handle) {
+    if (handle === void 0) {
+      return this.time;
+    }
+    const channel = this.channels.get(handle);
+    if (channel === void 0) {
+      return -1;
+    }
+    return channel.time;
+  }
+  setTime(time) {
+    this.time = Math.max(0, time);
+    const channels = this.channels.values();
+    for (const channel of channels) {
+      this._setChannelTime(channel, this.time);
+    }
+    const animations = this.animations.values();
+    for (const animationData of animations) {
+      const { animation, channel } = animationData;
+      animation.setTime(this.getTime(channel));
+    }
+  }
+  play() {
+    this.playing = true;
+  }
+  pause() {
+    this.playing = false;
+    this.lastEngineTime = -1;
+  }
+  reset() {
+    this.setTime(0);
+  }
+  attachAnimation(animation, channelHandle) {
+    const animationHandle = animationHandles++;
+    this.animations.set(animationHandle, {
+      animation,
+      channel: channelHandle
+    });
+    animation.setTime(this.getTime(channelHandle));
+    return animationHandle;
+  }
+  detachAnimation(handle) {
+    this.animations.delete(handle);
+  }
+  update(engineTime) {
+    if (this.playing) {
+      if (this.lastEngineTime === -1) {
+        this.lastEngineTime = engineTime;
+      }
+      this.setTime(this.time + (engineTime - this.lastEngineTime));
+      this.lastEngineTime = engineTime;
+    }
+  }
+  _setChannelTime(channel, time) {
+    const offsetTime = time - channel.delay;
+    const totalDuration = channel.duration * channel.repeat;
+    if (offsetTime >= totalDuration) {
+      channel.time = channel.duration * channel.rate;
+    } else {
+      channel.time = Math.max(0, offsetTime) % channel.duration;
+      channel.time *= channel.rate;
+    }
+  }
+};
+
+// src/animation/key-frames.ts
+var KeyFrames = class {
+  constructor(keyFrames) {
+    this.startIndex = -1;
+    this.endIndex = -1;
+    this.factor = 0;
+    this.times = [];
+    this.values = [];
+    this._lastTime = -1;
+    this.setKeyFrames(keyFrames);
+    this.setTime(0);
+  }
+  setKeyFrames(keyFrames) {
+    const numKeys = keyFrames.length;
+    this.times.length = numKeys;
+    this.values.length = numKeys;
+    for (let i = 0; i < numKeys; ++i) {
+      this.times[i] = keyFrames[i][0];
+      this.values[i] = keyFrames[i][1];
+    }
+    this._calculateKeys(this._lastTime);
+  }
+  setTime(time) {
+    time = Math.max(0, time);
+    if (time !== this._lastTime) {
+      this._calculateKeys(time);
+      this._lastTime = time;
+    }
+  }
+  getStartTime() {
+    return this.times[this.startIndex];
+  }
+  getEndTime() {
+    return this.times[this.endIndex];
+  }
+  getStartData() {
+    return this.values[this.startIndex];
+  }
+  getEndData() {
+    return this.values[this.endIndex];
+  }
+  _calculateKeys(time) {
+    let index = 0;
+    const numKeys = this.times.length;
+    for (index = 0; index < numKeys - 2; ++index) {
+      if (this.times[index + 1] > time) {
+        break;
+      }
+    }
+    this.startIndex = index;
+    this.endIndex = index + 1;
+    const startTime = this.times[this.startIndex];
+    const endTime = this.times[this.endIndex];
+    this.factor = Math.min(Math.max(0, (time - startTime) / (endTime - startTime)), 1);
+  }
+};
+
+// src/animation-loop/render-loop.ts
+var AnimationLoopTemplate = class {
+  constructor(animationProps) {
+  }
+  onInitialize(animationProps) {
+    return __async(this, null, function* () {
+      return null;
+    });
+  }
+};
+
+// src/animation-loop/animation-loop.ts
+var import_core = require("@luma.gl/core");
+var import_core2 = require("@luma.gl/core");
+var import_stats = require("@probe.gl/stats");
+var statIdCounter = 0;
+var DEFAULT_ANIMATION_LOOP_PROPS = {
+  device: null,
+  onAddHTML: () => "",
+  onInitialize: () => __async(void 0, null, function* () {
+    return null;
+  }),
+  onRender: () => {
+  },
+  onFinalize: () => {
+  },
+  onError: (error) => console.error(error),
+  // eslint-disable-line no-console
+  stats: import_core.luma.stats.get(`animation-loop-${statIdCounter++}`),
+  // view parameters
+  useDevicePixels: true,
+  autoResizeViewport: false,
+  autoResizeDrawingBuffer: false
+};
+var AnimationLoop = class {
+  // _gpuTimeQuery: Query | null = null;
+  /*
+   * @param {HTMLCanvasElement} canvas - if provided, width and height will be passed to context
+   */
+  constructor(props) {
+    this.device = null;
+    this.canvas = null;
+    this.animationProps = null;
+    this.timeline = null;
+    this.needsRedraw = "initialized";
+    this._initialized = false;
+    this._running = false;
+    this._animationFrameId = null;
+    this._nextFramePromise = null;
+    this._resolveNextFrame = null;
+    this._cpuStartTime = 0;
+    this.props = __spreadValues(__spreadValues({}, DEFAULT_ANIMATION_LOOP_PROPS), props);
+    props = this.props;
+    if (!props.device) {
+      throw new Error("No device provided");
+    }
+    const { useDevicePixels = true } = this.props;
+    this.stats = props.stats || new import_stats.Stats({ id: "animation-loop-stats" });
+    this.cpuTime = this.stats.get("CPU Time");
+    this.gpuTime = this.stats.get("GPU Time");
+    this.frameRate = this.stats.get("Frame Rate");
+    this.setProps({
+      autoResizeViewport: props.autoResizeViewport,
+      autoResizeDrawingBuffer: props.autoResizeDrawingBuffer,
+      useDevicePixels
+    });
+    this.start = this.start.bind(this);
+    this.stop = this.stop.bind(this);
+    this._onMousemove = this._onMousemove.bind(this);
+    this._onMouseleave = this._onMouseleave.bind(this);
+  }
+  destroy() {
+    this.stop();
+    this._setDisplay(null);
+  }
+  /** @deprecated Use .destroy() */
+  delete() {
+    this.destroy();
+  }
+  setNeedsRedraw(reason) {
+    this.needsRedraw = this.needsRedraw || reason;
+    return this;
+  }
+  // TODO - move to CanvasContext
+  setProps(props) {
+    if ("autoResizeViewport" in props) {
+      this.props.autoResizeViewport = props.autoResizeViewport || false;
+    }
+    if ("autoResizeDrawingBuffer" in props) {
+      this.props.autoResizeDrawingBuffer = props.autoResizeDrawingBuffer || false;
+    }
+    if ("useDevicePixels" in props) {
+      this.props.useDevicePixels = props.useDevicePixels || false;
+    }
+    return this;
+  }
+  /** Starts a render loop if not already running */
+  start() {
+    return __async(this, null, function* () {
+      if (this._running) {
+        return this;
+      }
+      this._running = true;
+      try {
+        if (!this._running) {
+          return null;
+        }
+        let appContext;
+        if (!this._initialized) {
+          this._initialized = true;
+          yield this._initDevice();
+          this._initialize();
+          yield this.props.onInitialize(this._getAnimationProps());
+        }
+        if (!this._running) {
+          return null;
+        }
+        if (appContext !== false) {
+          this._cancelAnimationFrame();
+          this._requestAnimationFrame();
+        }
+        return this;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Unknown error");
+        this.props.onError(error);
+        throw error;
+      }
+    });
+  }
+  /** Explicitly draw a frame */
+  redraw() {
+    var _a;
+    if ((_a = this.device) == null ? void 0 : _a.isLost) {
+      return this;
+    }
+    this._beginTimers();
+    this._setupFrame();
+    this._updateAnimationProps();
+    this._renderFrame(this._getAnimationProps());
+    this._clearNeedsRedraw();
+    if (this._resolveNextFrame) {
+      this._resolveNextFrame(this);
+      this._nextFramePromise = null;
+      this._resolveNextFrame = null;
+    }
+    this._endTimers();
+    return this;
+  }
+  // Stops a render loop if already running, finalizing
+  stop() {
+    if (this._running) {
+      if (this.animationProps) {
+        this.props.onFinalize(this.animationProps);
+      }
+      this._cancelAnimationFrame();
+      this._nextFramePromise = null;
+      this._resolveNextFrame = null;
+      this._running = false;
+    }
+    return this;
+  }
+  attachTimeline(timeline) {
+    this.timeline = timeline;
+    return this.timeline;
+  }
+  detachTimeline() {
+    this.timeline = null;
+  }
+  waitForRender() {
+    this.setNeedsRedraw("waitForRender");
+    if (!this._nextFramePromise) {
+      this._nextFramePromise = new Promise((resolve) => {
+        this._resolveNextFrame = resolve;
+      });
+    }
+    return this._nextFramePromise;
+  }
+  toDataURL() {
+    return __async(this, null, function* () {
+      this.setNeedsRedraw("toDataURL");
+      yield this.waitForRender();
+      if (this.canvas instanceof HTMLCanvasElement) {
+        return this.canvas.toDataURL();
+      }
+      throw new Error("OffscreenCanvas");
+    });
+  }
+  // PRIVATE METHODS
+  _initialize() {
+    this._startEventHandling();
+    this._initializeAnimationProps();
+    this._updateAnimationProps();
+    this._resizeCanvasDrawingBuffer();
+    this._resizeViewport();
+  }
+  _setDisplay(display) {
+    if (this.display) {
+      this.display.destroy();
+      this.display.animationLoop = null;
+    }
+    if (display) {
+      display.animationLoop = this;
+    }
+    this.display = display;
+  }
+  _requestAnimationFrame() {
+    if (!this._running) {
+      return;
+    }
+    this._animationFrameId = (0, import_core2.requestAnimationFrame)(this._animationFrame.bind(this));
+  }
+  _cancelAnimationFrame() {
+    if (this._animationFrameId !== null) {
+      return;
+    }
+    (0, import_core2.cancelAnimationFrame)(this._animationFrameId);
+    this._animationFrameId = null;
+  }
+  _animationFrame() {
+    if (!this._running) {
+      return;
+    }
+    this.redraw();
+    this._requestAnimationFrame();
+  }
+  // Called on each frame, can be overridden to call onRender multiple times
+  // to support e.g. stereoscopic rendering
+  _renderFrame(animationProps) {
+    if (this.display) {
+      this.display._renderFrame(animationProps);
+      return;
+    }
+    this.props.onRender(this._getAnimationProps());
+  }
+  _clearNeedsRedraw() {
+    this.needsRedraw = false;
+  }
+  _setupFrame() {
+    this._resizeCanvasDrawingBuffer();
+    this._resizeViewport();
+  }
+  // Initialize the  object that will be passed to app callbacks
+  _initializeAnimationProps() {
+    var _a, _b;
+    if (!this.device) {
+      throw new Error("loop");
+    }
+    this.animationProps = {
+      animationLoop: this,
+      device: this.device,
+      canvas: (_b = (_a = this.device) == null ? void 0 : _a.canvasContext) == null ? void 0 : _b.canvas,
+      renderPass: this.device.getDefaultRenderPass(),
+      timeline: this.timeline,
+      // Initial values
+      useDevicePixels: this.props.useDevicePixels,
+      needsRedraw: false,
+      // Placeholders
+      width: 1,
+      height: 1,
+      aspect: 1,
+      // Animation props
+      time: 0,
+      startTime: Date.now(),
+      engineTime: 0,
+      tick: 0,
+      tock: 0,
+      // Experimental
+      _mousePosition: null
+      // Event props
+    };
+  }
+  _getAnimationProps() {
+    if (!this.animationProps) {
+      throw new Error("animationProps");
+    }
+    return this.animationProps;
+  }
+  // Update the context object that will be passed to app callbacks
+  _updateAnimationProps() {
+    if (!this.animationProps) {
+      return;
+    }
+    this.animationProps.renderPass = this.device.getDefaultRenderPass();
+    const { width, height, aspect } = this._getSizeAndAspect();
+    if (width !== this.animationProps.width || height !== this.animationProps.height) {
+      this.setNeedsRedraw("drawing buffer resized");
+    }
+    if (aspect !== this.animationProps.aspect) {
+      this.setNeedsRedraw("drawing buffer aspect changed");
+    }
+    this.animationProps.width = width;
+    this.animationProps.height = height;
+    this.animationProps.aspect = aspect;
+    this.animationProps.needsRedraw = this.needsRedraw;
+    this.animationProps.engineTime = Date.now() - this.animationProps.startTime;
+    if (this.timeline) {
+      this.timeline.update(this.animationProps.engineTime);
+    }
+    this.animationProps.tick = Math.floor(this.animationProps.time / 1e3 * 60);
+    this.animationProps.tock++;
+    this.animationProps.time = this.timeline ? this.timeline.getTime() : this.animationProps.engineTime;
+  }
+  /** Wait for supplied device */
+  _initDevice() {
+    return __async(this, null, function* () {
+      var _a;
+      this.device = yield this.props.device;
+      if (!this.device) {
+        throw new Error("No device provided");
+      }
+      this.canvas = ((_a = this.device.canvasContext) == null ? void 0 : _a.canvas) || null;
+    });
+  }
+  _createInfoDiv() {
+    if (this.canvas && this.props.onAddHTML) {
+      const wrapperDiv = document.createElement("div");
+      document.body.appendChild(wrapperDiv);
+      wrapperDiv.style.position = "relative";
+      const div = document.createElement("div");
+      div.style.position = "absolute";
+      div.style.left = "10px";
+      div.style.bottom = "10px";
+      div.style.width = "300px";
+      div.style.background = "white";
+      if (this.canvas instanceof HTMLCanvasElement) {
+        wrapperDiv.appendChild(this.canvas);
+      }
+      wrapperDiv.appendChild(div);
+      const html = this.props.onAddHTML(div);
+      if (html) {
+        div.innerHTML = html;
+      }
+    }
+  }
+  _getSizeAndAspect() {
+    var _a, _b, _c, _d;
+    if (!this.device) {
+      return { width: 1, height: 1, aspect: 1 };
+    }
+    const [width, height] = ((_b = (_a = this.device) == null ? void 0 : _a.canvasContext) == null ? void 0 : _b.getPixelSize()) || [1, 1];
+    let aspect = 1;
+    const canvas = (_d = (_c = this.device) == null ? void 0 : _c.canvasContext) == null ? void 0 : _d.canvas;
+    if (canvas && canvas.clientHeight) {
+      aspect = canvas.clientWidth / canvas.clientHeight;
+    } else if (width > 0 && height > 0) {
+      aspect = width / height;
+    }
+    return { width, height, aspect };
+  }
+  /** Default viewport setup */
+  _resizeViewport() {
+    if (this.props.autoResizeViewport && this.device.gl) {
+      this.device.gl.viewport(0, 0, this.device.gl.drawingBufferWidth, this.device.gl.drawingBufferHeight);
+    }
+  }
+  /**
+   * Resize the render buffer of the canvas to match canvas client size
+   * Optionally multiplying with devicePixel ratio
+   */
+  _resizeCanvasDrawingBuffer() {
+    var _a, _b;
+    if (this.props.autoResizeDrawingBuffer) {
+      (_b = (_a = this.device) == null ? void 0 : _a.canvasContext) == null ? void 0 : _b.resize({ useDevicePixels: this.props.useDevicePixels });
+    }
+  }
+  _beginTimers() {
+    this.frameRate.timeEnd();
+    this.frameRate.timeStart();
+  }
+  _endTimers() {
+    this.cpuTime.timeEnd();
+  }
+  // Event handling
+  _startEventHandling() {
+    if (this.canvas) {
+      this.canvas.addEventListener("mousemove", this._onMousemove.bind(this));
+      this.canvas.addEventListener("mouseleave", this._onMouseleave.bind(this));
+    }
+  }
+  _onMousemove(event) {
+    if (event instanceof MouseEvent) {
+      this._getAnimationProps()._mousePosition = [event.offsetX, event.offsetY];
+    }
+  }
+  _onMouseleave(event) {
+    this._getAnimationProps()._mousePosition = null;
+  }
+};
+
+// src/animation-loop/make-animation-loop.ts
+var import_core3 = require("@luma.gl/core");
+function makeAnimationLoop(AnimationLoopTemplateCtor, props) {
+  let renderLoop = null;
+  const device = (props == null ? void 0 : props.device) || import_core3.luma.createDevice();
+  const animationLoop = new AnimationLoop(__spreadProps(__spreadValues({}, props), {
+    device,
+    onInitialize(animationProps) {
+      return __async(this, null, function* () {
+        renderLoop = new AnimationLoopTemplateCtor(animationProps);
+        return yield renderLoop == null ? void 0 : renderLoop.onInitialize(animationProps);
+      });
+    },
+    onRender: (animationProps) => renderLoop == null ? void 0 : renderLoop.onRender(animationProps),
+    onFinalize: (animationProps) => renderLoop == null ? void 0 : renderLoop.onFinalize(animationProps)
+  }));
+  animationLoop.getInfo = () => {
+    return this.AnimationLoopTemplateCtor.info;
+  };
+  return animationLoop;
+}
+
+// src/model/model.ts
+var import_core5 = require("@luma.gl/core");
+var import_core6 = require("@luma.gl/core");
+
+// src/model/model-utils.ts
+var import_core4 = require("@luma.gl/core");
+var GLTF_TO_LUMA_ATTRIBUTE_MAP = {
+  POSITION: "positions",
+  NORMAL: "normals",
+  COLOR_0: "colors",
+  TEXCOORD_0: "texCoords",
+  TEXCOORD_1: "texCoords1",
+  TEXCOORD_2: "texCoords2"
+};
+function getIndexBufferFromGeometry(device, geometry) {
+  if (!geometry.indices) {
+    return void 0;
+  }
+  const data = geometry.indices.value || geometry.indices;
+  (0, import_core4.assert)(
+    data instanceof Uint16Array || data instanceof Uint32Array,
+    'attribute array for "indices" must be of integer type'
+  );
+  return device.createBuffer({ usage: import_core4.Buffer.INDEX, data });
+}
+function getAttributeBuffersFromGeometry(device, geometry) {
+  const buffers = {};
+  for (const [name, attribute] of Object.entries(geometry.attributes)) {
+    const remappedName = mapAttributeName(name);
+    if (attribute == null ? void 0 : attribute.constant) {
+      throw new Error("constant attributes not supported");
+    } else {
+      const typedArray = attribute == null ? void 0 : attribute.value;
+      buffers[remappedName] = device.createBuffer({ data: typedArray, id: `${remappedName}-buffer` });
+    }
+  }
+  return buffers;
+}
+function mapAttributeName(name) {
+  return GLTF_TO_LUMA_ATTRIBUTE_MAP[name] || name;
+}
+
+// src/lib/pipeline-factory.ts
+var import_shadertools = require("@luma.gl/shadertools");
+var DEFAULT_RENDER_PIPELINE_OPTIONS = {
+  vs: "",
+  fs: "",
+  modules: [],
+  defines: {},
+  inject: {},
+  transpileToGLSL100: false,
+  layout: null,
+  varyings: [],
+  bufferMode: 35981,
+  // // varyings/bufferMode for xform feedback, 0x8c8d: SEPARATE_ATTRIBS
+  topology: "triangle-list",
+  parameters: {}
+};
+var PipelineFactory = class {
+  constructor(device) {
+    this.stateHash = 0;
+    // Used to change hashing if hooks are modified
+    this._hashCounter = 0;
+    this._hashes = {};
+    this._useCounts = {};
+    this._pipelineCache = {};
+    this._getUniforms = {};
+    this._hookFunctions = [];
+    this._defaultModules = [];
+    this.device = device;
+  }
+  // private readonly _registeredModules = {}; // TODO: Remove? This isn't used anywhere in luma.gl
+  static getDefaultPipelineFactory(device) {
+    device.defaultPipelineFactory = device.defaultPipelineFactory || new PipelineFactory(device);
+    return device.defaultPipelineFactory;
+  }
+  addDefaultModule(module2) {
+    if (!this._defaultModules.find((m) => m.name === (typeof module2 === "string" ? module2 : module2.name))) {
+      this._defaultModules.push(module2);
+    }
+    this.stateHash++;
+  }
+  removeDefaultModule(module2) {
+    const moduleName = typeof module2 === "string" ? module2 : module2.name;
+    this._defaultModules = this._defaultModules.filter((m) => m.name !== moduleName);
+    this.stateHash++;
+  }
+  addShaderHook(hook, opts) {
+    if (opts) {
+      hook = Object.assign(opts, { hook });
+    }
+    this._hookFunctions.push(hook);
+    this.stateHash++;
+  }
+  createRenderPipeline(options) {
+    const props = __spreadValues(__spreadValues({}, DEFAULT_RENDER_PIPELINE_OPTIONS), options);
+    const modules = this._getModuleList(props.modules);
+    const hash = this._hashRenderPipeline(__spreadProps(__spreadValues({}, props), { modules }));
+    if (!this._pipelineCache[hash]) {
+      const { pipeline, getUniforms } = this._createRenderPipeline(__spreadProps(__spreadValues({}, props), { modules }));
+      pipeline.hash = hash;
+      this._pipelineCache[hash] = pipeline;
+      this._getUniforms[hash] = getUniforms || ((x) => ({}));
+      this._useCounts[hash] = 0;
+    }
+    this._useCounts[hash]++;
+    return {
+      pipeline: this._pipelineCache[hash],
+      getUniforms: this._getUniforms[hash]
+    };
+  }
+  release(pipeline) {
+    const hash = pipeline.hash;
+    this._useCounts[hash]--;
+    if (this._useCounts[hash] === 0) {
+      this._pipelineCache[hash].destroy();
+      delete this._pipelineCache[hash];
+      delete this._getUniforms[hash];
+      delete this._useCounts[hash];
+    }
+  }
+  getUniforms(pipeline) {
+    return this._getUniforms[pipeline.hash] || null;
+  }
+  // PRIVATE
+  _createRenderPipeline(props) {
+    const platformInfo = {
+      gpu: this.device.info.gpu,
+      features: this.device.features
+    };
+    if (!props.fs) {
+      throw new Error("fs");
+    }
+    const assembled = (0, import_shadertools.assembleShaders)(platformInfo, __spreadProps(__spreadValues({}, props), { fs: props.fs, hookFunctions: this._hookFunctions }));
+    const pipeline = this.device.createRenderPipeline(__spreadProps(__spreadValues({}, props), {
+      vs: this.device.createShader({ stage: "vertex", source: assembled.vs }),
+      fs: assembled.fs ? this.device.createShader({ stage: "fragment", source: assembled.fs }) : null
+    }));
+    return { pipeline, getUniforms: assembled.getUniforms };
+  }
+  /** Calculate a hash based on all the inputs for a render pipeline */
+  _hashRenderPipeline(props) {
+    const { modules = [], varyings = [], defines = {}, inject = {}, parameters = {} } = props;
+    const vsHash = this._getHash(props.vs);
+    const fsHash = props.fs ? this._getHash(props.fs) : 0;
+    const moduleHashes = modules.map((m) => this._getHash(typeof m === "string" ? m : m.name)).sort();
+    const varyingHashes = varyings.map((v) => this._getHash(v));
+    const defineKeys = Object.keys(defines).sort();
+    const injectKeys = Object.keys(inject).sort();
+    const defineHashes = [];
+    const injectHashes = [];
+    for (const key of defineKeys) {
+      defineHashes.push(this._getHash(key));
+      defineHashes.push(this._getHash(String(defines[key])));
+    }
+    for (const key of injectKeys) {
+      injectHashes.push(this._getHash(key));
+      injectHashes.push(this._getHash(inject[key]));
+    }
+    const parameterHash = JSON.stringify(parameters);
+    return `${vsHash}/${fsHash}D${defineHashes.join("/")}M${moduleHashes.join(
+      "/"
+    )}I${injectHashes.join("/")}V${varyingHashes.join("/")}H${this.stateHash}B${props.bufferMode}${props.transpileToGLSL100 ? "T" : ""}P${parameterHash}`;
+  }
+  _getHash(key) {
+    if (this._hashes[key] === void 0) {
+      this._hashes[key] = this._hashCounter++;
+    }
+    return this._hashes[key];
+  }
+  // Dedupe and combine with default modules
+  _getModuleList(appModules = []) {
+    const modules = new Array(this._defaultModules.length + appModules.length);
+    const seen = {};
+    let count = 0;
+    for (let i = 0, len = this._defaultModules.length; i < len; ++i) {
+      const module2 = this._defaultModules[i];
+      const name = module2.name;
+      modules[count++] = module2;
+      seen[name] = true;
+    }
+    for (let i = 0, len = appModules.length; i < len; ++i) {
+      const module2 = appModules[i];
+      const name = module2.name;
+      if (!seen[name]) {
+        modules[count++] = module2;
+        seen[name] = true;
+      }
+    }
+    modules.length = count;
+    return modules;
+  }
+};
+
+// src/model/model.ts
+var DEFAULT_MODEL_PROPS = __spreadProps(__spreadValues({}, import_core6.RenderPipeline._DEFAULT_PROPS), {
+  vs: null,
+  fs: null,
+  id: "unnamed",
+  handle: void 0,
+  userData: {},
+  defines: {},
+  modules: [],
+  moduleSettings: {},
+  geometry: null,
+  pipelineFactory: void 0
+});
+var Model = class {
+  constructor(device, props) {
+    this.fs = null;
+    this.userData = {};
+    /** instance count */
+    this.instanceCount = 0;
+    /** Buffer-valued attributes */
+    this.bufferAttributes = {};
+    /** Constant-valued attributes */
+    this.constantAttributes = {};
+    /** Bindings (textures, samplers, uniform buffers) */
+    this.bindings = {};
+    /** Uniforms */
+    this.uniforms = {};
+    props = __spreadValues(__spreadValues({}, DEFAULT_MODEL_PROPS), props);
+    this.id = props.id;
+    this.device = device;
+    Object.assign(this.userData, props.userData);
+    if (!props.vs) {
+      throw new Error("no vertex shader");
+    }
+    this.vs = getShaderSource(this.device, props.vs);
+    if (props.fs) {
+      this.fs = getShaderSource(this.device, props.fs);
+    }
+    this.vertexCount = props.vertexCount;
+    this.instanceCount = props.instanceCount;
+    this.topology = props.topology;
+    if (props.geometry) {
+      this.vertexCount = props.geometry.vertexCount;
+      this.topology = props.geometry.topology || "triangle-list";
+    }
+    this.pipelineFactory = props.pipelineFactory || PipelineFactory.getDefaultPipelineFactory(this.device);
+    const { pipeline, getUniforms } = this.pipelineFactory.createRenderPipeline(__spreadProps(__spreadValues({}, props), {
+      vs: this.vs,
+      fs: this.fs,
+      topology: this.topology,
+      defines: props.defines,
+      parameters: props.parameters,
+      layout: props.layout
+    }));
+    this.pipeline = pipeline;
+    this._getModuleUniforms = getUniforms;
+    if (props.geometry) {
+      this._setGeometry(props.geometry);
+    }
+    this.setUniforms(this._getModuleUniforms());
+    this.setProps(props);
+  }
+  destroy() {
+    this.pipelineFactory.release(this.pipeline);
+  }
+  draw(renderPass) {
+    this.pipeline.draw({
+      renderPass,
+      vertexCount: this.vertexCount,
+      instanceCount: this.instanceCount
+    });
+  }
+  setProps(props) {
+    if (props.indices) {
+      this.setIndexBuffer(props.indices);
+    }
+    if (props.attributes) {
+      this.setAttributes(props.attributes);
+    }
+    if (props.bindings) {
+      this.setBindings(props.bindings);
+    }
+    if (props.uniforms) {
+      this.setUniforms(props.uniforms);
+    }
+    if (props.moduleSettings) {
+      this.updateModuleSettings(props.moduleSettings);
+    }
+  }
+  updateModuleSettings(props) {
+    const uniforms = this._getModuleUniforms(props);
+    this.setUniforms(uniforms);
+  }
+  setIndexBuffer(indices) {
+    this.pipeline.setIndexBuffer(indices);
+  }
+  setAttributes(bufferAttributes) {
+    if (bufferAttributes.indices) {
+      import_core5.log.warn(`Model:${this.id} setAttributes() - indices should be set using setIndexBuffer()`);
+    }
+    this.pipeline.setAttributes(bufferAttributes);
+    Object.assign(this.bufferAttributes, bufferAttributes);
+  }
+  setConstantAttributes(constantAttributes) {
+    this.pipeline.setConstantAttributes(constantAttributes);
+    Object.assign(this.constantAttributes, constantAttributes);
+  }
+  /** Set the bindings */
+  setBindings(bindings) {
+    this.pipeline.setBindings(bindings);
+    Object.assign(this.bindings, bindings);
+  }
+  setUniforms(uniforms) {
+    this.pipeline.setUniforms(uniforms);
+    Object.assign(this.uniforms, uniforms);
+  }
+  _setGeometry(geometry) {
+    const geometryBuffers = getAttributeBuffersFromGeometry(this.device, geometry);
+    this.setAttributes(geometryBuffers);
+    const indexBuffer = getIndexBufferFromGeometry(this.device, geometry);
+    if (indexBuffer) {
+      this.setIndexBuffer(indexBuffer);
+    }
+  }
+};
+function getShaderSource(device, shader) {
+  if (typeof shader === "string") {
+    return shader;
+  }
+  switch (device.info.type) {
+    case "webgpu":
+      if (shader == null ? void 0 : shader.wgsl) {
+        return shader.wgsl;
+      }
+      throw new Error("WebGPU does not support GLSL shaders");
+    default:
+      if (shader == null ? void 0 : shader.glsl) {
+        return shader.glsl;
+      }
+      throw new Error("WebGL does not support WGSL shaders");
+  }
+}
+
+// src/transform/transform.ts
+var import_shadertools2 = require("@luma.gl/shadertools");
+var import_constants = require("@luma.gl/constants");
+var import_webgl = require("@luma.gl/webgl");
+var Transform = class {
+  constructor(device, props = {}) {
+    // model: Model;
+    this.elementCount = 0;
+    // bufferTransform: BufferTransform | null = null;
+    // textureTransform: TextureTransform | null = null;
+    this.elementIDBuffer = null;
+    this.device = import_webgl.WebGLDevice.attach(device);
+    this.gl = this.device.gl2;
+    this._buildResourceTransforms(props);
+    props = this._updateModelProps(props);
+    this.model = new Model(this.device, __spreadProps(__spreadValues({}, props), {
+      fs: props.fs || (0, import_shadertools2.getPassthroughFS)({ version: (0, import_shadertools2.getShaderInfo)(props.vs).version }),
+      id: props.id || "transform-model",
+      // @ts-expect-error
+      drawMode: props.drawMode || import_constants.GL.POINTS,
+      vertexCount: props.elementCount
+    }));
+    Object.seal(this);
+  }
+  /**
+   * Check if Transforms are supported (they are not under WebGL1)
+   * @todo differentiate writing to buffer vs not
+   */
+  static isSupported(device) {
+    return false;
+  }
+  /** Delete owned resources. */
+  destroy() {
+  }
+  /** @deprecated Use destroy*() */
+  delete() {
+    this.destroy();
+  }
+  /** Run one transform loop. */
+  run(options) {
+    const { clearRenderTarget = true } = options || {};
+    const updatedOpts = this._updateDrawOptions(options);
+    if (clearRenderTarget && updatedOpts.framebuffer) {
+    }
+  }
+  /** swap resources if a map is provided */
+  swap() {
+  }
+  /** Return Buffer object for given varying name. */
+  getBuffer(varyingName) {
+    return null;
+  }
+  /** Return data either from Buffer or from Texture */
+  getData(options = {}) {
+  }
+  /** Return framebuffer object if rendering to textures */
+  getFramebuffer() {
+    return null;
+  }
+  /** Update some or all buffer/texture bindings. */
+  update(props) {
+  }
+  // Private
+  _updateModelProps(props) {
+    const updatedProps = __spreadValues({}, props);
+    return updatedProps;
+  }
+  _buildResourceTransforms(props) {
+  }
+  _updateDrawOptions(options) {
+    const updatedOpts = __spreadValues({}, options);
+    return updatedOpts;
+  }
+};
+
+// src/lib/clip-space.ts
+var import_core8 = require("@luma.gl/core");
+var import_webgl2 = require("@luma.gl/webgl");
+
+// src/geometry/geometry.ts
+var import_core7 = require("@luma.gl/core");
+var Geometry = class {
+  constructor(props) {
+    this.userData = {};
+    const { attributes = {}, indices = null, vertexCount = null } = props;
+    this.id = props.id || (0, import_core7.uid)("geometry");
+    this.topology = props.topology;
+    if (indices) {
+      this.indices = ArrayBuffer.isView(indices) ? { value: indices, size: 1 } : indices;
+    }
+    this.attributes = {};
+    for (const [attributeName, attributeValue] of Object.entries(attributes)) {
+      const attribute = ArrayBuffer.isView(attributeValue) ? { value: attributeValue } : attributeValue;
+      (0, import_core7.assert)(
+        ArrayBuffer.isView(attribute.value),
+        `${this._print(attributeName)}: must be typed array or object with value as typed array`
+      );
+      if ((attributeName === "POSITION" || attributeName === "positions") && !attribute.size) {
+        attribute.size = 3;
+      }
+      if (attributeName === "indices") {
+        (0, import_core7.assert)(!this.indices);
+        this.indices = attribute;
+      } else {
+        this.attributes[attributeName] = attribute;
+      }
+    }
+    if (this.indices && this.indices.isIndexed !== void 0) {
+      this.indices = Object.assign({}, this.indices);
+      delete this.indices.isIndexed;
+    }
+    this.vertexCount = vertexCount || this._calculateVertexCount(this.attributes, this.indices);
+  }
+  getVertexCount() {
+    return this.vertexCount;
+  }
+  // Return an object with all attributes plus indices added as a field.
+  getAttributes() {
+    return this.indices ? __spreadValues({ indices: this.indices }, this.attributes) : this.attributes;
+  }
+  // PRIVATE
+  _print(attributeName) {
+    return `Geometry ${this.id} attribute ${attributeName}`;
+  }
+  // GeometryAttribute
+  // value: typed array
+  // type: indices, vertices, uvs
+  // size: elements per vertex
+  // target: WebGL buffer type (string or constant)
+  _setAttributes(attributes, indices) {
+    return this;
+  }
+  _calculateVertexCount(attributes, indices) {
+    if (indices) {
+      return indices.value.length;
+    }
+    let vertexCount = Infinity;
+    for (const attributeName in attributes) {
+      const attribute = attributes[attributeName];
+      const { value, size, constant } = attribute;
+      if (!constant && value && size >= 1) {
+        vertexCount = Math.min(vertexCount, value.length / size);
+      }
+    }
+    (0, import_core7.assert)(Number.isFinite(vertexCount));
+    return vertexCount;
+  }
+};
+
+// src/lib/clip-space.ts
+var CLIPSPACE_VERTEX_SHADER = import_core8.glsl`\
+attribute vec2 aClipSpacePosition;
+attribute vec2 aTexCoord;
+attribute vec2 aCoordinate;
+
+varying vec2 position;
+varying vec2 coordinate;
+varying vec2 uv;
+
+void main(void) {
+  gl_Position = vec4(aClipSpacePosition, 0., 1.);
+  position = aClipSpacePosition;
+  coordinate = aCoordinate;
+  uv = aTexCoord;
+}
+`;
+var POSITIONS = [-1, -1, 1, -1, -1, 1, 1, 1];
+var ClipSpace = class extends Model {
+  constructor(device, opts) {
+    const TEX_COORDS = POSITIONS.map((coord) => coord === -1 ? 0 : coord);
+    super(
+      import_webgl2.WebGLDevice.attach(device),
+      __spreadProps(__spreadValues({}, opts), {
+        vs: CLIPSPACE_VERTEX_SHADER,
+        vertexCount: 4,
+        geometry: new Geometry({
+          topology: "triangle-strip",
+          vertexCount: 4,
+          attributes: {
+            aClipSpacePosition: { size: 2, value: new Float32Array(POSITIONS) },
+            aTexCoord: { size: 2, value: new Float32Array(TEX_COORDS) },
+            aCoordinate: { size: 2, value: new Float32Array(TEX_COORDS) }
+          }
+        })
+      })
+    );
+  }
+};
+
+// src/scenegraph/scenegraph-node.ts
+var import_core9 = require("@luma.gl/core");
+var import_core10 = require("@math.gl/core");
+var ScenegraphNode = class {
+  constructor(props = {}) {
+    this.matrix = new import_core10.Matrix4();
+    this.display = true;
+    this.position = new import_core10.Vector3();
+    this.rotation = new import_core10.Vector3();
+    this.scale = new import_core10.Vector3(1, 1, 1);
+    this.userData = {};
+    this.props = {};
+    const { id } = props;
+    this.id = id || (0, import_core9.uid)(this.constructor.name);
+    this._setScenegraphNodeProps(props);
+  }
+  getBounds() {
+    return null;
+  }
+  destroy() {
+  }
+  /** @deprecated use .destroy() */
+  delete() {
+    this.destroy();
+  }
+  setProps(props) {
+    this._setScenegraphNodeProps(props);
+    return this;
+  }
+  toString() {
+    return `{type: ScenegraphNode, id: ${this.id})}`;
+  }
+  setPosition(position) {
+    (0, import_core9.assert)(position.length === 3, "setPosition requires vector argument");
+    this.position = position;
+    return this;
+  }
+  setRotation(rotation) {
+    (0, import_core9.assert)(rotation.length === 3, "setRotation requires vector argument");
+    this.rotation = rotation;
+    return this;
+  }
+  setScale(scale) {
+    (0, import_core9.assert)(scale.length === 3, "setScale requires vector argument");
+    this.scale = scale;
+    return this;
+  }
+  setMatrix(matrix, copyMatrix = true) {
+    if (copyMatrix) {
+      this.matrix.copy(matrix);
+    } else {
+      this.matrix = matrix;
+    }
+  }
+  setMatrixComponents(components) {
+    const { position, rotation, scale, update = true } = components;
+    if (position) {
+      this.setPosition(position);
+    }
+    if (rotation) {
+      this.setRotation(rotation);
+    }
+    if (scale) {
+      this.setScale(scale);
+    }
+    if (update) {
+      this.updateMatrix();
+    }
+    return this;
+  }
+  updateMatrix() {
+    const pos = this.position;
+    const rot = this.rotation;
+    const scale = this.scale;
+    this.matrix.identity();
+    this.matrix.translate(pos);
+    this.matrix.rotateXYZ(rot);
+    this.matrix.scale(scale);
+    return this;
+  }
+  update(options = {}) {
+    const { position, rotation, scale } = options;
+    if (position) {
+      this.setPosition(position);
+    }
+    if (rotation) {
+      this.setRotation(rotation);
+    }
+    if (scale) {
+      this.setScale(scale);
+    }
+    this.updateMatrix();
+    return this;
+  }
+  getCoordinateUniforms(viewMatrix, modelMatrix) {
+    (0, import_core9.assert)(viewMatrix);
+    modelMatrix = modelMatrix || this.matrix;
+    const worldMatrix = new import_core10.Matrix4(viewMatrix).multiplyRight(modelMatrix);
+    const worldInverse = worldMatrix.invert();
+    const worldInverseTranspose = worldInverse.transpose();
+    return {
+      viewMatrix,
+      modelMatrix,
+      objectMatrix: modelMatrix,
+      worldMatrix,
+      worldInverseMatrix: worldInverse,
+      worldInverseTransposeMatrix: worldInverseTranspose
+    };
+  }
+  // TODO - copied code, not yet vetted
+  /*
+    transform() {
+      if (!this.parent) {
+        this.endPosition.set(this.position);
+        this.endRotation.set(this.rotation);
+        this.endScale.set(this.scale);
+      } else {
+        const parent = this.parent;
+        this.endPosition.set(this.position.add(parent.endPosition));
+        this.endRotation.set(this.rotation.add(parent.endRotation));
+        this.endScale.set(this.scale.add(parent.endScale));
+      }
+  
+      const ch = this.children;
+      for (let i = 0; i < ch.length; ++i) {
+        ch[i].transform();
+      }
+  
+      return this;
+    }
+    */
+  _setScenegraphNodeProps(props) {
+    if ("display" in props) {
+      this.display = props.display;
+    }
+    if ("position" in props) {
+      this.setPosition(props.position);
+    }
+    if ("rotation" in props) {
+      this.setRotation(props.rotation);
+    }
+    if ("scale" in props) {
+      this.setScale(props.scale);
+    }
+    if ("matrix" in props) {
+      this.setMatrix(props.matrix);
+    }
+    Object.assign(this.props, props);
+  }
+};
+
+// src/scenegraph/group-node.ts
+var import_core11 = require("@math.gl/core");
+var import_core12 = require("@luma.gl/core");
+var GroupNode = class extends ScenegraphNode {
+  constructor(props = {}) {
+    props = Array.isArray(props) ? { children: props } : props;
+    const { children = [] } = props;
+    import_core12.log.assert(
+      children.every((child) => child instanceof ScenegraphNode),
+      "every child must an instance of ScenegraphNode"
+    );
+    super(props);
+    this.children = children;
+  }
+  getBounds() {
+    const result = [[Infinity, Infinity, Infinity], [-Infinity, -Infinity, -Infinity]];
+    this.traverse((node, { worldMatrix }) => {
+      const bounds = node.getBounds();
+      if (!bounds) {
+        return;
+      }
+      const [min, max] = bounds;
+      const center = new import_core11.Vector3(min).add(max).divide([2, 2, 2]);
+      worldMatrix.transformAsPoint(center, center);
+      const halfSize = new import_core11.Vector3(max).subtract(min).divide([2, 2, 2]);
+      worldMatrix.transformAsVector(halfSize, halfSize);
+      for (let v = 0; v < 8; v++) {
+        const position = new import_core11.Vector3(
+          v & 1 ? -1 : 1,
+          v & 2 ? -1 : 1,
+          v & 4 ? -1 : 1
+        ).multiply(halfSize).add(center);
+        for (let i = 0; i < 3; i++) {
+          result[0][i] = Math.min(result[0][i], position[i]);
+          result[1][i] = Math.max(result[1][i], position[i]);
+        }
+      }
+    });
+    if (!Number.isFinite(result[0][0])) {
+      return null;
+    }
+    return result;
+  }
+  destroy() {
+    this.children.forEach((child) => child.destroy());
+    this.removeAll();
+    super.destroy();
+  }
+  // Unpacks arrays and nested arrays of children
+  add(...children) {
+    for (const child of children) {
+      if (Array.isArray(child)) {
+        this.add(...child);
+      } else {
+        this.children.push(child);
+      }
+    }
+    return this;
+  }
+  remove(child) {
+    const children = this.children;
+    const indexOf = children.indexOf(child);
+    if (indexOf > -1) {
+      children.splice(indexOf, 1);
+    }
+    return this;
+  }
+  removeAll() {
+    this.children = [];
+    return this;
+  }
+  traverse(visitor, { worldMatrix = new import_core11.Matrix4() } = {}) {
+    const modelMatrix = new import_core11.Matrix4(worldMatrix).multiplyRight(this.matrix);
+    for (const child of this.children) {
+      if (child instanceof GroupNode) {
+        child.traverse(visitor, { worldMatrix: modelMatrix });
+      } else {
+        visitor(child, { worldMatrix: modelMatrix });
+      }
+    }
+  }
+};
+
+// src/scenegraph/model-node.ts
+var ModelNode = class extends ScenegraphNode {
+  // TODO - is this used? override callbacks to make sure we call them with this
+  // onBeforeRender = null;
+  // onAfterRender = null;
+  // AfterRender = null;
+  constructor(props) {
+    super(props);
+    this.bounds = null;
+    this.model = props.model;
+    this.managedResources = props.managedResources || [];
+    this.bounds = props.bounds || null;
+    this.setProps(props);
+  }
+  getBounds() {
+    return this.bounds;
+  }
+  destroy() {
+    if (this.model) {
+      this.model.destroy();
+      this.model = null;
+    }
+    this.managedResources.forEach((resource) => resource.destroy());
+    this.managedResources = [];
+  }
+  // Expose model methods
+  draw(renderPass) {
+    return this.model.draw(renderPass);
+  }
+};
+
+// src/geometries/cone-geometry.ts
+var import_core14 = require("@luma.gl/core");
+
+// src/geometries/truncated-cone-geometry.ts
+var import_core13 = require("@luma.gl/core");
+var INDEX_OFFSETS = {
+  x: [2, 0, 1],
+  y: [0, 1, 2],
+  z: [1, 2, 0]
+};
+var TruncatedConeGeometry = class extends Geometry {
+  constructor(props = {}) {
+    const { id = (0, import_core13.uid)("truncated-code-geometry") } = props;
+    const { indices, attributes } = tesselateTruncatedCone(props);
+    super(__spreadProps(__spreadValues({}, props), {
+      id,
+      topology: "triangle-list",
+      indices,
+      attributes: __spreadValues({
+        POSITION: { size: 3, value: attributes.POSITION },
+        NORMAL: { size: 3, value: attributes.NORMAL },
+        TEXCOORD_0: { size: 2, value: attributes.TEXCOORD_0 }
+      }, props.attributes)
+    }));
+  }
+};
+function tesselateTruncatedCone(props = {}) {
+  const {
+    bottomRadius = 0,
+    topRadius = 0,
+    height = 1,
+    nradial = 10,
+    nvertical = 10,
+    verticalAxis = "y",
+    topCap = false,
+    bottomCap = false
+  } = props;
+  const extra = (topCap ? 2 : 0) + (bottomCap ? 2 : 0);
+  const numVertices = (nradial + 1) * (nvertical + 1 + extra);
+  const slant = Math.atan2(bottomRadius - topRadius, height);
+  const msin = Math.sin;
+  const mcos = Math.cos;
+  const mpi = Math.PI;
+  const cosSlant = mcos(slant);
+  const sinSlant = msin(slant);
+  const start = topCap ? -2 : 0;
+  const end = nvertical + (bottomCap ? 2 : 0);
+  const vertsAroundEdge = nradial + 1;
+  const indices = new Uint16Array(nradial * (nvertical + extra) * 6);
+  const indexOffset = INDEX_OFFSETS[verticalAxis];
+  const positions = new Float32Array(numVertices * 3);
+  const normals = new Float32Array(numVertices * 3);
+  const texCoords = new Float32Array(numVertices * 2);
+  let i3 = 0;
+  let i2 = 0;
+  for (let i = start; i <= end; i++) {
+    let v = i / nvertical;
+    let y = height * v;
+    let ringRadius;
+    if (i < 0) {
+      y = 0;
+      v = 1;
+      ringRadius = bottomRadius;
+    } else if (i > nvertical) {
+      y = height;
+      v = 1;
+      ringRadius = topRadius;
+    } else {
+      ringRadius = bottomRadius + (topRadius - bottomRadius) * (i / nvertical);
+    }
+    if (i === -2 || i === nvertical + 2) {
+      ringRadius = 0;
+      v = 0;
+    }
+    y -= height / 2;
+    for (let j = 0; j < vertsAroundEdge; j++) {
+      const sin = msin(j * mpi * 2 / nradial);
+      const cos = mcos(j * mpi * 2 / nradial);
+      positions[i3 + indexOffset[0]] = sin * ringRadius;
+      positions[i3 + indexOffset[1]] = y;
+      positions[i3 + indexOffset[2]] = cos * ringRadius;
+      normals[i3 + indexOffset[0]] = i < 0 || i > nvertical ? 0 : sin * cosSlant;
+      normals[i3 + indexOffset[1]] = i < 0 ? -1 : i > nvertical ? 1 : sinSlant;
+      normals[i3 + indexOffset[2]] = i < 0 || i > nvertical ? 0 : cos * cosSlant;
+      texCoords[i2 + 0] = j / nradial;
+      texCoords[i2 + 1] = v;
+      i2 += 2;
+      i3 += 3;
+    }
+  }
+  for (let i = 0; i < nvertical + extra; i++) {
+    for (let j = 0; j < nradial; j++) {
+      const index = (i * nradial + j) * 6;
+      indices[index + 0] = vertsAroundEdge * (i + 0) + 0 + j;
+      indices[index + 1] = vertsAroundEdge * (i + 0) + 1 + j;
+      indices[index + 2] = vertsAroundEdge * (i + 1) + 1 + j;
+      indices[index + 3] = vertsAroundEdge * (i + 0) + 0 + j;
+      indices[index + 4] = vertsAroundEdge * (i + 1) + 1 + j;
+      indices[index + 5] = vertsAroundEdge * (i + 1) + 0 + j;
+    }
+  }
+  return {
+    indices,
+    attributes: {
+      POSITION: positions,
+      NORMAL: normals,
+      TEXCOORD_0: texCoords
+    }
+  };
+}
+
+// src/geometries/cone-geometry.ts
+var ConeGeometry = class extends TruncatedConeGeometry {
+  constructor(props = {}) {
+    const { id = (0, import_core14.uid)("cone-geometry"), radius = 1, cap = true } = props;
+    super(__spreadProps(__spreadValues({}, props), {
+      id,
+      topRadius: 0,
+      topCap: Boolean(cap),
+      bottomCap: Boolean(cap),
+      bottomRadius: radius
+    }));
+  }
+};
+
+// src/geometries/cube-geometry.ts
+var import_core15 = require("@luma.gl/core");
+var CubeGeometry = class extends Geometry {
+  constructor(props = {}) {
+    const { id = (0, import_core15.uid)("cube-geometry"), indices = true } = props;
+    super(indices ? __spreadProps(__spreadValues({}, props), {
+      id,
+      topology: "triangle-list",
+      indices: { size: 1, value: CUBE_INDICES },
+      attributes: __spreadValues(__spreadValues({}, ATTRIBUTES), props.attributes)
+    }) : __spreadProps(__spreadValues({}, props), {
+      id,
+      topology: "triangle-list",
+      indices: void 0,
+      attributes: __spreadValues(__spreadValues({}, NON_INDEXED_ATTRIBUTES), props.attributes)
+    }));
+  }
+};
+var CUBE_INDICES = new Uint16Array([
+  0,
+  1,
+  2,
+  0,
+  2,
+  3,
+  4,
+  5,
+  6,
+  4,
+  6,
+  7,
+  8,
+  9,
+  10,
+  8,
+  10,
+  11,
+  12,
+  13,
+  14,
+  12,
+  14,
+  15,
+  16,
+  17,
+  18,
+  16,
+  18,
+  19,
+  20,
+  21,
+  22,
+  20,
+  22,
+  23
+]);
+var CUBE_POSITIONS = new Float32Array([
+  -1,
+  -1,
+  1,
+  1,
+  -1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  1,
+  1,
+  -1,
+  -1,
+  -1,
+  -1,
+  1,
+  -1,
+  1,
+  1,
+  -1,
+  1,
+  -1,
+  -1,
+  -1,
+  1,
+  -1,
+  -1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  -1,
+  -1,
+  -1,
+  1,
+  -1,
+  -1,
+  1,
+  -1,
+  1,
+  -1,
+  -1,
+  1,
+  1,
+  -1,
+  -1,
+  1,
+  1,
+  -1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  1,
+  -1,
+  -1,
+  -1,
+  -1,
+  -1,
+  1,
+  -1,
+  1,
+  1,
+  -1,
+  1,
+  -1
+]);
+var CUBE_NORMALS = new Float32Array([
+  // Front face
+  0,
+  0,
+  1,
+  0,
+  0,
+  1,
+  0,
+  0,
+  1,
+  0,
+  0,
+  1,
+  // Back face
+  0,
+  0,
+  -1,
+  0,
+  0,
+  -1,
+  0,
+  0,
+  -1,
+  0,
+  0,
+  -1,
+  // Top face
+  0,
+  1,
+  0,
+  0,
+  1,
+  0,
+  0,
+  1,
+  0,
+  0,
+  1,
+  0,
+  // Bottom face
+  0,
+  -1,
+  0,
+  0,
+  -1,
+  0,
+  0,
+  -1,
+  0,
+  0,
+  -1,
+  0,
+  // Right face
+  1,
+  0,
+  0,
+  1,
+  0,
+  0,
+  1,
+  0,
+  0,
+  1,
+  0,
+  0,
+  // Left face
+  -1,
+  0,
+  0,
+  -1,
+  0,
+  0,
+  -1,
+  0,
+  0,
+  -1,
+  0,
+  0
+]);
+var CUBE_TEX_COORDS = new Float32Array([
+  // Front face
+  0,
+  0,
+  1,
+  0,
+  1,
+  1,
+  0,
+  1,
+  // Back face
+  1,
+  0,
+  1,
+  1,
+  0,
+  1,
+  0,
+  0,
+  // Top face
+  0,
+  1,
+  0,
+  0,
+  1,
+  0,
+  1,
+  1,
+  // Bottom face
+  1,
+  1,
+  0,
+  1,
+  0,
+  0,
+  1,
+  0,
+  // Right face
+  1,
+  0,
+  1,
+  1,
+  0,
+  1,
+  0,
+  0,
+  // Left face
+  0,
+  0,
+  1,
+  0,
+  1,
+  1,
+  0,
+  1
+]);
+var CUBE_NON_INDEXED_POSITIONS = new Float32Array([
+  1,
+  -1,
+  1,
+  1,
+  -1,
+  -1,
+  1,
+  1,
+  -1,
+  -1,
+  -1,
+  1,
+  1,
+  -1,
+  -1,
+  1,
+  1,
+  -1,
+  1,
+  1,
+  -1,
+  -1,
+  -1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  1,
+  1,
+  1,
+  -1,
+  -1,
+  1,
+  1,
+  1,
+  -1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  -1,
+  1,
+  -1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  1,
+  -1,
+  1,
+  -1,
+  1,
+  -1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  1,
+  -1,
+  -1,
+  1,
+  1,
+  -1,
+  1,
+  1,
+  1,
+  -1,
+  1,
+  -1,
+  1,
+  -1,
+  -1,
+  -1,
+  1,
+  -1,
+  -1,
+  1,
+  1,
+  -1,
+  1,
+  -1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  1,
+  1,
+  1,
+  -1,
+  -1,
+  1,
+  1,
+  -1,
+  -1,
+  1,
+  1,
+  1,
+  -1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  -1,
+  1,
+  -1,
+  -1,
+  -1,
+  1,
+  -1,
+  1,
+  -1,
+  1,
+  1,
+  1,
+  -1,
+  1,
+  1,
+  -1,
+  -1,
+  1,
+  -1,
+  1,
+  -1,
+  1
+]);
+var CUBE_NON_INDEXED_TEX_COORDS = new Float32Array([
+  1,
+  1,
+  0,
+  1,
+  0,
+  0,
+  1,
+  0,
+  1,
+  1,
+  0,
+  0,
+  1,
+  1,
+  0,
+  1,
+  0,
+  0,
+  1,
+  0,
+  1,
+  1,
+  0,
+  0,
+  1,
+  1,
+  0,
+  1,
+  0,
+  0,
+  1,
+  0,
+  1,
+  1,
+  0,
+  0,
+  1,
+  1,
+  0,
+  1,
+  0,
+  0,
+  1,
+  0,
+  1,
+  1,
+  0,
+  0,
+  1,
+  1,
+  0,
+  1,
+  0,
+  0,
+  0,
+  0,
+  1,
+  0,
+  1,
+  1,
+  1,
+  1,
+  0,
+  1,
+  0,
+  0,
+  1,
+  0,
+  1,
+  1,
+  0,
+  0
+]);
+var CUBE_NON_INDEXED_COLORS = new Float32Array([
+  1,
+  0,
+  1,
+  1,
+  0,
+  0,
+  1,
+  1,
+  0,
+  0,
+  0,
+  1,
+  1,
+  0,
+  0,
+  1,
+  1,
+  0,
+  1,
+  1,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  1,
+  1,
+  1,
+  0,
+  0,
+  1,
+  1,
+  1,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  0,
+  1,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  1,
+  0,
+  1,
+  0,
+  1,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  1,
+  0,
+  0,
+  1,
+  1,
+  0,
+  1,
+  1,
+  1,
+  0,
+  1,
+  0,
+  1,
+  0,
+  0,
+  0,
+  1,
+  0,
+  0,
+  1,
+  1,
+  0,
+  1,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  1,
+  1,
+  1,
+  0,
+  0,
+  1,
+  1,
+  0,
+  0,
+  1,
+  1,
+  1,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  0,
+  1,
+  0,
+  0,
+  0,
+  1,
+  0,
+  1,
+  0,
+  1,
+  1,
+  1,
+  0,
+  1,
+  1,
+  0,
+  0,
+  1,
+  0,
+  1,
+  0,
+  1
+]);
+var ATTRIBUTES = {
+  POSITION: { size: 3, value: CUBE_POSITIONS },
+  NORMAL: { size: 3, value: CUBE_NORMALS },
+  TEXCOORD_0: { size: 2, value: CUBE_TEX_COORDS }
+};
+var NON_INDEXED_ATTRIBUTES = {
+  POSITION: { size: 4, value: CUBE_NON_INDEXED_POSITIONS },
+  // NORMAL: {size: 3, value: CUBE_NON_INDEXED_NORMALS},
+  TEXCOORD_0: { size: 2, value: CUBE_NON_INDEXED_TEX_COORDS },
+  COLOR_0: { size: 3, value: CUBE_NON_INDEXED_COLORS }
+};
+
+// src/geometries/cylinder-geometry.ts
+var import_core16 = require("@luma.gl/core");
+var CylinderGeometry = class extends TruncatedConeGeometry {
+  constructor(props = {}) {
+    const { id = (0, import_core16.uid)("cylinder-geometry"), radius = 1 } = props;
+    super(__spreadProps(__spreadValues({}, props), {
+      id,
+      bottomRadius: radius,
+      topRadius: radius
+    }));
+  }
+};
+
+// src/geometries/ico-sphere-geometry.ts
+var import_core17 = require("@luma.gl/core");
+var import_core18 = require("@math.gl/core");
+var ICO_POSITIONS = [-1, 0, 0, 0, 1, 0, 0, 0, -1, 0, 0, 1, 0, -1, 0, 1, 0, 0];
+var ICO_INDICES = [3, 4, 5, 3, 5, 1, 3, 1, 0, 3, 0, 4, 4, 0, 2, 4, 2, 5, 2, 0, 1, 5, 2, 1];
+var IcoSphereGeometry = class extends Geometry {
+  constructor(props = {}) {
+    const { id = (0, import_core17.uid)("ico-sphere-geometry") } = props;
+    const { indices, attributes } = tesselateIcosaHedron(props);
+    super(__spreadProps(__spreadValues({}, props), {
+      id,
+      topology: "triangle-list",
+      indices,
+      attributes: __spreadValues(__spreadValues({}, attributes), props.attributes)
+    }));
+  }
+};
+function tesselateIcosaHedron(props) {
+  const { iterations = 0 } = props;
+  const PI = Math.PI;
+  const PI2 = PI * 2;
+  const positions = [...ICO_POSITIONS];
+  let indices = [...ICO_INDICES];
+  positions.push();
+  indices.push();
+  const getMiddlePoint = (() => {
+    const pointMemo = {};
+    return (i1, i2) => {
+      i1 *= 3;
+      i2 *= 3;
+      const mini = i1 < i2 ? i1 : i2;
+      const maxi = i1 > i2 ? i1 : i2;
+      const key = `${mini}|${maxi}`;
+      if (key in pointMemo) {
+        return pointMemo[key];
+      }
+      const x1 = positions[i1];
+      const y1 = positions[i1 + 1];
+      const z1 = positions[i1 + 2];
+      const x2 = positions[i2];
+      const y2 = positions[i2 + 1];
+      const z2 = positions[i2 + 2];
+      let xm = (x1 + x2) / 2;
+      let ym = (y1 + y2) / 2;
+      let zm = (z1 + z2) / 2;
+      const len = Math.sqrt(xm * xm + ym * ym + zm * zm);
+      xm /= len;
+      ym /= len;
+      zm /= len;
+      positions.push(xm, ym, zm);
+      return pointMemo[key] = positions.length / 3 - 1;
+    };
+  })();
+  for (let i = 0; i < iterations; i++) {
+    const indices2 = [];
+    for (let j = 0; j < indices.length; j += 3) {
+      const a = getMiddlePoint(indices[j + 0], indices[j + 1]);
+      const b = getMiddlePoint(indices[j + 1], indices[j + 2]);
+      const c = getMiddlePoint(indices[j + 2], indices[j + 0]);
+      indices2.push(c, indices[j + 0], a, a, indices[j + 1], b, b, indices[j + 2], c, a, b, c);
+    }
+    indices = indices2;
+  }
+  const normals = new Array(positions.length);
+  const texCoords = new Array(positions.length / 3 * 2);
+  const l = indices.length;
+  for (let i = l - 3; i >= 0; i -= 3) {
+    const i1 = indices[i + 0];
+    const i2 = indices[i + 1];
+    const i3 = indices[i + 2];
+    const in1 = i1 * 3;
+    const in2 = i2 * 3;
+    const in3 = i3 * 3;
+    const iu1 = i1 * 2;
+    const iu2 = i2 * 2;
+    const iu3 = i3 * 2;
+    const x1 = positions[in1 + 0];
+    const y1 = positions[in1 + 1];
+    const z1 = positions[in1 + 2];
+    const theta1 = Math.acos(z1 / Math.sqrt(x1 * x1 + y1 * y1 + z1 * z1));
+    const phi1 = Math.atan2(y1, x1) + PI;
+    const v1 = theta1 / PI;
+    const u1 = 1 - phi1 / PI2;
+    const x2 = positions[in2 + 0];
+    const y2 = positions[in2 + 1];
+    const z2 = positions[in2 + 2];
+    const theta2 = Math.acos(z2 / Math.sqrt(x2 * x2 + y2 * y2 + z2 * z2));
+    const phi2 = Math.atan2(y2, x2) + PI;
+    const v2 = theta2 / PI;
+    const u2 = 1 - phi2 / PI2;
+    const x3 = positions[in3 + 0];
+    const y3 = positions[in3 + 1];
+    const z3 = positions[in3 + 2];
+    const theta3 = Math.acos(z3 / Math.sqrt(x3 * x3 + y3 * y3 + z3 * z3));
+    const phi3 = Math.atan2(y3, x3) + PI;
+    const v3 = theta3 / PI;
+    const u3 = 1 - phi3 / PI2;
+    const vec1 = [x3 - x2, y3 - y2, z3 - z2];
+    const vec2 = [x1 - x2, y1 - y2, z1 - z2];
+    const normal = new import_core18.Vector3(vec1).cross(vec2).normalize();
+    let newIndex;
+    if ((u1 === 0 || u2 === 0 || u3 === 0) && (u1 === 0 || u1 > 0.5) && (u2 === 0 || u2 > 0.5) && (u3 === 0 || u3 > 0.5)) {
+      positions.push(positions[in1 + 0], positions[in1 + 1], positions[in1 + 2]);
+      newIndex = positions.length / 3 - 1;
+      indices.push(newIndex);
+      texCoords[newIndex * 2 + 0] = 1;
+      texCoords[newIndex * 2 + 1] = v1;
+      normals[newIndex * 3 + 0] = normal.x;
+      normals[newIndex * 3 + 1] = normal.y;
+      normals[newIndex * 3 + 2] = normal.z;
+      positions.push(positions[in2 + 0], positions[in2 + 1], positions[in2 + 2]);
+      newIndex = positions.length / 3 - 1;
+      indices.push(newIndex);
+      texCoords[newIndex * 2 + 0] = 1;
+      texCoords[newIndex * 2 + 1] = v2;
+      normals[newIndex * 3 + 0] = normal.x;
+      normals[newIndex * 3 + 1] = normal.y;
+      normals[newIndex * 3 + 2] = normal.z;
+      positions.push(positions[in3 + 0], positions[in3 + 1], positions[in3 + 2]);
+      newIndex = positions.length / 3 - 1;
+      indices.push(newIndex);
+      texCoords[newIndex * 2 + 0] = 1;
+      texCoords[newIndex * 2 + 1] = v3;
+      normals[newIndex * 3 + 0] = normal.x;
+      normals[newIndex * 3 + 1] = normal.y;
+      normals[newIndex * 3 + 2] = normal.z;
+    }
+    normals[in1 + 0] = normals[in2 + 0] = normals[in3 + 0] = normal.x;
+    normals[in1 + 1] = normals[in2 + 1] = normals[in3 + 1] = normal.y;
+    normals[in1 + 2] = normals[in2 + 2] = normals[in3 + 2] = normal.z;
+    texCoords[iu1 + 0] = u1;
+    texCoords[iu1 + 1] = v1;
+    texCoords[iu2 + 0] = u2;
+    texCoords[iu2 + 1] = v2;
+    texCoords[iu3 + 0] = u3;
+    texCoords[iu3 + 1] = v3;
+  }
+  return {
+    indices: { size: 1, value: new Uint16Array(indices) },
+    attributes: {
+      POSITION: { size: 3, value: new Float32Array(positions) },
+      NORMAL: { size: 3, value: new Float32Array(normals) },
+      TEXCOORD_0: { size: 2, value: new Float32Array(texCoords) }
+    }
+  };
+}
+
+// src/geometries/plane-geometry.ts
+var import_core19 = require("@luma.gl/core");
+
+// src/geometry/geometry-utils.ts
+function unpackIndexedGeometry(geometry) {
+  const { indices, attributes } = geometry;
+  if (!indices) {
+    return geometry;
+  }
+  const vertexCount = indices.value.length;
+  const unpackedAttributes = {};
+  for (const attributeName in attributes) {
+    const attribute = attributes[attributeName];
+    const { constant, value, size } = attribute;
+    if (constant || !size) {
+      continue;
+    }
+    const unpackedValue = new value.constructor(vertexCount * size);
+    for (let x = 0; x < vertexCount; ++x) {
+      const index = indices.value[x];
+      for (let i = 0; i < size; i++) {
+        unpackedValue[x * size + i] = value[index * size + i];
+      }
+    }
+    unpackedAttributes[attributeName] = { size, value: unpackedValue };
+  }
+  return {
+    attributes: Object.assign({}, attributes, unpackedAttributes)
+  };
+}
+
+// src/geometries/plane-geometry.ts
+var PlaneGeometry = class extends Geometry {
+  constructor(props = {}) {
+    const { id = (0, import_core19.uid)("plane-geometry") } = props;
+    const { indices, attributes } = tesselatePlane(props);
+    super(__spreadProps(__spreadValues({}, props), {
+      id,
+      topology: "triangle-list",
+      indices,
+      attributes: __spreadValues(__spreadValues({}, attributes), props.attributes)
+    }));
+  }
+};
+function tesselatePlane(props) {
+  const { type = "x,y", offset = 0, flipCull = false, unpack = false } = props;
+  const coords = type.split(",");
+  let c1len = props[`${coords[0]}len`] || 1;
+  const c2len = props[`${coords[1]}len`] || 1;
+  const subdivisions1 = props[`n${coords[0]}`] || 1;
+  const subdivisions2 = props[`n${coords[1]}`] || 1;
+  const numVertices = (subdivisions1 + 1) * (subdivisions2 + 1);
+  const positions = new Float32Array(numVertices * 3);
+  const normals = new Float32Array(numVertices * 3);
+  const texCoords = new Float32Array(numVertices * 2);
+  if (flipCull) {
+    c1len = -c1len;
+  }
+  let i2 = 0;
+  let i3 = 0;
+  for (let z = 0; z <= subdivisions2; z++) {
+    for (let x = 0; x <= subdivisions1; x++) {
+      const u = x / subdivisions1;
+      const v = z / subdivisions2;
+      texCoords[i2 + 0] = flipCull ? 1 - u : u;
+      texCoords[i2 + 1] = v;
+      switch (type) {
+        case "x,y":
+          positions[i3 + 0] = c1len * u - c1len * 0.5;
+          positions[i3 + 1] = c2len * v - c2len * 0.5;
+          positions[i3 + 2] = offset;
+          normals[i3 + 0] = 0;
+          normals[i3 + 1] = 0;
+          normals[i3 + 2] = flipCull ? 1 : -1;
+          break;
+        case "x,z":
+          positions[i3 + 0] = c1len * u - c1len * 0.5;
+          positions[i3 + 1] = offset;
+          positions[i3 + 2] = c2len * v - c2len * 0.5;
+          normals[i3 + 0] = 0;
+          normals[i3 + 1] = flipCull ? 1 : -1;
+          normals[i3 + 2] = 0;
+          break;
+        case "y,z":
+          positions[i3 + 0] = offset;
+          positions[i3 + 1] = c1len * u - c1len * 0.5;
+          positions[i3 + 2] = c2len * v - c2len * 0.5;
+          normals[i3 + 0] = flipCull ? 1 : -1;
+          normals[i3 + 1] = 0;
+          normals[i3 + 2] = 0;
+          break;
+        default:
+          throw new Error("PlaneGeometry: unknown type");
+      }
+      i2 += 2;
+      i3 += 3;
+    }
+  }
+  const numVertsAcross = subdivisions1 + 1;
+  const indices = new Uint16Array(subdivisions1 * subdivisions2 * 6);
+  for (let z = 0; z < subdivisions2; z++) {
+    for (let x = 0; x < subdivisions1; x++) {
+      const index = (z * subdivisions1 + x) * 6;
+      indices[index + 0] = (z + 0) * numVertsAcross + x;
+      indices[index + 1] = (z + 1) * numVertsAcross + x;
+      indices[index + 2] = (z + 0) * numVertsAcross + x + 1;
+      indices[index + 3] = (z + 1) * numVertsAcross + x;
+      indices[index + 4] = (z + 1) * numVertsAcross + x + 1;
+      indices[index + 5] = (z + 0) * numVertsAcross + x + 1;
+    }
+  }
+  const geometry = {
+    indices: { size: 1, value: indices },
+    attributes: {
+      POSITION: { size: 3, value: positions },
+      NORMAL: { size: 3, value: normals },
+      TEXCOORD_0: { size: 2, value: texCoords }
+    }
+  };
+  return unpack ? unpackIndexedGeometry(geometry) : geometry;
+}
+
+// src/geometries/sphere-geometry.ts
+var import_core20 = require("@luma.gl/core");
+var SphereGeometry = class extends Geometry {
+  constructor(props = {}) {
+    const { id = (0, import_core20.uid)("sphere-geometry") } = props;
+    const { indices, attributes } = tesselateSphere(props);
+    super(__spreadProps(__spreadValues({}, props), {
+      id,
+      topology: "triangle-list",
+      indices,
+      attributes: __spreadValues(__spreadValues({}, attributes), props.attributes)
+    }));
+  }
+};
+function tesselateSphere(props) {
+  const { nlat = 10, nlong = 10 } = props;
+  const startLat = 0;
+  const endLat = Math.PI;
+  const latRange = endLat - startLat;
+  const startLong = 0;
+  const endLong = 2 * Math.PI;
+  const longRange = endLong - startLong;
+  const numVertices = (nlat + 1) * (nlong + 1);
+  const radius = (n1, n2, n3, u, v) => props.radius || 1;
+  const positions = new Float32Array(numVertices * 3);
+  const normals = new Float32Array(numVertices * 3);
+  const texCoords = new Float32Array(numVertices * 2);
+  const IndexType = numVertices > 65535 ? Uint32Array : Uint16Array;
+  const indices = new IndexType(nlat * nlong * 6);
+  for (let y = 0; y <= nlat; y++) {
+    for (let x = 0; x <= nlong; x++) {
+      const u = x / nlong;
+      const v = y / nlat;
+      const index = x + y * (nlong + 1);
+      const i2 = index * 2;
+      const i3 = index * 3;
+      const theta = longRange * u;
+      const phi = latRange * v;
+      const sinTheta = Math.sin(theta);
+      const cosTheta = Math.cos(theta);
+      const sinPhi = Math.sin(phi);
+      const cosPhi = Math.cos(phi);
+      const ux = cosTheta * sinPhi;
+      const uy = cosPhi;
+      const uz = sinTheta * sinPhi;
+      const r = radius(ux, uy, uz, u, v);
+      positions[i3 + 0] = r * ux;
+      positions[i3 + 1] = r * uy;
+      positions[i3 + 2] = r * uz;
+      normals[i3 + 0] = ux;
+      normals[i3 + 1] = uy;
+      normals[i3 + 2] = uz;
+      texCoords[i2 + 0] = u;
+      texCoords[i2 + 1] = 1 - v;
+    }
+  }
+  const numVertsAround = nlong + 1;
+  for (let x = 0; x < nlong; x++) {
+    for (let y = 0; y < nlat; y++) {
+      const index = (x * nlat + y) * 6;
+      indices[index + 0] = y * numVertsAround + x;
+      indices[index + 1] = y * numVertsAround + x + 1;
+      indices[index + 2] = (y + 1) * numVertsAround + x;
+      indices[index + 3] = (y + 1) * numVertsAround + x;
+      indices[index + 4] = y * numVertsAround + x + 1;
+      indices[index + 5] = (y + 1) * numVertsAround + x + 1;
+    }
+  }
+  return {
+    indices: { size: 1, value: indices },
+    attributes: {
+      POSITION: { size: 3, value: positions },
+      NORMAL: { size: 3, value: normals },
+      TEXCOORD_0: { size: 2, value: texCoords }
+    }
+  };
+}