Animated n.rel geometry is now parsed and rendered (without animations).

lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/AreaRenderGeometry.kt

@@ -15,6 +15,7 @@ class RenderSection(
     val position: Vec3,
     val rotation: Vec3,
     val objects: List<XjObject>,
+    val animatedObjects: List<XjObject>,
 )
 
 fun parseAreaRenderGeometry(cursor: Cursor): RenderGeometry {
@@ -30,6 +31,8 @@ fun parseAreaRenderGeometry(cursor: Cursor): RenderGeometry {
     val sectionTableOffset = cursor.int()
     // val textureNameOffset = cursor.int()
 
+    val xjObjectCache = mutableMapOf<Int, List<XjObject>>()
+
     for (i in 0 until sectionCount) {
         cursor.seekStart(sectionTableOffset + 52 * i)
 
@@ -41,19 +44,28 @@ fun parseAreaRenderGeometry(cursor: Cursor): RenderGeometry {
             angleToRad(cursor.int()),
         )
 
-        cursor.seek(4)
+        cursor.seek(4) // Radius?
 
         val simpleGeometryOffsetTableOffset = cursor.int()
-//         val animatedGeometryOffsetTableOffset = cursor.int()
+        val animatedGeometryOffsetTableOffset = cursor.int()
-        cursor.seek(4)
         val simpleGeometryOffsetCount = cursor.int()
-//         val animatedGeometryOffsetCount = cursor.int()
+        val animatedGeometryOffsetCount = cursor.int()
-        // Ignore animatedGeometryOffsetCount and the last 4 bytes.
+        // Ignore the last 4 bytes.
 
         val objects = parseGeometryTable(
             cursor,
+            xjObjectCache,
             simpleGeometryOffsetTableOffset,
             simpleGeometryOffsetCount,
+            animated = false,
+        )
+
+        val animatedObjects = parseGeometryTable(
+            cursor,
+            xjObjectCache,
+            animatedGeometryOffsetTableOffset,
+            animatedGeometryOffsetCount,
+            animated = true,
         )
 
         sections.add(RenderSection(
@@ -61,22 +73,25 @@ fun parseAreaRenderGeometry(cursor: Cursor): RenderGeometry {
             sectionPosition,
             sectionRotation,
             objects,
+            animatedObjects,
         ))
     }
 
     return RenderGeometry(sections)
 }
 
-// TODO: don't reparse the same objects multiple times. Create DAG instead of tree.
 private fun parseGeometryTable(
     cursor: Cursor,
+    xjObjectCache: MutableMap<Int, List<XjObject>>,
     tableOffset: Int,
     tableEntryCount: Int,
+    animated: Boolean,
 ): List<XjObject> {
+    val tableEntrySize = if (animated) 32 else 16
     val objects = mutableListOf<XjObject>()
 
     for (i in 0 until tableEntryCount) {
-        cursor.seekStart(tableOffset + 16 * i)
+        cursor.seekStart(tableOffset + tableEntrySize * i)
 
         var offset = cursor.int()
         cursor.seek(8)
@@ -86,8 +101,12 @@ private fun parseGeometryTable(
             offset = cursor.seekStart(offset).int()
         }
 
-        cursor.seekStart(offset)
+        objects.addAll(
-        objects.addAll(parseXjObject(cursor))
+            xjObjectCache.getOrPut(offset) {
+                cursor.seekStart(offset)
+                parseXjObject(cursor)
+            }
+        )
     }
 
     return objects

web/src/main/kotlin/world/phantasmal/web/core/rendering/conversion/NinjaGeometryConversion.kt

@@ -130,34 +130,63 @@ fun renderGeometryToGroup(
 ): Group {
     val group = Group()
     val textureCache = mutableMapOf<Int, Texture?>()
+    val meshCache = mutableMapOf<XjObject, Mesh>()
 
     for ((i, section) in renderGeometry.sections.withIndex()) {
         for (xjObj in section.objects) {
-            val builder = MeshBuilder(textures, textureCache)
+            group.add(xjObjectToMesh(
-            ninjaObjectToMeshBuilder(xjObj, builder)
+                textures, textureCache, meshCache, xjObj, i, section, processMesh,
+            ))
+        }
 
-            builder.defaultMaterial(MeshBasicMaterial(obj {
+        for (xjObj in section.animatedObjects) {
-                color = Color().setHSL((i % 7) / 7.0, 1.0, .5)
+            group.add(xjObjectToMesh(
-                transparent = true
+                textures, textureCache, meshCache, xjObj, i, section, processMesh,
-                opacity = .25
+            ))
-                side = DoubleSide
-            }))
-
-            val mesh = builder.buildMesh(boundingVolumes = true)
-
-            mesh.position.setFromVec3(section.position)
-            mesh.rotation.setFromVec3(section.rotation)
-            mesh.updateMatrixWorld()
-
-            processMesh(section, xjObj, mesh)
-
-            group.add(mesh)
         }
     }
 
     return group
 }
 
+private fun xjObjectToMesh(
+    textures: List<XvrTexture?>,
+    textureCache: MutableMap<Int, Texture?>,
+    meshCache: MutableMap<XjObject, Mesh>,
+    xjObj: XjObject,
+    index: Int,
+    section: RenderSection,
+    processMesh: (RenderSection, XjObject, Mesh) -> Unit,
+): Mesh {
+    var mesh = meshCache[xjObj]
+
+    if (mesh == null) {
+        val builder = MeshBuilder(textures, textureCache)
+        ninjaObjectToMeshBuilder(xjObj, builder)
+
+        builder.defaultMaterial(MeshBasicMaterial(obj {
+            color = Color().setHSL((index % 7) / 7.0, 1.0, .5)
+            transparent = true
+            opacity = .25
+            side = DoubleSide
+        }))
+
+        mesh = builder.buildMesh(boundingVolumes = true)
+    } else {
+        // If we already have a mesh for this XjObject, make a copy and reuse the existing buffer
+        // geometry and materials.
+        mesh = Mesh(mesh.geometry, mesh.material.unsafeCast<Array<Material>>())
+    }
+
+    mesh.position.setFromVec3(section.position)
+    mesh.rotation.setFromVec3(section.rotation)
+    mesh.updateMatrixWorld()
+
+    processMesh(section, xjObj, mesh)
+
+    return mesh
+}
+
 fun collisionGeometryToGroup(
     collisionGeometry: CollisionGeometry,
     trianglePredicate: (CollisionTriangle) -> Boolean = { true },