poppygl 0.0.24 → 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,12 +193,8 @@ 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 RenderGLTFToPNGFromURLOptions extends RenderOptionsInput, LoadGLTFWithResourcesFromURLOptions {
 }
 declare function renderGLTFToPNGFromURL(url: string, options?: RenderGLTFToPNGFromURLOptions): Promise<Uint8Array>;
@@ -206,17 +202,6 @@ declare function renderGLTFToPNGFromURL(url: string, options?: RenderGLTFToPNGFr
 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>;
-
-type RenderGLTFToPNGBufferFromGLBBufferOptions = RenderOptionsInput;
-declare function renderGLTFToPNGBufferFromGLBBuffer(glb: ArrayBuffer | Uint8Array, options?: RenderGLTFToPNGBufferFromGLBBufferOptions): 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 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 };
+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

@@ -1620,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);
@@ -1646,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) {
@@ -1678,13 +1660,13 @@ async function decodeImageViaFastPng(buf) {
   };
 }
 async function decodeImageViaPureImage(buf, mimeType) {
-  const { PassThrough: PassThrough2 } = await import("readable-stream");
-  const PImage3 = await import("pureimage");
-  const stream = new PassThrough2();
+  const { PassThrough } = await import("readable-stream");
+  const PImage = await import("pureimage");
+  const stream = new PassThrough();
   stream.end(buf);
-  if (mimeType === "image/png") return PImage3.decodePNGFromStream(stream);
+  if (mimeType === "image/png") return PImage.decodePNGFromStream(stream);
   if (mimeType === "image/jpeg" || mimeType === "image/jpg")
-    return PImage3.decodeJPEGFromStream(stream);
+    return PImage.decodeJPEGFromStream(stream);
   throw new Error(`Unsupported embedded image mimeType: ${mimeType}`);
 }
 async function decodeImageFromBuffer(buf, mimeType) {
@@ -1852,10 +1834,6 @@ async function loadGLTFWithResourcesFromURL(url, options = {}) {
   };
 }
 
-// lib/image/pureImageFactory.ts
-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) {
@@ -1868,28 +1846,6 @@ async function encodePNG(image) {
   });
 }
 
-// lib/image/encodePNGToBuffer.ts
-import { PassThrough } from "readable-stream";
-import * as PImage2 from "pureimage";
-async function encodePNGToBuffer(image) {
-  const passThrough = new PassThrough();
-  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);
-  });
-  await PImage2.encodePNGToStream(image, passThrough);
-  return await resultPromise;
-}
-
 // lib/render/renderGLTFToPNGFromURL.ts
 async function renderGLTFToPNGFromURL(url, options = {}) {
   const { fetchImpl, ...renderOptions } = options;
@@ -1983,213 +1939,6 @@ async function renderGLTFToPNGFromGLB(glb, options = {}) {
   return encodePNG(bitmap);
 }
 
-// lib/render/renderGLTFToPNGBufferFromURL.ts
-async function renderGLTFToPNGBufferFromURL(url, options = {}) {
-  const { fetchImpl, ...renderOptions } = options;
-  const { gltf, resources } = await loadGLTFWithResourcesFromURL(url, {
-    fetchImpl
-  });
-  const scene = createSceneFromGLTF(gltf, resources);
-  const { bitmap } = renderDrawCalls(
-    scene.drawCalls,
-    renderOptions,
-    pureImageFactory
-  );
-  return encodePNGToBuffer(bitmap);
-}
-
-// lib/render/renderGLTFToPNGBufferFromGLBBuffer.ts
-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 = normalizeToArrayBuffer2(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 renderGLTFToPNGBufferFromURL 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 renderGLTFToPNGBufferFromURL.`
-          );
-        }
-        const data = bufferFromDataURI(image.uri);
-        return decodeImageFromBuffer(data, 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, 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."
-      );
-    })
-  );
-  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);
-}
-
 // lib/index.ts
 function renderSceneFromGLTF(scene, options, imageFactory) {
   return renderDrawCalls(scene.drawCalls, options, imageFactory);
@@ -2209,17 +1958,12 @@ export {
   decodeImageFromBuffer,
   drawInfiniteGrid,
   encodePNG,
-  encodePNGToBuffer,
   getDefaultRenderOptions,
   hexToRgb,
   isJPG,
   isPNG,
   loadGLTFWithResourcesFromURL,
-  pureImageFactory,
   renderDrawCalls,
-  renderGLTFToPNGBuffer,
-  renderGLTFToPNGBufferFromGLBBuffer,
-  renderGLTFToPNGBufferFromURL,
   renderGLTFToPNGFromGLB,
   renderGLTFToPNGFromURL,
   renderSceneFromGLTF,

package/package.json

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