poppygl 0.0.4 → 0.0.6

package/dist/index.d.ts

@@ -0,0 +1,127 @@
+import { mat4 } from 'gl-matrix';
+
+type RGBA = readonly [number, number, number, number];
+type MutableRGBA = [number, number, number, number];
+interface BitmapLike {
+    width: number;
+    height: number;
+    data: Uint8Array | Uint8ClampedArray;
+}
+type ImageFactory = (width: number, height: number) => BitmapLike;
+declare const createUint8Bitmap: ImageFactory;
+
+declare const DEFAULT_LIGHT_DIR: readonly [-0.4, -0.9, -0.2];
+interface RenderOptions {
+    width: number;
+    height: number;
+    fov: number;
+    cull: boolean;
+    gamma: boolean;
+    ambient: number;
+    lightDir: readonly [number, number, number];
+    camPos?: readonly [number, number, number] | null;
+    lookAt?: readonly [number, number, number] | null;
+}
+type RenderOptionsInput = Partial<RenderOptions>;
+declare const DEFAULT_RENDER_OPTIONS: RenderOptions;
+declare function getDefaultRenderOptions(): RenderOptions;
+
+interface Material {
+    baseColorFactor: [number, number, number, number];
+    baseColorTexture: BitmapLike | null;
+}
+interface DrawCall {
+    positions: Float32Array;
+    normals: Float32Array | null;
+    uvs: Float32Array | null;
+    indices: Uint32Array | null;
+    model: mat4;
+    material: Material;
+}
+interface GLTFResources {
+    buffers: Uint8Array[];
+    images: BitmapLike[];
+}
+interface GLTFScene {
+    drawCalls: DrawCall[];
+    gltf: any;
+}
+
+interface Camera {
+    view: mat4;
+    proj: mat4;
+}
+declare function buildCamera(drawCalls: DrawCall[], width: number, height: number, fovDeg: number, camPos: readonly [number, number, number] | null | undefined, lookAt: readonly [number, number, number] | null | undefined): Camera;
+
+interface RenderResult {
+    bitmap: BitmapLike;
+    camera: Camera;
+    options: RenderOptions;
+}
+declare function renderDrawCalls(drawCalls: DrawCall[], optionsInput?: RenderOptionsInput, imageFactory?: ImageFactory): RenderResult;
+
+declare function resolveRenderOptions(options?: RenderOptionsInput): RenderOptions;
+
+type GLTF = any;
+declare function createSceneFromGLTF(gltf: GLTF, resources: GLTFResources): GLTFScene;
+
+declare function computeSmoothNormals(positions: Float32Array, indices: Uint32Array | null): Float32Array;
+
+declare function computeWorldAABB(drawCalls: DrawCall[]): {
+    min: number[];
+    max: number[];
+};
+
+interface FetchLikeResponse {
+    ok: boolean;
+    status: number;
+    statusText: string;
+    url?: string;
+    arrayBuffer(): Promise<ArrayBuffer>;
+}
+type FetchLike = (input: string, init?: Record<string, unknown>) => Promise<FetchLikeResponse>;
+interface LoadGLTFWithResourcesFromURLOptions {
+    fetchImpl?: FetchLike;
+}
+declare function loadGLTFWithResourcesFromURL(url: string, options?: LoadGLTFWithResourcesFromURLOptions): Promise<{
+    gltf: any;
+    resources: GLTFResources;
+}>;
+
+declare function bufferFromDataURI(uri: string): Uint8Array;
+declare function isPNG(filenameOrUri: string): boolean;
+declare function isJPG(filenameOrUri: string): boolean;
+declare function decodeImageFromBuffer(buf: Uint8Array, mimeType?: string | null): Promise<BitmapLike>;
+
+interface LightSettings {
+    dir: readonly [number, number, number];
+    ambient: number;
+}
+declare class SoftwareRenderer {
+    readonly width: number;
+    readonly height: number;
+    readonly bitmap: BitmapLike;
+    readonly depth: Float32Array;
+    constructor(width: number, height: number, imageFactory?: ImageFactory);
+    get buffer(): Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike>;
+    clear(colorRGBA?: [number, number, number, number]): void;
+    setPixel(x: number, y: number, r: number, g: number, b: number, a: number): void;
+    sampleTextureNearest(img: BitmapLike | null, u: number, v: number): MutableRGBA;
+    perspInterp(attrs: number[][], invWs: number[], lambdas: number[]): number[];
+    drawMesh(mesh: DrawCall, camera: Camera, light: LightSettings, material: Material, cullBackFaces?: boolean, gammaOut?: boolean): void;
+}
+
+declare const pureImageFactory: ImageFactory;
+
+declare function encodePNGToBuffer(image: BitmapLike): Promise<Buffer>;
+
+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>;
+
+declare function renderSceneFromGLTF(scene: GLTFScene, options?: RenderOptionsInput, imageFactory?: ImageFactory): RenderResult;
+
+export { type BitmapLike, type Camera, DEFAULT_LIGHT_DIR, DEFAULT_RENDER_OPTIONS, type DrawCall, type FetchLike, type GLTFResources, type GLTFScene, 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, createSceneFromGLTF, createUint8Bitmap, decodeImageFromBuffer, encodePNGToBuffer, getDefaultRenderOptions, isJPG, isPNG, loadGLTFWithResourcesFromURL, pureImageFactory, renderDrawCalls, renderGLTFToPNGBufferFromGLBBuffer, renderGLTFToPNGBufferFromURL, renderSceneFromGLTF, resolveRenderOptions };

package/dist/index.js

@@ -10,13 +10,7 @@ function computeWorldAABB(drawCalls) {
   for (const dc of drawCalls) {
     const { positions, model } = dc;
     for (let i = 0; i < positions.length; i += 3) {
-      vec4.set(
-        tmp,
-        positions[i],
-        positions[i + 1],
-        positions[i + 2],
-        1
-      );
+      vec4.set(tmp, positions[i], positions[i + 1], positions[i + 2], 1);
       vec4.transformMat4(tmp, tmp, model);
       const x = tmp[0];
       const y = tmp[1];
@@ -799,7 +793,8 @@ function parseGLB(arrayBuffer) {
     const chunkLength = view.getUint32(offset, true);
     const chunkType = view.getUint32(offset + 4, true);
     offset += 8;
-    if (offset + chunkLength > length) throw new Error("Truncated GLB chunk data.");
+    if (offset + chunkLength > length)
+      throw new Error("Truncated GLB chunk data.");
     const chunkData = new Uint8Array(arrayBuffer, offset, chunkLength);
     offset += chunkLength;
     if (chunkType === JSON_CHUNK_TYPE) {
@@ -817,7 +812,8 @@ function parseGLB(arrayBuffer) {
 // lib/gltf/loadGLTFWithResourcesFromURL.ts
 function ensureFetch(fetchImpl) {
   const impl = fetchImpl ?? globalThis.fetch;
-  if (!impl) throw new Error("Global fetch API is not available; provide fetchImpl.");
+  if (!impl)
+    throw new Error("Global fetch API is not available; provide fetchImpl.");
   return impl;
 }
 async function fetchBinary(fetchImpl, url) {
@@ -832,7 +828,9 @@ async function loadGLTFWithResourcesFromURL(url, options = {}) {
   const fetchImpl = ensureFetch(options.fetchImpl);
   const response = await fetchImpl(url);
   if (!response.ok)
-    throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+    throw new Error(
+      `Failed to fetch ${url}: ${response.status} ${response.statusText}`
+    );
   const resolvedURL = new URL(response.url || url);
   const baseURL = resolvedURL;
   const sourceBuffer = await response.arrayBuffer();
@@ -867,7 +865,9 @@ async function loadGLTFWithResourcesFromURL(url, options = {}) {
       buffers[index] = buf;
       return buf;
     }
-    throw new Error(`Buffer ${index} is missing a uri and no GLB chunk was provided.`);
+    throw new Error(
+      `Buffer ${index} is missing a uri and no GLB chunk was provided.`
+    );
   }
   await Promise.all(
     (gltf.buffers || []).map(async (entry, idx) => {
@@ -892,7 +892,10 @@ async function loadGLTFWithResourcesFromURL(url, options = {}) {
       const bufferView = gltf.bufferViews?.[img.bufferView];
       if (!bufferView)
         throw new Error(`Invalid image bufferView index ${img.bufferView}`);
-      const buffer = await resolveBuffer(bufferView.buffer, gltf.buffers?.[bufferView.buffer]);
+      const buffer = await resolveBuffer(
+        bufferView.buffer,
+        gltf.buffers?.[bufferView.buffer]
+      );
       if (!buffer)
         throw new Error(`Missing buffer for image bufferView ${img.bufferView}`);
       const byteOffset = bufferView.byteOffset ?? 0;
@@ -981,7 +984,9 @@ async function renderGLTFToPNGBufferFromGLBBuffer(glb, options = {}) {
       continue;
     }
     if (!binaryChunk) {
-      throw new Error(`GLB is missing the binary chunk required for buffer ${index}.`);
+      throw new Error(
+        `GLB is missing the binary chunk required for buffer ${index}.`
+      );
     }
     buffers[index] = binaryChunk;
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "poppygl",
   "main": "dist/index.js",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "repository": {
     "type": "git",
     "url": "https://github.com/tscircuit/poppygl.git"
@@ -12,7 +12,7 @@
   "scripts": {
     "start": "cosmos",
     "build:site": "cosmos-export",
-    "build": "tsup-node ./lib/index.ts --format esm",
+    "build": "tsup-node ./lib/index.ts --format esm --dts",
     "format": "biome format --write .",
     "format:check": "biome format .",
     "test": "bun test"
@@ -21,6 +21,7 @@
   "devDependencies": {
     "@biomejs/biome": "^2.2.4",
     "@types/bun": "^1.2.23",
+    "@types/readable-stream": "^4.0.21",
     "looks-same": "^10.0.1",
     "react": "^19.1.1",
     "react-cosmos": "^7.0.0",