poppygl 0.0.21 → 0.0.23

package/dist/index.d.ts

@@ -204,8 +204,10 @@ declare function renderGLTFToPNGBufferFromURL(url: string, options?: RenderGLTFT
 type RenderGLTFToPNGBufferFromGLBBufferOptions = RenderOptionsInput;
 declare function renderGLTFToPNGBufferFromGLBBuffer(glb: ArrayBuffer | Uint8Array, options?: RenderGLTFToPNGBufferFromGLBBufferOptions): Promise<Buffer>;
 
-declare function renderGLTFToPNGBuffer(gltfPathOrString: string, options?: RenderOptionsInput): Promise<Buffer>;
+interface RenderGLTFToPNGBufferOptions extends RenderOptionsInput, LoadGLTFWithResourcesFromURLOptions {
+}
+declare function renderGLTFToPNGBuffer(gltfOrJson: string | any, options?: RenderGLTFToPNGBufferOptions, resources?: GLTFResources): Promise<Buffer>;
 
 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 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 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 };

package/dist/index.js

@@ -1612,10 +1612,50 @@ function createSceneFromGLTF(gltf, resources) {
 // lib/gltf/resourceUtils.ts
 import { PassThrough } from "readable-stream";
 import * as PImage from "pureimage";
+
+// 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);
@@ -1632,7 +1672,7 @@ function detectMimeTypeFromBuffer(buf, hint) {
 }
 function bufferToStream(buf) {
   const stream = new PassThrough();
-  stream.end(Buffer.from(buf));
+  stream.end(buf);
   return stream;
 }
 async function decodeImageFromBuffer(buf, mimeType) {
@@ -1808,11 +1848,16 @@ import * as PImage3 from "pureimage";
 async function encodePNGToBuffer(image) {
   const passThrough = new PassThrough2();
   const chunks = [];
-  passThrough.on("data", (chunk) => {
-    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-  });
-  const resultPromise = new Promise((resolve2, reject) => {
-    passThrough.on("end", () => resolve2(Buffer.concat(chunks)));
+  passThrough.on(
+    "data",
+    (chunk) => {
+      chunks.push(toUint8Array(chunk));
+    }
+  );
+  const resultPromise = new Promise((resolve, reject) => {
+    passThrough.on("end", () => {
+      resolve(uint8ArrayToNodeBuffer(concatUint8Arrays(chunks)));
+    });
     passThrough.on("error", reject);
   });
   await PImage3.encodePNGToStream(image, passThrough);
@@ -1908,62 +1953,59 @@ async function renderGLTFToPNGBufferFromGLBBuffer(glb, options = {}) {
   return encodePNGToBuffer(bitmap);
 }
 
-// cli/loadGLTFWithResources.ts
-import * as fs from "fs";
-import * as path from "path";
-async function loadGLTFWithResources(gltfPath) {
+// lib/gltf/loadGLTFWithResourcesFromPath.ts
+async function loadGLTFWithResourcesFromPath(gltfPath) {
+  const fs = await import("fs/promises");
+  const path = await import("path");
   const baseDir = path.dirname(gltfPath);
-  const gltf = JSON.parse(await fs.promises.readFile(gltfPath, "utf8"));
+  const gltf = JSON.parse(await fs.readFile(gltfPath, "utf8"));
   const buffers = await Promise.all(
-    (gltf.buffers || []).map(async (b) => {
-      if (b.uri && b.uri.startsWith("data:")) {
-        return bufferFromDataURI(b.uri);
+    (gltf.buffers || []).map(async (buffer) => {
+      if (buffer.uri?.startsWith("data:")) {
+        return bufferFromDataURI(buffer.uri);
       }
-      if (b.uri) {
-        const resolved = path.resolve(baseDir, decodeURIComponent(b.uri));
-        return fs.promises.readFile(resolved);
+      if (buffer.uri) {
+        const resolved = path.resolve(baseDir, decodeURIComponent(buffer.uri));
+        return fs.readFile(resolved);
       }
       throw new Error("Buffer without uri not supported in this loader.");
     })
   );
   const images = await Promise.all(
-    (gltf.images || []).map(async (img) => {
-      if (img.uri) {
-        if (img.uri.startsWith("data:")) {
-          const buf = bufferFromDataURI(img.uri);
-          return decodeImageFromBuffer(buf, img.mimeType);
+    (gltf.images || []).map(async (image) => {
+      if (image.uri) {
+        if (image.uri.startsWith("data:")) {
+          const bytes = bufferFromDataURI(image.uri);
+          return decodeImageFromBuffer(bytes, image.mimeType);
         }
-        const filePath = path.resolve(baseDir, decodeURIComponent(img.uri));
-        const fileBuf = await fs.promises.readFile(filePath);
-        const hintedMime = isPNG(img.uri) ? "image/png" : isJPG(img.uri) ? "image/jpeg" : img.mimeType;
-        return decodeImageFromBuffer(fileBuf, hintedMime);
+        const filePath = path.resolve(baseDir, decodeURIComponent(image.uri));
+        const fileBytes = await fs.readFile(filePath);
+        const hintedMime = isPNG(image.uri) ? "image/png" : isJPG(image.uri) ? "image/jpeg" : image.mimeType;
+        return decodeImageFromBuffer(fileBytes, hintedMime);
       }
-      if (typeof img.bufferView === "number") {
-        const bufferView = gltf.bufferViews?.[img.bufferView];
+      if (typeof image.bufferView === "number") {
+        const bufferView = gltf.bufferViews?.[image.bufferView];
         if (!bufferView) {
-          throw new Error(`Invalid image bufferView index ${img.bufferView}`);
+          throw new Error(`Invalid image bufferView index ${image.bufferView}`);
         }
         const buffer = buffers[bufferView.buffer];
-        if (!buffer)
+        if (!buffer) {
           throw new Error(
-            `Missing buffer for image bufferView ${img.bufferView}`
+            `Missing buffer for image bufferView ${image.bufferView}`
           );
+        }
         const byteOffset = bufferView.byteOffset ?? 0;
         const byteLength = bufferView.byteLength;
         if (typeof byteLength !== "number") {
           throw new Error(
-            `bufferView ${img.bufferView} missing byteLength for image.`
+            `bufferView ${image.bufferView} missing byteLength for image.`
           );
         }
-        const slice = Buffer.from(
-          buffer.buffer,
-          buffer.byteOffset + byteOffset,
-          byteLength
-        );
-        return decodeImageFromBuffer(slice, img.mimeType);
+        const slice = buffer.subarray(byteOffset, byteOffset + byteLength);
+        return decodeImageFromBuffer(slice, image.mimeType);
       }
       throw new Error(
-        "images[*] entry missing uri or bufferView; unsupported in this lightweight loader."
+        "images[*] entry missing uri or bufferView; unsupported in this loader."
       );
     })
   );
@@ -1976,22 +2018,58 @@ async function loadGLTFWithResources(gltfPath) {
   };
 }
 
-// cli/renderGLTFToPNGBuffer.ts
-async function renderGLTFToPNGBuffer(gltfPathOrString, options = {}) {
-  let gltf;
-  let resources;
+// lib/gltf/resolveGLTFInput.ts
+function isNodeRuntime() {
+  const runtimeProcess = globalThis.process;
+  return !!runtimeProcess?.versions?.node;
+}
+function isFetchableURLInNode(source) {
   try {
-    gltf = JSON.parse(gltfPathOrString);
-    resources = { buffers: [], images: [] };
+    const url = new URL(source);
+    return ["http:", "https:", "data:", "blob:"].includes(url.protocol);
   } catch {
-    const result = await loadGLTFWithResources(gltfPathOrString);
-    gltf = result.gltf;
-    resources = result.resources;
+    return false;
+  }
+}
+function parseGLTFJSON(source) {
+  try {
+    return JSON.parse(source);
+  } catch (error) {
+    if (error instanceof SyntaxError) return null;
+    throw error;
   }
+}
+async function resolveGLTFInput(source, options = {}) {
+  const gltf = parseGLTFJSON(source);
+  if (gltf !== null) {
+    return {
+      gltf,
+      resources: { buffers: [], images: [] }
+    };
+  }
+  if (!isNodeRuntime()) {
+    return loadGLTFWithResourcesFromURL(source, options);
+  }
+  if (isFetchableURLInNode(source)) {
+    return loadGLTFWithResourcesFromURL(source, options);
+  }
+  return loadGLTFWithResourcesFromPath(source);
+}
+
+// lib/render/renderGLTFToPNGBuffer.ts
+function renderFromGLTF(gltf, options, resources) {
   const scene = createSceneFromGLTF(gltf, resources);
-  const { bitmap } = renderSceneFromGLTF(scene, options, pureImageFactory);
+  const { bitmap } = renderDrawCalls(scene.drawCalls, options, pureImageFactory);
   return encodePNGToBuffer(bitmap);
 }
+async function renderGLTFToPNGBuffer(gltfOrJson, options = {}, resources = { buffers: [], images: [] }) {
+  const { fetchImpl, ...renderOptions } = options;
+  if (typeof gltfOrJson !== "string") {
+    return renderFromGLTF(gltfOrJson, renderOptions, resources);
+  }
+  const loaded = await resolveGLTFInput(gltfOrJson, { fetchImpl });
+  return renderFromGLTF(loaded.gltf, renderOptions, loaded.resources);
+}
 
 // lib/index.ts
 function renderSceneFromGLTF(scene, options, imageFactory) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "poppygl",
   "main": "dist/index.js",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "repository": {
     "type": "git",
     "url": "https://github.com/tscircuit/poppygl.git"