Sancaros/phantasmal-world
1
0
Fork 0
mirror of https://github.com/DaanVandenBosch/phantasmal-world.git synced 2025-04-05 15:28:29 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Clearer naming of NJ types.

Browse Source
This commit is contained in:
Daan Vanden Bosch 2019-07-06 21:55:02 +02:00
parent ee7756487d
commit 9c71c3deb8
6 changed files with 133 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
src/data_formats/parsing/ninja/index.ts
View File

@ -1,6 +1,6 @@
import { Vec3 } from "../../Vec3";
import { BufferCursor } from "../../BufferCursor"; import { BufferCursor } from "../../BufferCursor";
import { NjModel, parse_nj_model } from "./nj"; import { Vec3 } from "../../Vec3";
import { NjcmModel, parse_njcm_model } from "./njcm";
import { parse_xj_model, XjModel } from "./xj"; import { parse_xj_model, XjModel } from "./xj";
// TODO: // TODO:
@ -9,7 +9,7 @@ import { parse_xj_model, XjModel } from "./xj";
const ANGLE_TO_RAD = (2 * Math.PI) / 65536; const ANGLE_TO_RAD = (2 * Math.PI) / 65536;
export type NinjaVertex = { export type NjVertex = {
position: Vec3; position: Vec3;
normal?: Vec3; normal?: Vec3;
bone_weight: number; bone_weight: number;
@ -17,26 +17,34 @@ export type NinjaVertex = {
calc_continue: boolean; calc_continue: boolean;
}; };
export type NinjaModel = NjModel | XjModel; export type NjModel = NjcmModel | XjModel;
export class NinjaObject<M extends NinjaModel> { export function is_njcm_model(model: NjModel): model is NjcmModel {
evaluation_flags: NinjaEvaluationFlags; return model.type === "njcm";
}
export function is_xj_model(model: NjModel): model is XjModel {
return model.type === "xj";
}
export class NjObject<M extends NjModel> {
evaluation_flags: NjEvaluationFlags;
model: M | undefined; model: M | undefined;
position: Vec3; position: Vec3;
rotation: Vec3; // Euler angles in radians. rotation: Vec3; // Euler angles in radians.
scale: Vec3; scale: Vec3;
children: NinjaObject<M>[]; children: NjObject<M>[];
private bone_cache = new Map<number, NinjaObject<M> | null>(); private bone_cache = new Map<number, NjObject<M> | null>();
private _bone_count = -1; private _bone_count = -1;
constructor( constructor(
evaluation_flags: NinjaEvaluationFlags, evaluation_flags: NjEvaluationFlags,
model: M | undefined, model: M | undefined,
position: Vec3, position: Vec3,
rotation: Vec3, // Euler angles in radians. rotation: Vec3, // Euler angles in radians.
scale: Vec3, scale: Vec3,
children: NinjaObject<M>[] children: NjObject<M>[]
) { ) {
this.evaluation_flags = evaluation_flags; this.evaluation_flags = evaluation_flags;
this.model = model; this.model = model;
@ -56,7 +64,7 @@ export class NinjaObject<M extends NinjaModel> {
return this._bone_count; return this._bone_count;
} }
get_bone(bone_id: number): NinjaObject<M> | undefined { get_bone(bone_id: number): NjObject<M> | undefined {
let bone = this.bone_cache.get(bone_id); let bone = this.bone_cache.get(bone_id);
// Strict check because null means there's no bone with this id. // Strict check because null means there's no bone with this id.
@ -69,10 +77,10 @@ export class NinjaObject<M extends NinjaModel> {
} }
private get_bone_internal( private get_bone_internal(
object: NinjaObject<M>, object: NjObject<M>,
bone_id: number, bone_id: number,
id_ref: [number] id_ref: [number]
): NinjaObject<M> | undefined { ): NjObject<M> | undefined {
if (!object.evaluation_flags.skip) { if (!object.evaluation_flags.skip) {
const id = id_ref[0]++; const id = id_ref[0]++;
this.bone_cache.set(id, object); this.bone_cache.set(id, object);
@ -91,7 +99,7 @@ export class NinjaObject<M extends NinjaModel> {
} }
} }
export type NinjaEvaluationFlags = { export type NjEvaluationFlags = {
no_translate: boolean; no_translate: boolean;
no_rotate: boolean; no_rotate: boolean;
no_scale: boolean; no_scale: boolean;
@ -102,19 +110,19 @@ export type NinjaEvaluationFlags = {
shape_skip: boolean; shape_skip: boolean;
}; };
export function parse_nj(cursor: BufferCursor): NinjaObject<NjModel>[] { export function parse_nj(cursor: BufferCursor): NjObject<NjcmModel>[] {
return parse_ninja(cursor, parse_nj_model, []); return parse_ninja(cursor, parse_njcm_model, []);
} }
export function parse_xj(cursor: BufferCursor): NinjaObject<XjModel>[] { export function parse_xj(cursor: BufferCursor): NjObject<XjModel>[] {
return parse_ninja(cursor, parse_xj_model, undefined); return parse_ninja(cursor, parse_xj_model, undefined);
} }
function parse_ninja<M extends NinjaModel>( function parse_ninja<M extends NjModel>(
cursor: BufferCursor, cursor: BufferCursor,
parse_model: (cursor: BufferCursor, context: any) => M, parse_model: (cursor: BufferCursor, context: any) => M,
context: any context: any
): NinjaObject<M>[] { ): NjObject<M>[] {
while (cursor.bytes_left) { while (cursor.bytes_left) {
// Ninja uses a little endian variant of the IFF format. // Ninja uses a little endian variant of the IFF format.
// IFF files contain chunks preceded by an 8-byte header. // IFF files contain chunks preceded by an 8-byte header.
@ -137,11 +145,11 @@ function parse_ninja<M extends NinjaModel>(
} }
// TODO: cache model and object offsets so we don't reparse the same data. // TODO: cache model and object offsets so we don't reparse the same data.
function parse_sibling_objects<M extends NinjaModel>( function parse_sibling_objects<M extends NjModel>(
cursor: BufferCursor, cursor: BufferCursor,
parse_model: (cursor: BufferCursor, context: any) => M, parse_model: (cursor: BufferCursor, context: any) => M,
context: any context: any
): NinjaObject<M>[] { ): NjObject<M>[] {
const eval_flags = cursor.u32(); const eval_flags = cursor.u32();
const no_translate = (eval_flags & 0b1) !== 0; const no_translate = (eval_flags & 0b1) !== 0;
const no_rotate = (eval_flags & 0b10) !== 0; const no_rotate = (eval_flags & 0b10) !== 0;
@ -166,8 +174,8 @@ function parse_sibling_objects<M extends NinjaModel>(
const sibling_offset = cursor.u32(); const sibling_offset = cursor.u32();
let model: M | undefined; let model: M | undefined;
let children: NinjaObject<M>[]; let children: NjObject<M>[];
let siblings: NinjaObject<M>[]; let siblings: NjObject<M>[];
if (model_offset) { if (model_offset) {
cursor.seek_start(model_offset); cursor.seek_start(model_offset);
@ -188,7 +196,7 @@ function parse_sibling_objects<M extends NinjaModel>(
siblings = []; siblings = [];
} }
const object = new NinjaObject<M>( const object = new NjObject<M>(
{ {
no_translate, no_translate,
no_rotate, no_rotate,

146
src/data_formats/parsing/ninja/nj.ts → src/data_formats/parsing/ninja/njcm.ts
View File

@ -1,7 +1,7 @@
import Logger from "js-logger"; import Logger from "js-logger";
import { BufferCursor } from "../../BufferCursor"; import { BufferCursor } from "../../BufferCursor";
import { Vec3 } from "../../Vec3"; import { Vec3 } from "../../Vec3";
import { NinjaVertex } from "../ninja"; import { NjVertex } from ".";
const logger = Logger.get("data_formats/parsing/ninja/nj"); const logger = Logger.get("data_formats/parsing/ninja/nj");
@ -12,19 +12,19 @@ const logger = Logger.get("data_formats/parsing/ninja/nj");
// - animation // - animation
// - deal with vertex information contained in triangle strips // - deal with vertex information contained in triangle strips
export type NjModel = { export type NjcmModel = {
type: "nj"; type: "njcm";
/** /**
* Sparse array of vertices. * Sparse array of vertices.
*/ */
vertices: NinjaVertex[]; vertices: NjVertex[];
meshes: NjTriangleStrip[]; meshes: NjcmTriangleStrip[];
// materials: [], // materials: [],
bounding_sphere_center: Vec3; bounding_sphere_center: Vec3;
bounding_sphere_radius: number; bounding_sphere_radius: number;
}; };
enum NjChunkType { enum NjcmChunkType {
Unknown, Unknown,
Null, Null,
Bits, Bits,
@ -38,72 +38,72 @@ enum NjChunkType {
End, End,
} }
type NjChunk = { type NjcmChunk = {
type: NjChunkType; type: NjcmChunkType;
type_id: number; type_id: number;
} & ( } & (
| NjUnknownChunk | NjcmUnknownChunk
| NjNullChunk | NjcmNullChunk
| NjBitsChunk | NjcmBitsChunk
| NjCachePolygonListChunk | NjcmCachePolygonListChunk
| NjDrawPolygonListChunk | NjcmDrawPolygonListChunk
| NjTinyChunk | NjcmTinyChunk
| NjMaterialChunk | NjcmMaterialChunk
| NjVertexChunk | NjcmVertexChunk
| NjVolumeChunk | NjcmVolumeChunk
| NjStripChunk | NjcmStripChunk
| NjEndChunk); | NjcmEndChunk);
type NjUnknownChunk = { type NjcmUnknownChunk = {
type: NjChunkType.Unknown; type: NjcmChunkType.Unknown;
}; };
type NjNullChunk = { type NjcmNullChunk = {
type: NjChunkType.Null; type: NjcmChunkType.Null;
}; };
type NjBitsChunk = { type NjcmBitsChunk = {
type: NjChunkType.Bits; type: NjcmChunkType.Bits;
}; };
type NjCachePolygonListChunk = { type NjcmCachePolygonListChunk = {
type: NjChunkType.CachePolygonList; type: NjcmChunkType.CachePolygonList;
cache_index: number; cache_index: number;
offset: number; offset: number;
}; };
type NjDrawPolygonListChunk = { type NjcmDrawPolygonListChunk = {
type: NjChunkType.DrawPolygonList; type: NjcmChunkType.DrawPolygonList;
cache_index: number; cache_index: number;
}; };
type NjTinyChunk = { type NjcmTinyChunk = {
type: NjChunkType.Tiny; type: NjcmChunkType.Tiny;
}; };
type NjMaterialChunk = { type NjcmMaterialChunk = {
type: NjChunkType.Material; type: NjcmChunkType.Material;
}; };
type NjVertexChunk = { type NjcmVertexChunk = {
type: NjChunkType.Vertex; type: NjcmChunkType.Vertex;
vertices: NjVertex[]; vertices: NjcmVertex[];
}; };
type NjVolumeChunk = { type NjcmVolumeChunk = {
type: NjChunkType.Volume; type: NjcmChunkType.Volume;
}; };
type NjStripChunk = { type NjcmStripChunk = {
type: NjChunkType.Strip; type: NjcmChunkType.Strip;
triangle_strips: NjTriangleStrip[]; triangle_strips: NjcmTriangleStrip[];
}; };
type NjEndChunk = { type NjcmEndChunk = {
type: NjChunkType.End; type: NjcmChunkType.End;
}; };
type NjVertex = { type NjcmVertex = {
index: number; index: number;
position: Vec3; position: Vec3;
normal?: Vec3; normal?: Vec3;
@ -112,7 +112,7 @@ type NjVertex = {
calc_continue: boolean; calc_continue: boolean;
}; };
type NjTriangleStrip = { type NjcmTriangleStrip = {
ignore_light: boolean; ignore_light: boolean;
ignore_specular: boolean; ignore_specular: boolean;
ignore_ambient: boolean; ignore_ambient: boolean;
@ -121,27 +121,27 @@ type NjTriangleStrip = {
flat_shading: boolean; flat_shading: boolean;
environment_mapping: boolean; environment_mapping: boolean;
clockwise_winding: boolean; clockwise_winding: boolean;
vertices: NjMeshVertex[]; vertices: NjcmMeshVertex[];
}; };
type NjMeshVertex = { type NjcmMeshVertex = {
index: number; index: number;
normal?: Vec3; normal?: Vec3;
}; };
export function parse_nj_model(cursor: BufferCursor, cached_chunk_offsets: number[]): NjModel { export function parse_njcm_model(cursor: BufferCursor, cached_chunk_offsets: number[]): NjcmModel {
const vlist_offset = cursor.u32(); // Vertex list const vlist_offset = cursor.u32(); // Vertex list
const plist_offset = cursor.u32(); // Triangle strip index list const plist_offset = cursor.u32(); // Triangle strip index list
const bounding_sphere_center = new Vec3(cursor.f32(), cursor.f32(), cursor.f32()); const bounding_sphere_center = new Vec3(cursor.f32(), cursor.f32(), cursor.f32());
const bounding_sphere_radius = cursor.f32(); const bounding_sphere_radius = cursor.f32();
const vertices: NinjaVertex[] = []; const vertices: NjVertex[] = [];
const meshes: NjTriangleStrip[] = []; const meshes: NjcmTriangleStrip[] = [];
if (vlist_offset) { if (vlist_offset) {
cursor.seek_start(vlist_offset); cursor.seek_start(vlist_offset);
for (const chunk of parse_chunks(cursor, cached_chunk_offsets, true)) { for (const chunk of parse_chunks(cursor, cached_chunk_offsets, true)) {
if (chunk.type === NjChunkType.Vertex) { if (chunk.type === NjcmChunkType.Vertex) {
for (const vertex of chunk.vertices) { for (const vertex of chunk.vertices) {
vertices[vertex.index] = { vertices[vertex.index] = {
position: vertex.position, position: vertex.position,
@ -159,14 +159,14 @@ export function parse_nj_model(cursor: BufferCursor, cached_chunk_offsets: numbe
cursor.seek_start(plist_offset); cursor.seek_start(plist_offset);
for (const chunk of parse_chunks(cursor, cached_chunk_offsets, false)) { for (const chunk of parse_chunks(cursor, cached_chunk_offsets, false)) {
if (chunk.type === NjChunkType.Strip) { if (chunk.type === NjcmChunkType.Strip) {
meshes.push(...chunk.triangle_strips); meshes.push(...chunk.triangle_strips);
} }
} }
} }
return { return {
type: "nj", type: "njcm",
vertices, vertices,
meshes, meshes,
bounding_sphere_center, bounding_sphere_center,
@ -179,8 +179,8 @@ function parse_chunks(
cursor: BufferCursor, cursor: BufferCursor,
cached_chunk_offsets: number[], cached_chunk_offsets: number[],
wide_end_chunks: boolean wide_end_chunks: boolean
): NjChunk[] { ): NjcmChunk[] {
const chunks: NjChunk[] = []; const chunks: NjcmChunk[] = [];
let loop = true; let loop = true;
while (loop) { while (loop) {
@ -191,19 +191,19 @@ function parse_chunks(
if (type_id === 0) { if (type_id === 0) {
chunks.push({ chunks.push({
type: NjChunkType.Null, type: NjcmChunkType.Null,
type_id, type_id,
}); });
} else if (1 <= type_id && type_id <= 3) { } else if (1 <= type_id && type_id <= 3) {
chunks.push({ chunks.push({
type: NjChunkType.Bits, type: NjcmChunkType.Bits,
type_id, type_id,
}); });
} else if (type_id === 4) { } else if (type_id === 4) {
const cache_index = flags; const cache_index = flags;
const offset = cursor.position; const offset = cursor.position;
chunks.push({ chunks.push({
type: NjChunkType.CachePolygonList, type: NjcmChunkType.CachePolygonList,
type_id, type_id,
cache_index, cache_index,
offset, offset,
@ -220,53 +220,53 @@ function parse_chunks(
} }
chunks.push({ chunks.push({
type: NjChunkType.DrawPolygonList, type: NjcmChunkType.DrawPolygonList,
type_id, type_id,
cache_index, cache_index,
}); });
} else if (8 <= type_id && type_id <= 9) { } else if (8 <= type_id && type_id <= 9) {
size = 2; size = 2;
chunks.push({ chunks.push({
type: NjChunkType.Tiny, type: NjcmChunkType.Tiny,
type_id, type_id,
}); });
} else if (17 <= type_id && type_id <= 31) { } else if (17 <= type_id && type_id <= 31) {
size = 2 + 2 * cursor.u16(); size = 2 + 2 * cursor.u16();
chunks.push({ chunks.push({
type: NjChunkType.Material, type: NjcmChunkType.Material,
type_id, type_id,
}); });
} else if (32 <= type_id && type_id <= 50) { } else if (32 <= type_id && type_id <= 50) {
size = 2 + 4 * cursor.u16(); size = 2 + 4 * cursor.u16();
chunks.push({ chunks.push({
type: NjChunkType.Vertex, type: NjcmChunkType.Vertex,
type_id, type_id,
vertices: parse_vertex_chunk(cursor, type_id, flags), vertices: parse_vertex_chunk(cursor, type_id, flags),
}); });
} else if (56 <= type_id && type_id <= 58) { } else if (56 <= type_id && type_id <= 58) {
size = 2 + 2 * cursor.u16(); size = 2 + 2 * cursor.u16();
chunks.push({ chunks.push({
type: NjChunkType.Volume, type: NjcmChunkType.Volume,
type_id, type_id,
}); });
} else if (64 <= type_id && type_id <= 75) { } else if (64 <= type_id && type_id <= 75) {
size = 2 + 2 * cursor.u16(); size = 2 + 2 * cursor.u16();
chunks.push({ chunks.push({
type: NjChunkType.Strip, type: NjcmChunkType.Strip,
type_id, type_id,
triangle_strips: parse_triangle_strip_chunk(cursor, type_id, flags), triangle_strips: parse_triangle_strip_chunk(cursor, type_id, flags),
}); });
} else if (type_id === 255) { } else if (type_id === 255) {
size = wide_end_chunks ? 2 : 0; size = wide_end_chunks ? 2 : 0;
chunks.push({ chunks.push({
type: NjChunkType.End, type: NjcmChunkType.End,
type_id, type_id,
}); });
loop = false; loop = false;
} else { } else {
size = 2 + 2 * cursor.u16(); size = 2 + 2 * cursor.u16();
chunks.push({ chunks.push({
type: NjChunkType.Unknown, type: NjcmChunkType.Unknown,
type_id, type_id,
}); });
logger.warn(`Unknown chunk type ${type_id} at offset ${chunk_start_position}.`); logger.warn(`Unknown chunk type ${type_id} at offset ${chunk_start_position}.`);
@ -282,7 +282,7 @@ function parse_vertex_chunk(
cursor: BufferCursor, cursor: BufferCursor,
chunk_type_id: number, chunk_type_id: number,
flags: number flags: number
): NjVertex[] { ): NjcmVertex[] {
if (chunk_type_id < 32 || chunk_type_id > 50) { if (chunk_type_id < 32 || chunk_type_id > 50) {
logger.warn(`Unknown vertex chunk type ${chunk_type_id}.`); logger.warn(`Unknown vertex chunk type ${chunk_type_id}.`);
return []; return [];
@ -294,10 +294,10 @@ function parse_vertex_chunk(
const index = cursor.u16(); const index = cursor.u16();
const vertex_count = cursor.u16(); const vertex_count = cursor.u16();
const vertices: NjVertex[] = []; const vertices: NjcmVertex[] = [];
for (let i = 0; i < vertex_count; ++i) { for (let i = 0; i < vertex_count; ++i) {
const vertex: NjVertex = { const vertex: NjcmVertex = {
index: index + i, index: index + i,
position: new Vec3( position: new Vec3(
cursor.f32(), // x cursor.f32(), // x
@ -374,7 +374,7 @@ function parse_triangle_strip_chunk(
cursor: BufferCursor, cursor: BufferCursor,
chunk_type_id: number, chunk_type_id: number,
flags: number flags: number
): NjTriangleStrip[] { ): NjcmTriangleStrip[] {
const render_flags = { const render_flags = {
ignore_light: (flags & 0b1) !== 0, ignore_light: (flags & 0b1) !== 0,
ignore_specular: (flags & 0b10) !== 0, ignore_specular: (flags & 0b10) !== 0,
@ -432,17 +432,17 @@ function parse_triangle_strip_chunk(
const [parse_texture_coords, parse_color, parse_normal, parse_texture_coords_hires] = options; const [parse_texture_coords, parse_color, parse_normal, parse_texture_coords_hires] = options;
const strips: NjTriangleStrip[] = []; const strips: NjcmTriangleStrip[] = [];
for (let i = 0; i < strip_count; ++i) { for (let i = 0; i < strip_count; ++i) {
const winding_flag_and_index_count = cursor.i16(); const winding_flag_and_index_count = cursor.i16();
const clockwise_winding = winding_flag_and_index_count < 1; const clockwise_winding = winding_flag_and_index_count < 1;
const index_count = Math.abs(winding_flag_and_index_count); const index_count = Math.abs(winding_flag_and_index_count);
const vertices: NjMeshVertex[] = []; const vertices: NjcmMeshVertex[] = [];
for (let j = 0; j < index_count; ++j) { for (let j = 0; j < index_count; ++j) {
const vertex: NjMeshVertex = { const vertex: NjcmMeshVertex = {
index: cursor.u16(), index: cursor.u16(),
}; };
vertices.push(vertex); vertices.push(vertex);

4
src/data_formats/parsing/ninja/xj.ts
View File

@ -1,6 +1,6 @@
import { BufferCursor } from "../../BufferCursor"; import { BufferCursor } from "../../BufferCursor";
import { Vec3 } from "../../Vec3"; import { Vec3 } from "../../Vec3";
import { NinjaVertex } from "../ninja"; import { NjVertex } from "../ninja";
// TODO: // TODO:
// - textures // - textures
@ -10,7 +10,7 @@ import { NinjaVertex } from "../ninja";
export type XjModel = { export type XjModel = {
type: "xj"; type: "xj";
vertices: NinjaVertex[]; vertices: NjVertex[];
meshes: XjTriangleStrip[]; meshes: XjTriangleStrip[];
}; };

14
src/rendering/animation.ts
View File

@ -8,7 +8,7 @@ import {
QuaternionKeyframeTrack, QuaternionKeyframeTrack,
VectorKeyframeTrack, VectorKeyframeTrack,
} from "three"; } from "three";
import { NinjaModel, NinjaObject } from "../data_formats/parsing/ninja"; import { NjModel, NjObject } from "../data_formats/parsing/ninja";
import { import {
NjInterpolation, NjInterpolation,
NjKeyframeTrackType, NjKeyframeTrackType,
@ -18,16 +18,16 @@ import {
export const PSO_FRAME_RATE = 30; export const PSO_FRAME_RATE = 30;
export function create_animation_clip( export function create_animation_clip(
object: NinjaObject<NinjaModel>, nj_object: NjObject<NjModel>,
motion: NjMotion nj_motion: NjMotion
): AnimationClip { ): AnimationClip {
const interpolation = const interpolation =
motion.interpolation === NjInterpolation.Spline ? InterpolateSmooth : InterpolateLinear; nj_motion.interpolation === NjInterpolation.Spline ? InterpolateSmooth : InterpolateLinear;
const tracks: KeyframeTrack[] = []; const tracks: KeyframeTrack[] = [];
motion.motion_data.forEach((motion_data, bone_id) => { nj_motion.motion_data.forEach((motion_data, bone_id) => {
const bone = object.get_bone(bone_id); const bone = nj_object.get_bone(bone_id);
if (!bone) return; if (!bone) return;
motion_data.tracks.forEach(({ type, keyframes }) => { motion_data.tracks.forEach(({ type, keyframes }) => {
@ -71,7 +71,7 @@ export function create_animation_clip(
return new AnimationClip( return new AnimationClip(
"Animation", "Animation",
(motion.frame_count - 1) / PSO_FRAME_RATE, (nj_motion.frame_count - 1) / PSO_FRAME_RATE,
tracks tracks
).optimize(); ).optimize();
} }

22
src/rendering/models.ts
View File

@ -15,8 +15,8 @@ import {
Vector3, Vector3,
} from "three"; } from "three";
import { vec3_to_threejs } from "."; import { vec3_to_threejs } from ".";
import { NinjaModel, NinjaObject } from "../data_formats/parsing/ninja"; import { NjModel, NjObject, is_njcm_model } from "../data_formats/parsing/ninja";
import { NjModel } from "../data_formats/parsing/ninja/nj"; import { NjcmModel } from "../data_formats/parsing/ninja/njcm";
import { XjModel } from "../data_formats/parsing/ninja/xj"; import { XjModel } from "../data_formats/parsing/ninja/xj";
const DEFAULT_MATERIAL = new MeshLambertMaterial({ const DEFAULT_MATERIAL = new MeshLambertMaterial({
@ -34,14 +34,14 @@ const NO_ROTATION = new Quaternion(0, 0, 0, 1);
const NO_SCALE = new Vector3(1, 1, 1); const NO_SCALE = new Vector3(1, 1, 1);
export function ninja_object_to_buffer_geometry( export function ninja_object_to_buffer_geometry(
object: NinjaObject<NinjaModel>, object: NjObject<NjModel>,
material: Material = DEFAULT_MATERIAL material: Material = DEFAULT_MATERIAL
): BufferGeometry { ): BufferGeometry {
return new Object3DCreator(material).create_buffer_geometry(object); return new Object3DCreator(material).create_buffer_geometry(object);
} }
export function ninja_object_to_skinned_mesh( export function ninja_object_to_skinned_mesh(
object: NinjaObject<NinjaModel>, object: NjObject<NjModel>,
material: Material = DEFAULT_SKINNED_MATERIAL material: Material = DEFAULT_SKINNED_MATERIAL
): SkinnedMesh { ): SkinnedMesh {
return new Object3DCreator(material).create_skinned_mesh(object); return new Object3DCreator(material).create_skinned_mesh(object);
@ -93,7 +93,7 @@ class Object3DCreator {
this.material = material; this.material = material;
} }
create_buffer_geometry(object: NinjaObject<NinjaModel>): BufferGeometry { create_buffer_geometry(object: NjObject<NjModel>): BufferGeometry {
this.object_to_geometry(object, undefined, new Matrix4()); this.object_to_geometry(object, undefined, new Matrix4());
const geom = new BufferGeometry(); const geom = new BufferGeometry();
@ -108,7 +108,7 @@ class Object3DCreator {
return geom; return geom;
} }
create_skinned_mesh(object: NinjaObject<NinjaModel>): SkinnedMesh { create_skinned_mesh(object: NjObject<NjModel>): SkinnedMesh {
const geom = this.create_buffer_geometry(object); const geom = this.create_buffer_geometry(object);
geom.addAttribute("skinIndex", new Uint16BufferAttribute(this.bone_indices, 4)); geom.addAttribute("skinIndex", new Uint16BufferAttribute(this.bone_indices, 4));
geom.addAttribute("skinWeight", new Float32BufferAttribute(this.bone_weights, 4)); geom.addAttribute("skinWeight", new Float32BufferAttribute(this.bone_weights, 4));
@ -123,7 +123,7 @@ class Object3DCreator {
} }
private object_to_geometry( private object_to_geometry(
object: NinjaObject<NinjaModel>, object: NjObject<NjModel>,
parent_bone: Bone | undefined, parent_bone: Bone | undefined,
parent_matrix: Matrix4 parent_matrix: Matrix4
): void { ): void {
@ -184,15 +184,15 @@ class Object3DCreator {
} }
} }
private model_to_geometry(model: NinjaModel, matrix: Matrix4): void { private model_to_geometry(model: NjModel, matrix: Matrix4): void {
if (model.type === "nj") { if (is_njcm_model(model)) {
this.nj_model_to_geometry(model, matrix); this.njcm_model_to_geometry(model, matrix);
} else { } else {
this.xj_model_to_geometry(model, matrix); this.xj_model_to_geometry(model, matrix);
} }
} }
private nj_model_to_geometry(model: NjModel, matrix: Matrix4): void { private njcm_model_to_geometry(model: NjcmModel, matrix: Matrix4): void {
const normal_matrix = new Matrix3().getNormalMatrix(matrix); const normal_matrix = new Matrix3().getNormalMatrix(matrix);
const new_vertices = model.vertices.map(vertex => { const new_vertices = model.vertices.map(vertex => {

16
src/stores/ModelViewerStore.ts
View File

@ -2,7 +2,7 @@ import Logger from "js-logger";
import { action, observable } from "mobx"; import { action, observable } from "mobx";
import { AnimationAction, AnimationClip, AnimationMixer, SkinnedMesh } from "three"; import { AnimationAction, AnimationClip, AnimationMixer, SkinnedMesh } from "three";
import { BufferCursor } from "../data_formats/BufferCursor"; import { BufferCursor } from "../data_formats/BufferCursor";
import { NinjaModel, NinjaObject, parse_nj, parse_xj } from "../data_formats/parsing/ninja"; import { NjModel, NjObject, parse_nj, parse_xj } from "../data_formats/parsing/ninja";
import { parse_njm, NjMotion } from "../data_formats/parsing/ninja/motion"; import { parse_njm, NjMotion } from "../data_formats/parsing/ninja/motion";
import { PlayerModel, PlayerAnimation } from "../domain"; import { PlayerModel, PlayerAnimation } from "../domain";
import { create_animation_clip, PSO_FRAME_RATE } from "../rendering/animation"; import { create_animation_clip, PSO_FRAME_RATE } from "../rendering/animation";
@ -10,7 +10,7 @@ import { ninja_object_to_skinned_mesh } from "../rendering/models";
import { get_player_data, get_player_animation_data } from "./binary_assets"; import { get_player_data, get_player_animation_data } from "./binary_assets";
const logger = Logger.get("stores/ModelViewerStore"); const logger = Logger.get("stores/ModelViewerStore");
const nj_object_cache: Map<string, Promise<NinjaObject<NinjaModel>>> = new Map(); const nj_object_cache: Map<string, Promise<NjObject<NjModel>>> = new Map();
const nj_motion_cache: Map<number, Promise<NjMotion>> = new Map(); const nj_motion_cache: Map<number, Promise<NjMotion>> = new Map();
class ModelViewerStore { class ModelViewerStore {
@ -33,7 +33,7 @@ class ModelViewerStore {
.map((_, i) => new PlayerAnimation(i, `Animation ${i + 1}`)); .map((_, i) => new PlayerAnimation(i, `Animation ${i + 1}`));
@observable.ref current_player_model?: PlayerModel; @observable.ref current_player_model?: PlayerModel;
@observable.ref current_model?: NinjaObject<NinjaModel>; @observable.ref current_model?: NjObject<NjModel>;
@observable.ref current_bone_count: number = 0; @observable.ref current_bone_count: number = 0;
@observable.ref current_obj3d?: SkinnedMesh; @observable.ref current_obj3d?: SkinnedMesh;
@ -130,7 +130,7 @@ class ModelViewerStore {
private set_model = action( private set_model = action(
"set_model", "set_model",
(model: NinjaObject<NinjaModel>, player_model?: PlayerModel) => { (model: NjObject<NjModel>, player_model?: PlayerModel) => {
if (this.current_obj3d && this.animation) { if (this.current_obj3d && this.animation) {
this.animation.mixer.stopAllAction(); this.animation.mixer.stopAllAction();
this.animation.mixer.uncacheRoot(this.current_obj3d); this.animation.mixer.uncacheRoot(this.current_obj3d);
@ -174,8 +174,8 @@ class ModelViewerStore {
}; };
private add_to_bone( private add_to_bone(
object: NinjaObject<NinjaModel>, object: NjObject<NjModel>,
head_part: NinjaObject<NinjaModel>, head_part: NjObject<NjModel>,
bone_id: number bone_id: number
): void { ): void {
const bone = object.get_bone(bone_id); const bone = object.get_bone(bone_id);
@ -187,7 +187,7 @@ class ModelViewerStore {
} }
} }
private async get_player_ninja_object(model: PlayerModel): Promise<NinjaObject<NinjaModel>> { private async get_player_ninja_object(model: PlayerModel): Promise<NjObject<NjModel>> {
let ninja_object = nj_object_cache.get(model.name); let ninja_object = nj_object_cache.get(model.name);
if (ninja_object) { if (ninja_object) {
@ -199,7 +199,7 @@ class ModelViewerStore {
} }
} }
private async get_all_assets(model: PlayerModel): Promise<NinjaObject<NinjaModel>> { private async get_all_assets(model: PlayerModel): Promise<NjObject<NjModel>> {
const body_data = await get_player_data(model.name, "Body"); const body_data = await get_player_data(model.name, "Body");
const body = parse_nj(new BufferCursor(body_data, true))[0]; const body = parse_nj(new BufferCursor(body_data, true))[0];