poppygl 0.0.21 → 0.0.22

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

@@ -1811,8 +1811,8 @@ async function encodePNGToBuffer(image) {
   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)));
+  const resultPromise = new Promise((resolve, reject) => {
+    passThrough.on("end", () => resolve(Buffer.concat(chunks)));
     passThrough.on("error", reject);
   });
   await PImage3.encodePNGToStream(image, passThrough);
@@ -1908,62 +1908,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 +1973,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.22",
   "repository": {
     "type": "git",
     "url": "https://github.com/tscircuit/poppygl.git"