Refactored area collision detection geometry parsing code.

src/data_formats/BufferCursor.ts

@@ -32,10 +32,14 @@ export class BufferCursor {
         this._size = size;
     }
 
+    private _position: number;
+
     /**
      * The position from where bytes will be read or written.
      */
-    position: number;
+    get position(): number {
+        return this._position;
+    }
 
     private _little_endian: boolean = false;
 
@@ -66,33 +70,37 @@ export class BufferCursor {
         return this.buffer.byteLength;
     }
 
-    buffer: ArrayBuffer;
+    private _buffer: ArrayBuffer;
+
+    get buffer(): ArrayBuffer {
+        return this._buffer;
+    }
 
     private dv: DataView;
     private utf16_decoder: TextDecoder = UTF_16BE_DECODER;
     private utf16_encoder: TextEncoder = UTF_16BE_ENCODER;
 
     /**
-     * @param buffer_or_capacity - If an ArrayBuffer or Buffer is given, writes to the cursor will be reflected in this buffer and vice versa until a cursor write that requires allocating a new internal buffer happens
+     * @param buffer_or_capacity - If an ArrayBuffer or Buffer is given, writes to the cursor will be reflected in this buffer and vice versa until a cursor write that requires allocating a new internal buffer happens.
-     * @param little_endian - Decides in which byte order multi-byte integers and floats will be interpreted
+     * @param little_endian - Decides in which byte order multi-byte integers and floats will be interpreted.
      */
     constructor(buffer_or_capacity: ArrayBuffer | Buffer | number, little_endian: boolean = false) {
         if (typeof buffer_or_capacity === "number") {
-            this.buffer = new ArrayBuffer(buffer_or_capacity);
+            this._buffer = new ArrayBuffer(buffer_or_capacity);
             this.size = 0;
         } else if (buffer_or_capacity instanceof ArrayBuffer) {
-            this.buffer = buffer_or_capacity;
+            this._buffer = buffer_or_capacity;
             this.size = buffer_or_capacity.byteLength;
         } else if (buffer_or_capacity instanceof Buffer) {
             // Use the backing ArrayBuffer.
-            this.buffer = buffer_or_capacity.buffer;
+            this._buffer = buffer_or_capacity.buffer;
             this.size = buffer_or_capacity.byteLength;
         } else {
             throw new Error("buffer_or_capacity should be an ArrayBuffer, a Buffer or a number.");
         }
 
         this.little_endian = little_endian;
-        this.position = 0;
+        this._position = 0;
         this.dv = new DataView(this.buffer);
     }
 
@@ -115,7 +123,7 @@ export class BufferCursor {
             throw new Error(`Offset ${offset} is out of bounds.`);
         }
 
-        this.position = offset;
+        this._position = offset;
         return this;
     }
 
@@ -129,7 +137,7 @@ export class BufferCursor {
             throw new Error(`Offset ${offset} is out of bounds.`);
         }
 
-        this.position = this.size - offset;
+        this._position = this.size - offset;
         return this;
     }
 
@@ -137,7 +145,7 @@ export class BufferCursor {
      * Reads an unsigned 8-bit integer and increments position by 1.
      */
     u8(): number {
-        return this.dv.getUint8(this.position++);
+        return this.dv.getUint8(this._position++);
     }
 
     /**
@@ -145,7 +153,7 @@ export class BufferCursor {
      */
     u16(): number {
         const r = this.dv.getUint16(this.position, this.little_endian);
-        this.position += 2;
+        this._position += 2;
         return r;
     }
 
@@ -154,7 +162,7 @@ export class BufferCursor {
      */
     u32(): number {
         const r = this.dv.getUint32(this.position, this.little_endian);
-        this.position += 4;
+        this._position += 4;
         return r;
     }
 
@@ -162,7 +170,7 @@ export class BufferCursor {
      * Reads an signed 8-bit integer and increments position by 1.
      */
     i8(): number {
-        return this.dv.getInt8(this.position++);
+        return this.dv.getInt8(this._position++);
     }
 
     /**
@@ -170,7 +178,7 @@ export class BufferCursor {
      */
     i16(): number {
         const r = this.dv.getInt16(this.position, this.little_endian);
-        this.position += 2;
+        this._position += 2;
         return r;
     }
 
@@ -179,7 +187,7 @@ export class BufferCursor {
      */
     i32(): number {
         const r = this.dv.getInt32(this.position, this.little_endian);
-        this.position += 4;
+        this._position += 4;
         return r;
     }
 
@@ -188,7 +196,7 @@ export class BufferCursor {
      */
     f32(): number {
         const r = this.dv.getFloat32(this.position, this.little_endian);
-        this.position += 4;
+        this._position += 4;
         return r;
     }
 
@@ -197,7 +205,7 @@ export class BufferCursor {
      */
     u8_array(n: number): number[] {
         const array = [];
-        for (let i = 0; i < n; ++i) array.push(this.dv.getUint8(this.position++));
+        for (let i = 0; i < n; ++i) array.push(this.dv.getUint8(this._position++));
         return array;
     }
 
@@ -209,7 +217,7 @@ export class BufferCursor {
 
         for (let i = 0; i < n; ++i) {
             array.push(this.dv.getUint16(this.position, this.little_endian));
-            this.position += 2;
+            this._position += 2;
         }
 
         return array;
@@ -223,7 +231,7 @@ export class BufferCursor {
 
         for (let i = 0; i < n; ++i) {
             array.push(this.dv.getUint32(this.position, this.little_endian));
-            this.position += 4;
+            this._position += 4;
         }
 
         return array;
@@ -240,7 +248,7 @@ export class BufferCursor {
             throw new Error(`Size ${size} out of bounds.`);
         }
 
-        this.position += size;
+        this._position += size;
         return new BufferCursor(
             this.buffer.slice(this.position - size, this.position),
             this.little_endian
@@ -260,7 +268,7 @@ export class BufferCursor {
             : max_byte_length;
 
         const r = ASCII_DECODER.decode(new DataView(this.buffer, this.position, string_length));
-        this.position += drop_remaining
+        this._position += drop_remaining
             ? max_byte_length
             : Math.min(string_length + 1, max_byte_length);
         return r;
@@ -281,7 +289,7 @@ export class BufferCursor {
         const r = this.utf16_decoder.decode(
             new DataView(this.buffer, this.position, string_length)
         );
-        this.position += drop_remaining
+        this._position += drop_remaining
             ? max_byte_length
             : Math.min(string_length + 2, max_byte_length);
         return r;
@@ -293,7 +301,7 @@ export class BufferCursor {
     write_u8(value: number): BufferCursor {
         this.ensure_capacity(this.position + 1);
 
-        this.dv.setUint8(this.position++, value);
+        this.dv.setUint8(this._position++, value);
 
         if (this.position > this.size) {
             this.size = this.position;
@@ -309,7 +317,7 @@ export class BufferCursor {
         this.ensure_capacity(this.position + 2);
 
         this.dv.setUint16(this.position, value, this.little_endian);
-        this.position += 2;
+        this._position += 2;
 
         if (this.position > this.size) {
             this.size = this.position;
@@ -325,7 +333,7 @@ export class BufferCursor {
         this.ensure_capacity(this.position + 4);
 
         this.dv.setUint32(this.position, value, this.little_endian);
-        this.position += 4;
+        this._position += 4;
 
         if (this.position > this.size) {
             this.size = this.position;
@@ -341,7 +349,7 @@ export class BufferCursor {
         this.ensure_capacity(this.position + 4);
 
         this.dv.setInt32(this.position, value, this.little_endian);
-        this.position += 4;
+        this._position += 4;
 
         if (this.position > this.size) {
             this.size = this.position;
@@ -357,7 +365,7 @@ export class BufferCursor {
         this.ensure_capacity(this.position + 4);
 
         this.dv.setFloat32(this.position, value, this.little_endian);
-        this.position += 4;
+        this._position += 4;
 
         if (this.position > this.size) {
             this.size = this.position;
@@ -373,7 +381,7 @@ export class BufferCursor {
         this.ensure_capacity(this.position + array.length);
 
         new Uint8Array(this.buffer, this.position).set(new Uint8Array(array));
-        this.position += array.length;
+        this._position += array.length;
 
         if (this.position > this.size) {
             this.size = this.position;
@@ -389,7 +397,7 @@ export class BufferCursor {
         this.ensure_capacity(this.position + other.size);
 
         new Uint8Array(this.buffer, this.position).set(new Uint8Array(other.buffer));
-        this.position += other.size;
+        this._position += other.size;
 
         if (this.position > this.size) {
             this.size = this.position;
@@ -460,7 +468,7 @@ export class BufferCursor {
 
             const new_buffer = new ArrayBuffer(new_size);
             new Uint8Array(new_buffer).set(new Uint8Array(this.buffer, 0, this.size));
-            this.buffer = new_buffer;
+            this._buffer = new_buffer;
             this.dv = new DataView(this.buffer);
         }
     }

src/data_formats/encryption/prc.ts

@@ -43,7 +43,7 @@ class PrcDecryptor {
             out_cursor.write_u32(this.decrypt_u32(u32));
         }
 
-        out_cursor.position = 0;
+        out_cursor.seek_start(0);
         out_cursor.size = actual_size;
         return out_cursor;
     }

src/data_formats/parsing/area_collision_geometry.ts

@@ -0,0 +1,85 @@
+import { BufferCursor } from "../BufferCursor";
+import { Vec3 } from "../Vec3";
+
+export type CollisionObject = {
+    meshes: CollisionMesh[];
+};
+
+export type CollisionMesh = {
+    vertices: Vec3[];
+    triangles: CollisionTriangle[];
+};
+
+export type CollisionTriangle = {
+    indices: [number, number, number];
+    flags: number;
+    normal: Vec3;
+};
+
+export function parse_area_collision_geometry(cursor: BufferCursor): CollisionObject {
+    cursor.seek_end(16);
+    const main_block_offset = cursor.u32();
+    cursor.seek_start(main_block_offset);
+    const main_offset_table_offset = cursor.u32();
+    cursor.seek_start(main_offset_table_offset);
+
+    const object: CollisionObject = {
+        meshes: [],
+    };
+
+    while (cursor.bytes_left) {
+        const start_pos = cursor.position;
+
+        const block_trailer_offset = cursor.u32();
+
+        if (block_trailer_offset === 0) {
+            break;
+        }
+
+        const mesh: CollisionMesh = {
+            vertices: [],
+            triangles: [],
+        };
+        object.meshes.push(mesh);
+
+        cursor.seek_start(block_trailer_offset);
+
+        const vertex_count = cursor.u32();
+        const vertex_table_offset = cursor.u32();
+        const triangle_count = cursor.u32();
+        const triangle_table_offset = cursor.u32();
+
+        cursor.seek_start(vertex_table_offset);
+
+        for (let i = 0; i < vertex_count; i++) {
+            const x = cursor.f32();
+            const y = cursor.f32();
+            const z = cursor.f32();
+
+            mesh.vertices.push(new Vec3(x, y, z));
+        }
+
+        cursor.seek_start(triangle_table_offset);
+
+        for (let i = 0; i < triangle_count; i++) {
+            const v1 = cursor.u16();
+            const v2 = cursor.u16();
+            const v3 = cursor.u16();
+            const flags = cursor.u16();
+            const n_x = cursor.f32();
+            const n_y = cursor.f32();
+            const n_z = cursor.f32();
+            cursor.seek(16);
+
+            mesh.triangles.push({
+                indices: [v1, v2, v3],
+                flags,
+                normal: new Vec3(n_x, n_y, n_z),
+            });
+        }
+
+        cursor.seek_start(start_pos + 24);
+    }
+
+    return object;
+}

src/data_formats/parsing/area_geometry.ts

@@ -2,131 +2,19 @@ import Logger from "js-logger";
 import {
     BufferGeometry,
     DoubleSide,
-    Face3,
     Float32BufferAttribute,
-    Geometry,
     Mesh,
-    MeshBasicMaterial,
     MeshLambertMaterial,
     Object3D,
     TriangleStripDrawMode,
     Uint16BufferAttribute,
-    Vector3,
 } from "three";
 import { Section } from "../../domain";
 import { Vec3 } from "../Vec3";
 
-const logger = Logger.get("data_formats/parsing/geometry");
+const logger = Logger.get("data_formats/parsing/area_geometry");
 
-export function parse_c_rel(array_buffer: ArrayBuffer): Object3D {
+export function parse_area_geometry(
-    const dv = new DataView(array_buffer);
-
-    const object = new Object3D();
-    const materials = [
-        // Wall
-        new MeshBasicMaterial({
-            color: 0x80c0d0,
-            transparent: true,
-            opacity: 0.25,
-        }),
-        // Ground
-        new MeshLambertMaterial({
-            color: 0x50d0d0,
-            side: DoubleSide,
-        }),
-        // Vegetation
-        new MeshLambertMaterial({
-            color: 0x50b070,
-            side: DoubleSide,
-        }),
-        // Section transition zone
-        new MeshLambertMaterial({
-            color: 0x604080,
-            side: DoubleSide,
-        }),
-    ];
-    const wireframe_materials = [
-        // Wall
-        new MeshBasicMaterial({
-            color: 0x90d0e0,
-            wireframe: true,
-            transparent: true,
-            opacity: 0.3,
-        }),
-        // Ground
-        new MeshBasicMaterial({
-            color: 0x60f0f0,
-            wireframe: true,
-        }),
-        // Vegetation
-        new MeshBasicMaterial({
-            color: 0x60c080,
-            wireframe: true,
-        }),
-        // Section transition zone
-        new MeshBasicMaterial({
-            color: 0x705090,
-            wireframe: true,
-        }),
-    ];
-
-    const main_block_offset = dv.getUint32(dv.byteLength - 16, true);
-    const main_offset_table_offset = dv.getUint32(main_block_offset, true);
-
-    for (
-        let i = main_offset_table_offset;
-        i === main_offset_table_offset || dv.getUint32(i) !== 0;
-        i += 24
-    ) {
-        const block_geometry = new Geometry();
-
-        const block_trailer_offset = dv.getUint32(i, true);
-        const vertex_count = dv.getUint32(block_trailer_offset, true);
-        const vertex_table_offset = dv.getUint32(block_trailer_offset + 4, true);
-        const vertex_table_end = vertex_table_offset + 12 * vertex_count;
-        const triangle_count = dv.getUint32(block_trailer_offset + 8, true);
-        const triangle_table_offset = dv.getUint32(block_trailer_offset + 12, true);
-        const triangle_table_end = triangle_table_offset + 36 * triangle_count;
-
-        for (let j = vertex_table_offset; j < vertex_table_end; j += 12) {
-            const x = dv.getFloat32(j, true);
-            const y = dv.getFloat32(j + 4, true);
-            const z = dv.getFloat32(j + 8, true);
-
-            block_geometry.vertices.push(new Vector3(x, y, z));
-        }
-
-        for (let j = triangle_table_offset; j < triangle_table_end; j += 36) {
-            const v1 = dv.getUint16(j, true);
-            const v2 = dv.getUint16(j + 2, true);
-            const v3 = dv.getUint16(j + 4, true);
-            const flags = dv.getUint16(j + 6, true);
-            const n = new Vector3(
-                dv.getFloat32(j + 8, true),
-                dv.getFloat32(j + 12, true),
-                dv.getFloat32(j + 16, true)
-            );
-            const is_section_transition = flags & 0b1000000;
-            const is_vegetation = flags & 0b10000;
-            const is_ground = flags & 0b1;
-            const color_index = is_section_transition ? 3 : is_vegetation ? 2 : is_ground ? 1 : 0;
-
-            block_geometry.faces.push(new Face3(v1, v2, v3, n, undefined, color_index));
-        }
-
-        const mesh = new Mesh(block_geometry, materials);
-        mesh.renderOrder = 1;
-        object.add(mesh);
-
-        const wireframe_mesh = new Mesh(block_geometry, wireframe_materials);
-        wireframe_mesh.renderOrder = 2;
-        object.add(wireframe_mesh);
-    }
-
-    return object;
-}
-
-export function parse_n_rel(
     array_buffer: ArrayBuffer
 ): { sections: Section[]; object_3d: Object3D } {
     const dv = new DataView(array_buffer);

src/data_formats/parsing/ninja/njcm.ts

@@ -3,7 +3,7 @@ import { BufferCursor } from "../../BufferCursor";
 import { Vec3 } from "../../Vec3";
 import { NjVertex } from ".";
 
-const logger = Logger.get("data_formats/parsing/ninja/nj");
+const logger = Logger.get("data_formats/parsing/ninja/njcm");
 
 // TODO:
 // - textures
@@ -20,8 +20,8 @@ export type NjcmModel = {
     vertices: NjVertex[];
     meshes: NjcmTriangleStrip[];
     // materials: [],
-    bounding_sphere_center: Vec3;
+    collision_sphere_center: Vec3;
-    bounding_sphere_radius: number;
+    collision_sphere_radius: number;
 };
 
 enum NjcmChunkType {
@@ -169,8 +169,8 @@ export function parse_njcm_model(cursor: BufferCursor, cached_chunk_offsets: num
         type: "njcm",
         vertices,
         meshes,
-        bounding_sphere_center,
+        collision_sphere_center: bounding_sphere_center,
-        bounding_sphere_radius,
+        collision_sphere_radius: bounding_sphere_radius,
     };
 }
 

src/rendering/areas.ts

@@ -0,0 +1,101 @@
+import {
+    DoubleSide,
+    Face3,
+    Geometry,
+    Group,
+    Mesh,
+    MeshBasicMaterial,
+    MeshLambertMaterial,
+    Object3D,
+    Vector3,
+} from "three";
+import { CollisionObject } from "../data_formats/parsing/area_collision_geometry";
+
+const materials = [
+    // Wall
+    new MeshBasicMaterial({
+        color: 0x80c0d0,
+        transparent: true,
+        opacity: 0.25,
+    }),
+    // Ground
+    new MeshLambertMaterial({
+        color: 0x50d0d0,
+        side: DoubleSide,
+    }),
+    // Vegetation
+    new MeshLambertMaterial({
+        color: 0x50b070,
+        side: DoubleSide,
+    }),
+    // Section transition zone
+    new MeshLambertMaterial({
+        color: 0x604080,
+        side: DoubleSide,
+    }),
+];
+const wireframe_materials = [
+    // Wall
+    new MeshBasicMaterial({
+        color: 0x90d0e0,
+        wireframe: true,
+        transparent: true,
+        opacity: 0.3,
+    }),
+    // Ground
+    new MeshBasicMaterial({
+        color: 0x60f0f0,
+        wireframe: true,
+    }),
+    // Vegetation
+    new MeshBasicMaterial({
+        color: 0x60c080,
+        wireframe: true,
+    }),
+    // Section transition zone
+    new MeshBasicMaterial({
+        color: 0x705090,
+        wireframe: true,
+    }),
+];
+
+export function area_collision_geometry_to_object_3d(object: CollisionObject): Object3D {
+    const group = new Group();
+
+    for (const collision_mesh of object.meshes) {
+        // Use Geometry and not BufferGeometry for better raycaster performance.
+        const geom = new Geometry();
+
+        for (const { x, y, z } of collision_mesh.vertices) {
+            geom.vertices.push(new Vector3(x, y, z));
+        }
+
+        for (const { indices, flags, normal } of collision_mesh.triangles) {
+            const is_section_transition = flags & 0b1000000;
+            const is_vegetation = flags & 0b10000;
+            const is_ground = flags & 0b1;
+            const color_index = is_section_transition ? 3 : is_vegetation ? 2 : is_ground ? 1 : 0;
+
+            geom.faces.push(
+                new Face3(
+                    indices[0],
+                    indices[1],
+                    indices[2],
+                    new Vector3(normal.x, normal.y, normal.z),
+                    undefined,
+                    color_index
+                )
+            );
+        }
+
+        const mesh = new Mesh(geom, materials);
+        mesh.renderOrder = 1;
+        group.add(mesh);
+
+        const wireframe_mesh = new Mesh(geom, wireframe_materials);
+        wireframe_mesh.renderOrder = 2;
+        group.add(wireframe_mesh);
+    }
+
+    return group;
+}

src/rendering/entities.test.ts

@@ -1,7 +1,7 @@
-import { CylinderBufferGeometry, MeshLambertMaterial, Object3D, Vector3 } from "three";
+import { CylinderBufferGeometry, MeshLambertMaterial, Object3D } from "three";
 import { DatNpc, DatObject } from "../data_formats/parsing/quest/dat";
-import { NpcType, ObjectType, QuestNpc, QuestObject } from "../domain";
 import { Vec3 } from "../data_formats/Vec3";
+import { NpcType, ObjectType, QuestNpc, QuestObject } from "../domain";
 import { create_npc_mesh, create_object_mesh, NPC_COLOR, OBJECT_COLOR } from "./entities";
 
 const cylinder = new CylinderBufferGeometry(3, 3, 20).translate(0, 10, 0);
@@ -45,33 +45,3 @@ test("create geometry for quest NPCs", () => {
     expect(geometry.position.z).toBe(23);
     expect((geometry.material as MeshLambertMaterial).color.getHex()).toBe(NPC_COLOR);
 });
-
-test("geometry position changes when entity position changes element-wise", () => {
-    const npc = new QuestNpc(
-        7,
-        13,
-        new Vec3(17, 19, 23),
-        new Vec3(0, 0, 0),
-        NpcType.Booma,
-        {} as DatNpc
-    );
-    const geometry = create_npc_mesh(npc, cylinder);
-    npc.position = new Vec3(2, 3, 5).add(npc.position);
-
-    expect(geometry.position).toEqual(new Vector3(19, 22, 28));
-});
-
-test("geometry position changes when entire entity position changes", () => {
-    const npc = new QuestNpc(
-        7,
-        13,
-        new Vec3(17, 19, 23),
-        new Vec3(0, 0, 0),
-        NpcType.Booma,
-        {} as DatNpc
-    );
-    const geometry = create_npc_mesh(npc, cylinder);
-    npc.position = new Vec3(2, 3, 5);
-
-    expect(geometry.position).toEqual(new Vector3(2, 3, 5));
-});

src/rendering/entities.ts

@@ -32,5 +32,10 @@ function create_mesh(
     mesh.name = type;
     mesh.userData.entity = entity;
 
+    const { x, y, z } = entity.position;
+    mesh.position.set(x, y, z);
+    const rot = entity.rotation;
+    mesh.rotation.set(rot.x, rot.y, rot.z);
+
     return mesh;
 }

src/rendering/models.ts

@@ -102,7 +102,6 @@ class Object3DCreator {
         geom.addAttribute("normal", new Float32BufferAttribute(this.normals, 3));
         geom.setIndex(new Uint16BufferAttribute(this.indices, 1));
 
-        // The bounding spheres from the object seem be too small.
         geom.computeBoundingSphere();
 
         return geom;

src/stores/AreaStore.ts

@@ -1,7 +1,10 @@
-import { Area, AreaVariant, Section } from "../domain";
 import { Object3D } from "three";
-import { parse_c_rel, parse_n_rel } from "../data_formats/parsing/geometry";
+import { BufferCursor } from "../data_formats/BufferCursor";
-import { get_area_render_data, get_area_collision_data } from "./binary_assets";
+import { parse_area_collision_geometry } from "../data_formats/parsing/area_collision_geometry";
+import { parse_area_geometry } from "../data_formats/parsing/area_geometry";
+import { Area, AreaVariant, Section } from "../domain";
+import { area_collision_geometry_to_object_3d } from "../rendering/areas";
+import { get_area_collision_data, get_area_render_data } from "./binary_assets";
 
 function area(id: number, name: string, order: number, variants: number): Area {
     const area = new Area(id, name, order, []);
@@ -137,8 +140,10 @@ class AreaStore {
         if (object_3d) {
             return object_3d;
         } else {
-            const object_3d = get_area_collision_data(episode, area_id, area_variant).then(
+            const object_3d = get_area_collision_data(episode, area_id, area_variant).then(buffer =>
-                parse_c_rel
+                area_collision_geometry_to_object_3d(
+                    parse_area_collision_geometry(new BufferCursor(buffer, true))
+                )
             );
             collision_geometry_cache.set(`${area_id}-${area_variant}`, object_3d);
             return object_3d;
@@ -150,7 +155,9 @@ class AreaStore {
         area_id: number,
         area_variant: number
     ): Promise<{ sections: Section[]; object_3d: Object3D }> {
-        const promise = get_area_render_data(episode, area_id, area_variant).then(parse_n_rel);
+        const promise = get_area_render_data(episode, area_id, area_variant).then(
+            parse_area_geometry
+        );
 
         const sections = new Promise<Section[]>((resolve, reject) => {
             promise.then(({ sections }) => resolve(sections)).catch(reject);