@opentui/core 0.1.75 → 0.1.77

package/3d/ThreeRenderable.d.ts

@@ -0,0 +1,40 @@
+import { OrthographicCamera, PerspectiveCamera, Scene } from "three";
+import { OptimizedBuffer } from "../buffer";
+import { Renderable, type RenderableOptions } from "../Renderable";
+import type { RenderContext } from "../types";
+import { ThreeCliRenderer, type ThreeCliRendererOptions } from "./WGPURenderer";
+export interface ThreeRenderableOptions extends RenderableOptions<ThreeRenderable> {
+    scene?: Scene | null;
+    camera?: PerspectiveCamera | OrthographicCamera;
+    renderer?: Omit<ThreeCliRendererOptions, "width" | "height" | "autoResize">;
+    autoAspect?: boolean;
+}
+export declare class ThreeRenderable extends Renderable {
+    private engine;
+    private scene;
+    private autoAspect;
+    private initPromise;
+    private initFailed;
+    private drawInFlight;
+    private frameCallback;
+    private frameCallbackRegistered;
+    private cliRenderer;
+    private clearColor;
+    constructor(ctx: RenderContext, options: ThreeRenderableOptions);
+    get aspectRatio(): number;
+    get renderer(): ThreeCliRenderer;
+    getScene(): Scene | null;
+    setScene(scene: Scene | null): void;
+    getActiveCamera(): PerspectiveCamera | OrthographicCamera;
+    setActiveCamera(camera: PerspectiveCamera | OrthographicCamera): void;
+    setAutoAspect(autoAspect: boolean): void;
+    protected onResize(width: number, height: number): void;
+    protected renderSelf(buffer: OptimizedBuffer, deltaTime: number): void;
+    protected destroySelf(): void;
+    private registerFrameCallback;
+    private renderToBuffer;
+    private ensureInitialized;
+    private updateCameraAspect;
+    private getAspectRatio;
+    private getRenderSize;
+}

package/3d/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./WGPURenderer";
+export * from "./ThreeRenderable";
 export * from "./TextureUtils";
 export * from "./canvas";
 export * from "./SpriteUtils";

package/3d.js

@@ -1,11 +1,12 @@
 // @bun
 import {
   RGBA,
+  Renderable,
   __commonJS,
   __export,
   __require,
   __toESM
-} from "./index-s0q9547t.js";
+} from "./index-h3dbfsf6.js";
 
 // ../../node_modules/.bun/omggif@1.0.10/node_modules/omggif/omggif.js
 var require_omggif = __commonJS((exports) => {
@@ -32013,6 +32014,167 @@ class ThreeCliRenderer {
     this.renderMethod = () => Promise.resolve();
   }
 }
+// src/3d/ThreeRenderable.ts
+import { PerspectiveCamera as PerspectiveCamera2 } from "three";
+class ThreeRenderable extends Renderable {
+  engine;
+  scene;
+  autoAspect;
+  initPromise = null;
+  initFailed = false;
+  drawInFlight = false;
+  frameCallback = null;
+  frameCallbackRegistered = false;
+  cliRenderer;
+  clearColor;
+  constructor(ctx, options) {
+    const { scene = null, camera, renderer, autoAspect = true, ...renderableOptions } = options;
+    super(ctx, { ...renderableOptions, buffered: true, live: options.live ?? true });
+    const cliRenderer = ctx;
+    if (typeof cliRenderer.setFrameCallback !== "function" || typeof cliRenderer.removeFrameCallback !== "function") {
+      throw new Error("ThreeRenderable requires a CliRenderer context");
+    }
+    this.cliRenderer = cliRenderer;
+    this.scene = scene;
+    this.autoAspect = autoAspect;
+    this.clearColor = renderer?.backgroundColor ?? RGBA.fromValues(0, 0, 0, 1);
+    const { width, height } = this.getRenderSize();
+    this.engine = new ThreeCliRenderer(cliRenderer, {
+      width,
+      height,
+      autoResize: false,
+      ...renderer
+    });
+    if (camera) {
+      this.engine.setActiveCamera(camera);
+    }
+    this.updateCameraAspect(width, height);
+    this.registerFrameCallback();
+  }
+  get aspectRatio() {
+    return this.getAspectRatio(this.width, this.height);
+  }
+  get renderer() {
+    return this.engine;
+  }
+  getScene() {
+    return this.scene;
+  }
+  setScene(scene) {
+    this.scene = scene;
+    this.requestRender();
+  }
+  getActiveCamera() {
+    return this.engine.getActiveCamera();
+  }
+  setActiveCamera(camera) {
+    this.engine.setActiveCamera(camera);
+    this.updateCameraAspect(this.width, this.height);
+    this.requestRender();
+  }
+  setAutoAspect(autoAspect) {
+    if (this.autoAspect === autoAspect)
+      return;
+    this.autoAspect = autoAspect;
+    if (autoAspect) {
+      this.updateCameraAspect(this.width, this.height);
+    }
+  }
+  onResize(width, height) {
+    if (width > 0 && height > 0) {
+      this.engine.setSize(width, height, true);
+      this.updateCameraAspect(width, height);
+    }
+    super.onResize(width, height);
+  }
+  renderSelf(buffer, deltaTime) {
+    if (!this.visible || this.isDestroyed)
+      return;
+    if (this.frameCallbackRegistered)
+      return;
+    if (this.buffered && !this.frameBuffer)
+      return;
+    this.renderToBuffer(buffer, deltaTime / 1000);
+  }
+  destroySelf() {
+    if (this.frameCallback && this.frameCallbackRegistered) {
+      this.cliRenderer.removeFrameCallback(this.frameCallback);
+      this.frameCallbackRegistered = false;
+      this.frameCallback = null;
+    }
+    this.engine.destroy();
+    super.destroySelf();
+  }
+  registerFrameCallback() {
+    if (this.frameCallbackRegistered)
+      return;
+    this.frameCallback = async (deltaTime) => {
+      if (this.isDestroyed || !this.visible || !this.parent)
+        return;
+      if (!this.scene || !this.frameBuffer)
+        return;
+      await this.renderToBuffer(this.frameBuffer, deltaTime / 1000);
+    };
+    this.cliRenderer.setFrameCallback(this.frameCallback);
+    this.frameCallbackRegistered = true;
+  }
+  async renderToBuffer(buffer, deltaTime) {
+    if (!this.scene || this.isDestroyed || this.drawInFlight)
+      return;
+    this.drawInFlight = true;
+    try {
+      const initialized = await this.ensureInitialized();
+      if (!initialized || !this.scene)
+        return;
+      if (buffer === this.frameBuffer) {
+        buffer.clear(this.clearColor);
+      }
+      await this.engine.drawScene(this.scene, buffer, deltaTime);
+    } finally {
+      this.drawInFlight = false;
+    }
+  }
+  async ensureInitialized() {
+    if (this.initFailed)
+      return false;
+    if (!this.initPromise) {
+      this.initPromise = this.engine.init().then(() => true).catch((error) => {
+        this.initFailed = true;
+        console.error("ThreeRenderable init failed:", error);
+        return false;
+      });
+    }
+    return this.initPromise;
+  }
+  updateCameraAspect(width, height) {
+    if (!this.autoAspect || width <= 0 || height <= 0)
+      return;
+    const camera = this.engine.getActiveCamera();
+    if (camera instanceof PerspectiveCamera2) {
+      camera.aspect = this.getAspectRatio(width, height);
+      camera.updateProjectionMatrix();
+    }
+  }
+  getAspectRatio(width, height) {
+    if (width <= 0 || height <= 0)
+      return 1;
+    const resolution = this.cliRenderer.resolution;
+    if (resolution && this.cliRenderer.terminalWidth > 0 && this.cliRenderer.terminalHeight > 0) {
+      const cellWidth = resolution.width / this.cliRenderer.terminalWidth;
+      const cellHeight = resolution.height / this.cliRenderer.terminalHeight;
+      if (cellHeight > 0) {
+        return width * cellWidth / (height * cellHeight);
+      }
+    }
+    return width / (height * 2);
+  }
+  getRenderSize() {
+    return {
+      width: Math.max(1, this.width),
+      height: Math.max(1, this.height)
+    };
+  }
+}
 // src/3d/TextureUtils.ts
 import { Color as Color2, DataTexture, NearestFilter, ClampToEdgeWrapping, RGBAFormat, UnsignedByteType } from "three";
 class TextureUtils {
@@ -33848,6 +34010,7 @@ class SpriteResourceManager {
 import * as THREE6 from "three";
 export {
   TiledSprite,
+  ThreeRenderable,
   ThreeCliRenderer,
   TextureUtils,
   THREE6 as THREE,
@@ -33874,5 +34037,5 @@ export {
   CLICanvas
 };
 
-//# debugId=D1F311FB11168D3664756E2164756E21
+//# debugId=A658FFDC4E7D1D3B64756E2164756E21
 //# sourceMappingURL=3d.js.map