Added various improvements.

src/data_formats/parsing/ninja/index.ts

@@ -95,6 +95,10 @@ function parse_ninja<M extends NinjaModel>(
         if (iff_type_id === 'NJCM') {
             return parse_sibling_objects(cursor.take(iff_chunk_size), parse_model, context);
         } else {
+            if (iff_chunk_size > cursor.bytes_left) {
+                break;
+            }
+
             cursor.seek(iff_chunk_size);
         }
     }

src/data_formats/parsing/ninja/nj.ts

@@ -92,8 +92,20 @@ type NjVertex = {
 }
 
 type NjTriangleStrip = {
+    ignore_light: boolean,
+    ignore_specular: boolean,
+    ignore_ambient: boolean,
+    use_alpha: boolean,
+    double_side: boolean,
+    flat_shading: boolean,
+    environment_mapping: boolean,
     clockwise_winding: boolean,
-    indices: number[],
+    vertices: NjMeshVertex[],
+}
+
+type NjMeshVertex = {
+    index: number,
+    normal?: Vec3,
 }
 
 export function parse_nj_model(cursor: BufferCursor, cached_chunk_offsets: number[]): NjModel {
@@ -227,7 +239,7 @@ function parse_chunks(
             chunks.push({
                 type: NjChunkType.Strip,
                 type_id,
-                triangle_strips: parse_triangle_strip_chunk(cursor, type_id)
+                triangle_strips: parse_triangle_strip_chunk(cursor, type_id, flags)
             });
         } else if (type_id === 255) {
             size = wide_end_chunks ? 2 : 0;
@@ -345,8 +357,18 @@ function parse_vertex_chunk(
 
 function parse_triangle_strip_chunk(
     cursor: BufferCursor,
-    chunk_type_id: number
+    chunk_type_id: number,
+    flags: number
 ): NjTriangleStrip[] {
+    const render_flags = {
+        ignore_light: (flags & 0b1) !== 0,
+        ignore_specular: (flags & 0b10) !== 0,
+        ignore_ambient: (flags & 0b100) !== 0,
+        use_alpha: (flags & 0b1000) !== 0,
+        double_side: (flags & 0b10000) !== 0,
+        flat_shading: (flags & 0b100000) !== 0,
+        environment_mapping: (flags & 0b1000000) !== 0,
+    };
     const user_offset_and_strip_count = cursor.u16();
     const user_flags_size = user_offset_and_strip_count >>> 14;
     const strip_count = user_offset_and_strip_count & 0x3FFF;
@@ -382,10 +404,13 @@ function parse_triangle_strip_chunk(
         const clockwise_winding = winding_flag_and_index_count < 1;
         const index_count = Math.abs(winding_flag_and_index_count);
 
-        const indices = [];
+        const vertices: NjMeshVertex[] = [];
 
         for (let j = 0; j < index_count; ++j) {
-            indices.push(cursor.u16());
+            const vertex: NjMeshVertex = {
+                index: cursor.u16()
+            };
+            vertices.push(vertex);
 
             if (parse_texture_coords) {
                 cursor.seek(4);
@@ -396,7 +421,11 @@ function parse_triangle_strip_chunk(
             }
 
             if (parse_normal) {
-                cursor.seek(6);
+                vertex.normal = new Vec3(
+                    cursor.u16(),
+                    cursor.u16(),
+                    cursor.u16()
+                );
             }
 
             if (parse_texture_coords_hires) {
@@ -408,7 +437,11 @@ function parse_triangle_strip_chunk(
             }
         }
 
-        strips.push({ clockwise_winding, indices });
+        strips.push({
+            ...render_flags,
+            clockwise_winding,
+            vertices,
+        });
     }
 
     return strips;

src/rendering/models.ts

@@ -188,13 +188,13 @@ class Object3DCreator {
         this.vertices.put(new_vertices);
 
         for (const mesh of model.meshes) {
-            for (let i = 0; i < mesh.indices.length; ++i) {
+            for (let i = 0; i < mesh.vertices.length; ++i) {
-                const vertex_idx = mesh.indices[i];
+                const mesh_vertex = mesh.vertices[i];
-                const vertices = this.vertices.get(vertex_idx);
+                const vertices = this.vertices.get(mesh_vertex.index);
 
                 if (vertices.length) {
                     const vertex = vertices[0];
-                    const normal = vertex.normal || DEFAULT_NORMAL;
+                    const normal = vertex.normal || mesh_vertex.normal || DEFAULT_NORMAL;
                     const index = this.positions.length / 3;
 
                     this.positions.push(vertex.position.x, vertex.position.y, vertex.position.z);

src/stores/EntityStore.ts

@@ -1,16 +1,26 @@
-import { BufferGeometry } from "three";
+import { BufferGeometry, CylinderBufferGeometry } from "three";
 import { NpcType, ObjectType } from "../domain";
 import { BufferCursor } from "../data_formats/BufferCursor";
 import { get_npc_data, get_object_data } from "./binary_assets";
 import { ninja_object_to_buffer_geometry } from "../rendering/models";
 import { parse_nj, parse_xj } from "../data_formats/parsing/ninja";
 
-const npc_cache: Map<number, Promise<BufferGeometry>> = new Map();
+const DEFAULT_ENTITY = new CylinderBufferGeometry(3, 3, 20);
-const object_cache: Map<number, Promise<BufferGeometry>> = new Map();
+DEFAULT_ENTITY.translate(0, 10, 0);
+
+const DEFAULT_ENTITY_PROMISE: Promise<BufferGeometry> = new Promise(resolve =>
+    resolve(DEFAULT_ENTITY)
+);
+
+const npc_cache: Map<NpcType, Promise<BufferGeometry>> = new Map();
+npc_cache.set(NpcType.Unknown, DEFAULT_ENTITY_PROMISE);
+
+const object_cache: Map<ObjectType, Promise<BufferGeometry>> = new Map();
+object_cache.set(ObjectType.Unknown, DEFAULT_ENTITY_PROMISE);
 
 class EntityStore {
     async get_npc_geometry(npc_type: NpcType): Promise<BufferGeometry> {
-        let mesh = npc_cache.get(npc_type.id);
+        let mesh = npc_cache.get(npc_type);
 
         if (mesh) {
             return mesh;
@@ -26,13 +36,13 @@ class EntityStore {
                 }
             });
 
-            npc_cache.set(npc_type.id, mesh);
+            npc_cache.set(npc_type, mesh);
             return mesh;
         }
     }
 
     async get_object_geometry(object_type: ObjectType): Promise<BufferGeometry> {
-        let geometry = object_cache.get(object_type.id);
+        let geometry = object_cache.get(object_type);
 
         if (geometry) {
             return geometry;
@@ -48,7 +58,7 @@ class EntityStore {
                 }
             });
 
-            object_cache.set(object_type.id, geometry);
+            object_cache.set(object_type, geometry);
             return geometry;
         }
     }