poppygl 0.0.23 → 0.0.25

package/README.md

@@ -9,10 +9,10 @@ Render GLTF files to PNG images in completely native JavaScript without WebGL/Op
 Give poppygl a `.gltf` or `.glb` URL and it will fetch every referenced buffer/texture, rasterize the scene, and hand back a PNG buffer.
 
 ```ts
-import { renderGLTFToPNGBufferFromURL } from "poppygl"
+import { renderGLTFToPNGFromURL } from "poppygl"
 import { writeFile } from "node:fs/promises"
 
-const png = await renderGLTFToPNGBufferFromURL(
+const png = await renderGLTFToPNGFromURL(
   "https://models.babylonjs.com/DamagedHelmet.glb",
   {
     width: 800,
@@ -28,14 +28,14 @@ await writeFile("DamagedHelmet.png", png)
 
 ## Render from an in-memory GLB buffer
 
-Already have the `.glb` bytes (for example, uploaded by a user or read from disk)? Send the buffer straight to `renderGLTFToPNGBufferFromGLBBuffer` and receive the PNG output.
+Already have the `.glb` bytes (for example, uploaded by a user or read from disk)? Send the buffer straight to `renderGLTFToPNGFromGLB` and receive the PNG output.
 
 ```ts
 import { readFile } from "node:fs/promises"
-import { renderGLTFToPNGBufferFromGLBBuffer } from "poppygl"
+import { renderGLTFToPNGFromGLB } from "poppygl"
 
 const glb = await readFile("DamagedHelmet.glb")
-const png = await renderGLTFToPNGBufferFromGLBBuffer(glb, {
+const png = await renderGLTFToPNGFromGLB(glb, {
   width: 1024,
   height: 768,
 })
@@ -43,11 +43,11 @@ const png = await renderGLTFToPNGBufferFromGLBBuffer(glb, {
 // write or return the PNG buffer
 ```
 
-> This helper expects every referenced buffer/image to be embedded in the GLB (the usual single-file package). If the asset links out to external resources, load it with `renderGLTFToPNGBufferFromURL` instead so poppygl can fetch the extras.
+> This helper expects every referenced buffer/image to be embedded in the GLB (the usual single-file package). If the asset links out to external resources, load it with `renderGLTFToPNGFromURL` instead so poppygl can fetch the extras.
 
 ## Render options
 
-`renderGLTFToPNGBufferFromURL` accepts the same render options as the lower-level APIs:
+`renderGLTFToPNGFromURL` accepts the same render options as the lower-level APIs:
 
 - `width`/`height` (default `512`): output resolution in pixels.
 - `supersampling`: render at `width * supersampling` / `height * supersampling`, then downsample (default `1`).
@@ -76,8 +76,8 @@ import {
   bufferFromDataURI,
   createSceneFromGLTF,
   decodeImageFromBuffer,
-  encodePNGToBuffer,
-  pureImageFactory,
+  encodePNG,
+  createUint8Bitmap,
   renderSceneFromGLTF,
 } from "poppygl"
 import gltfJson from "./CesiumMan.gltf.json" assert { type: "json" }
@@ -105,8 +105,8 @@ const images = await Promise.all(
 )
 
 const scene = createSceneFromGLTF(gltfJson, { buffers, images })
-const { bitmap } = renderSceneFromGLTF(scene, { width: 512, height: 512 }, pureImageFactory)
-const png = await encodePNGToBuffer(bitmap)
+const { bitmap } = renderSceneFromGLTF(scene, { width: 512, height: 512 }, createUint8Bitmap)
+const png = await encodePNG(bitmap)
 ```
 
 The only contract is that `buffers` is an array of `Uint8Array` instances and `images` is an array of `BitmapLike` textures (PNG and JPEG are supported out of the box via `decodeImageFromBuffer`).
@@ -116,7 +116,7 @@ The only contract is that `buffers` is an array of `Uint8Array` instances and `i
 - `loadGLTFWithResourcesFromURL` returns `{ gltf, resources }` if you prefer to inspect or cache the parsed data before rendering.
 - `createSceneFromGLTF` builds draw calls ready for the software rasterizer.
 - `computeSmoothNormals` and `computeWorldAABB` expose useful preprocessing helpers.
-- `pureImageFactory` allocates the `pureimage` bitmap implementation used by the renderer.
-- `encodePNGToBuffer` packs any `BitmapLike` into a PNG buffer that can be written to disk or served over the network.
+- `createUint8Bitmap` allocates a portable in-memory bitmap used by the renderer.
+- `encodePNG` packs any `BitmapLike` into a `Uint8Array` PNG that can be written to disk or served over the network.
 
 Happy rendering!

package/dist/index.d.ts

@@ -193,21 +193,15 @@ declare function drawInfiniteGrid(software_renderer: SoftwareRenderer, params: {
     gamma_out?: boolean;
 }): void;
 
-declare const pureImageFactory: ImageFactory;
+declare function encodePNG(image: BitmapLike): Promise<Uint8Array>;
 
-declare function encodePNGToBuffer(image: BitmapLike): Promise<Buffer>;
-
-interface RenderGLTFToPNGBufferFromURLOptions extends RenderOptionsInput, LoadGLTFWithResourcesFromURLOptions {
+interface RenderGLTFToPNGFromURLOptions extends RenderOptionsInput, LoadGLTFWithResourcesFromURLOptions {
 }
-declare function renderGLTFToPNGBufferFromURL(url: string, options?: RenderGLTFToPNGBufferFromURLOptions): Promise<Buffer>;
-
-type RenderGLTFToPNGBufferFromGLBBufferOptions = RenderOptionsInput;
-declare function renderGLTFToPNGBufferFromGLBBuffer(glb: ArrayBuffer | Uint8Array, options?: RenderGLTFToPNGBufferFromGLBBufferOptions): Promise<Buffer>;
+declare function renderGLTFToPNGFromURL(url: string, options?: RenderGLTFToPNGFromURLOptions): Promise<Uint8Array>;
 
-interface RenderGLTFToPNGBufferOptions extends RenderOptionsInput, LoadGLTFWithResourcesFromURLOptions {
-}
-declare function renderGLTFToPNGBuffer(gltfOrJson: string | any, options?: RenderGLTFToPNGBufferOptions, resources?: GLTFResources): Promise<Buffer>;
+type RenderGLTFToPNGFromGLBOptions = RenderOptionsInput;
+declare function renderGLTFToPNGFromGLB(glb: ArrayBuffer | Uint8Array, options?: RenderGLTFToPNGFromGLBOptions): Promise<Uint8Array>;
 
 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 RenderGLTFToPNGFromGLBOptions, type RenderGLTFToPNGFromURLOptions, type RenderOptions, type RenderOptionsInput, type RenderResult, SoftwareRenderer, bufferFromDataURI, buildCamera, computeSmoothNormals, computeWorldAABB, createGrid, createInfiniteGrid, createSceneFromGLTF, createUint8Bitmap, decodeImageFromBuffer, drawInfiniteGrid, encodePNG, getDefaultRenderOptions, hexToRgb, isJPG, isPNG, loadGLTFWithResourcesFromURL, renderDrawCalls, 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() {
@@ -1621,21 +1620,6 @@ function getNodeBuffer() {
   }
   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);
@@ -1647,9 +1631,6 @@ function base64ToUint8Array(base64) {
   }
   return new Uint8Array(getNodeBuffer().from(base64, "base64"));
 }
-function uint8ArrayToNodeBuffer(bytes) {
-  return getNodeBuffer().from(bytes);
-}
 
 // lib/gltf/resourceUtils.ts
 function bufferFromDataURI(uri) {
@@ -1670,20 +1651,35 @@ function detectMimeTypeFromBuffer(buf, hint) {
   if (buf.length >= 2 && buf[0] === 255 && buf[1] === 216) return "image/jpeg";
   return null;
 }
-function bufferToStream(buf) {
+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 } = await import("readable-stream");
+  const PImage = await import("pureimage");
   const stream = new PassThrough();
   stream.end(buf);
-  return stream;
+  if (mimeType === "image/png") return PImage.decodePNGFromStream(stream);
+  if (mimeType === "image/jpeg" || mimeType === "image/jpg")
+    return PImage.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
@@ -1838,34 +1834,20 @@ async function loadGLTFWithResourcesFromURL(url, options = {}) {
   };
 }
 
-// lib/image/pureImageFactory.ts
-import * as PImage2 from "pureimage";
-var pureImageFactory = (width, height) => PImage2.make(width, height);
-
-// lib/image/encodePNGToBuffer.ts
-import { PassThrough as PassThrough2 } from "readable-stream";
-import * as PImage3 from "pureimage";
-async function encodePNGToBuffer(image) {
-  const passThrough = new PassThrough2();
-  const 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);
+// 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
   });
-  await PImage3.encodePNGToStream(image, passThrough);
-  return await resultPromise;
 }
 
-// lib/render/renderGLTFToPNGBufferFromURL.ts
-async function renderGLTFToPNGBufferFromURL(url, options = {}) {
+// lib/render/renderGLTFToPNGFromURL.ts
+async function renderGLTFToPNGFromURL(url, options = {}) {
   const { fetchImpl, ...renderOptions } = options;
   const { gltf, resources } = await loadGLTFWithResourcesFromURL(url, {
     fetchImpl
@@ -1874,19 +1856,19 @@ async function renderGLTFToPNGBufferFromURL(url, options = {}) {
   const { bitmap } = renderDrawCalls(
     scene.drawCalls,
     renderOptions,
-    pureImageFactory
+    createUint8Bitmap
   );
-  return encodePNGToBuffer(bitmap);
+  return encodePNG(bitmap);
 }
 
-// lib/render/renderGLTFToPNGBufferFromGLBBuffer.ts
+// 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 renderGLTFToPNGBufferFromGLBBuffer(glb, options = {}) {
+async function renderGLTFToPNGFromGLB(glb, options = {}) {
   const arrayBuffer = normalizeToArrayBuffer(glb);
   const { gltf, binaryChunk } = parseGLB(arrayBuffer);
   const totalBuffers = Array.isArray(gltf.buffers) ? gltf.buffers.length : 0;
@@ -1896,7 +1878,7 @@ async function renderGLTFToPNGBufferFromGLBBuffer(glb, options = {}) {
     if (entry?.uri) {
       if (!entry.uri.startsWith("data:")) {
         throw new Error(
-          `Buffer ${index} references external resource ${entry.uri}. Use renderGLTFToPNGBufferFromURL for GLBs with external buffer URIs.`
+          `Buffer ${index} references external resource ${entry.uri}. Use renderGLTFToPNGFromURL for GLBs with external buffer URIs.`
         );
       }
       buffers[index] = bufferFromDataURI(entry.uri);
@@ -1933,11 +1915,11 @@ async function renderGLTFToPNGBufferFromGLBBuffer(glb, options = {}) {
       if (image.uri) {
         if (!image.uri.startsWith("data:")) {
           throw new Error(
-            `Image ${imageIndex} references external resource ${image.uri}. Embed textures or load via renderGLTFToPNGBufferFromURL.`
+            `Image ${imageIndex} references external resource ${image.uri}. Embed textures or load via renderGLTFToPNGFromURL.`
           );
         }
-        const data = bufferFromDataURI(image.uri);
-        return decodeImageFromBuffer(data, image.mimeType);
+        const imageBytes = bufferFromDataURI(image.uri);
+        return decodeImageFromBuffer(imageBytes, image.mimeType);
       }
       if (typeof image.bufferView === "number") {
         const slice = resolveBufferViewSlice(image.bufferView);
@@ -1949,126 +1931,12 @@ async function renderGLTFToPNGBufferFromGLBBuffer(glb, options = {}) {
     })
   );
   const scene = createSceneFromGLTF(gltf, { buffers, images });
-  const { bitmap } = renderDrawCalls(scene.drawCalls, options, pureImageFactory);
-  return encodePNGToBuffer(bitmap);
-}
-
-// 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.readFile(gltfPath, "utf8"));
-  const buffers = await Promise.all(
-    (gltf.buffers || []).map(async (buffer) => {
-      if (buffer.uri?.startsWith("data:")) {
-        return bufferFromDataURI(buffer.uri);
-      }
-      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 (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(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 image.bufferView === "number") {
-        const bufferView = gltf.bufferViews?.[image.bufferView];
-        if (!bufferView) {
-          throw new Error(`Invalid image bufferView index ${image.bufferView}`);
-        }
-        const buffer = buffers[bufferView.buffer];
-        if (!buffer) {
-          throw new Error(
-            `Missing buffer for image bufferView ${image.bufferView}`
-          );
-        }
-        const byteOffset = bufferView.byteOffset ?? 0;
-        const byteLength = bufferView.byteLength;
-        if (typeof byteLength !== "number") {
-          throw new Error(
-            `bufferView ${image.bufferView} missing byteLength for image.`
-          );
-        }
-        const slice = buffer.subarray(byteOffset, byteOffset + byteLength);
-        return decodeImageFromBuffer(slice, image.mimeType);
-      }
-      throw new Error(
-        "images[*] entry missing uri or bufferView; unsupported in this loader."
-      );
-    })
+  const { bitmap } = renderDrawCalls(
+    scene.drawCalls,
+    options,
+    createUint8Bitmap
   );
-  return {
-    gltf,
-    resources: {
-      buffers,
-      images
-    }
-  };
-}
-
-// lib/gltf/resolveGLTFInput.ts
-function isNodeRuntime() {
-  const runtimeProcess = globalThis.process;
-  return !!runtimeProcess?.versions?.node;
-}
-function isFetchableURLInNode(source) {
-  try {
-    const url = new URL(source);
-    return ["http:", "https:", "data:", "blob:"].includes(url.protocol);
-  } catch {
-    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 } = 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);
+  return encodePNG(bitmap);
 }
 
 // lib/index.ts
@@ -2089,17 +1957,15 @@ export {
   createUint8Bitmap,
   decodeImageFromBuffer,
   drawInfiniteGrid,
-  encodePNGToBuffer,
+  encodePNG,
   getDefaultRenderOptions,
   hexToRgb,
   isJPG,
   isPNG,
   loadGLTFWithResourcesFromURL,
-  pureImageFactory,
   renderDrawCalls,
-  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.25",
   "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"