poppygl 0.0.3 → 0.0.5

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

@@ -742,7 +742,7 @@ function createSceneFromGLTF(gltf, resources) {
 }
 
 // lib/gltf/resourceUtils.ts
-import { PassThrough } from "stream";
+import { PassThrough } from "readable-stream";
 import * as PImage from "pureimage";
 function bufferFromDataURI(uri) {
   const match = uri.match(/^data:.*?;base64,(.*)$/);
@@ -773,7 +773,9 @@ async function decodeImageFromBuffer(buf, mimeType) {
     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"}`);
+  throw new Error(
+    `Unsupported embedded image mimeType: ${mimeType ?? "unknown"}`
+  );
 }
 
 // lib/gltf/parseGLB.ts
@@ -924,7 +926,7 @@ import * as PImage2 from "pureimage";
 var pureImageFactory = (width, height) => PImage2.make(width, height);
 
 // lib/image/encodePNGToBuffer.ts
-import { PassThrough as PassThrough2 } from "stream";
+import { PassThrough as PassThrough2 } from "readable-stream";
 import * as PImage3 from "pureimage";
 async function encodePNGToBuffer(image) {
   const passThrough = new PassThrough2();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "poppygl",
   "main": "dist/index.js",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "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",
@@ -34,6 +35,7 @@
   },
   "dependencies": {
     "gl-matrix": "^3.4.4",
-    "pureimage": "^0.4.18"
+    "pureimage": "^0.4.18",
+    "readable-stream": "^4.7.0"
   }
 }