Fixed issues with textures and tweaked lighting and ground color in quest renderer.

src/data_formats/parsing/ninja/xj.ts

@@ -62,9 +62,8 @@ export function parse_xj_model(cursor: Cursor): XjModel {
         }
 
         cursor.seek_start(vertex_info_table_offset);
-        cursor.seek(4); // Vertex type.
-        // Vertex Types
-        // 3) size: 32, has position, normal, uv
+        const vertex_type = cursor.u16();
+        cursor.seek(2); // Flags?
         const vertex_table_offset = cursor.u32();
         const vertex_size = cursor.u32();
         const vertex_count = cursor.u32();
@@ -76,13 +75,38 @@ export function parse_xj_model(cursor: Cursor): XjModel {
             let normal: Vec3 | undefined;
             let uv: Vec2 | undefined;
 
-            if (vertex_size === 28 || vertex_size === 32 || vertex_size === 36) {
-                normal = cursor.vec3_f32();
+            switch (vertex_type) {
+                case 3:
+                    normal = cursor.vec3_f32();
+                    uv = cursor.vec2_f32();
+                    break;
+                case 4:
+                    // Skip 4 bytes.
+                    break;
+                case 5:
+                    cursor.seek(4);
+                    uv = cursor.vec2_f32();
+                    break;
+                case 6:
+                    normal = cursor.vec3_f32();
+                    // Skip 4 bytes.
+                    break;
+                case 7:
+                    normal = cursor.vec3_f32();
+                    uv = cursor.vec2_f32();
+                    break;
+                default:
+                    logger.warn(`Unknown vertex type ${vertex_type} with size ${vertex_size}.`);
+                    break;
             }
 
-            if (vertex_size === 24 || vertex_size === 32 || vertex_size === 36) {
-                uv = cursor.vec2_f32();
-            }
+            // if (vertex_size === 28 || vertex_size === 32 || vertex_size === 36) {
+            //     normal = cursor.vec3_f32();
+            // }
+
+            // if (vertex_size === 24 || vertex_size === 32 || vertex_size === 36) {
+            //     uv = cursor.vec2_f32();
+            // }
 
             model.vertices.push({
                 position,

src/rendering/Renderer.ts

@@ -22,7 +22,7 @@ export class Renderer<C extends Camera> {
 
     private renderer = new WebGLRenderer({ antialias: true });
     private render_scheduled = false;
-    private light = new HemisphereLight(0xffffff, 0x505050, 1);
+    private light = new HemisphereLight(0xffffff, 0x505050, 1.2);
 
     constructor(camera: C) {
         this.renderer.setPixelRatio(window.devicePixelRatio);

src/rendering/areas.ts

@@ -28,7 +28,7 @@ const materials = [
     }),
     // Ground
     new MeshLambertMaterial({
-        color: 0x50d0d0,
+        color: 0xa0a0a0,
         side: DoubleSide,
     }),
     // Vegetation
@@ -53,17 +53,17 @@ const wireframe_materials = [
     }),
     // Ground
     new MeshBasicMaterial({
-        color: 0x60f0f0,
+        color: 0xd0d0d0,
         wireframe: true,
     }),
     // Vegetation
     new MeshBasicMaterial({
-        color: 0x60c080,
+        color: 0x80e0a0,
         wireframe: true,
     }),
     // Section transition zone
     new MeshBasicMaterial({
-        color: 0x705090,
+        color: 0x9070b0,
         wireframe: true,
     }),
 ];

src/rendering/entities.ts

@@ -44,6 +44,7 @@ function create_mesh(
     const materials: Material[] = [
         new MeshBasicMaterial({
             color,
+            side: DoubleSide,
         }),
     ];
 
@@ -51,7 +52,6 @@ function create_mesh(
         ...textures.map(
             tex =>
                 new MeshLambertMaterial({
-                    skinning: true,
                     map: tex,
                     side: DoubleSide,
                     alphaTest: 0.5,

src/rendering/models.ts

@@ -127,6 +127,7 @@ class Object3DCreator {
             geom.addGroup(group.start, group.count, group.material_index);
         }
 
+        geom.computeBoundingSphere();
         geom.computeBoundingBox();
 
         return geom;

src/rendering/textures.ts

@@ -5,6 +5,7 @@ import {
     RGBA_S3TC_DXT1_Format,
     RGBA_S3TC_DXT3_Format,
     Texture,
+    CompressedPixelFormat,
 } from "three";
 import { Xvm, XvmTexture } from "../data_formats/parsing/ninja/texture";
 
@@ -13,33 +14,36 @@ export function xvm_to_textures(xvm: Xvm): Texture[] {
 }
 
 export function xvm_texture_to_texture(tex: XvmTexture): Texture {
+    let format: CompressedPixelFormat;
+    let data_size: number;
+
+    // Ignore mipmaps.
+    switch (tex.format[1]) {
+        case 6:
+            format = RGBA_S3TC_DXT1_Format;
+            data_size = (tex.width * tex.height) / 2;
+            break;
+        case 7:
+            format = RGBA_S3TC_DXT3_Format;
+            data_size = tex.width * tex.height;
+            break;
+        default:
+            throw new Error(`Format ${tex.format.join(", ")} not supported.`);
+    }
+
     const texture_3js = new CompressedTexture(
         [
             {
-                data: new Uint8Array(tex.data) as any,
+                data: new Uint8Array(tex.data, 0, data_size) as any,
                 width: tex.width,
                 height: tex.height,
             },
         ],
         tex.width,
-        tex.height
+        tex.height,
+        format
     );
 
-    switch (tex.format[1]) {
-        case 6:
-            texture_3js.format = RGBA_S3TC_DXT1_Format as any;
-            break;
-        case 7:
-            if (tex.format[0] === 2) {
-                texture_3js.format = RGBA_S3TC_DXT3_Format as any;
-            } else {
-                throw new Error(`Format[0] ${tex.format[0]} not supported.`);
-            }
-            break;
-        default:
-            throw new Error(`Format[1] ${tex.format[1]} not supported.`);
-    }
-
     texture_3js.minFilter = LinearFilter;
     texture_3js.wrapS = MirroredRepeatWrapping;
     texture_3js.wrapT = MirroredRepeatWrapping;

src/stores/EntityStore.ts

@@ -31,10 +31,32 @@ const npc_tex_cache: Map<NpcType, Promise<Texture[]>> = new Map();
 npc_tex_cache.set(NpcType.Unknown, DEFAULT_ENTITY_TEX_PROMISE);
 
 const object_cache: Map<ObjectType, Promise<BufferGeometry>> = new Map();
-object_cache.set(ObjectType.Unknown, DEFAULT_ENTITY_PROMISE);
-
 const object_tex_cache: Map<ObjectType, Promise<Texture[]>> = new Map();
-object_tex_cache.set(ObjectType.Unknown, DEFAULT_ENTITY_TEX_PROMISE);
+
+for (const type of [
+    ObjectType.Unknown,
+    ObjectType.PlayerSet,
+    ObjectType.FogCollision,
+    ObjectType.EventCollision,
+    ObjectType.ObjRoomID,
+    ObjectType.ScriptCollision,
+    ObjectType.ItemLight,
+    ObjectType.FogCollisionSW,
+    ObjectType.MenuActivation,
+    ObjectType.BoxDetectObject,
+    ObjectType.SymbolChatObject,
+    ObjectType.TouchPlateObject,
+    ObjectType.TargetableObject,
+    ObjectType.EffectObject,
+    ObjectType.CountDownObject,
+    ObjectType.TelepipeLocation,
+    ObjectType.Pioneer2InvisibleTouchplate,
+    ObjectType.TempleMapDetect,
+    ObjectType.LabInvisibleObject,
+]) {
+    object_cache.set(type, DEFAULT_ENTITY_PROMISE);
+    object_tex_cache.set(type, DEFAULT_ENTITY_TEX_PROMISE);
+}
 
 class EntityStore {
     async get_npc_geometry(npc_type: NpcType): Promise<BufferGeometry> {

src/stores/ModelViewerStore.ts

@@ -297,7 +297,7 @@ class ModelViewerStore {
                 textures.map(
                     tex =>
                         new MeshLambertMaterial({
-                            skinning: true,
+                            skinning: this.has_skeleton,
                             map: tex,
                             side: DoubleSide,
                             alphaTest: 0.5,