poppygl 0.0.23 → 0.0.24

package/dist/index.d.ts

@@ -195,8 +195,17 @@ declare function drawInfiniteGrid(software_renderer: SoftwareRenderer, params: {
 
 declare const pureImageFactory: ImageFactory;
 
+declare function encodePNG(image: BitmapLike): Promise<Uint8Array>;
+
 declare function encodePNGToBuffer(image: BitmapLike): Promise<Buffer>;
 
+interface RenderGLTFToPNGFromURLOptions extends RenderOptionsInput, LoadGLTFWithResourcesFromURLOptions {
+}
+declare function renderGLTFToPNGFromURL(url: string, options?: RenderGLTFToPNGFromURLOptions): Promise<Uint8Array>;
+
+type RenderGLTFToPNGFromGLBOptions = RenderOptionsInput;
+declare function renderGLTFToPNGFromGLB(glb: ArrayBuffer | Uint8Array, options?: RenderGLTFToPNGFromGLBOptions): Promise<Uint8Array>;
+
 interface RenderGLTFToPNGBufferFromURLOptions extends RenderOptionsInput, LoadGLTFWithResourcesFromURLOptions {
 }
 declare function renderGLTFToPNGBufferFromURL(url: string, options?: RenderGLTFToPNGBufferFromURLOptions): Promise<Buffer>;
@@ -210,4 +219,4 @@ declare function renderGLTFToPNGBuffer(gltfOrJson: string | any, options?: Rende
 
 declare function renderSceneFromGLTF(scene: GLTFScene, options?: RenderOptionsInput, imageFactory?: ImageFactory): RenderResult;
 
-export { type BitmapLike, type Camera, type CameraRotation, type CameraUp, DEFAULT_LIGHT_DIR, DEFAULT_RENDER_OPTIONS, type DebugPoint, type DrawCall, type FetchLike, type GLTFResources, type GLTFScene, type GridOptions, type ImageFactory, type LightSettings, type LoadGLTFWithResourcesFromURLOptions, type Material, type MutableRGBA, type RGBA, type RenderGLTFToPNGBufferFromGLBBufferOptions, type RenderGLTFToPNGBufferFromURLOptions, type RenderGLTFToPNGBufferOptions, type RenderOptions, type RenderOptionsInput, type RenderResult, SoftwareRenderer, bufferFromDataURI, buildCamera, computeSmoothNormals, computeWorldAABB, createGrid, createInfiniteGrid, createSceneFromGLTF, createUint8Bitmap, decodeImageFromBuffer, drawInfiniteGrid, encodePNGToBuffer, getDefaultRenderOptions, hexToRgb, isJPG, isPNG, loadGLTFWithResourcesFromURL, pureImageFactory, renderDrawCalls, renderGLTFToPNGBuffer, renderGLTFToPNGBufferFromGLBBuffer, renderGLTFToPNGBufferFromURL, renderSceneFromGLTF, resolveRenderOptions };
+export { type BitmapLike, type Camera, type CameraRotation, type CameraUp, DEFAULT_LIGHT_DIR, DEFAULT_RENDER_OPTIONS, type DebugPoint, type DrawCall, type FetchLike, type GLTFResources, type GLTFScene, type GridOptions, type ImageFactory, type LightSettings, type LoadGLTFWithResourcesFromURLOptions, type Material, type MutableRGBA, type RGBA, type RenderGLTFToPNGBufferFromGLBBufferOptions, type RenderGLTFToPNGBufferFromURLOptions, type RenderGLTFToPNGBufferOptions, type RenderGLTFToPNGFromGLBOptions, type RenderGLTFToPNGFromURLOptions, type RenderOptions, type RenderOptionsInput, type RenderResult, SoftwareRenderer, bufferFromDataURI, buildCamera, computeSmoothNormals, computeWorldAABB, createGrid, createInfiniteGrid, createSceneFromGLTF, createUint8Bitmap, decodeImageFromBuffer, drawInfiniteGrid, encodePNG, encodePNGToBuffer, getDefaultRenderOptions, hexToRgb, isJPG, isPNG, loadGLTFWithResourcesFromURL, pureImageFactory, renderDrawCalls, renderGLTFToPNGBuffer, renderGLTFToPNGBufferFromGLBBuffer, renderGLTFToPNGBufferFromURL, renderGLTFToPNGFromGLB, renderGLTFToPNGFromURL, renderSceneFromGLTF, resolveRenderOptions };

package/dist/index.js

@@ -1610,8 +1610,7 @@ function createSceneFromGLTF(gltf, resources) {
 }
 
 // lib/gltf/resourceUtils.ts
-import { PassThrough } from "readable-stream";
-import * as PImage from "pureimage";
+import { decode } from "fast-png";
 
 // lib/utils/bytes.ts
 function getNodeBuffer() {
@@ -1670,20 +1669,35 @@ function detectMimeTypeFromBuffer(buf, hint) {
   if (buf.length >= 2 && buf[0] === 255 && buf[1] === 216) return "image/jpeg";
   return null;
 }
-function bufferToStream(buf) {
-  const stream = new PassThrough();
+async function decodeImageViaFastPng(buf) {
+  const decoded = decode(buf);
+  return {
+    width: decoded.width,
+    height: decoded.height,
+    data: new Uint8ClampedArray(decoded.data)
+  };
+}
+async function decodeImageViaPureImage(buf, mimeType) {
+  const { PassThrough: PassThrough2 } = await import("readable-stream");
+  const PImage3 = await import("pureimage");
+  const stream = new PassThrough2();
   stream.end(buf);
-  return stream;
+  if (mimeType === "image/png") return PImage3.decodePNGFromStream(stream);
+  if (mimeType === "image/jpeg" || mimeType === "image/jpg")
+    return PImage3.decodeJPEGFromStream(stream);
+  throw new Error(`Unsupported embedded image mimeType: ${mimeType}`);
 }
 async function decodeImageFromBuffer(buf, mimeType) {
   const type = detectMimeTypeFromBuffer(buf, mimeType);
-  if (type === "image/png")
-    return PImage.decodePNGFromStream(bufferToStream(buf));
-  if (type === "image/jpeg" || type === "image/jpg")
-    return PImage.decodeJPEGFromStream(bufferToStream(buf));
-  throw new Error(
-    `Unsupported embedded image mimeType: ${mimeType ?? "unknown"}`
-  );
+  if (!type) {
+    throw new Error(
+      `Unsupported embedded image mimeType: ${mimeType ?? "unknown"}`
+    );
+  }
+  if (type === "image/png") {
+    return decodeImageViaFastPng(buf);
+  }
+  return decodeImageViaPureImage(buf, type);
 }
 
 // lib/gltf/parseGLB.ts
@@ -1839,14 +1853,26 @@ async function loadGLTFWithResourcesFromURL(url, options = {}) {
 }
 
 // lib/image/pureImageFactory.ts
-import * as PImage2 from "pureimage";
-var pureImageFactory = (width, height) => PImage2.make(width, height);
+import * as PImage from "pureimage";
+var pureImageFactory = (width, height) => PImage.make(width, height);
+
+// lib/image/encodePNG.ts
+import { encode } from "fast-png";
+async function encodePNG(image) {
+  return encode({
+    width: image.width,
+    height: image.height,
+    data: image.data,
+    channels: 4,
+    depth: 8
+  });
+}
 
 // lib/image/encodePNGToBuffer.ts
-import { PassThrough as PassThrough2 } from "readable-stream";
-import * as PImage3 from "pureimage";
+import { PassThrough } from "readable-stream";
+import * as PImage2 from "pureimage";
 async function encodePNGToBuffer(image) {
-  const passThrough = new PassThrough2();
+  const passThrough = new PassThrough();
   const chunks = [];
   passThrough.on(
     "data",
@@ -1860,10 +1886,103 @@ async function encodePNGToBuffer(image) {
     });
     passThrough.on("error", reject);
   });
-  await PImage3.encodePNGToStream(image, passThrough);
+  await PImage2.encodePNGToStream(image, passThrough);
   return await resultPromise;
 }
 
+// lib/render/renderGLTFToPNGFromURL.ts
+async function renderGLTFToPNGFromURL(url, options = {}) {
+  const { fetchImpl, ...renderOptions } = options;
+  const { gltf, resources } = await loadGLTFWithResourcesFromURL(url, {
+    fetchImpl
+  });
+  const scene = createSceneFromGLTF(gltf, resources);
+  const { bitmap } = renderDrawCalls(
+    scene.drawCalls,
+    renderOptions,
+    createUint8Bitmap
+  );
+  return encodePNG(bitmap);
+}
+
+// lib/render/renderGLTFToPNGFromGLB.ts
+function normalizeToArrayBuffer(source) {
+  if (source instanceof ArrayBuffer) return source;
+  const { buffer, byteOffset, byteLength } = source;
+  const viewBuffer = buffer;
+  return viewBuffer.slice(byteOffset, byteOffset + byteLength);
+}
+async function renderGLTFToPNGFromGLB(glb, options = {}) {
+  const arrayBuffer = normalizeToArrayBuffer(glb);
+  const { gltf, binaryChunk } = parseGLB(arrayBuffer);
+  const totalBuffers = Array.isArray(gltf.buffers) ? gltf.buffers.length : 0;
+  const buffers = new Array(totalBuffers);
+  for (let index = 0; index < totalBuffers; index++) {
+    const entry = gltf.buffers[index];
+    if (entry?.uri) {
+      if (!entry.uri.startsWith("data:")) {
+        throw new Error(
+          `Buffer ${index} references external resource ${entry.uri}. Use renderGLTFToPNGFromURL for GLBs with external buffer URIs.`
+        );
+      }
+      buffers[index] = bufferFromDataURI(entry.uri);
+      continue;
+    }
+    if (!binaryChunk) {
+      throw new Error(
+        `GLB is missing the binary chunk required for buffer ${index}.`
+      );
+    }
+    buffers[index] = binaryChunk;
+  }
+  const resolveBufferViewSlice = (bufferViewIndex) => {
+    const bufferView = gltf.bufferViews?.[bufferViewIndex];
+    if (!bufferView) {
+      throw new Error(`Invalid bufferView index ${bufferViewIndex}.`);
+    }
+    const bufferIndex = bufferView.buffer;
+    const buffer = buffers[bufferIndex];
+    if (!buffer) {
+      throw new Error(
+        `Missing buffer data for bufferView ${bufferViewIndex} (buffer ${bufferIndex}).`
+      );
+    }
+    const byteOffset = bufferView.byteOffset ?? 0;
+    const byteLength = bufferView.byteLength;
+    if (typeof byteLength !== "number") {
+      throw new Error(`bufferView ${bufferViewIndex} is missing byteLength.`);
+    }
+    return buffer.subarray(byteOffset, byteOffset + byteLength);
+  };
+  const images = await Promise.all(
+    (gltf.images ?? []).map(async (image, imageIndex) => {
+      if (image.uri) {
+        if (!image.uri.startsWith("data:")) {
+          throw new Error(
+            `Image ${imageIndex} references external resource ${image.uri}. Embed textures or load via renderGLTFToPNGFromURL.`
+          );
+        }
+        const imageBytes = bufferFromDataURI(image.uri);
+        return decodeImageFromBuffer(imageBytes, image.mimeType);
+      }
+      if (typeof image.bufferView === "number") {
+        const slice = resolveBufferViewSlice(image.bufferView);
+        return decodeImageFromBuffer(slice, image.mimeType);
+      }
+      throw new Error(
+        `Image ${imageIndex} must supply a data URI or bufferView for GLB rendering.`
+      );
+    })
+  );
+  const scene = createSceneFromGLTF(gltf, { buffers, images });
+  const { bitmap } = renderDrawCalls(
+    scene.drawCalls,
+    options,
+    createUint8Bitmap
+  );
+  return encodePNG(bitmap);
+}
+
 // lib/render/renderGLTFToPNGBufferFromURL.ts
 async function renderGLTFToPNGBufferFromURL(url, options = {}) {
   const { fetchImpl, ...renderOptions } = options;
@@ -1880,14 +1999,14 @@ async function renderGLTFToPNGBufferFromURL(url, options = {}) {
 }
 
 // lib/render/renderGLTFToPNGBufferFromGLBBuffer.ts
-function normalizeToArrayBuffer(source) {
+function normalizeToArrayBuffer2(source) {
   if (source instanceof ArrayBuffer) return source;
   const { buffer, byteOffset, byteLength } = source;
   const viewBuffer = buffer;
   return viewBuffer.slice(byteOffset, byteOffset + byteLength);
 }
 async function renderGLTFToPNGBufferFromGLBBuffer(glb, options = {}) {
-  const arrayBuffer = normalizeToArrayBuffer(glb);
+  const arrayBuffer = normalizeToArrayBuffer2(glb);
   const { gltf, binaryChunk } = parseGLB(arrayBuffer);
   const totalBuffers = Array.isArray(gltf.buffers) ? gltf.buffers.length : 0;
   const buffers = new Array(totalBuffers);
@@ -2089,6 +2208,7 @@ export {
   createUint8Bitmap,
   decodeImageFromBuffer,
   drawInfiniteGrid,
+  encodePNG,
   encodePNGToBuffer,
   getDefaultRenderOptions,
   hexToRgb,
@@ -2100,6 +2220,8 @@ export {
   renderGLTFToPNGBuffer,
   renderGLTFToPNGBufferFromGLBBuffer,
   renderGLTFToPNGBufferFromURL,
+  renderGLTFToPNGFromGLB,
+  renderGLTFToPNGFromURL,
   renderSceneFromGLTF,
   resolveRenderOptions
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "poppygl",
   "main": "dist/index.js",
-  "version": "0.0.23",
+  "version": "0.0.24",
   "repository": {
     "type": "git",
     "url": "https://github.com/tscircuit/poppygl.git"
@@ -37,6 +37,7 @@
     "typescript": "^5"
   },
   "dependencies": {
+    "fast-png": "^8.0.0",
     "gl-matrix": "^3.4.4",
     "pureimage": "^0.4.18",
     "readable-stream": "^4.7.0"