poppygl 0.0.28 → 0.0.30

package/dist/index.js

@@ -503,9 +503,86 @@ function srgbEncodeLinear01(linear) {
   return 1.055 * Math.pow(linear, 1 / 2.4) - 0.055;
 }
 
+// lib/utils/srgbDecodeToLinear01.ts
+function srgbDecodeToLinear01(srgb) {
+  if (srgb <= 0.04045) return srgb / 12.92;
+  return ((srgb + 0.055) / 1.055) ** 2.4;
+}
+
 // lib/utils/clamp.ts
 var clamp = (value, min, max) => Math.max(min, Math.min(max, value));
 
+// lib/render/clipMeshToNearPlane.ts
+function clipMeshToNearPlane(mesh, mvp) {
+  const count = mesh.positions.length / 3;
+  const distances = new Float64Array(count);
+  let needsClipping = false;
+  for (let i = 0; i < count; i++) {
+    const distance = (mvp[2] + mvp[3]) * mesh.positions[i * 3] + (mvp[6] + mvp[7]) * mesh.positions[i * 3 + 1] + (mvp[10] + mvp[11]) * mesh.positions[i * 3 + 2] + mvp[14] + mvp[15];
+    distances[i] = distance;
+    if (!(distance >= 0)) needsClipping = true;
+  }
+  if (!needsClipping) return mesh;
+  const positions = Array.from(mesh.positions);
+  const normals = mesh.normals ? Array.from(mesh.normals) : null;
+  const uvs = mesh.uvs ? Array.from(mesh.uvs) : null;
+  const colors = mesh.colors ? Array.from(mesh.colors) : null;
+  const indices = [];
+  const sourceIndices = mesh.indices ?? Uint32Array.from({ length: count }, (_, i) => i);
+  const intersections = /* @__PURE__ */ new Map();
+  const intersect = (a, b) => {
+    if (a > b) [a, b] = [b, a];
+    if (distances[a] === 0) return a;
+    if (distances[b] === 0) return b;
+    const key = `${a}:${b}`;
+    const cached = intersections.get(key);
+    if (cached !== void 0) return cached;
+    const t = distances[a] / (distances[a] - distances[b]);
+    const index = positions.length / 3;
+    const interpolate = (values, size) => {
+      if (!values) return;
+      for (let k = 0; k < size; k++) {
+        const start = values[a * size + k];
+        values.push(start + t * (values[b * size + k] - start));
+      }
+    };
+    interpolate(positions, 3);
+    interpolate(normals, 3);
+    interpolate(uvs, 2);
+    interpolate(colors, 3);
+    intersections.set(key, index);
+    return index;
+  };
+  for (let i = 0; i < sourceIndices.length; i += 3) {
+    const triangle = [
+      sourceIndices[i],
+      sourceIndices[i + 1],
+      sourceIndices[i + 2]
+    ];
+    if (triangle.some((vertex) => !Number.isFinite(distances[vertex]))) continue;
+    const polygon = [];
+    for (let j = 0; j < 3; j++) {
+      const a = triangle[j];
+      const b = triangle[(j + 1) % 3];
+      const aInside = distances[a] >= 0;
+      const bInside = distances[b] >= 0;
+      if (aInside) polygon.push(a);
+      if (aInside !== bInside) polygon.push(intersect(a, b));
+    }
+    for (let j = 1; j + 1 < polygon.length; j++) {
+      indices.push(polygon[0], polygon[j], polygon[j + 1]);
+    }
+  }
+  return {
+    ...mesh,
+    positions: new Float32Array(positions),
+    normals: normals ? new Float32Array(normals) : null,
+    uvs: uvs ? new Float32Array(uvs) : null,
+    colors: colors ? new Float32Array(colors) : null,
+    indices: new Uint32Array(indices)
+  };
+}
+
 // lib/render/SoftwareRenderer.ts
 var SoftwareRenderer = class {
   width;
@@ -676,15 +753,15 @@ var SoftwareRenderer = class {
     return out;
   }
   drawMesh(mesh, camera, light, material, cullBackFaces = true, gammaOut = true) {
-    const { positions, normals, uvs, indices, model, colors } = mesh;
+    let { positions, normals, uvs, indices, model, colors } = mesh;
     const view = camera.view;
     const proj = camera.proj;
     const mvp = mat43.create();
     mat43.multiply(mvp, proj, mat43.multiply(mat43.create(), view, model));
     const normalMat = mat3.create();
     mat3.normalFromMat4(normalMat, model);
-    const vertexCount = positions.length / 3 | 0;
-    const idx = indices ?? (() => {
+    let vertexCount = positions.length / 3 | 0;
+    let idx = indices ?? (() => {
       const a = new Uint32Array(vertexCount);
       for (let i = 0; i < vertexCount; i++) a[i] = i;
       return a;
@@ -693,6 +770,16 @@ var SoftwareRenderer = class {
     if (!useNormals) {
       useNormals = computeSmoothNormals(positions, idx);
     }
+    const clipped = clipMeshToNearPlane(
+      { ...mesh, normals: useNormals, indices: idx },
+      mvp
+    );
+    positions = clipped.positions;
+    useNormals = clipped.normals;
+    uvs = clipped.uvs;
+    colors = clipped.colors;
+    idx = clipped.indices;
+    vertexCount = positions.length / 3;
     const vScreen = new Array(vertexCount);
     const vInvW = new Float32Array(vertexCount);
     const vNDCz = new Float32Array(vertexCount);
@@ -808,7 +895,12 @@ var SoftwareRenderer = class {
               uvp[0],
               uvp[1]
             );
-            baseColor = mulColor(baseColor, texel);
+            baseColor = mulColor(baseColor, [
+              srgbDecodeToLinear01(texel[0]),
+              srgbDecodeToLinear01(texel[1]),
+              srgbDecodeToLinear01(texel[2]),
+              texel[3]
+            ]);
           }
           const [cr, cg, cb] = this.perspInterp(cs, invW, [l0, l1, l2]);
           baseColor = [

package/package.json

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