protosprite-geom 0.2.1 → 0.2.2

package/src/core/data.ts

@@ -9,8 +9,12 @@ import {
   FrameGeometrySchema,
   FrameLayerGeometry,
   FrameLayerGeometrySchema,
+  IndexedPolygon,
+  IndexedPolygonSchema,
   Polygon,
   PolygonSchema,
+  ShapePoolEntry,
+  ShapePoolEntrySchema,
   SpriteGeometry,
   SpriteGeometryEntry,
   SpriteGeometryEntrySchema,
@@ -89,70 +93,102 @@ export class ConvexDecompositionData {
   }
 }
 
+export class IndexedPolygonData {
+  public vertexIndices: number[] = [];
+
+  static fromProto(proto: IndexedPolygon) {
+    const instance = new IndexedPolygonData();
+    instance.vertexIndices = [...proto.vertexIndices];
+    return instance;
+  }
+
+  toProto(protoIn?: IndexedPolygon) {
+    const proto = protoIn ?? create(IndexedPolygonSchema);
+    proto.vertexIndices = [...this.vertexIndices];
+    return proto;
+  }
+
+  clone() {
+    const other = new IndexedPolygonData();
+    other.vertexIndices = [...this.vertexIndices];
+    return other;
+  }
+}
+
+export class ShapePoolEntryData {
+  public polygon: IndexedPolygonData = new IndexedPolygonData();
+  public convexDecompositionComponents: IndexedPolygonData[] = [];
+
+  static fromProto(proto: ShapePoolEntry) {
+    const instance = new ShapePoolEntryData();
+    if (proto.polygon) {
+      instance.polygon = IndexedPolygonData.fromProto(proto.polygon);
+    }
+    instance.convexDecompositionComponents = proto.convexDecompositionComponents.map(
+      IndexedPolygonData.fromProto
+    );
+    return instance;
+  }
+
+  toProto(protoIn?: ShapePoolEntry) {
+    const proto = protoIn ?? create(ShapePoolEntrySchema);
+    proto.polygon = this.polygon.toProto();
+    proto.convexDecompositionComponents = this.convexDecompositionComponents.map((c) => c.toProto());
+    return proto;
+  }
+
+  clone() {
+    const other = new ShapePoolEntryData();
+    other.polygon = this.polygon.clone();
+    other.convexDecompositionComponents = this.convexDecompositionComponents.map((c) => c.clone());
+    return other;
+  }
+}
+
 export class FrameLayerGeometryData {
   public layerIndex = 0;
-  public polygons: PolygonData[] = [];
-  public convexDecompositions: ConvexDecompositionData[] = [];
+  public shapeIndices: number[] = [];
 
   static fromProto(proto: FrameLayerGeometry) {
     const instance = new FrameLayerGeometryData();
     instance.layerIndex = proto.layerIndex;
-    instance.polygons = proto.polygons.map(PolygonData.fromProto);
-    instance.convexDecompositions = proto.convexDecompositions.map(
-      ConvexDecompositionData.fromProto
-    );
+    instance.shapeIndices = [...proto.shapeIndices];
     return instance;
   }
 
   toProto(protoIn?: FrameLayerGeometry) {
     const proto = protoIn ?? create(FrameLayerGeometrySchema);
     proto.layerIndex = this.layerIndex;
-    proto.polygons = this.polygons.map((p) => p.toProto());
-    proto.convexDecompositions = this.convexDecompositions.map((d) =>
-      d.toProto()
-    );
+    proto.shapeIndices = [...this.shapeIndices];
     return proto;
   }
 
   clone() {
     const other = new FrameLayerGeometryData();
     other.layerIndex = this.layerIndex;
-    other.polygons = this.polygons.map((p) => p.clone());
-    other.convexDecompositions = this.convexDecompositions.map((d) =>
-      d.clone()
-    );
+    other.shapeIndices = [...this.shapeIndices];
     return other;
   }
 }
 
 export class CompositeFrameGeometryData {
-  public polygons: PolygonData[] = [];
-  public convexDecompositions: ConvexDecompositionData[] = [];
+  public shapeIndices: number[] = [];
 
   static fromProto(proto: CompositeFrameGeometry) {
     const instance = new CompositeFrameGeometryData();
-    instance.polygons = proto.polygons.map(PolygonData.fromProto);
-    instance.convexDecompositions = proto.convexDecompositions.map(
-      ConvexDecompositionData.fromProto
-    );
+    instance.shapeIndices = [...proto.shapeIndices];
     return instance;
   }
 
   toProto(protoIn?: CompositeFrameGeometry) {
     const proto = protoIn ?? create(CompositeFrameGeometrySchema);
-    proto.polygons = this.polygons.map((p) => p.toProto());
-    proto.convexDecompositions = this.convexDecompositions.map((d) =>
-      d.toProto()
-    );
+    proto.shapeIndices = [...this.shapeIndices];
     return proto;
   }
 
   clone() {
     const other = new CompositeFrameGeometryData();
-    other.polygons = this.polygons.map((p) => p.clone());
-    other.convexDecompositions = this.convexDecompositions.map((d) =>
-      d.clone()
-    );
+    other.shapeIndices = [...this.shapeIndices];
     return other;
   }
 }
@@ -193,12 +229,16 @@ export class SpriteGeometryEntryData {
   public spriteName = "";
   public frames: FrameGeometryData[] = [];
   public simplifyTolerance = 1.0;
+  public shapePool: ShapePoolEntryData[] = [];
+  public vertexPool: Vec2Data[] = [];
 
   static fromProto(proto: SpriteGeometryEntry) {
     const instance = new SpriteGeometryEntryData();
     instance.spriteName = proto.spriteName;
     instance.frames = proto.frames.map(FrameGeometryData.fromProto);
     instance.simplifyTolerance = proto.simplifyTolerance;
+    instance.shapePool = proto.shapePool.map(ShapePoolEntryData.fromProto);
+    instance.vertexPool = proto.vertexPool.map(Vec2Data.fromProto);
     return instance;
   }
 
@@ -207,6 +247,8 @@ export class SpriteGeometryEntryData {
     proto.spriteName = this.spriteName;
     proto.frames = this.frames.map((f) => f.toProto());
     proto.simplifyTolerance = this.simplifyTolerance;
+    proto.shapePool = this.shapePool.map((s) => s.toProto());
+    proto.vertexPool = this.vertexPool.map((v) => v.toProto());
     return proto;
   }
 
@@ -215,6 +257,8 @@ export class SpriteGeometryEntryData {
     other.spriteName = this.spriteName;
     other.frames = this.frames.map((f) => f.clone());
     other.simplifyTolerance = this.simplifyTolerance;
+    other.shapePool = this.shapePool.map((s) => s.clone());
+    other.vertexPool = this.vertexPool.map((v) => v.clone());
     return other;
   }
 }

package/src/core/index.ts

@@ -8,6 +8,8 @@ export {
   Vec2Data,
   PolygonData,
   ConvexDecompositionData,
+  IndexedPolygonData,
+  ShapePoolEntryData,
   FrameLayerGeometryData,
   CompositeFrameGeometryData,
   FrameGeometryData,
@@ -16,3 +18,9 @@ export {
 } from "./data.js";
 
 export type { SpriteSourceData } from "./data.js";
+
+export type {
+  ResolvedLayerGeometry,
+  ResolvedCompositeGeometry,
+  ResolvedFrameGeometry
+} from "./protosprite-geom.js";

package/src/core/protosprite-geom.ts

@@ -1,7 +1,14 @@
 import { fromBinary, toBinary, toJson } from "@bufbuild/protobuf";
 import { ProtoSpriteSheet } from "protosprite-core";
 import { SpriteGeometrySchema } from "../../proto_dist/sprite_geometry_pb.js";
-import { SpriteGeometryData } from "./data.js";
+import {
+  ConvexDecompositionData,
+  IndexedPolygonData,
+  PolygonData,
+  SpriteGeometryData,
+  SpriteGeometryEntryData,
+  Vec2Data
+} from "./data.js";
 import fs from "fs";
 
 export class ProtoSpriteGeometry {
@@ -68,4 +75,83 @@ export class ProtoSpriteGeometry {
       };
     }
   }
+
+  getEntry(spriteName: string): SpriteGeometryEntryData | undefined {
+    return this.data.entries.find((e) => e.spriteName === spriteName);
+  }
+
+  getFrameGeometry(
+    spriteName: string,
+    frameIndex: number
+  ): ResolvedFrameGeometry | undefined {
+    const entry = this.getEntry(spriteName);
+    if (!entry) return undefined;
+
+    const frameGeom = entry.frames.find((f) => f.frameIndex === frameIndex);
+    if (!frameGeom) return undefined;
+
+    const shapePool = entry.shapePool;
+    const vertexPool = entry.vertexPool;
+
+    const resolveIndexedPolygon = (indexed: IndexedPolygonData): PolygonData => {
+      const poly = new PolygonData();
+      poly.vertices = indexed.vertexIndices.map((vi) => vertexPool[vi]);
+      return poly;
+    };
+
+    const resolveShape = (idx: number): { polygon: PolygonData; decomposition: ConvexDecompositionData } | undefined => {
+      const shape = shapePool[idx];
+      if (!shape) return undefined;
+      const polygon = resolveIndexedPolygon(shape.polygon);
+      const decomposition = new ConvexDecompositionData();
+      decomposition.components = shape.convexDecompositionComponents.map(resolveIndexedPolygon);
+      return { polygon, decomposition };
+    };
+
+    const layers: ResolvedLayerGeometry[] = frameGeom.layers.map((layer) => {
+      const polygons: PolygonData[] = [];
+      const convexDecompositions: ConvexDecompositionData[] = [];
+      for (const idx of layer.shapeIndices) {
+        const resolved = resolveShape(idx);
+        if (resolved) {
+          polygons.push(resolved.polygon);
+          convexDecompositions.push(resolved.decomposition);
+        }
+      }
+      return { layerIndex: layer.layerIndex, polygons, convexDecompositions };
+    });
+
+    let composite: ResolvedCompositeGeometry | undefined;
+    if (frameGeom.composite) {
+      const polygons: PolygonData[] = [];
+      const convexDecompositions: ConvexDecompositionData[] = [];
+      for (const idx of frameGeom.composite.shapeIndices) {
+        const resolved = resolveShape(idx);
+        if (resolved) {
+          polygons.push(resolved.polygon);
+          convexDecompositions.push(resolved.decomposition);
+        }
+      }
+      composite = { polygons, convexDecompositions };
+    }
+
+    return { frameIndex: frameGeom.frameIndex, layers, composite };
+  }
+}
+
+export interface ResolvedLayerGeometry {
+  layerIndex: number;
+  polygons: PolygonData[];
+  convexDecompositions: ConvexDecompositionData[];
+}
+
+export interface ResolvedCompositeGeometry {
+  polygons: PolygonData[];
+  convexDecompositions: ConvexDecompositionData[];
+}
+
+export interface ResolvedFrameGeometry {
+  frameIndex: number;
+  layers: ResolvedLayerGeometry[];
+  composite?: ResolvedCompositeGeometry;
 }

package/src/trace/index.ts

@@ -12,9 +12,12 @@ import {
   ConvexDecompositionData,
   FrameGeometryData,
   FrameLayerGeometryData,
+  IndexedPolygonData,
   PolygonData,
+  ShapePoolEntryData,
   SpriteGeometryData,
-  SpriteGeometryEntryData
+  SpriteGeometryEntryData,
+  Vec2Data
 } from "../core/data.js";
 import { decomposeConvex } from "./convex.js";
 import { simplifyPolygon } from "./simplify.js";
@@ -90,6 +93,67 @@ function traceAndProcess(
   return { polygons, convexDecompositions };
 }
 
+class VertexPoolBuilder {
+  private pool: Vec2Data[] = [];
+  private hashMap = new Map<string, number>();
+
+  addVertex(v: Vec2Data): number {
+    const key = `${v.x},${v.y}`;
+    const existing = this.hashMap.get(key);
+    if (existing !== undefined) {
+      return existing;
+    }
+    const index = this.pool.length;
+    this.pool.push(v);
+    this.hashMap.set(key, index);
+    return index;
+  }
+
+  getPool(): Vec2Data[] {
+    return this.pool;
+  }
+}
+
+class ShapePoolBuilder {
+  private pool: ShapePoolEntryData[] = [];
+  private hashMap = new Map<string, number>();
+  private vertexBuilder: VertexPoolBuilder;
+
+  constructor(vertexBuilder: VertexPoolBuilder) {
+    this.vertexBuilder = vertexBuilder;
+  }
+
+  private indexPolygon(polygon: PolygonData): IndexedPolygonData {
+    const indexed = new IndexedPolygonData();
+    indexed.vertexIndices = polygon.vertices.map((v) => this.vertexBuilder.addVertex(v));
+    return indexed;
+  }
+
+  private hashIndexedPolygon(indexed: IndexedPolygonData): string {
+    return indexed.vertexIndices.join(";");
+  }
+
+  addShape(polygon: PolygonData, decomposition: ConvexDecompositionData): number {
+    const indexedPolygon = this.indexPolygon(polygon);
+    const key = this.hashIndexedPolygon(indexedPolygon);
+    const existing = this.hashMap.get(key);
+    if (existing !== undefined) {
+      return existing;
+    }
+    const index = this.pool.length;
+    const entry = new ShapePoolEntryData();
+    entry.polygon = indexedPolygon;
+    entry.convexDecompositionComponents = decomposition.components.map((c) => this.indexPolygon(c));
+    this.pool.push(entry);
+    this.hashMap.set(key, index);
+    return index;
+  }
+
+  getPool(): ShapePoolEntryData[] {
+    return this.pool;
+  }
+}
+
 export async function traceSpriteSheet(
   sheet: ProtoSpriteSheet,
   options: TraceSpriteSheetOptions
@@ -115,6 +179,9 @@ export async function traceSpriteSheet(
     entry.spriteName = sprite.data.name;
     entry.simplifyTolerance = tolerance;
 
+    const vertexBuilder = new VertexPoolBuilder();
+    const poolBuilder = new ShapePoolBuilder(vertexBuilder);
+
     // Try sprite-level pixel source, fall back to sheet image.
     let spriteImg = sheetImg;
     if (sprite.data.pixelSource) {
@@ -176,8 +243,11 @@ export async function traceSpriteSheet(
             }
           }
 
-          layerGeom.polygons = polygons;
-          layerGeom.convexDecompositions = convexDecompositions;
+          const shapeIndices: number[] = [];
+          for (let i = 0; i < polygons.length; i++) {
+            shapeIndices.push(poolBuilder.addShape(polygons[i], convexDecompositions[i]));
+          }
+          layerGeom.shapeIndices = shapeIndices;
           frameGeom.layers.push(layerGeom);
         }
       }
@@ -202,14 +272,19 @@ export async function traceSpriteSheet(
         );
 
         const compositeGeom = new CompositeFrameGeometryData();
-        compositeGeom.polygons = polygons;
-        compositeGeom.convexDecompositions = convexDecompositions;
+        const shapeIndices: number[] = [];
+        for (let i = 0; i < polygons.length; i++) {
+          shapeIndices.push(poolBuilder.addShape(polygons[i], convexDecompositions[i]));
+        }
+        compositeGeom.shapeIndices = shapeIndices;
         frameGeom.composite = compositeGeom;
       }
 
       entry.frames.push(frameGeom);
     }
 
+    entry.shapePool = poolBuilder.getPool();
+    entry.vertexPool = vertexBuilder.getPool();
     result.entries.push(entry);
   }