poppygl 0.0.22 → 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,12 +1610,51 @@ 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() {
+  const maybeBuffer = globalThis.Buffer;
+  if (!maybeBuffer) {
+    throw new Error("Node Buffer API is not available in this runtime.");
+  }
+  return maybeBuffer;
+}
+function toUint8Array(chunk) {
+  if (chunk instanceof Uint8Array) return chunk;
+  if (chunk instanceof ArrayBuffer) return new Uint8Array(chunk);
+  return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+}
+function concatUint8Arrays(chunks) {
+  const totalLength = chunks.reduce((length, chunk) => length + chunk.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+function base64ToUint8Array(base64) {
+  if (typeof globalThis.atob === "function") {
+    const binary = globalThis.atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  }
+  return new Uint8Array(getNodeBuffer().from(base64, "base64"));
+}
+function uint8ArrayToNodeBuffer(bytes) {
+  return getNodeBuffer().from(bytes);
+}
+
+// lib/gltf/resourceUtils.ts
 function bufferFromDataURI(uri) {
   const match = uri.match(/^data:.*?;base64,(.*)$/);
   if (!match) throw new Error(`Unsupported data URI: ${uri.slice(0, 64)}...`);
-  return Buffer.from(match[1], "base64");
+  return base64ToUint8Array(match[1]);
 }
 function isPNG(filenameOrUri) {
   return /\.png(\?|$)/i.test(filenameOrUri) || /image\/png/i.test(filenameOrUri);
@@ -1630,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();
-  stream.end(Buffer.from(buf));
-  return stream;
+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);
+  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
@@ -1799,26 +1853,136 @@ 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", (chunk) => {
-    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-  });
+  passThrough.on(
+    "data",
+    (chunk) => {
+      chunks.push(toUint8Array(chunk));
+    }
+  );
   const resultPromise = new Promise((resolve, reject) => {
-    passThrough.on("end", () => resolve(Buffer.concat(chunks)));
+    passThrough.on("end", () => {
+      resolve(uint8ArrayToNodeBuffer(concatUint8Arrays(chunks)));
+    });
     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;
@@ -1835,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);
@@ -2044,6 +2208,7 @@ export {
   createUint8Bitmap,
   decodeImageFromBuffer,
   drawInfiniteGrid,
+  encodePNG,
   encodePNGToBuffer,
   getDefaultRenderOptions,
   hexToRgb,
@@ -2055,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.22",
+  "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"