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

Started working on animation support in model viewer.

Browse Source
This commit is contained in:
Daan Vanden Bosch 2019-06-27 18:50:22 +02:00
parent a639eb683f
commit de3de9256b
14 changed files with 549 additions and 406 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
src/bin_data/loading/areas.ts
View File

@ -6,74 +6,78 @@ import { parseCRel, parseNRel } from '../parsing/geometry';
// //
// Caches // Caches
// //
const sectionsCache: Map<string, Promise<Section[]>> = new Map(); const sections_cache: Map<string, Promise<Section[]>> = new Map();
const renderGeometryCache: Map<string, Promise<Object3D>> = new Map(); const render_geometry_cache: Map<string, Promise<Object3D>> = new Map();
const collisionGeometryCache: Map<string, Promise<Object3D>> = new Map(); const collision_geometry_cache: Map<string, Promise<Object3D>> = new Map();
export function getAreaSections( export function get_area_sections(
episode: number, episode: number,
areaId: number, area_id: number,
areaVariant: number area_variant: number
): Promise<Section[]> { ): Promise<Section[]> {
const sections = sectionsCache.get(`${episode}-${areaId}-${areaVariant}`); const sections = sections_cache.get(`${episode}-${area_id}-${area_variant}`);
if (sections) { if (sections) {
return sections; return sections;
} else { } else {
return getAreaSectionsAndRenderGeometry( return get_area_sections_and_render_geometry(
episode, areaId, areaVariant).then(({sections}) => sections); episode, area_id, area_variant
).then(({ sections }) => sections);
} }
} }
export function getAreaRenderGeometry( export function get_area_render_geometry(
episode: number, episode: number,
areaId: number, area_id: number,
areaVariant: number area_variant: number
): Promise<Object3D> { ): Promise<Object3D> {
const object3d = renderGeometryCache.get(`${episode}-${areaId}-${areaVariant}`); const object_3d = render_geometry_cache.get(`${episode}-${area_id}-${area_variant}`);
if (object3d) { if (object_3d) {
return object3d; return object_3d;
} else { } else {
return getAreaSectionsAndRenderGeometry( return get_area_sections_and_render_geometry(
episode, areaId, areaVariant).then(({object3d}) => object3d); episode, area_id, area_variant
).then(({ object3d }) => object3d);
} }
} }
export function getAreaCollisionGeometry( export function get_area_collision_geometry(
episode: number, episode: number,
areaId: number, area_id: number,
areaVariant: number area_variant: number
): Promise<Object3D> { ): Promise<Object3D> {
const object3d = collisionGeometryCache.get(`${episode}-${areaId}-${areaVariant}`); const object_3d = collision_geometry_cache.get(`${episode}-${area_id}-${area_variant}`);
if (object3d) { if (object_3d) {
return object3d; return object_3d;
} else { } else {
const object3d = getAreaCollisionData( const object_3d = getAreaCollisionData(
episode, areaId, areaVariant).then(parseCRel); episode, area_id, area_variant
collisionGeometryCache.set(`${areaId}-${areaVariant}`, object3d); ).then(parseCRel);
return object3d; collision_geometry_cache.set(`${area_id}-${area_variant}`, object_3d);
return object_3d;
} }
} }
function getAreaSectionsAndRenderGeometry( function get_area_sections_and_render_geometry(
episode: number, episode: number,
areaId: number, area_id: number,
areaVariant: number area_variant: number
): Promise<{ sections: Section[], object3d: Object3D }> { ): Promise<{ sections: Section[], object3d: Object3D }> {
const promise = getAreaRenderData( const promise = getAreaRenderData(
episode, areaId, areaVariant).then(parseNRel); episode, area_id, area_variant
).then(parseNRel);
const sections = new Promise<Section[]>((resolve, reject) => { const sections = new Promise<Section[]>((resolve, reject) => {
promise.then(({ sections }) => resolve(sections)).catch(reject); promise.then(({ sections }) => resolve(sections)).catch(reject);
}); });
const object3d = new Promise<Object3D>((resolve, reject) => { const object_3d = new Promise<Object3D>((resolve, reject) => {
promise.then(({ object3d }) => resolve(object3d)).catch(reject); promise.then(({ object3d }) => resolve(object3d)).catch(reject);
}); });
sectionsCache.set(`${episode}-${areaId}-${areaVariant}`, sections); sections_cache.set(`${episode}-${area_id}-${area_variant}`, sections);
renderGeometryCache.set(`${episode}-${areaId}-${areaVariant}`, object3d); render_geometry_cache.set(`${episode}-${area_id}-${area_variant}`, object_3d);
return promise; return promise;
} }

34
src/bin_data/loading/entities.ts
View File

@ -2,51 +2,51 @@ import { BufferGeometry } from 'three';
import { NpcType, ObjectType } from '../../domain'; import { NpcType, ObjectType } from '../../domain';
import { getNpcData, getObjectData } from './binaryAssets'; import { getNpcData, getObjectData } from './binaryAssets';
import { BufferCursor } from '../BufferCursor'; import { BufferCursor } from '../BufferCursor';
import { parseNj, parseXj } from '../parsing/ninja'; import { parse_nj, parse_xj } from '../parsing/ninja';
const npcCache: Map<string, Promise<BufferGeometry>> = new Map(); const npc_cache: Map<string, Promise<BufferGeometry>> = new Map();
const objectCache: Map<string, Promise<BufferGeometry>> = new Map(); const object_cache: Map<string, Promise<BufferGeometry>> = new Map();
export function getNpcGeometry(npcType: NpcType): Promise<BufferGeometry> { export function get_npc_geometry(npc_type: NpcType): Promise<BufferGeometry> {
let geometry = npcCache.get(String(npcType.id)); let geometry = npc_cache.get(String(npc_type.id));
if (geometry) { if (geometry) {
return geometry; return geometry;
} else { } else {
geometry = getNpcData(npcType).then(({ url, data }) => { geometry = getNpcData(npc_type).then(({ url, data }) => {
const cursor = new BufferCursor(data, true); const cursor = new BufferCursor(data, true);
const object3d = url.endsWith('.nj') ? parseNj(cursor) : parseXj(cursor); const object_3d = url.endsWith('.nj') ? parse_nj(cursor) : parse_xj(cursor);
if (object3d) { if (object_3d) {
return object3d; return object_3d;
} else { } else {
throw new Error('File could not be parsed into a BufferGeometry.'); throw new Error('File could not be parsed into a BufferGeometry.');
} }
}); });
npcCache.set(String(npcType.id), geometry); npc_cache.set(String(npc_type.id), geometry);
return geometry; return geometry;
} }
} }
export function getObjectGeometry(objectType: ObjectType): Promise<BufferGeometry> { export function get_object_geometry(object_type: ObjectType): Promise<BufferGeometry> {
let geometry = objectCache.get(String(objectType.id)); let geometry = object_cache.get(String(object_type.id));
if (geometry) { if (geometry) {
return geometry; return geometry;
} else { } else {
geometry = getObjectData(objectType).then(({ url, data }) => { geometry = getObjectData(object_type).then(({ url, data }) => {
const cursor = new BufferCursor(data, true); const cursor = new BufferCursor(data, true);
const object3d = url.endsWith('.nj') ? parseNj(cursor) : parseXj(cursor); const object_3d = url.endsWith('.nj') ? parse_nj(cursor) : parse_xj(cursor);
if (object3d) { if (object_3d) {
return object3d; return object_3d;
} else { } else {
throw new Error('File could not be parsed into a BufferGeometry.'); throw new Error('File could not be parsed into a BufferGeometry.');
} }
}); });
objectCache.set(String(objectType.id), geometry); object_cache.set(String(object_type.id), geometry);
return geometry; return geometry;
} }
} }

110
src/bin_data/parsing/ninja/index.ts
View File

@ -7,41 +7,41 @@ import {
Vector3 Vector3
} from 'three'; } from 'three';
import { BufferCursor } from '../../BufferCursor'; import { BufferCursor } from '../../BufferCursor';
import { parseNjModel, NjContext } from './nj'; import { parse_nj_model, NjContext } from './nj';
import { parseXjModel, XjContext } from './xj'; import { parse_xj_model, XjContext } from './xj';
// TODO: // TODO:
// - deal with multiple NJCM chunks // - deal with multiple NJCM chunks
// - deal with other types of chunks // - deal with other types of chunks
export function parseNj(cursor: BufferCursor): BufferGeometry | undefined { export function parse_nj(cursor: BufferCursor): BufferGeometry | undefined {
return parseNinja(cursor, 'nj'); return parse_ninja(cursor, 'nj');
} }
export function parseXj(cursor: BufferCursor): BufferGeometry | undefined { export function parse_xj(cursor: BufferCursor): BufferGeometry | undefined {
return parseNinja(cursor, 'xj'); return parse_ninja(cursor, 'xj');
} }
type Format = 'nj' | 'xj'; type Format = 'nj' | 'xj';
type Context = NjContext | XjContext; type Context = NjContext | XjContext;
function parseNinja(cursor: BufferCursor, format: Format): BufferGeometry | undefined { function parse_ninja(cursor: BufferCursor, format: Format): BufferGeometry | undefined {
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.
// The header consists of 4 ASCII characters for the "Type ID" and a 32-bit integer specifying the chunk size. // The header consists of 4 ASCII characters for the "Type ID" and a 32-bit integer specifying the chunk size.
const iffTypeId = cursor.string_ascii(4, false, false); const iff_type_id = cursor.string_ascii(4, false, false);
const iffChunkSize = cursor.u32(); const iff_chunk_size = cursor.u32();
if (iffTypeId === 'NJCM') { if (iff_type_id === 'NJCM') {
return parseNjcm(cursor.take(iffChunkSize), format); return parse_njcm(cursor.take(iff_chunk_size), format);
} else { } else {
cursor.seek(iffChunkSize); cursor.seek(iff_chunk_size);
} }
} }
} }
function parseNjcm(cursor: BufferCursor, format: Format): BufferGeometry | undefined { function parse_njcm(cursor: BufferCursor, format: Format): BufferGeometry | undefined {
if (cursor.bytes_left) { if (cursor.bytes_left) {
let context: Context; let context: Context;
@ -50,7 +50,7 @@ function parseNjcm(cursor: BufferCursor, format: Format): BufferGeometry | undef
format, format,
positions: [], positions: [],
normals: [], normals: [],
cachedChunkOffsets: [], cached_chunk_offsets: [],
vertices: [] vertices: []
}; };
} else { } else {
@ -62,63 +62,63 @@ function parseNjcm(cursor: BufferCursor, format: Format): BufferGeometry | undef
}; };
} }
parseSiblingObjects(cursor, new Matrix4(), context); parse_sibling_objects(cursor, new Matrix4(), context);
return createBufferGeometry(context); return create_buffer_geometry(context);
} }
} }
function parseSiblingObjects( function parse_sibling_objects(
cursor: BufferCursor, cursor: BufferCursor,
parentMatrix: Matrix4, parent_matrix: Matrix4,
context: Context context: Context
): void { ): void {
const evalFlags = cursor.u32(); const eval_flags = cursor.u32();
const noTranslate = (evalFlags & 0b1) !== 0; const no_translate = (eval_flags & 0b1) !== 0;
const noRotate = (evalFlags & 0b10) !== 0; const no_rotate = (eval_flags & 0b10) !== 0;
const noScale = (evalFlags & 0b100) !== 0; const no_scale = (eval_flags & 0b100) !== 0;
const hidden = (evalFlags & 0b1000) !== 0; const hidden = (eval_flags & 0b1000) !== 0;
const breakChildTrace = (evalFlags & 0b10000) !== 0; const break_child_trace = (eval_flags & 0b10000) !== 0;
const zxyRotationOrder = (evalFlags & 0b100000) !== 0; const zxy_rotation_order = (eval_flags & 0b100000) !== 0;
const modelOffset = cursor.u32(); const model_offset = cursor.u32();
const posX = cursor.f32(); const pos_x = cursor.f32();
const posY = cursor.f32(); const pos_y = cursor.f32();
const posZ = cursor.f32(); const pos_z = cursor.f32();
const rotationX = cursor.i32() * (2 * Math.PI / 0xFFFF); const rotation_x = cursor.i32() * (2 * Math.PI / 0xFFFF);
const rotationY = cursor.i32() * (2 * Math.PI / 0xFFFF); const rotation_y = cursor.i32() * (2 * Math.PI / 0xFFFF);
const rotationZ = cursor.i32() * (2 * Math.PI / 0xFFFF); const rotation_z = cursor.i32() * (2 * Math.PI / 0xFFFF);
const scaleX = cursor.f32(); const scale_x = cursor.f32();
const scaleY = cursor.f32(); const scale_y = cursor.f32();
const scaleZ = cursor.f32(); const scale_z = cursor.f32();
const childOffset = cursor.u32(); const child_offset = cursor.u32();
const siblingOffset = cursor.u32(); const sibling_offset = cursor.u32();
const rotation = new Euler(rotationX, rotationY, rotationZ, zxyRotationOrder ? 'ZXY' : 'ZYX'); const rotation = new Euler(rotation_x, rotation_y, rotation_z, zxy_rotation_order ? 'ZXY' : 'ZYX');
const matrix = new Matrix4() const matrix = new Matrix4()
.compose( .compose(
noTranslate ? new Vector3() : new Vector3(posX, posY, posZ), no_translate ? new Vector3() : new Vector3(pos_x, pos_y, pos_z),
noRotate ? new Quaternion(0, 0, 0, 1) : new Quaternion().setFromEuler(rotation), no_rotate ? new Quaternion(0, 0, 0, 1) : new Quaternion().setFromEuler(rotation),
noScale ? new Vector3(1, 1, 1) : new Vector3(scaleX, scaleY, scaleZ) no_scale ? new Vector3(1, 1, 1) : new Vector3(scale_x, scale_y, scale_z)
) )
.premultiply(parentMatrix); .premultiply(parent_matrix);
if (modelOffset && !hidden) { if (model_offset && !hidden) {
cursor.seek_start(modelOffset); cursor.seek_start(model_offset);
parseModel(cursor, matrix, context); parse_model(cursor, matrix, context);
} }
if (childOffset && !breakChildTrace) { if (child_offset && !break_child_trace) {
cursor.seek_start(childOffset); cursor.seek_start(child_offset);
parseSiblingObjects(cursor, matrix, context); parse_sibling_objects(cursor, matrix, context);
} }
if (siblingOffset) { if (sibling_offset) {
cursor.seek_start(siblingOffset); cursor.seek_start(sibling_offset);
parseSiblingObjects(cursor, parentMatrix, context); parse_sibling_objects(cursor, parent_matrix, context);
} }
} }
function createBufferGeometry(context: Context): BufferGeometry { function create_buffer_geometry(context: Context): BufferGeometry {
const geometry = new BufferGeometry(); const geometry = new BufferGeometry();
geometry.addAttribute('position', new BufferAttribute(new Float32Array(context.positions), 3)); geometry.addAttribute('position', new BufferAttribute(new Float32Array(context.positions), 3));
geometry.addAttribute('normal', new BufferAttribute(new Float32Array(context.normals), 3)); geometry.addAttribute('normal', new BufferAttribute(new Float32Array(context.normals), 3));
@ -130,10 +130,10 @@ function createBufferGeometry(context: Context): BufferGeometry {
return geometry; return geometry;
} }
function parseModel(cursor: BufferCursor, matrix: Matrix4, context: Context): void { function parse_model(cursor: BufferCursor, matrix: Matrix4, context: Context): void {
if (context.format === 'nj') { if (context.format === 'nj') {
parseNjModel(cursor, matrix, context); parse_nj_model(cursor, matrix, context);
} else { } else {
parseXjModel(cursor, matrix, context); parse_xj_model(cursor, matrix, context);
} }
} }

91
src/bin_data/parsing/ninja/njm2.ts → src/bin_data/parsing/ninja/motion.ts
View File

@ -12,13 +12,38 @@ export type NjMotion = {
motion_data: NjMotionData[], motion_data: NjMotionData[],
frame_count: number, frame_count: number,
type: number, type: number,
interpolation: number, interpolation: NjInterpolation,
element_count: number, element_count: number,
} }
export enum NjInterpolation {
Linear, Spline, UserFunction, SamplingMask
}
export type NjMotionData = { export type NjMotionData = {
keyframes: NjKeyframe[][], tracks: NjKeyframeTrack[],
keyframe_count: number[], }
export enum NjKeyframeTrackType {
Position, Rotation, Scale
}
export type NjKeyframeTrack =
NjKeyframeTrackPosition | NjKeyframeTrackRotation | NjKeyframeTrackScale
export type NjKeyframeTrackPosition = {
type: NjKeyframeTrackType.Position,
keyframes: NjKeyframeF[],
}
export type NjKeyframeTrackRotation = {
type: NjKeyframeTrackType.Rotation,
keyframes: NjKeyframeA[],
}
export type NjKeyframeTrackScale = {
type: NjKeyframeTrackType.Scale,
keyframes: NjKeyframeF[],
} }
export type NjKeyframe = NjKeyframeF | NjKeyframeA export type NjKeyframe = NjKeyframeF | NjKeyframeA
@ -40,9 +65,9 @@ export type NjKeyframeA = {
} }
/** /**
* Format used by plymotiondata.rlc. * Format used by PSO:BB plymotiondata.rlc.
*/ */
export function parse_njm2(cursor: BufferCursor): NjAction { export function parse_njm_4(cursor: BufferCursor): NjAction {
cursor.seek_end(16); cursor.seek_end(16);
const offset1 = cursor.u32(); const offset1 = cursor.u32();
log_offset('offset1', offset1); log_offset('offset1', offset1);
@ -67,6 +92,7 @@ function parse_action(cursor: BufferCursor): NjAction {
}; };
} }
// TODO: parse data for all objects.
function parse_motion(cursor: BufferCursor): NjMotion { function parse_motion(cursor: BufferCursor): NjMotion {
// Points to an array the size of the total amount of objects in the object tree. // Points to an array the size of the total amount of objects in the object tree.
const mdata_offset = cursor.u32(); const mdata_offset = cursor.u32();
@ -74,12 +100,11 @@ function parse_motion(cursor: BufferCursor): NjMotion {
const type = cursor.u16(); const type = cursor.u16();
const inp_fn = cursor.u16(); const inp_fn = cursor.u16();
// Linear, spline, user function or sampling mask. // Linear, spline, user function or sampling mask.
const interpolation = (inp_fn & 0b11000000) >> 6; const interpolation: NjInterpolation = (inp_fn & 0b11000000) >> 6;
const element_count = inp_fn & 0b1111; const element_count = inp_fn & 0b1111;
let motion_data: NjMotionData = { let motion_data: NjMotionData = {
keyframes: [], tracks: [],
keyframe_count: [],
}; };
const size = count_set_bits(type); const size = count_set_bits(type);
@ -93,49 +118,51 @@ function parse_motion(cursor: BufferCursor): NjMotion {
for (let i = 0; i < size; i++) { for (let i = 0; i < size; i++) {
const count = cursor.u32(); const count = cursor.u32();
motion_data.keyframe_count.push(count);
keyframe_counts.push(count); keyframe_counts.push(count);
} }
// NJD_MTYPE_POS_0 // NJD_MTYPE_POS_0
if ((type & (1 << 0)) !== 0) { if ((type & (1 << 0)) !== 0) {
cursor.seek_start(keyframe_offsets.shift()!); cursor.seek_start(keyframe_offsets.shift()!);
motion_data.keyframes.push( motion_data.tracks.push({
parse_motion_data_f(cursor, keyframe_counts.shift()!) type: NjKeyframeTrackType.Position,
); keyframes: parse_motion_data_f(cursor, keyframe_counts.shift()!)
});
} }
// NJD_MTYPE_ANG_1 // NJD_MTYPE_ANG_1
if ((type & (1 << 1)) !== 0) { if ((type & (1 << 1)) !== 0) {
cursor.seek_start(keyframe_offsets.shift()!); cursor.seek_start(keyframe_offsets.shift()!);
motion_data.keyframes.push( motion_data.tracks.push({
parse_motion_data_a(cursor, keyframe_counts.shift()!) type: NjKeyframeTrackType.Rotation,
); keyframes: parse_motion_data_a(cursor, keyframe_counts.shift()!)
});
} }
// NJD_MTYPE_SCL_2 // NJD_MTYPE_SCL_2
if ((type & (1 << 2)) !== 0) { if ((type & (1 << 2)) !== 0) {
cursor.seek_start(keyframe_offsets.shift()!); cursor.seek_start(keyframe_offsets.shift()!);
motion_data.keyframes.push( motion_data.tracks.push({
parse_motion_data_f(cursor, keyframe_counts.shift()!) type: NjKeyframeTrackType.Scale,
); keyframes: parse_motion_data_f(cursor, keyframe_counts.shift()!)
});
} }
// NJD_MTYPE_VEC_3 // // NJD_MTYPE_VEC_3
if ((type & (1 << 3)) !== 0) { // if ((type & (1 << 3)) !== 0) {
cursor.seek_start(keyframe_offsets.shift()!); // cursor.seek_start(keyframe_offsets.shift()!);
motion_data.keyframes.push( // motion_data.tracks.push(
parse_motion_data_f(cursor, keyframe_counts.shift()!) // parse_motion_data_f(cursor, keyframe_counts.shift()!)
); // );
} // }
// NJD_MTYPE_TARGET_3 // // NJD_MTYPE_TARGET_3
if ((type & (1 << 6)) !== 0) { // if ((type & (1 << 6)) !== 0) {
cursor.seek_start(keyframe_offsets.shift()!); // cursor.seek_start(keyframe_offsets.shift()!);
motion_data.keyframes.push( // motion_data.tracks.push(
parse_motion_data_f(cursor, keyframe_counts.shift()!) // parse_motion_data_f(cursor, keyframe_counts.shift()!)
); // );
} // }
// TODO: all NJD_MTYPE's // TODO: all NJD_MTYPE's

197
src/bin_data/parsing/ninja/nj.ts
View File

@ -17,7 +17,7 @@ export interface NjContext {
format: 'nj'; format: 'nj';
positions: number[]; positions: number[];
normals: number[]; normals: number[];
cachedChunkOffsets: number[]; cached_chunk_offsets: number[];
vertices: { position: Vector3, normal: Vector3 }[]; vertices: { position: Vector3, normal: Vector3 }[];
} }
@ -35,39 +35,39 @@ interface ChunkVertex {
} }
interface ChunkTriangleStrip { interface ChunkTriangleStrip {
clockwiseWinding: boolean; clockwise_winding: boolean;
indices: number[]; indices: number[];
} }
export function parseNjModel(cursor: BufferCursor, matrix: Matrix4, context: NjContext): void { export function parse_nj_model(cursor: BufferCursor, matrix: Matrix4, context: NjContext): void {
const { positions, normals, cachedChunkOffsets, vertices } = context; const { positions, normals, cached_chunk_offsets, vertices } = context;
const vlistOffset = cursor.u32(); // Vertex list const vlist_offset = cursor.u32(); // Vertex list
const plistOffset = cursor.u32(); // Triangle strip index list const plist_offset = cursor.u32(); // Triangle strip index list
const normalMatrix = new Matrix3().getNormalMatrix(matrix); const normal_matrix = new Matrix3().getNormalMatrix(matrix);
if (vlistOffset) { if (vlist_offset) {
cursor.seek_start(vlistOffset); cursor.seek_start(vlist_offset);
for (const chunk of parseChunks(cursor, cachedChunkOffsets, true)) { for (const chunk of parse_chunks(cursor, cached_chunk_offsets, true)) {
if (chunk.chunkType === 'VERTEX') { if (chunk.chunk_type === 'VERTEX') {
const chunkVertices: ChunkVertex[] = chunk.data; const chunk_vertices: ChunkVertex[] = chunk.data;
for (const vertex of chunkVertices) { for (const vertex of chunk_vertices) {
const position = new Vector3(...vertex.position).applyMatrix4(matrix); const position = new Vector3(...vertex.position).applyMatrix4(matrix);
const normal = vertex.normal ? new Vector3(...vertex.normal).applyMatrix3(normalMatrix) : new Vector3(0, 1, 0); const normal = vertex.normal ? new Vector3(...vertex.normal).applyMatrix3(normal_matrix) : new Vector3(0, 1, 0);
vertices[vertex.index] = { position, normal }; vertices[vertex.index] = { position, normal };
} }
} }
} }
} }
if (plistOffset) { if (plist_offset) {
cursor.seek_start(plistOffset); cursor.seek_start(plist_offset);
for (const chunk of parseChunks(cursor, cachedChunkOffsets, false)) { for (const chunk of parse_chunks(cursor, cached_chunk_offsets, false)) {
if (chunk.chunkType === 'STRIP') { if (chunk.chunk_type === 'STRIP') {
for (const { clockwiseWinding, indices: stripIndices } of chunk.data) { for (const { clockwiseWinding, indices: stripIndices } of chunk.data) {
for (let j = 2; j < stripIndices.length; ++j) { for (let j = 2; j < stripIndices.length; ++j) {
const a = vertices[stripIndices[j - 2]]; const a = vertices[stripIndices[j - 2]];
@ -98,78 +98,84 @@ export function parseNjModel(cursor: BufferCursor, matrix: Matrix4, context: NjC
} }
} }
function parseChunks(cursor: BufferCursor, cachedChunkOffsets: number[], wideEndChunks: boolean): Array<{ function parse_chunks(
chunkType: string, cursor: BufferCursor,
chunkSubType: string | null, cached_chunk_offsets: number[],
chunkTypeId: number, wide_end_chunks: boolean
): Array<{
chunk_type: string,
chunk_sub_type: string | null,
chunk_type_id: number,
data: any data: any
}> { }> {
const chunks = []; const chunks = [];
let loop = true; let loop = true;
while (loop) { while (loop) {
const chunkTypeId = cursor.u8(); const chunk_type_id = cursor.u8();
const flags = cursor.u8(); const flags = cursor.u8();
const chunkStartPosition = cursor.position; const chunk_start_position = cursor.position;
let chunkType = 'UNKOWN'; let chunk_type = 'UNKOWN';
let chunkSubType = null; let chunk_sub_type = null;
let data = null; let data = null;
let size = 0; let size = 0;
if (chunkTypeId === 0) { if (chunk_type_id === 0) {
chunkType = 'NULL'; chunk_type = 'NULL';
} else if (1 <= chunkTypeId && chunkTypeId <= 5) { } else if (1 <= chunk_type_id && chunk_type_id <= 5) {
chunkType = 'BITS'; chunk_type = 'BITS';
if (chunkTypeId === 4) { if (chunk_type_id === 4) {
chunkSubType = 'CACHE_POLYGON_LIST'; chunk_sub_type = 'CACHE_POLYGON_LIST';
data = { data = {
storeIndex: flags, store_index: flags,
offset: cursor.position offset: cursor.position
}; };
cachedChunkOffsets[data.storeIndex] = data.offset; cached_chunk_offsets[data.store_index] = data.offset;
loop = false; loop = false;
} else if (chunkTypeId === 5) { } else if (chunk_type_id === 5) {
chunkSubType = 'DRAW_POLYGON_LIST'; chunk_sub_type = 'DRAW_POLYGON_LIST';
data = { data = {
storeIndex: flags store_index: flags
}; };
cursor.seek_start(cachedChunkOffsets[data.storeIndex]); cursor.seek_start(cached_chunk_offsets[data.store_index]);
chunks.splice(chunks.length, 0, ...parseChunks(cursor, cachedChunkOffsets, wideEndChunks)); chunks.push(
...parse_chunks(cursor, cached_chunk_offsets, wide_end_chunks)
);
} }
} else if (8 <= chunkTypeId && chunkTypeId <= 9) { } else if (8 <= chunk_type_id && chunk_type_id <= 9) {
chunkType = 'TINY'; chunk_type = 'TINY';
size = 2; size = 2;
} else if (17 <= chunkTypeId && chunkTypeId <= 31) { } else if (17 <= chunk_type_id && chunk_type_id <= 31) {
chunkType = 'MATERIAL'; chunk_type = 'MATERIAL';
size = 2 + 2 * cursor.u16(); size = 2 + 2 * cursor.u16();
} else if (32 <= chunkTypeId && chunkTypeId <= 50) { } else if (32 <= chunk_type_id && chunk_type_id <= 50) {
chunkType = 'VERTEX'; chunk_type = 'VERTEX';
size = 2 + 4 * cursor.u16(); size = 2 + 4 * cursor.u16();
data = parseChunkVertex(cursor, chunkTypeId, flags); data = parse_chunk_vertex(cursor, chunk_type_id, flags);
} else if (56 <= chunkTypeId && chunkTypeId <= 58) { } else if (56 <= chunk_type_id && chunk_type_id <= 58) {
chunkType = 'VOLUME'; chunk_type = 'VOLUME';
size = 2 + 2 * cursor.u16(); size = 2 + 2 * cursor.u16();
} else if (64 <= chunkTypeId && chunkTypeId <= 75) { } else if (64 <= chunk_type_id && chunk_type_id <= 75) {
chunkType = 'STRIP'; chunk_type = 'STRIP';
size = 2 + 2 * cursor.u16(); size = 2 + 2 * cursor.u16();
data = parseChunkTriangleStrip(cursor, chunkTypeId); data = parse_chunk_triangle_strip(cursor, chunk_type_id);
} else if (chunkTypeId === 255) { } else if (chunk_type_id === 255) {
chunkType = 'END'; chunk_type = 'END';
size = wideEndChunks ? 2 : 0; size = wide_end_chunks ? 2 : 0;
loop = false; loop = false;
} else { } else {
// Ignore unknown chunks. // Ignore unknown chunks.
logger.warn(`Unknown chunk type: ${chunkTypeId}.`); logger.warn(`Unknown chunk type: ${chunk_type_id}.`);
size = 2 + 2 * cursor.u16(); size = 2 + 2 * cursor.u16();
} }
cursor.seek_start(chunkStartPosition + size); cursor.seek_start(chunk_start_position + size);
chunks.push({ chunks.push({
chunkType, chunk_type,
chunkSubType, chunk_sub_type,
chunkTypeId, chunk_type_id,
data data
}); });
} }
@ -177,18 +183,22 @@ function parseChunks(cursor: BufferCursor, cachedChunkOffsets: number[], wideEnd
return chunks; return chunks;
} }
function parseChunkVertex(cursor: BufferCursor, chunkTypeId: number, flags: number): ChunkVertex[] { function parse_chunk_vertex(
cursor: BufferCursor,
chunk_type_id: number,
flags: number
): ChunkVertex[] {
// There are apparently 4 different sets of vertices, ignore all but set 0. // There are apparently 4 different sets of vertices, ignore all but set 0.
if ((flags & 0b11) !== 0) { if ((flags & 0b11) !== 0) {
return []; return [];
} }
const index = cursor.u16(); const index = cursor.u16();
const vertexCount = cursor.u16(); const vertex_count = cursor.u16();
const vertices: ChunkVertex[] = []; const vertices: ChunkVertex[] = [];
for (let i = 0; i < vertexCount; ++i) { for (let i = 0; i < vertex_count; ++i) {
const vertex: ChunkVertex = { const vertex: ChunkVertex = {
index: index + i, index: index + i,
position: [ position: [
@ -198,9 +208,9 @@ function parseChunkVertex(cursor: BufferCursor, chunkTypeId: number, flags: numb
] ]
}; };
if (chunkTypeId === 32) { if (chunk_type_id === 32) {
cursor.seek(4); // Always 1.0 cursor.seek(4); // Always 1.0
} else if (chunkTypeId === 33) { } else if (chunk_type_id === 33) {
cursor.seek(4); // Always 1.0 cursor.seek(4); // Always 1.0
vertex.normal = [ vertex.normal = [
cursor.f32(), // x cursor.f32(), // x
@ -208,8 +218,8 @@ function parseChunkVertex(cursor: BufferCursor, chunkTypeId: number, flags: numb
cursor.f32(), // z cursor.f32(), // z
]; ];
cursor.seek(4); // Always 0.0 cursor.seek(4); // Always 0.0
} else if (35 <= chunkTypeId && chunkTypeId <= 40) { } else if (35 <= chunk_type_id && chunk_type_id <= 40) {
if (chunkTypeId === 37) { if (chunk_type_id === 37) {
// Ninja flags // Ninja flags
vertex.index = index + cursor.u16(); vertex.index = index + cursor.u16();
cursor.seek(2); cursor.seek(2);
@ -217,15 +227,15 @@ function parseChunkVertex(cursor: BufferCursor, chunkTypeId: number, flags: numb
// Skip user flags and material information. // Skip user flags and material information.
cursor.seek(4); cursor.seek(4);
} }
} else if (41 <= chunkTypeId && chunkTypeId <= 47) { } else if (41 <= chunk_type_id && chunk_type_id <= 47) {
vertex.normal = [ vertex.normal = [
cursor.f32(), // x cursor.f32(), // x
cursor.f32(), // y cursor.f32(), // y
cursor.f32(), // z cursor.f32(), // z
]; ];
if (chunkTypeId >= 42) { if (chunk_type_id >= 42) {
if (chunkTypeId === 44) { if (chunk_type_id === 44) {
// Ninja flags // Ninja flags
vertex.index = index + cursor.u16(); vertex.index = index + cursor.u16();
cursor.seek(2); cursor.seek(2);
@ -234,11 +244,11 @@ function parseChunkVertex(cursor: BufferCursor, chunkTypeId: number, flags: numb
cursor.seek(4); cursor.seek(4);
} }
} }
} else if (chunkTypeId >= 48) { } else if (chunk_type_id >= 48) {
// Skip 32-bit vertex normal in format: reserved(2)|x(10)|y(10)|z(10) // Skip 32-bit vertex normal in format: reserved(2)|x(10)|y(10)|z(10)
cursor.seek(4); cursor.seek(4);
if (chunkTypeId >= 49) { if (chunk_type_id >= 49) {
// Skip user flags and material information. // Skip user flags and material information.
cursor.seek(4); cursor.seek(4);
} }
@ -250,13 +260,16 @@ function parseChunkVertex(cursor: BufferCursor, chunkTypeId: number, flags: numb
return vertices; return vertices;
} }
function parseChunkTriangleStrip(cursor: BufferCursor, chunkTypeId: number): ChunkTriangleStrip[] { function parse_chunk_triangle_strip(
const userOffsetAndStripCount = cursor.u16(); cursor: BufferCursor,
const userFlagsSize = userOffsetAndStripCount >>> 14; chunk_type_id: number
const stripCount = userOffsetAndStripCount & 0x3FFF; ): ChunkTriangleStrip[] {
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;
let options; let options;
switch (chunkTypeId) { switch (chunk_type_id) {
case 64: options = [false, false, false, false]; break; case 64: options = [false, false, false, false]; break;
case 65: options = [true, false, false, false]; break; case 65: options = [true, false, false, false]; break;
case 66: options = [true, false, false, false]; break; case 66: options = [true, false, false, false]; break;
@ -269,50 +282,50 @@ function parseChunkTriangleStrip(cursor: BufferCursor, chunkTypeId: number): Chu
case 73: options = [false, false, false, false]; break; case 73: options = [false, false, false, false]; break;
case 74: options = [true, false, false, true]; break; case 74: options = [true, false, false, true]; break;
case 75: options = [true, false, false, true]; break; case 75: options = [true, false, false, true]; break;
default: throw new Error(`Unexpected chunk type ID: ${chunkTypeId}.`); default: throw new Error(`Unexpected chunk type ID: ${chunk_type_id}.`);
} }
const [ const [
parseTextureCoords, parse_texture_coords,
parseColor, parse_color,
parseNormal, parse_normal,
parseTextureCoordsHires parse_texture_coords_hires
] = options; ] = options;
const strips = []; const strips = [];
for (let i = 0; i < stripCount; ++i) { for (let i = 0; i < strip_count; ++i) {
const windingFlagAndIndexCount = cursor.i16(); const winding_flag_and_index_count = cursor.i16();
const clockwiseWinding = windingFlagAndIndexCount < 1; const clockwise_winding = winding_flag_and_index_count < 1;
const indexCount = Math.abs(windingFlagAndIndexCount); const index_count = Math.abs(winding_flag_and_index_count);
const indices = []; const indices = [];
for (let j = 0; j < indexCount; ++j) { for (let j = 0; j < index_count; ++j) {
indices.push(cursor.u16()); indices.push(cursor.u16());
if (parseTextureCoords) { if (parse_texture_coords) {
cursor.seek(4); cursor.seek(4);
} }
if (parseColor) { if (parse_color) {
cursor.seek(4); cursor.seek(4);
} }
if (parseNormal) { if (parse_normal) {
cursor.seek(6); cursor.seek(6);
} }
if (parseTextureCoordsHires) { if (parse_texture_coords_hires) {
cursor.seek(8); cursor.seek(8);
} }
if (j >= 2) { if (j >= 2) {
cursor.seek(2 * userFlagsSize); cursor.seek(2 * user_flags_size);
} }
} }
strips.push({ clockwiseWinding, indices }); strips.push({ clockwise_winding, indices });
} }
return strips; return strips;

86
src/bin_data/parsing/ninja/xj.ts
View File

@ -14,30 +14,30 @@ export interface XjContext {
indices: number[]; indices: number[];
} }
export function parseXjModel(cursor: BufferCursor, matrix: Matrix4, context: XjContext): void { export function parse_xj_model(cursor: BufferCursor, matrix: Matrix4, context: XjContext): void {
const { positions, normals, indices } = context; const { positions, normals, indices } = context;
cursor.seek(4); // Flags according to QEdit, seemingly always 0. cursor.seek(4); // Flags according to QEdit, seemingly always 0.
const vertexInfoListOffset = cursor.u32(); const vertex_info_list_offset = cursor.u32();
cursor.seek(4); // Seems to be the vertexInfoCount, always 1. cursor.seek(4); // Seems to be the vertexInfoCount, always 1.
const triangleStripListAOffset = cursor.u32(); const triangle_strip_list_a_offset = cursor.u32();
const triangleStripACount = cursor.u32(); const triangle_strip_a_count = cursor.u32();
const triangleStripListBOffset = cursor.u32(); const triangle_strip_list_b_offset = cursor.u32();
const triangleStripBCount = cursor.u32(); const triangle_strip_b_count = cursor.u32();
cursor.seek(16); // Bounding sphere position and radius in floats. cursor.seek(16); // Bounding sphere position and radius in floats.
const normalMatrix = new Matrix3().getNormalMatrix(matrix); const normal_matrix = new Matrix3().getNormalMatrix(matrix);
const indexOffset = positions.length / 3; const index_offset = positions.length / 3;
if (vertexInfoListOffset) { if (vertex_info_list_offset) {
cursor.seek_start(vertexInfoListOffset); cursor.seek_start(vertex_info_list_offset);
cursor.seek(4); // Possibly the vertex type. cursor.seek(4); // Possibly the vertex type.
const vertexListOffset = cursor.u32(); const vertexList_offset = cursor.u32();
const vertexSize = cursor.u32(); const vertex_size = cursor.u32();
const vertexCount = cursor.u32(); const vertex_count = cursor.u32();
for (let i = 0; i < vertexCount; ++i) { for (let i = 0; i < vertex_count; ++i) {
cursor.seek_start(vertexListOffset + i * vertexSize); cursor.seek_start(vertexList_offset + i * vertex_size);
const position = new Vector3( const position = new Vector3(
cursor.f32(), cursor.f32(),
cursor.f32(), cursor.f32(),
@ -45,12 +45,12 @@ export function parseXjModel(cursor: BufferCursor, matrix: Matrix4, context: XjC
).applyMatrix4(matrix); ).applyMatrix4(matrix);
let normal; let normal;
if (vertexSize === 28 || vertexSize === 32 || vertexSize === 36) { if (vertex_size === 28 || vertex_size === 32 || vertex_size === 36) {
normal = new Vector3( normal = new Vector3(
cursor.f32(), cursor.f32(),
cursor.f32(), cursor.f32(),
cursor.f32() cursor.f32()
).applyMatrix3(normalMatrix); ).applyMatrix3(normal_matrix);
} else { } else {
normal = new Vector3(0, 1, 0); normal = new Vector3(0, 1, 0);
} }
@ -64,55 +64,55 @@ export function parseXjModel(cursor: BufferCursor, matrix: Matrix4, context: XjC
} }
} }
if (triangleStripListAOffset) { if (triangle_strip_list_a_offset) {
parseTriangleStripList( parse_triangle_strip_list(
cursor, cursor,
triangleStripListAOffset, triangle_strip_list_a_offset,
triangleStripACount, triangle_strip_a_count,
positions, positions,
normals, normals,
indices, indices,
indexOffset index_offset
); );
} }
if (triangleStripListBOffset) { if (triangle_strip_list_b_offset) {
parseTriangleStripList( parse_triangle_strip_list(
cursor, cursor,
triangleStripListBOffset, triangle_strip_list_b_offset,
triangleStripBCount, triangle_strip_b_count,
positions, positions,
normals, normals,
indices, indices,
indexOffset index_offset
); );
} }
} }
function parseTriangleStripList( function parse_triangle_strip_list(
cursor: BufferCursor, cursor: BufferCursor,
triangleStripListOffset: number, triangle_strip_list_offset: number,
triangleStripCount: number, triangle_strip_count: number,
positions: number[], positions: number[],
normals: number[], normals: number[],
indices: number[], indices: number[],
indexOffset: number index_offset: number
): void { ): void {
for (let i = 0; i < triangleStripCount; ++i) { for (let i = 0; i < triangle_strip_count; ++i) {
cursor.seek_start(triangleStripListOffset + i * 20); cursor.seek_start(triangle_strip_list_offset + i * 20);
cursor.seek(8); // Skip material information. cursor.seek(8); // Skip material information.
const indexListOffset = cursor.u32(); const index_list_offset = cursor.u32();
const indexCount = cursor.u32(); const index_count = cursor.u32();
// Ignoring 4 bytes. // Ignoring 4 bytes.
cursor.seek_start(indexListOffset); cursor.seek_start(index_list_offset);
const stripIndices = cursor.u16_array(indexCount); const strip_indices = cursor.u16_array(index_count);
let clockwise = true; let clockwise = true;
for (let j = 2; j < stripIndices.length; ++j) { for (let j = 2; j < strip_indices.length; ++j) {
const a = indexOffset + stripIndices[j - 2]; const a = index_offset + strip_indices[j - 2];
const b = indexOffset + stripIndices[j - 1]; const b = index_offset + strip_indices[j - 1];
const c = indexOffset + stripIndices[j]; const c = index_offset + strip_indices[j];
const pa = new Vector3(positions[3 * a], positions[3 * a + 1], positions[3 * a + 2]); const pa = new Vector3(positions[3 * a], positions[3 * a + 1], positions[3 * a + 2]);
const pb = new Vector3(positions[3 * b], positions[3 * b + 1], positions[3 * b + 2]); const pb = new Vector3(positions[3 * b], positions[3 * b + 1], positions[3 * b + 2]);
const pc = new Vector3(positions[3 * c], positions[3 * c + 1], positions[3 * c + 2]); const pc = new Vector3(positions[3 * c], positions[3 * c + 1], positions[3 * c + 2]);
@ -128,12 +128,12 @@ function parseTriangleStripList(
normal.negate(); normal.negate();
} }
const oppositeCount = const opposite_count =
(normal.dot(na) < 0 ? 1 : 0) + (normal.dot(na) < 0 ? 1 : 0) +
(normal.dot(nb) < 0 ? 1 : 0) + (normal.dot(nb) < 0 ? 1 : 0) +
(normal.dot(nc) < 0 ? 1 : 0); (normal.dot(nc) < 0 ? 1 : 0);
if (oppositeCount >= 2) { if (opposite_count >= 2) {
clockwise = !clockwise; clockwise = !clockwise;
} }

18
src/rendering/Renderer.ts
View File

@ -1,9 +1,9 @@
import * as THREE from 'three'; import * as THREE from 'three';
import { Color, HemisphereLight, Intersection, Mesh, MeshLambertMaterial, MOUSE, Object3D, PerspectiveCamera, Plane, Raycaster, Scene, Vector2, Vector3, WebGLRenderer } from 'three'; import { Color, HemisphereLight, Intersection, Mesh, MeshLambertMaterial, MOUSE, Object3D, PerspectiveCamera, Plane, Raycaster, Scene, Vector2, Vector3, WebGLRenderer, Clock } from 'three';
import OrbitControlsCreator from 'three-orbit-controls'; import OrbitControlsCreator from 'three-orbit-controls';
import { getAreaCollisionGeometry, getAreaRenderGeometry } from '../bin_data/loading/areas'; import { get_area_collision_geometry, get_area_render_geometry } from '../bin_data/loading/areas';
import { Area, Quest, QuestEntity, QuestNpc, QuestObject, Section, Vec3 } from '../domain'; import { Area, Quest, QuestEntity, QuestNpc, QuestObject, Section, Vec3 } from '../domain';
import { questEditorStore } from '../stores/QuestEditorStore'; import { quest_editor_store } from '../stores/QuestEditorStore';
import { NPC_COLOR, NPC_HOVER_COLOR, NPC_SELECTED_COLOR, OBJECT_COLOR, OBJECT_HOVER_COLOR, OBJECT_SELECTED_COLOR } from './entities'; import { NPC_COLOR, NPC_HOVER_COLOR, NPC_SELECTED_COLOR, OBJECT_COLOR, OBJECT_HOVER_COLOR, OBJECT_SELECTED_COLOR } from './entities';
const OrbitControls = OrbitControlsCreator(THREE); const OrbitControls = OrbitControlsCreator(THREE);
@ -48,6 +48,7 @@ export class Renderer {
private hoveredData?: PickEntityResult; private hoveredData?: PickEntityResult;
private selectedData?: PickEntityResult; private selectedData?: PickEntityResult;
private model?: Object3D; private model?: Object3D;
private clock = new Clock();
constructor() { constructor() {
this.renderer.domElement.addEventListener( this.renderer.domElement.addEventListener(
@ -153,7 +154,7 @@ export class Renderer {
const variant = this.quest.area_variants.find(v => v.area.id === areaId); const variant = this.quest.area_variants.find(v => v.area.id === areaId);
const variantId = (variant && variant.id) || 0; const variantId = (variant && variant.id) || 0;
getAreaCollisionGeometry(episode, areaId, variantId).then(geometry => { get_area_collision_geometry(episode, areaId, variantId).then(geometry => {
if (this.quest && this.area) { if (this.quest && this.area) {
this.setModel(undefined); this.setModel(undefined);
this.scene.remove(this.collisionGeometry); this.scene.remove(this.collisionGeometry);
@ -165,7 +166,7 @@ export class Renderer {
} }
}); });
getAreaRenderGeometry(episode, areaId, variantId).then(geometry => { get_area_render_geometry(episode, areaId, variantId).then(geometry => {
if (this.quest && this.area) { if (this.quest && this.area) {
this.renderGeometry = geometry; this.renderGeometry = geometry;
} }
@ -182,6 +183,11 @@ export class Renderer {
private renderLoop = () => { private renderLoop = () => {
this.controls.update(); this.controls.update();
this.addLoadedEntities(); this.addLoadedEntities();
if (quest_editor_store.animation_mixer) {
quest_editor_store.animation_mixer.update(this.clock.getDelta());
}
this.renderer.render(this.scene, this.camera); this.renderer.render(this.scene, this.camera);
requestAnimationFrame(this.renderLoop); requestAnimationFrame(this.renderLoop);
} }
@ -251,7 +257,7 @@ export class Renderer {
: oldSelectedData !== data; : oldSelectedData !== data;
if (selectionChanged) { if (selectionChanged) {
questEditorStore.setSelectedEntity(data && data.entity); quest_editor_store.setSelectedEntity(data && data.entity);
} }
} }

44
src/rendering/animation.ts Normal file
View File

@ -0,0 +1,44 @@
import { AnimationClip, InterpolateLinear, InterpolateSmooth, KeyframeTrack, VectorKeyframeTrack } from "three";
import { NjAction, NjInterpolation, NjKeyframeTrackType } from "../bin_data/parsing/ninja/motion";
const PSO_FRAME_RATE = 30;
export function create_animation_clip(action: NjAction): AnimationClip {
const motion = action.motion;
const interpolation = motion.interpolation === NjInterpolation.Spline
? InterpolateSmooth
: InterpolateLinear;
// TODO: parse data for all objects.
const motion_data = motion.motion_data[0];
const tracks: KeyframeTrack[] = [];
motion_data.tracks.forEach(({ type, keyframes }) => {
// TODO: rotation
if (type === NjKeyframeTrackType.Rotation) return;
const times: number[] = [];
const values: number[] = [];
for (const keyframe of keyframes) {
times.push(keyframe.frame / PSO_FRAME_RATE);
values.push(...keyframe.value);
}
let name: string;
switch (type) {
case NjKeyframeTrackType.Position: name = '.position'; break;
// case NjKeyframeTrackType.Rotation: name = 'rotation'; break;
case NjKeyframeTrackType.Scale: name = '.scale'; break;
}
tracks.push(new VectorKeyframeTrack(name!, times, values, interpolation));
});
return new AnimationClip(
'Animation',
motion.frame_count / PSO_FRAME_RATE,
tracks
);
}

10
src/rendering/entities.test.ts
View File

@ -1,13 +1,13 @@
import { CylinderBufferGeometry, MeshLambertMaterial, Object3D, Vector3 } from 'three'; import { CylinderBufferGeometry, MeshLambertMaterial, Object3D, Vector3 } from 'three';
import { DatNpc, DatObject } from '../bin_data/parsing/quest/dat'; import { DatNpc, DatObject } from '../bin_data/parsing/quest/dat';
import { NpcType, ObjectType, QuestNpc, QuestObject, Vec3 } from '../domain'; import { NpcType, ObjectType, QuestNpc, QuestObject, Vec3 } from '../domain';
import { createNpcMesh, createObjectMesh, NPC_COLOR, OBJECT_COLOR } from './entities'; import { create_npc_mesh, create_object_mesh, NPC_COLOR, OBJECT_COLOR } from './entities';
const cylinder = new CylinderBufferGeometry(3, 3, 20).translate(0, 10, 0); const cylinder = new CylinderBufferGeometry(3, 3, 20).translate(0, 10, 0);
test('create geometry for quest objects', () => { test('create geometry for quest objects', () => {
const object = new QuestObject(7, 13, new Vec3(17, 19, 23), new Vec3(), ObjectType.PrincipalWarp, {} as DatObject); const object = new QuestObject(7, 13, new Vec3(17, 19, 23), new Vec3(), ObjectType.PrincipalWarp, {} as DatObject);
const geometry = createObjectMesh(object, cylinder); const geometry = create_object_mesh(object, cylinder);
expect(geometry).toBeInstanceOf(Object3D); expect(geometry).toBeInstanceOf(Object3D);
expect(geometry.name).toBe('Object'); expect(geometry.name).toBe('Object');
@ -20,7 +20,7 @@ test('create geometry for quest objects', () => {
test('create geometry for quest NPCs', () => { test('create geometry for quest NPCs', () => {
const npc = new QuestNpc(7, 13, new Vec3(17, 19, 23), new Vec3(), NpcType.Booma, {} as DatNpc); const npc = new QuestNpc(7, 13, new Vec3(17, 19, 23), new Vec3(), NpcType.Booma, {} as DatNpc);
const geometry = createNpcMesh(npc, cylinder); const geometry = create_npc_mesh(npc, cylinder);
expect(geometry).toBeInstanceOf(Object3D); expect(geometry).toBeInstanceOf(Object3D);
expect(geometry.name).toBe('NPC'); expect(geometry.name).toBe('NPC');
@ -33,7 +33,7 @@ test('create geometry for quest NPCs', () => {
test('geometry position changes when entity position changes element-wise', () => { test('geometry position changes when entity position changes element-wise', () => {
const npc = new QuestNpc(7, 13, new Vec3(17, 19, 23), new Vec3(), NpcType.Booma, {} as DatNpc); const npc = new QuestNpc(7, 13, new Vec3(17, 19, 23), new Vec3(), NpcType.Booma, {} as DatNpc);
const geometry = createNpcMesh(npc, cylinder); const geometry = create_npc_mesh(npc, cylinder);
npc.position = new Vec3(2, 3, 5).add(npc.position); npc.position = new Vec3(2, 3, 5).add(npc.position);
expect(geometry.position).toEqual(new Vector3(19, 22, 28)); expect(geometry.position).toEqual(new Vector3(19, 22, 28));
@ -41,7 +41,7 @@ test('geometry position changes when entity position changes element-wise', () =
test('geometry position changes when entire entity position changes', () => { test('geometry position changes when entire entity position changes', () => {
const npc = new QuestNpc(7, 13, new Vec3(17, 19, 23), new Vec3(), NpcType.Booma, {} as DatNpc); const npc = new QuestNpc(7, 13, new Vec3(17, 19, 23), new Vec3(), NpcType.Booma, {} as DatNpc);
const geometry = createNpcMesh(npc, cylinder); const geometry = create_npc_mesh(npc, cylinder);
npc.position = new Vec3(2, 3, 5); npc.position = new Vec3(2, 3, 5);
expect(geometry.position).toEqual(new Vector3(2, 3, 5)); expect(geometry.position).toEqual(new Vector3(2, 3, 5));

22
src/rendering/entities.ts
View File

@ -9,37 +9,37 @@ export const NPC_COLOR = 0xFF0000;
export const NPC_HOVER_COLOR = 0xFF3F5F; export const NPC_HOVER_COLOR = 0xFF3F5F;
export const NPC_SELECTED_COLOR = 0xFF0054; export const NPC_SELECTED_COLOR = 0xFF0054;
export function createObjectMesh(object: QuestObject, geometry: BufferGeometry): Mesh { export function create_object_mesh(object: QuestObject, geometry: BufferGeometry): Mesh {
return createMesh(object, geometry, OBJECT_COLOR, 'Object'); return create_mesh(object, geometry, OBJECT_COLOR, 'Object');
} }
export function createNpcMesh(npc: QuestNpc, geometry: BufferGeometry): Mesh { export function create_npc_mesh(npc: QuestNpc, geometry: BufferGeometry): Mesh {
return createMesh(npc, geometry, NPC_COLOR, 'NPC'); return create_mesh(npc, geometry, NPC_COLOR, 'NPC');
} }
function createMesh( function create_mesh(
entity: QuestEntity, entity: QuestEntity,
geometry: BufferGeometry, geometry: BufferGeometry,
color: number, color: number,
type: string type: string
): Mesh { ): Mesh {
const object3d = new Mesh( const object_3d = new Mesh(
geometry, geometry,
new MeshLambertMaterial({ new MeshLambertMaterial({
color, color,
side: DoubleSide side: DoubleSide
}) })
); );
object3d.name = type; object_3d.name = type;
object3d.userData.entity = entity; object_3d.userData.entity = entity;
// TODO: dispose autorun? // TODO: dispose autorun?
autorun(() => { autorun(() => {
const { x, y, z } = entity.position; const { x, y, z } = entity.position;
object3d.position.set(x, y, z); object_3d.position.set(x, y, z);
const rot = entity.rotation; const rot = entity.rotation;
object3d.rotation.set(rot.x, rot.y, rot.z); object_3d.rotation.set(rot.x, rot.y, rot.z);
}); });
return object3d; return object_3d;
} }

2
src/rendering/models.ts
View File

@ -1,6 +1,6 @@
import { BufferGeometry, DoubleSide, Mesh, MeshLambertMaterial } from 'three'; import { BufferGeometry, DoubleSide, Mesh, MeshLambertMaterial } from 'three';
export function createModelMesh(geometry?: BufferGeometry): Mesh | undefined { export function create_model_mesh(geometry?: BufferGeometry): Mesh | undefined {
return geometry && new Mesh( return geometry && new Mesh(
geometry, geometry,
new MeshLambertMaterial({ new MeshLambertMaterial({

153
src/stores/QuestEditorStore.ts
View File

@ -1,62 +1,86 @@
import { observable, action } from 'mobx'; import Logger from 'js-logger';
import { Object3D } from 'three'; import { action, observable } from 'mobx';
import { AnimationClip, AnimationMixer, Object3D } from 'three';
import { BufferCursor } from '../bin_data/BufferCursor'; import { BufferCursor } from '../bin_data/BufferCursor';
import { getAreaSections } from '../bin_data/loading/areas'; import { get_area_sections } from '../bin_data/loading/areas';
import { getNpcGeometry, getObjectGeometry } from '../bin_data/loading/entities'; import { get_npc_geometry, get_object_geometry } from '../bin_data/loading/entities';
import { parseNj, parseXj } from '../bin_data/parsing/ninja'; import { parse_nj, parse_xj } from '../bin_data/parsing/ninja';
import { parse_njm_4 } from '../bin_data/parsing/ninja/motion';
import { parse_quest, write_quest_qst } from '../bin_data/parsing/quest'; import { parse_quest, write_quest_qst } from '../bin_data/parsing/quest';
import { Area, Quest, QuestEntity, Section, Vec3 } from '../domain'; import { Area, Quest, QuestEntity, Section, Vec3 } from '../domain';
import { createNpcMesh, createObjectMesh } from '../rendering/entities'; import { create_animation_clip } from '../rendering/animation';
import { createModelMesh } from '../rendering/models'; import { create_npc_mesh, create_object_mesh } from '../rendering/entities';
import Logger from 'js-logger'; import { create_model_mesh } from '../rendering/models';
const logger = Logger.get('stores/QuestEditorStore'); const logger = Logger.get('stores/QuestEditorStore');
class QuestEditorStore { class QuestEditorStore {
@observable currentModel?: Object3D; @observable current_quest?: Quest;
@observable currentQuest?: Quest; @observable current_area?: Area;
@observable currentArea?: Area; @observable selected_entity?: QuestEntity;
@observable selectedEntity?: QuestEntity;
setModel = action('setModel', (model?: Object3D) => { @observable.ref current_model?: Object3D;
this.resetModelAndQuestState(); @observable.ref animation_mixer?: AnimationMixer;
this.currentModel = model;
})
setQuest = action('setQuest', (quest?: Quest) => { set_quest = action('set_quest', (quest?: Quest) => {
this.resetModelAndQuestState(); this.reset_model_and_quest_state();
this.currentQuest = quest; this.current_quest = quest;
if (quest && quest.area_variants.length) { if (quest && quest.area_variants.length) {
this.currentArea = quest.area_variants[0].area; this.current_area = quest.area_variants[0].area;
} }
}) })
private resetModelAndQuestState() { set_model = action('set_model', (model?: Object3D) => {
this.currentQuest = undefined; this.reset_model_and_quest_state();
this.currentArea = undefined; this.current_model = model;
this.selectedEntity = undefined; })
this.currentModel = undefined;
add_animation = action('add_animation', (clip: AnimationClip) => {
if (!this.current_model) return;
if (this.animation_mixer) {
this.animation_mixer.stopAllAction();
this.animation_mixer.uncacheRoot(this.current_model);
} else {
this.animation_mixer = new AnimationMixer(this.current_model);
}
const action = this.animation_mixer.clipAction(clip);
action.play();
})
private reset_model_and_quest_state() {
this.current_quest = undefined;
this.current_area = undefined;
this.selected_entity = undefined;
if (this.current_model && this.animation_mixer) {
this.animation_mixer.uncacheRoot(this.current_model);
}
this.current_model = undefined;
this.animation_mixer = undefined;
} }
setSelectedEntity = (entity?: QuestEntity) => { setSelectedEntity = (entity?: QuestEntity) => {
this.selectedEntity = entity; this.selected_entity = entity;
} }
setCurrentAreaId = action('setCurrentAreaId', (areaId?: number) => { set_current_area_id = action('set_current_area_id', (area_id?: number) => {
this.selectedEntity = undefined; this.selected_entity = undefined;
if (areaId == null) { if (area_id == null) {
this.currentArea = undefined; this.current_area = undefined;
} else if (this.currentQuest) { } else if (this.current_quest) {
const areaVariant = this.currentQuest.area_variants.find( const area_variant = this.current_quest.area_variants.find(
variant => variant.area.id === areaId variant => variant.area.id === area_id
); );
this.currentArea = areaVariant && areaVariant.area; this.current_area = area_variant && area_variant.area;
} }
}) })
loadFile = (file: File) => { load_file = (file: File) => {
const reader = new FileReader(); const reader = new FileReader();
reader.addEventListener('loadend', () => { this.loadend(file, reader) }); reader.addEventListener('loadend', () => { this.loadend(file, reader) });
reader.readAsArrayBuffer(file); reader.readAsArrayBuffer(file);
@ -70,25 +94,33 @@ class QuestEditorStore {
} }
if (file.name.endsWith('.nj')) { if (file.name.endsWith('.nj')) {
this.setModel(createModelMesh(parseNj(new BufferCursor(reader.result, true)))); this.set_model(create_model_mesh(parse_nj(new BufferCursor(reader.result, true))));
} else if (file.name.endsWith('.xj')) { } else if (file.name.endsWith('.xj')) {
this.setModel(createModelMesh(parseXj(new BufferCursor(reader.result, true)))); this.set_model(create_model_mesh(parse_xj(new BufferCursor(reader.result, true))));
} else if (file.name.endsWith('.njm')) {
this.add_animation(
create_animation_clip(parse_njm_4(new BufferCursor(reader.result, true)))
);
} else { } else {
const quest = parse_quest(new BufferCursor(reader.result, true)); const quest = parse_quest(new BufferCursor(reader.result, true));
this.setQuest(quest); this.set_quest(quest);
if (quest) { if (quest) {
// Load section data. // Load section data.
for (const variant of quest.area_variants) { for (const variant of quest.area_variants) {
const sections = await getAreaSections(quest.episode, variant.area.id, variant.id); const sections = await get_area_sections(
quest.episode,
variant.area.id,
variant.id
);
variant.sections = sections; variant.sections = sections;
// Generate object geometry. // Generate object geometry.
for (const object of quest.objects.filter(o => o.area_id === variant.area.id)) { for (const object of quest.objects.filter(o => o.area_id === variant.area.id)) {
try { try {
const geometry = await getObjectGeometry(object.type); const geometry = await get_object_geometry(object.type);
this.setSectionOnVisibleQuestEntity(object, sections); this.set_section_on_visible_quest_entity(object, sections);
object.object3d = createObjectMesh(object, geometry); object.object3d = create_object_mesh(object, geometry);
} catch (e) { } catch (e) {
logger.error(e); logger.error(e);
} }
@ -97,9 +129,9 @@ class QuestEditorStore {
// Generate NPC geometry. // Generate NPC geometry.
for (const npc of quest.npcs.filter(npc => npc.area_id === variant.area.id)) { for (const npc of quest.npcs.filter(npc => npc.area_id === variant.area.id)) {
try { try {
const geometry = await getNpcGeometry(npc.type); const geometry = await get_npc_geometry(npc.type);
this.setSectionOnVisibleQuestEntity(npc, sections); this.set_section_on_visible_quest_entity(npc, sections);
npc.object3d = createNpcMesh(npc, geometry); npc.object3d = create_npc_mesh(npc, geometry);
} catch (e) { } catch (e) {
logger.error(e); logger.error(e);
} }
@ -111,19 +143,22 @@ class QuestEditorStore {
} }
} }
private setSectionOnVisibleQuestEntity = async (entity: QuestEntity, sections: Section[]) => { private set_section_on_visible_quest_entity = async (
entity: QuestEntity,
sections: Section[]
) => {
let { x, y, z } = entity.position; let { x, y, z } = entity.position;
const section = sections.find(s => s.id === entity.section_id); const section = sections.find(s => s.id === entity.section_id);
entity.section = section; entity.section = section;
if (section) { if (section) {
const { x: secX, y: secY, z: secZ } = section.position; const { x: sec_x, y: sec_y, z: sec_z } = section.position;
const rotX = section.cos_y_axis_rotation * x + section.sin_y_axis_rotation * z; const rot_x = section.cos_y_axis_rotation * x + section.sin_y_axis_rotation * z;
const rotZ = -section.sin_y_axis_rotation * x + section.cos_y_axis_rotation * z; const rot_z = -section.sin_y_axis_rotation * x + section.cos_y_axis_rotation * z;
x = rotX + secX; x = rot_x + sec_x;
y += secY; y += sec_y;
z = rotZ + secZ; z = rot_z + sec_z;
} else { } else {
logger.warn(`Section ${entity.section_id} not found.`); logger.warn(`Section ${entity.section_id} not found.`);
} }
@ -131,17 +166,17 @@ class QuestEditorStore {
entity.position = new Vec3(x, y, z); entity.position = new Vec3(x, y, z);
} }
saveCurrentQuestToFile = (fileName: string) => { save_current_quest_to_file = (file_name: string) => {
if (this.currentQuest) { if (this.current_quest) {
const cursor = write_quest_qst(this.currentQuest, fileName); const cursor = write_quest_qst(this.current_quest, file_name);
if (!fileName.endsWith('.qst')) { if (!file_name.endsWith('.qst')) {
fileName += '.qst'; file_name += '.qst';
} }
const a = document.createElement('a'); const a = document.createElement('a');
a.href = URL.createObjectURL(new Blob([cursor.buffer])); a.href = URL.createObjectURL(new Blob([cursor.buffer]));
a.download = fileName; a.download = file_name;
document.body.appendChild(a); document.body.appendChild(a);
a.click(); a.click();
URL.revokeObjectURL(a.href); URL.revokeObjectURL(a.href);
@ -150,4 +185,4 @@ class QuestEditorStore {
} }
} }
export const questEditorStore = new QuestEditorStore(); export const quest_editor_store = new QuestEditorStore();

94
src/ui/quest_editor/QuestEditorComponent.tsx
View File

@ -3,7 +3,7 @@ import { UploadChangeParam } from "antd/lib/upload";
import { UploadFile } from "antd/lib/upload/interface"; import { UploadFile } from "antd/lib/upload/interface";
import { observer } from "mobx-react"; import { observer } from "mobx-react";
import React, { ChangeEvent } from "react"; import React, { ChangeEvent } from "react";
import { questEditorStore } from "../../stores/QuestEditorStore"; import { quest_editor_store } from "../../stores/QuestEditorStore";
import { EntityInfoComponent } from "./EntityInfoComponent"; import { EntityInfoComponent } from "./EntityInfoComponent";
import './QuestEditorComponent.css'; import './QuestEditorComponent.css';
import { QuestInfoComponent } from "./QuestInfoComponent"; import { QuestInfoComponent } from "./QuestInfoComponent";
@ -12,22 +12,22 @@ import { RendererComponent } from "./RendererComponent";
@observer @observer
export class QuestEditorComponent extends React.Component<{}, { export class QuestEditorComponent extends React.Component<{}, {
filename?: string, filename?: string,
saveDialogOpen: boolean, save_dialog_open: boolean,
saveDialogFilename: string save_dialog_filename: string
}> { }> {
state = { state = {
saveDialogOpen: false, save_dialog_open: false,
saveDialogFilename: 'Untitled', save_dialog_filename: 'Untitled',
}; };
render() { render() {
const quest = questEditorStore.currentQuest; const quest = quest_editor_store.current_quest;
const model = questEditorStore.currentModel; const model = quest_editor_store.current_model;
const area = questEditorStore.currentArea; const area = quest_editor_store.current_area;
return ( return (
<div className="qe-QuestEditorComponent"> <div className="qe-QuestEditorComponent">
<Toolbar onSaveAsClicked={this.saveAsClicked} /> <Toolbar onSaveAsClicked={this.save_as_clicked} />
<div className="qe-QuestEditorComponent-main"> <div className="qe-QuestEditorComponent-main">
<QuestInfoComponent quest={quest} /> <QuestInfoComponent quest={quest} />
<RendererComponent <RendererComponent
@ -35,41 +35,41 @@ export class QuestEditorComponent extends React.Component<{}, {
area={area} area={area}
model={model} model={model}
/> />
<EntityInfoComponent entity={questEditorStore.selectedEntity} /> <EntityInfoComponent entity={quest_editor_store.selected_entity} />
</div> </div>
<SaveAsForm <SaveAsForm
isOpen={this.state.saveDialogOpen} is_open={this.state.save_dialog_open}
filename={this.state.saveDialogFilename} filename={this.state.save_dialog_filename}
onFilenameChange={this.saveDialogFilenameChanged} on_filename_change={this.save_dialog_filename_changed}
onOk={this.saveDialogAffirmed} on_ok={this.save_dialog_affirmed}
onCancel={this.saveDialogCancelled} on_cancel={this.save_dialog_cancelled}
/> />
</div> </div>
); );
} }
private saveAsClicked = (filename?: string) => { private save_as_clicked = (filename?: string) => {
const name = filename const name = filename
? filename.endsWith('.qst') ? filename.slice(0, -4) : filename ? filename.endsWith('.qst') ? filename.slice(0, -4) : filename
: this.state.saveDialogFilename; : this.state.save_dialog_filename;
this.setState({ this.setState({
saveDialogOpen: true, save_dialog_open: true,
saveDialogFilename: name save_dialog_filename: name
}); });
} }
private saveDialogFilenameChanged = (filename: string) => { private save_dialog_filename_changed = (filename: string) => {
this.setState({ saveDialogFilename: filename }); this.setState({ save_dialog_filename: filename });
} }
private saveDialogAffirmed = () => { private save_dialog_affirmed = () => {
questEditorStore.saveCurrentQuestToFile(this.state.saveDialogFilename); quest_editor_store.save_current_quest_to_file(this.state.save_dialog_filename);
this.setState({ saveDialogOpen: false }); this.setState({ save_dialog_open: false });
} }
private saveDialogCancelled = () => { private save_dialog_cancelled = () => {
this.setState({ saveDialogOpen: false }); this.setState({ save_dialog_open: false });
} }
} }
@ -80,17 +80,17 @@ class Toolbar extends React.Component<{ onSaveAsClicked: (filename?: string) =>
} }
render() { render() {
const quest = questEditorStore.currentQuest; const quest = quest_editor_store.current_quest;
const areas = quest && Array.from(quest.area_variants).map(a => a.area); const areas = quest && Array.from(quest.area_variants).map(a => a.area);
const area = questEditorStore.currentArea; const area = quest_editor_store.current_area;
const areaId = area && area.id; const area_id = area && area.id;
return ( return (
<div className="qe-QuestEditorComponent-toolbar"> <div className="qe-QuestEditorComponent-toolbar">
<Upload <Upload
accept=".nj, .qst, .xj" accept=".nj, .njm, .qst, .xj"
showUploadList={false} showUploadList={false}
onChange={this.setFilename} onChange={this.set_filename}
// Make sure it doesn't do a POST: // Make sure it doesn't do a POST:
customRequest={() => false} customRequest={() => false}
> >
@ -98,8 +98,8 @@ class Toolbar extends React.Component<{ onSaveAsClicked: (filename?: string) =>
</Upload> </Upload>
{areas && ( {areas && (
<Select <Select
onChange={questEditorStore.setCurrentAreaId} onChange={quest_editor_store.set_current_area_id}
value={areaId} value={area_id}
style={{ width: 200 }} style={{ width: 200 }}
> >
{areas.map(area => {areas.map(area =>
@ -110,39 +110,39 @@ class Toolbar extends React.Component<{ onSaveAsClicked: (filename?: string) =>
{quest && ( {quest && (
<Button <Button
icon="save" icon="save"
onClick={this.saveAsClicked} onClick={this.save_as_clicked}
>Save as...</Button> >Save as...</Button>
)} )}
</div> </div>
); );
} }
private setFilename = (info: UploadChangeParam<UploadFile>) => { private set_filename = (info: UploadChangeParam<UploadFile>) => {
if (info.file.originFileObj) { if (info.file.originFileObj) {
this.setState({ filename: info.file.name }); this.setState({ filename: info.file.name });
questEditorStore.loadFile(info.file.originFileObj); quest_editor_store.load_file(info.file.originFileObj);
} }
} }
private saveAsClicked = () => { private save_as_clicked = () => {
this.props.onSaveAsClicked(this.state.filename); this.props.onSaveAsClicked(this.state.filename);
} }
} }
class SaveAsForm extends React.Component<{ class SaveAsForm extends React.Component<{
isOpen: boolean, is_open: boolean,
filename: string, filename: string,
onFilenameChange: (name: string) => void, on_filename_change: (name: string) => void,
onOk: () => void, on_ok: () => void,
onCancel: () => void on_cancel: () => void
}> { }> {
render() { render() {
return ( return (
<Modal <Modal
title={<><Icon type="save" /> Save as...</>} title={<><Icon type="save" /> Save as...</>}
visible={this.props.isOpen} visible={this.props.is_open}
onOk={this.props.onOk} onOk={this.props.on_ok}
onCancel={this.props.onCancel} onCancel={this.props.on_cancel}
> >
<Form layout="vertical"> <Form layout="vertical">
<Form.Item label="Name"> <Form.Item label="Name">
@ -150,7 +150,7 @@ class SaveAsForm extends React.Component<{
autoFocus={true} autoFocus={true}
maxLength={12} maxLength={12}
value={this.props.filename} value={this.props.filename}
onChange={this.nameChanged} onChange={this.name_changed}
/> />
</Form.Item> </Form.Item>
</Form> </Form>
@ -158,7 +158,7 @@ class SaveAsForm extends React.Component<{
); );
} }
private nameChanged = (e: ChangeEvent<HTMLInputElement>) => { private name_changed = (e: ChangeEvent<HTMLInputElement>) => {
this.props.onFilenameChange(e.currentTarget.value); this.props.on_filename_change(e.currentTarget.value);
} }
} }

18
static/update_generic_data.ts
View File

@ -1,7 +1,7 @@
import fs from "fs"; import fs from "fs";
import { BufferCursor } from "../src/bin_data/BufferCursor"; import { BufferCursor } from "../src/bin_data/BufferCursor";
import { parse_rlc } from "../src/bin_data/parsing/rlc"; import { parse_rlc } from "../src/bin_data/parsing/rlc";
import { parse_njm2 } from "../src/bin_data/parsing/ninja/njm2"; import { parse_njm_4 } from "../src/bin_data/parsing/ninja/motion";
import Logger from 'js-logger'; import Logger from 'js-logger';
const logger = Logger.get('static/updateGenericData'); const logger = Logger.get('static/updateGenericData');
@ -21,8 +21,22 @@ update();
function update() { function update() {
const buf = fs.readFileSync(`${RESOURCE_DIR}/plymotiondata.rlc`); const buf = fs.readFileSync(`${RESOURCE_DIR}/plymotiondata.rlc`);
let i = 0;
for (const file of parse_rlc(new BufferCursor(buf, false))) { for (const file of parse_rlc(new BufferCursor(buf, false))) {
logger.info(`Frame count: ${parse_njm2(file).motion.frame_count}`); const action = parse_njm_4(file);
const nmdm = new BufferCursor(file.size + 8);
nmdm.write_string_ascii("NMDM", 4);
nmdm.seek(4); // File size placeholder.
nmdm.write_u8_array([0xC, 0, 0, 0]);
nmdm.write_u32(action.motion.frame_count);
nmdm.write_u8_array([3, 0, 2, 0, 0xC, 4, 0, 0]);
nmdm.seek(32);
fs.writeFileSync(
`${RESOURCE_DIR}/plymotiondata/plymotion_${(i++).toString().padStart(3, '0')}.njm`,
file.uint8_array_view()
);
} }
} }