mirror of
https://github.com/DaanVandenBosch/phantasmal-world.git
synced 2025-04-04 22:58:29 +08:00
Started working on animation support in model viewer.
This commit is contained in:
Daan Vanden Bosch
parent
a639eb683f
commit
de3de9256b
@ -6,74 +6,78 @@ import { parseCRel, parseNRel } from '../parsing/geometry';
|
||||
//
|
||||
// Caches
|
||||
//
|
||||
const sectionsCache: Map<string, Promise<Section[]>> = new Map();
|
||||
const renderGeometryCache: Map<string, Promise<Object3D>> = new Map();
|
||||
const collisionGeometryCache: Map<string, Promise<Object3D>> = new Map();
|
||||
const sections_cache: Map<string, Promise<Section[]>> = new Map();
|
||||
const render_geometry_cache: 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,
|
||||
areaId: number,
|
||||
areaVariant: number
|
||||
area_id: number,
|
||||
area_variant: number
|
||||
): Promise<Section[]> {
|
||||
const sections = sectionsCache.get(`${episode}-${areaId}-${areaVariant}`);
|
||||
const sections = sections_cache.get(`${episode}-${area_id}-${area_variant}`);
|
||||
|
||||
if (sections) {
|
||||
return sections;
|
||||
} else {
|
||||
return getAreaSectionsAndRenderGeometry(
|
||||
episode, areaId, areaVariant).then(({sections}) => sections);
|
||||
return get_area_sections_and_render_geometry(
|
||||
episode, area_id, area_variant
|
||||
).then(({ sections }) => sections);
|
||||
}
|
||||
}
|
||||
|
||||
export function getAreaRenderGeometry(
|
||||
export function get_area_render_geometry(
|
||||
episode: number,
|
||||
areaId: number,
|
||||
areaVariant: number
|
||||
area_id: number,
|
||||
area_variant: number
|
||||
): Promise<Object3D> {
|
||||
const object3d = renderGeometryCache.get(`${episode}-${areaId}-${areaVariant}`);
|
||||
const object_3d = render_geometry_cache.get(`${episode}-${area_id}-${area_variant}`);
|
||||
|
||||
if (object3d) {
|
||||
return object3d;
|
||||
if (object_3d) {
|
||||
return object_3d;
|
||||
} else {
|
||||
return getAreaSectionsAndRenderGeometry(
|
||||
episode, areaId, areaVariant).then(({object3d}) => object3d);
|
||||
return get_area_sections_and_render_geometry(
|
||||
episode, area_id, area_variant
|
||||
).then(({ object3d }) => object3d);
|
||||
}
|
||||
}
|
||||
|
||||
export function getAreaCollisionGeometry(
|
||||
export function get_area_collision_geometry(
|
||||
episode: number,
|
||||
areaId: number,
|
||||
areaVariant: number
|
||||
area_id: number,
|
||||
area_variant: number
|
||||
): Promise<Object3D> {
|
||||
const object3d = collisionGeometryCache.get(`${episode}-${areaId}-${areaVariant}`);
|
||||
const object_3d = collision_geometry_cache.get(`${episode}-${area_id}-${area_variant}`);
|
||||
|
||||
if (object3d) {
|
||||
return object3d;
|
||||
if (object_3d) {
|
||||
return object_3d;
|
||||
} else {
|
||||
const object3d = getAreaCollisionData(
|
||||
episode, areaId, areaVariant).then(parseCRel);
|
||||
collisionGeometryCache.set(`${areaId}-${areaVariant}`, object3d);
|
||||
return object3d;
|
||||
const object_3d = getAreaCollisionData(
|
||||
episode, area_id, area_variant
|
||||
).then(parseCRel);
|
||||
collision_geometry_cache.set(`${area_id}-${area_variant}`, object_3d);
|
||||
return object_3d;
|
||||
}
|
||||
}
|
||||
|
||||
function getAreaSectionsAndRenderGeometry(
|
||||
function get_area_sections_and_render_geometry(
|
||||
episode: number,
|
||||
areaId: number,
|
||||
areaVariant: number
|
||||
area_id: number,
|
||||
area_variant: number
|
||||
): Promise<{ sections: Section[], object3d: Object3D }> {
|
||||
const promise = getAreaRenderData(
|
||||
episode, areaId, areaVariant).then(parseNRel);
|
||||
episode, area_id, area_variant
|
||||
).then(parseNRel);
|
||||
|
||||
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) => {
|
||||
promise.then(({object3d}) => resolve(object3d)).catch(reject);
|
||||
const object_3d = new Promise<Object3D>((resolve, reject) => {
|
||||
promise.then(({ object3d }) => resolve(object3d)).catch(reject);
|
||||
});
|
||||
|
||||
sectionsCache.set(`${episode}-${areaId}-${areaVariant}`, sections);
|
||||
renderGeometryCache.set(`${episode}-${areaId}-${areaVariant}`, object3d);
|
||||
sections_cache.set(`${episode}-${area_id}-${area_variant}`, sections);
|
||||
render_geometry_cache.set(`${episode}-${area_id}-${area_variant}`, object_3d);
|
||||
|
||||
return promise;
|
||||
}
|
||||
|
||||
@ -2,51 +2,51 @@ import { BufferGeometry } from 'three';
|
||||
import { NpcType, ObjectType } from '../../domain';
|
||||
import { getNpcData, getObjectData } from './binaryAssets';
|
||||
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 objectCache: Map<string, Promise<BufferGeometry>> = new Map();
|
||||
const npc_cache: Map<string, Promise<BufferGeometry>> = new Map();
|
||||
const object_cache: Map<string, Promise<BufferGeometry>> = new Map();
|
||||
|
||||
export function getNpcGeometry(npcType: NpcType): Promise<BufferGeometry> {
|
||||
let geometry = npcCache.get(String(npcType.id));
|
||||
export function get_npc_geometry(npc_type: NpcType): Promise<BufferGeometry> {
|
||||
let geometry = npc_cache.get(String(npc_type.id));
|
||||
|
||||
if (geometry) {
|
||||
return geometry;
|
||||
} else {
|
||||
geometry = getNpcData(npcType).then(({ url, data }) => {
|
||||
geometry = getNpcData(npc_type).then(({ url, data }) => {
|
||||
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) {
|
||||
return object3d;
|
||||
if (object_3d) {
|
||||
return object_3d;
|
||||
} else {
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
export function getObjectGeometry(objectType: ObjectType): Promise<BufferGeometry> {
|
||||
let geometry = objectCache.get(String(objectType.id));
|
||||
export function get_object_geometry(object_type: ObjectType): Promise<BufferGeometry> {
|
||||
let geometry = object_cache.get(String(object_type.id));
|
||||
|
||||
if (geometry) {
|
||||
return geometry;
|
||||
} else {
|
||||
geometry = getObjectData(objectType).then(({ url, data }) => {
|
||||
geometry = getObjectData(object_type).then(({ url, data }) => {
|
||||
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) {
|
||||
return object3d;
|
||||
if (object_3d) {
|
||||
return object_3d;
|
||||
} else {
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
@ -7,41 +7,41 @@ import {
|
||||
Vector3
|
||||
} from 'three';
|
||||
import { BufferCursor } from '../../BufferCursor';
|
||||
import { parseNjModel, NjContext } from './nj';
|
||||
import { parseXjModel, XjContext } from './xj';
|
||||
import { parse_nj_model, NjContext } from './nj';
|
||||
import { parse_xj_model, XjContext } from './xj';
|
||||
|
||||
// TODO:
|
||||
// - deal with multiple NJCM chunks
|
||||
// - deal with other types of chunks
|
||||
|
||||
export function parseNj(cursor: BufferCursor): BufferGeometry | undefined {
|
||||
return parseNinja(cursor, 'nj');
|
||||
export function parse_nj(cursor: BufferCursor): BufferGeometry | undefined {
|
||||
return parse_ninja(cursor, 'nj');
|
||||
}
|
||||
|
||||
export function parseXj(cursor: BufferCursor): BufferGeometry | undefined {
|
||||
return parseNinja(cursor, 'xj');
|
||||
export function parse_xj(cursor: BufferCursor): BufferGeometry | undefined {
|
||||
return parse_ninja(cursor, 'xj');
|
||||
}
|
||||
|
||||
type Format = 'nj' | 'xj';
|
||||
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) {
|
||||
// Ninja uses a little endian variant of the IFF format.
|
||||
// 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.
|
||||
const iffTypeId = cursor.string_ascii(4, false, false);
|
||||
const iffChunkSize = cursor.u32();
|
||||
const iff_type_id = cursor.string_ascii(4, false, false);
|
||||
const iff_chunk_size = cursor.u32();
|
||||
|
||||
if (iffTypeId === 'NJCM') {
|
||||
return parseNjcm(cursor.take(iffChunkSize), format);
|
||||
if (iff_type_id === 'NJCM') {
|
||||
return parse_njcm(cursor.take(iff_chunk_size), format);
|
||||
} 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) {
|
||||
let context: Context;
|
||||
|
||||
@ -50,7 +50,7 @@ function parseNjcm(cursor: BufferCursor, format: Format): BufferGeometry | undef
|
||||
format,
|
||||
positions: [],
|
||||
normals: [],
|
||||
cachedChunkOffsets: [],
|
||||
cached_chunk_offsets: [],
|
||||
vertices: []
|
||||
};
|
||||
} else {
|
||||
@ -62,63 +62,63 @@ function parseNjcm(cursor: BufferCursor, format: Format): BufferGeometry | undef
|
||||
};
|
||||
}
|
||||
|
||||
parseSiblingObjects(cursor, new Matrix4(), context);
|
||||
return createBufferGeometry(context);
|
||||
parse_sibling_objects(cursor, new Matrix4(), context);
|
||||
return create_buffer_geometry(context);
|
||||
}
|
||||
}
|
||||
|
||||
function parseSiblingObjects(
|
||||
function parse_sibling_objects(
|
||||
cursor: BufferCursor,
|
||||
parentMatrix: Matrix4,
|
||||
parent_matrix: Matrix4,
|
||||
context: Context
|
||||
): void {
|
||||
const evalFlags = cursor.u32();
|
||||
const noTranslate = (evalFlags & 0b1) !== 0;
|
||||
const noRotate = (evalFlags & 0b10) !== 0;
|
||||
const noScale = (evalFlags & 0b100) !== 0;
|
||||
const hidden = (evalFlags & 0b1000) !== 0;
|
||||
const breakChildTrace = (evalFlags & 0b10000) !== 0;
|
||||
const zxyRotationOrder = (evalFlags & 0b100000) !== 0;
|
||||
const eval_flags = cursor.u32();
|
||||
const no_translate = (eval_flags & 0b1) !== 0;
|
||||
const no_rotate = (eval_flags & 0b10) !== 0;
|
||||
const no_scale = (eval_flags & 0b100) !== 0;
|
||||
const hidden = (eval_flags & 0b1000) !== 0;
|
||||
const break_child_trace = (eval_flags & 0b10000) !== 0;
|
||||
const zxy_rotation_order = (eval_flags & 0b100000) !== 0;
|
||||
|
||||
const modelOffset = cursor.u32();
|
||||
const posX = cursor.f32();
|
||||
const posY = cursor.f32();
|
||||
const posZ = cursor.f32();
|
||||
const rotationX = cursor.i32() * (2 * Math.PI / 0xFFFF);
|
||||
const rotationY = cursor.i32() * (2 * Math.PI / 0xFFFF);
|
||||
const rotationZ = cursor.i32() * (2 * Math.PI / 0xFFFF);
|
||||
const scaleX = cursor.f32();
|
||||
const scaleY = cursor.f32();
|
||||
const scaleZ = cursor.f32();
|
||||
const childOffset = cursor.u32();
|
||||
const siblingOffset = cursor.u32();
|
||||
const model_offset = cursor.u32();
|
||||
const pos_x = cursor.f32();
|
||||
const pos_y = cursor.f32();
|
||||
const pos_z = cursor.f32();
|
||||
const rotation_x = cursor.i32() * (2 * Math.PI / 0xFFFF);
|
||||
const rotation_y = cursor.i32() * (2 * Math.PI / 0xFFFF);
|
||||
const rotation_z = cursor.i32() * (2 * Math.PI / 0xFFFF);
|
||||
const scale_x = cursor.f32();
|
||||
const scale_y = cursor.f32();
|
||||
const scale_z = cursor.f32();
|
||||
const child_offset = 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()
|
||||
.compose(
|
||||
noTranslate ? new Vector3() : new Vector3(posX, posY, posZ),
|
||||
noRotate ? new Quaternion(0, 0, 0, 1) : new Quaternion().setFromEuler(rotation),
|
||||
noScale ? new Vector3(1, 1, 1) : new Vector3(scaleX, scaleY, scaleZ)
|
||||
no_translate ? new Vector3() : new Vector3(pos_x, pos_y, pos_z),
|
||||
no_rotate ? new Quaternion(0, 0, 0, 1) : new Quaternion().setFromEuler(rotation),
|
||||
no_scale ? new Vector3(1, 1, 1) : new Vector3(scale_x, scale_y, scale_z)
|
||||
)
|
||||
.premultiply(parentMatrix);
|
||||
.premultiply(parent_matrix);
|
||||
|
||||
if (modelOffset && !hidden) {
|
||||
cursor.seek_start(modelOffset);
|
||||
parseModel(cursor, matrix, context);
|
||||
if (model_offset && !hidden) {
|
||||
cursor.seek_start(model_offset);
|
||||
parse_model(cursor, matrix, context);
|
||||
}
|
||||
|
||||
if (childOffset && !breakChildTrace) {
|
||||
cursor.seek_start(childOffset);
|
||||
parseSiblingObjects(cursor, matrix, context);
|
||||
if (child_offset && !break_child_trace) {
|
||||
cursor.seek_start(child_offset);
|
||||
parse_sibling_objects(cursor, matrix, context);
|
||||
}
|
||||
|
||||
if (siblingOffset) {
|
||||
cursor.seek_start(siblingOffset);
|
||||
parseSiblingObjects(cursor, parentMatrix, context);
|
||||
if (sibling_offset) {
|
||||
cursor.seek_start(sibling_offset);
|
||||
parse_sibling_objects(cursor, parent_matrix, context);
|
||||
}
|
||||
}
|
||||
|
||||
function createBufferGeometry(context: Context): BufferGeometry {
|
||||
function create_buffer_geometry(context: Context): BufferGeometry {
|
||||
const geometry = new BufferGeometry();
|
||||
geometry.addAttribute('position', new BufferAttribute(new Float32Array(context.positions), 3));
|
||||
geometry.addAttribute('normal', new BufferAttribute(new Float32Array(context.normals), 3));
|
||||
@ -130,10 +130,10 @@ function createBufferGeometry(context: Context): BufferGeometry {
|
||||
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') {
|
||||
parseNjModel(cursor, matrix, context);
|
||||
parse_nj_model(cursor, matrix, context);
|
||||
} else {
|
||||
parseXjModel(cursor, matrix, context);
|
||||
parse_xj_model(cursor, matrix, context);
|
||||
}
|
||||
}
|
||||
|
||||
@ -12,13 +12,38 @@ export type NjMotion = {
|
||||
motion_data: NjMotionData[],
|
||||
frame_count: number,
|
||||
type: number,
|
||||
interpolation: number,
|
||||
interpolation: NjInterpolation,
|
||||
element_count: number,
|
||||
}
|
||||
|
||||
export enum NjInterpolation {
|
||||
Linear, Spline, UserFunction, SamplingMask
|
||||
}
|
||||
|
||||
export type NjMotionData = {
|
||||
keyframes: NjKeyframe[][],
|
||||
keyframe_count: number[],
|
||||
tracks: NjKeyframeTrack[],
|
||||
}
|
||||
|
||||
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
|
||||
@ -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);
|
||||
const offset1 = cursor.u32();
|
||||
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 {
|
||||
// Points to an array the size of the total amount of objects in the object tree.
|
||||
const mdata_offset = cursor.u32();
|
||||
@ -74,12 +100,11 @@ function parse_motion(cursor: BufferCursor): NjMotion {
|
||||
const type = cursor.u16();
|
||||
const inp_fn = cursor.u16();
|
||||
// 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;
|
||||
|
||||
let motion_data: NjMotionData = {
|
||||
keyframes: [],
|
||||
keyframe_count: [],
|
||||
tracks: [],
|
||||
};
|
||||
|
||||
const size = count_set_bits(type);
|
||||
@ -93,49 +118,51 @@ function parse_motion(cursor: BufferCursor): NjMotion {
|
||||
|
||||
for (let i = 0; i < size; i++) {
|
||||
const count = cursor.u32();
|
||||
motion_data.keyframe_count.push(count);
|
||||
keyframe_counts.push(count);
|
||||
}
|
||||
|
||||
// NJD_MTYPE_POS_0
|
||||
if ((type & (1 << 0)) !== 0) {
|
||||
cursor.seek_start(keyframe_offsets.shift()!);
|
||||
motion_data.keyframes.push(
|
||||
parse_motion_data_f(cursor, keyframe_counts.shift()!)
|
||||
);
|
||||
motion_data.tracks.push({
|
||||
type: NjKeyframeTrackType.Position,
|
||||
keyframes: parse_motion_data_f(cursor, keyframe_counts.shift()!)
|
||||
});
|
||||
}
|
||||
|
||||
// NJD_MTYPE_ANG_1
|
||||
if ((type & (1 << 1)) !== 0) {
|
||||
cursor.seek_start(keyframe_offsets.shift()!);
|
||||
motion_data.keyframes.push(
|
||||
parse_motion_data_a(cursor, keyframe_counts.shift()!)
|
||||
);
|
||||
motion_data.tracks.push({
|
||||
type: NjKeyframeTrackType.Rotation,
|
||||
keyframes: parse_motion_data_a(cursor, keyframe_counts.shift()!)
|
||||
});
|
||||
}
|
||||
|
||||
// NJD_MTYPE_SCL_2
|
||||
if ((type & (1 << 2)) !== 0) {
|
||||
cursor.seek_start(keyframe_offsets.shift()!);
|
||||
motion_data.keyframes.push(
|
||||
parse_motion_data_f(cursor, keyframe_counts.shift()!)
|
||||
);
|
||||
motion_data.tracks.push({
|
||||
type: NjKeyframeTrackType.Scale,
|
||||
keyframes: parse_motion_data_f(cursor, keyframe_counts.shift()!)
|
||||
});
|
||||
}
|
||||
|
||||
// NJD_MTYPE_VEC_3
|
||||
if ((type & (1 << 3)) !== 0) {
|
||||
cursor.seek_start(keyframe_offsets.shift()!);
|
||||
motion_data.keyframes.push(
|
||||
parse_motion_data_f(cursor, keyframe_counts.shift()!)
|
||||
);
|
||||
}
|
||||
// // NJD_MTYPE_VEC_3
|
||||
// if ((type & (1 << 3)) !== 0) {
|
||||
// cursor.seek_start(keyframe_offsets.shift()!);
|
||||
// motion_data.tracks.push(
|
||||
// parse_motion_data_f(cursor, keyframe_counts.shift()!)
|
||||
// );
|
||||
// }
|
||||
|
||||
// NJD_MTYPE_TARGET_3
|
||||
if ((type & (1 << 6)) !== 0) {
|
||||
cursor.seek_start(keyframe_offsets.shift()!);
|
||||
motion_data.keyframes.push(
|
||||
parse_motion_data_f(cursor, keyframe_counts.shift()!)
|
||||
);
|
||||
}
|
||||
// // NJD_MTYPE_TARGET_3
|
||||
// if ((type & (1 << 6)) !== 0) {
|
||||
// cursor.seek_start(keyframe_offsets.shift()!);
|
||||
// motion_data.tracks.push(
|
||||
// parse_motion_data_f(cursor, keyframe_counts.shift()!)
|
||||
// );
|
||||
// }
|
||||
|
||||
// TODO: all NJD_MTYPE's
|
||||
|
||||
@ -17,7 +17,7 @@ export interface NjContext {
|
||||
format: 'nj';
|
||||
positions: number[];
|
||||
normals: number[];
|
||||
cachedChunkOffsets: number[];
|
||||
cached_chunk_offsets: number[];
|
||||
vertices: { position: Vector3, normal: Vector3 }[];
|
||||
}
|
||||
|
||||
@ -35,39 +35,39 @@ interface ChunkVertex {
|
||||
}
|
||||
|
||||
interface ChunkTriangleStrip {
|
||||
clockwiseWinding: boolean;
|
||||
clockwise_winding: boolean;
|
||||
indices: number[];
|
||||
}
|
||||
|
||||
export function parseNjModel(cursor: BufferCursor, matrix: Matrix4, context: NjContext): void {
|
||||
const { positions, normals, cachedChunkOffsets, vertices } = context;
|
||||
export function parse_nj_model(cursor: BufferCursor, matrix: Matrix4, context: NjContext): void {
|
||||
const { positions, normals, cached_chunk_offsets, vertices } = context;
|
||||
|
||||
const vlistOffset = cursor.u32(); // Vertex list
|
||||
const plistOffset = cursor.u32(); // Triangle strip index list
|
||||
const vlist_offset = cursor.u32(); // Vertex 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) {
|
||||
cursor.seek_start(vlistOffset);
|
||||
if (vlist_offset) {
|
||||
cursor.seek_start(vlist_offset);
|
||||
|
||||
for (const chunk of parseChunks(cursor, cachedChunkOffsets, true)) {
|
||||
if (chunk.chunkType === 'VERTEX') {
|
||||
const chunkVertices: ChunkVertex[] = chunk.data;
|
||||
for (const chunk of parse_chunks(cursor, cached_chunk_offsets, true)) {
|
||||
if (chunk.chunk_type === 'VERTEX') {
|
||||
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 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 };
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (plistOffset) {
|
||||
cursor.seek_start(plistOffset);
|
||||
if (plist_offset) {
|
||||
cursor.seek_start(plist_offset);
|
||||
|
||||
for (const chunk of parseChunks(cursor, cachedChunkOffsets, false)) {
|
||||
if (chunk.chunkType === 'STRIP') {
|
||||
for (const chunk of parse_chunks(cursor, cached_chunk_offsets, false)) {
|
||||
if (chunk.chunk_type === 'STRIP') {
|
||||
for (const { clockwiseWinding, indices: stripIndices } of chunk.data) {
|
||||
for (let j = 2; j < stripIndices.length; ++j) {
|
||||
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<{
|
||||
chunkType: string,
|
||||
chunkSubType: string | null,
|
||||
chunkTypeId: number,
|
||||
function parse_chunks(
|
||||
cursor: BufferCursor,
|
||||
cached_chunk_offsets: number[],
|
||||
wide_end_chunks: boolean
|
||||
): Array<{
|
||||
chunk_type: string,
|
||||
chunk_sub_type: string | null,
|
||||
chunk_type_id: number,
|
||||
data: any
|
||||
}> {
|
||||
const chunks = [];
|
||||
let loop = true;
|
||||
|
||||
while (loop) {
|
||||
const chunkTypeId = cursor.u8();
|
||||
const chunk_type_id = cursor.u8();
|
||||
const flags = cursor.u8();
|
||||
const chunkStartPosition = cursor.position;
|
||||
let chunkType = 'UNKOWN';
|
||||
let chunkSubType = null;
|
||||
const chunk_start_position = cursor.position;
|
||||
let chunk_type = 'UNKOWN';
|
||||
let chunk_sub_type = null;
|
||||
let data = null;
|
||||
let size = 0;
|
||||
|
||||
if (chunkTypeId === 0) {
|
||||
chunkType = 'NULL';
|
||||
} else if (1 <= chunkTypeId && chunkTypeId <= 5) {
|
||||
chunkType = 'BITS';
|
||||
if (chunk_type_id === 0) {
|
||||
chunk_type = 'NULL';
|
||||
} else if (1 <= chunk_type_id && chunk_type_id <= 5) {
|
||||
chunk_type = 'BITS';
|
||||
|
||||
if (chunkTypeId === 4) {
|
||||
chunkSubType = 'CACHE_POLYGON_LIST';
|
||||
if (chunk_type_id === 4) {
|
||||
chunk_sub_type = 'CACHE_POLYGON_LIST';
|
||||
data = {
|
||||
storeIndex: flags,
|
||||
store_index: flags,
|
||||
offset: cursor.position
|
||||
};
|
||||
cachedChunkOffsets[data.storeIndex] = data.offset;
|
||||
cached_chunk_offsets[data.store_index] = data.offset;
|
||||
loop = false;
|
||||
} else if (chunkTypeId === 5) {
|
||||
chunkSubType = 'DRAW_POLYGON_LIST';
|
||||
} else if (chunk_type_id === 5) {
|
||||
chunk_sub_type = 'DRAW_POLYGON_LIST';
|
||||
data = {
|
||||
storeIndex: flags
|
||||
store_index: flags
|
||||
};
|
||||
cursor.seek_start(cachedChunkOffsets[data.storeIndex]);
|
||||
chunks.splice(chunks.length, 0, ...parseChunks(cursor, cachedChunkOffsets, wideEndChunks));
|
||||
cursor.seek_start(cached_chunk_offsets[data.store_index]);
|
||||
chunks.push(
|
||||
...parse_chunks(cursor, cached_chunk_offsets, wide_end_chunks)
|
||||
);
|
||||
}
|
||||
} else if (8 <= chunkTypeId && chunkTypeId <= 9) {
|
||||
chunkType = 'TINY';
|
||||
} else if (8 <= chunk_type_id && chunk_type_id <= 9) {
|
||||
chunk_type = 'TINY';
|
||||
size = 2;
|
||||
} else if (17 <= chunkTypeId && chunkTypeId <= 31) {
|
||||
chunkType = 'MATERIAL';
|
||||
} else if (17 <= chunk_type_id && chunk_type_id <= 31) {
|
||||
chunk_type = 'MATERIAL';
|
||||
size = 2 + 2 * cursor.u16();
|
||||
} else if (32 <= chunkTypeId && chunkTypeId <= 50) {
|
||||
chunkType = 'VERTEX';
|
||||
} else if (32 <= chunk_type_id && chunk_type_id <= 50) {
|
||||
chunk_type = 'VERTEX';
|
||||
size = 2 + 4 * cursor.u16();
|
||||
data = parseChunkVertex(cursor, chunkTypeId, flags);
|
||||
} else if (56 <= chunkTypeId && chunkTypeId <= 58) {
|
||||
chunkType = 'VOLUME';
|
||||
data = parse_chunk_vertex(cursor, chunk_type_id, flags);
|
||||
} else if (56 <= chunk_type_id && chunk_type_id <= 58) {
|
||||
chunk_type = 'VOLUME';
|
||||
size = 2 + 2 * cursor.u16();
|
||||
} else if (64 <= chunkTypeId && chunkTypeId <= 75) {
|
||||
chunkType = 'STRIP';
|
||||
} else if (64 <= chunk_type_id && chunk_type_id <= 75) {
|
||||
chunk_type = 'STRIP';
|
||||
size = 2 + 2 * cursor.u16();
|
||||
data = parseChunkTriangleStrip(cursor, chunkTypeId);
|
||||
} else if (chunkTypeId === 255) {
|
||||
chunkType = 'END';
|
||||
size = wideEndChunks ? 2 : 0;
|
||||
data = parse_chunk_triangle_strip(cursor, chunk_type_id);
|
||||
} else if (chunk_type_id === 255) {
|
||||
chunk_type = 'END';
|
||||
size = wide_end_chunks ? 2 : 0;
|
||||
loop = false;
|
||||
} else {
|
||||
// Ignore unknown chunks.
|
||||
logger.warn(`Unknown chunk type: ${chunkTypeId}.`);
|
||||
logger.warn(`Unknown chunk type: ${chunk_type_id}.`);
|
||||
size = 2 + 2 * cursor.u16();
|
||||
}
|
||||
|
||||
cursor.seek_start(chunkStartPosition + size);
|
||||
cursor.seek_start(chunk_start_position + size);
|
||||
|
||||
chunks.push({
|
||||
chunkType,
|
||||
chunkSubType,
|
||||
chunkTypeId,
|
||||
chunk_type,
|
||||
chunk_sub_type,
|
||||
chunk_type_id,
|
||||
data
|
||||
});
|
||||
}
|
||||
@ -177,18 +183,22 @@ function parseChunks(cursor: BufferCursor, cachedChunkOffsets: number[], wideEnd
|
||||
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.
|
||||
if ((flags & 0b11) !== 0) {
|
||||
return [];
|
||||
}
|
||||
|
||||
const index = cursor.u16();
|
||||
const vertexCount = cursor.u16();
|
||||
const vertex_count = cursor.u16();
|
||||
|
||||
const vertices: ChunkVertex[] = [];
|
||||
|
||||
for (let i = 0; i < vertexCount; ++i) {
|
||||
for (let i = 0; i < vertex_count; ++i) {
|
||||
const vertex: ChunkVertex = {
|
||||
index: index + i,
|
||||
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
|
||||
} else if (chunkTypeId === 33) {
|
||||
} else if (chunk_type_id === 33) {
|
||||
cursor.seek(4); // Always 1.0
|
||||
vertex.normal = [
|
||||
cursor.f32(), // x
|
||||
@ -208,8 +218,8 @@ function parseChunkVertex(cursor: BufferCursor, chunkTypeId: number, flags: numb
|
||||
cursor.f32(), // z
|
||||
];
|
||||
cursor.seek(4); // Always 0.0
|
||||
} else if (35 <= chunkTypeId && chunkTypeId <= 40) {
|
||||
if (chunkTypeId === 37) {
|
||||
} else if (35 <= chunk_type_id && chunk_type_id <= 40) {
|
||||
if (chunk_type_id === 37) {
|
||||
// Ninja flags
|
||||
vertex.index = index + cursor.u16();
|
||||
cursor.seek(2);
|
||||
@ -217,15 +227,15 @@ function parseChunkVertex(cursor: BufferCursor, chunkTypeId: number, flags: numb
|
||||
// Skip user flags and material information.
|
||||
cursor.seek(4);
|
||||
}
|
||||
} else if (41 <= chunkTypeId && chunkTypeId <= 47) {
|
||||
} else if (41 <= chunk_type_id && chunk_type_id <= 47) {
|
||||
vertex.normal = [
|
||||
cursor.f32(), // x
|
||||
cursor.f32(), // y
|
||||
cursor.f32(), // z
|
||||
];
|
||||
|
||||
if (chunkTypeId >= 42) {
|
||||
if (chunkTypeId === 44) {
|
||||
if (chunk_type_id >= 42) {
|
||||
if (chunk_type_id === 44) {
|
||||
// Ninja flags
|
||||
vertex.index = index + cursor.u16();
|
||||
cursor.seek(2);
|
||||
@ -234,11 +244,11 @@ function parseChunkVertex(cursor: BufferCursor, chunkTypeId: number, flags: numb
|
||||
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)
|
||||
cursor.seek(4);
|
||||
|
||||
if (chunkTypeId >= 49) {
|
||||
if (chunk_type_id >= 49) {
|
||||
// Skip user flags and material information.
|
||||
cursor.seek(4);
|
||||
}
|
||||
@ -250,13 +260,16 @@ function parseChunkVertex(cursor: BufferCursor, chunkTypeId: number, flags: numb
|
||||
return vertices;
|
||||
}
|
||||
|
||||
function parseChunkTriangleStrip(cursor: BufferCursor, chunkTypeId: number): ChunkTriangleStrip[] {
|
||||
const userOffsetAndStripCount = cursor.u16();
|
||||
const userFlagsSize = userOffsetAndStripCount >>> 14;
|
||||
const stripCount = userOffsetAndStripCount & 0x3FFF;
|
||||
function parse_chunk_triangle_strip(
|
||||
cursor: BufferCursor,
|
||||
chunk_type_id: number
|
||||
): 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;
|
||||
|
||||
switch (chunkTypeId) {
|
||||
switch (chunk_type_id) {
|
||||
case 64: options = [false, false, false, false]; break;
|
||||
case 65: 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 74: 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 [
|
||||
parseTextureCoords,
|
||||
parseColor,
|
||||
parseNormal,
|
||||
parseTextureCoordsHires
|
||||
parse_texture_coords,
|
||||
parse_color,
|
||||
parse_normal,
|
||||
parse_texture_coords_hires
|
||||
] = options;
|
||||
|
||||
const strips = [];
|
||||
|
||||
for (let i = 0; i < stripCount; ++i) {
|
||||
const windingFlagAndIndexCount = cursor.i16();
|
||||
const clockwiseWinding = windingFlagAndIndexCount < 1;
|
||||
const indexCount = Math.abs(windingFlagAndIndexCount);
|
||||
for (let i = 0; i < strip_count; ++i) {
|
||||
const winding_flag_and_index_count = cursor.i16();
|
||||
const clockwise_winding = winding_flag_and_index_count < 1;
|
||||
const index_count = Math.abs(winding_flag_and_index_count);
|
||||
|
||||
const indices = [];
|
||||
|
||||
for (let j = 0; j < indexCount; ++j) {
|
||||
for (let j = 0; j < index_count; ++j) {
|
||||
indices.push(cursor.u16());
|
||||
|
||||
if (parseTextureCoords) {
|
||||
if (parse_texture_coords) {
|
||||
cursor.seek(4);
|
||||
}
|
||||
|
||||
if (parseColor) {
|
||||
if (parse_color) {
|
||||
cursor.seek(4);
|
||||
}
|
||||
|
||||
if (parseNormal) {
|
||||
if (parse_normal) {
|
||||
cursor.seek(6);
|
||||
}
|
||||
|
||||
if (parseTextureCoordsHires) {
|
||||
if (parse_texture_coords_hires) {
|
||||
cursor.seek(8);
|
||||
}
|
||||
|
||||
if (j >= 2) {
|
||||
cursor.seek(2 * userFlagsSize);
|
||||
cursor.seek(2 * user_flags_size);
|
||||
}
|
||||
}
|
||||
|
||||
strips.push({ clockwiseWinding, indices });
|
||||
strips.push({ clockwise_winding, indices });
|
||||
}
|
||||
|
||||
return strips;
|
||||
|
||||
@ -14,30 +14,30 @@ export interface XjContext {
|
||||
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;
|
||||
|
||||
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.
|
||||
const triangleStripListAOffset = cursor.u32();
|
||||
const triangleStripACount = cursor.u32();
|
||||
const triangleStripListBOffset = cursor.u32();
|
||||
const triangleStripBCount = cursor.u32();
|
||||
const triangle_strip_list_a_offset = cursor.u32();
|
||||
const triangle_strip_a_count = cursor.u32();
|
||||
const triangle_strip_list_b_offset = cursor.u32();
|
||||
const triangle_strip_b_count = cursor.u32();
|
||||
cursor.seek(16); // Bounding sphere position and radius in floats.
|
||||
|
||||
const normalMatrix = new Matrix3().getNormalMatrix(matrix);
|
||||
const indexOffset = positions.length / 3;
|
||||
const normal_matrix = new Matrix3().getNormalMatrix(matrix);
|
||||
const index_offset = positions.length / 3;
|
||||
|
||||
if (vertexInfoListOffset) {
|
||||
cursor.seek_start(vertexInfoListOffset);
|
||||
if (vertex_info_list_offset) {
|
||||
cursor.seek_start(vertex_info_list_offset);
|
||||
cursor.seek(4); // Possibly the vertex type.
|
||||
const vertexListOffset = cursor.u32();
|
||||
const vertexSize = cursor.u32();
|
||||
const vertexCount = cursor.u32();
|
||||
const vertexList_offset = cursor.u32();
|
||||
const vertex_size = cursor.u32();
|
||||
const vertex_count = cursor.u32();
|
||||
|
||||
for (let i = 0; i < vertexCount; ++i) {
|
||||
cursor.seek_start(vertexListOffset + i * vertexSize);
|
||||
for (let i = 0; i < vertex_count; ++i) {
|
||||
cursor.seek_start(vertexList_offset + i * vertex_size);
|
||||
const position = new Vector3(
|
||||
cursor.f32(),
|
||||
cursor.f32(),
|
||||
@ -45,12 +45,12 @@ export function parseXjModel(cursor: BufferCursor, matrix: Matrix4, context: XjC
|
||||
).applyMatrix4(matrix);
|
||||
let normal;
|
||||
|
||||
if (vertexSize === 28 || vertexSize === 32 || vertexSize === 36) {
|
||||
if (vertex_size === 28 || vertex_size === 32 || vertex_size === 36) {
|
||||
normal = new Vector3(
|
||||
cursor.f32(),
|
||||
cursor.f32(),
|
||||
cursor.f32()
|
||||
).applyMatrix3(normalMatrix);
|
||||
).applyMatrix3(normal_matrix);
|
||||
} else {
|
||||
normal = new Vector3(0, 1, 0);
|
||||
}
|
||||
@ -64,55 +64,55 @@ export function parseXjModel(cursor: BufferCursor, matrix: Matrix4, context: XjC
|
||||
}
|
||||
}
|
||||
|
||||
if (triangleStripListAOffset) {
|
||||
parseTriangleStripList(
|
||||
if (triangle_strip_list_a_offset) {
|
||||
parse_triangle_strip_list(
|
||||
cursor,
|
||||
triangleStripListAOffset,
|
||||
triangleStripACount,
|
||||
triangle_strip_list_a_offset,
|
||||
triangle_strip_a_count,
|
||||
positions,
|
||||
normals,
|
||||
indices,
|
||||
indexOffset
|
||||
index_offset
|
||||
);
|
||||
}
|
||||
|
||||
if (triangleStripListBOffset) {
|
||||
parseTriangleStripList(
|
||||
if (triangle_strip_list_b_offset) {
|
||||
parse_triangle_strip_list(
|
||||
cursor,
|
||||
triangleStripListBOffset,
|
||||
triangleStripBCount,
|
||||
triangle_strip_list_b_offset,
|
||||
triangle_strip_b_count,
|
||||
positions,
|
||||
normals,
|
||||
indices,
|
||||
indexOffset
|
||||
index_offset
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function parseTriangleStripList(
|
||||
function parse_triangle_strip_list(
|
||||
cursor: BufferCursor,
|
||||
triangleStripListOffset: number,
|
||||
triangleStripCount: number,
|
||||
triangle_strip_list_offset: number,
|
||||
triangle_strip_count: number,
|
||||
positions: number[],
|
||||
normals: number[],
|
||||
indices: number[],
|
||||
indexOffset: number
|
||||
index_offset: number
|
||||
): void {
|
||||
for (let i = 0; i < triangleStripCount; ++i) {
|
||||
cursor.seek_start(triangleStripListOffset + i * 20);
|
||||
for (let i = 0; i < triangle_strip_count; ++i) {
|
||||
cursor.seek_start(triangle_strip_list_offset + i * 20);
|
||||
cursor.seek(8); // Skip material information.
|
||||
const indexListOffset = cursor.u32();
|
||||
const indexCount = cursor.u32();
|
||||
const index_list_offset = cursor.u32();
|
||||
const index_count = cursor.u32();
|
||||
// Ignoring 4 bytes.
|
||||
|
||||
cursor.seek_start(indexListOffset);
|
||||
const stripIndices = cursor.u16_array(indexCount);
|
||||
cursor.seek_start(index_list_offset);
|
||||
const strip_indices = cursor.u16_array(index_count);
|
||||
let clockwise = true;
|
||||
|
||||
for (let j = 2; j < stripIndices.length; ++j) {
|
||||
const a = indexOffset + stripIndices[j - 2];
|
||||
const b = indexOffset + stripIndices[j - 1];
|
||||
const c = indexOffset + stripIndices[j];
|
||||
for (let j = 2; j < strip_indices.length; ++j) {
|
||||
const a = index_offset + strip_indices[j - 2];
|
||||
const b = index_offset + strip_indices[j - 1];
|
||||
const c = index_offset + strip_indices[j];
|
||||
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 pc = new Vector3(positions[3 * c], positions[3 * c + 1], positions[3 * c + 2]);
|
||||
@ -128,12 +128,12 @@ function parseTriangleStripList(
|
||||
normal.negate();
|
||||
}
|
||||
|
||||
const oppositeCount =
|
||||
const opposite_count =
|
||||
(normal.dot(na) < 0 ? 1 : 0) +
|
||||
(normal.dot(nb) < 0 ? 1 : 0) +
|
||||
(normal.dot(nc) < 0 ? 1 : 0);
|
||||
|
||||
if (oppositeCount >= 2) {
|
||||
if (opposite_count >= 2) {
|
||||
clockwise = !clockwise;
|
||||
}
|
||||
|
||||
|
||||
@ -1,9 +1,9 @@
|
||||
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 { 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 { 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';
|
||||
|
||||
const OrbitControls = OrbitControlsCreator(THREE);
|
||||
@ -48,6 +48,7 @@ export class Renderer {
|
||||
private hoveredData?: PickEntityResult;
|
||||
private selectedData?: PickEntityResult;
|
||||
private model?: Object3D;
|
||||
private clock = new Clock();
|
||||
|
||||
constructor() {
|
||||
this.renderer.domElement.addEventListener(
|
||||
@ -153,7 +154,7 @@ export class Renderer {
|
||||
const variant = this.quest.area_variants.find(v => v.area.id === areaId);
|
||||
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) {
|
||||
this.setModel(undefined);
|
||||
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) {
|
||||
this.renderGeometry = geometry;
|
||||
}
|
||||
@ -182,6 +183,11 @@ export class Renderer {
|
||||
private renderLoop = () => {
|
||||
this.controls.update();
|
||||
this.addLoadedEntities();
|
||||
|
||||
if (quest_editor_store.animation_mixer) {
|
||||
quest_editor_store.animation_mixer.update(this.clock.getDelta());
|
||||
}
|
||||
|
||||
this.renderer.render(this.scene, this.camera);
|
||||
requestAnimationFrame(this.renderLoop);
|
||||
}
|
||||
@ -251,7 +257,7 @@ export class Renderer {
|
||||
: oldSelectedData !== data;
|
||||
|
||||
if (selectionChanged) {
|
||||
questEditorStore.setSelectedEntity(data && data.entity);
|
||||
quest_editor_store.setSelectedEntity(data && data.entity);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
44
src/rendering/animation.ts
Normal file
44
src/rendering/animation.ts
Normal 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
|
||||
);
|
||||
}
|
||||
@ -1,13 +1,13 @@
|
||||
import { CylinderBufferGeometry, MeshLambertMaterial, Object3D, Vector3 } from 'three';
|
||||
import { DatNpc, DatObject } from '../bin_data/parsing/quest/dat';
|
||||
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);
|
||||
|
||||
test('create geometry for quest objects', () => {
|
||||
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.name).toBe('Object');
|
||||
@ -20,7 +20,7 @@ test('create geometry for quest objects', () => {
|
||||
|
||||
test('create geometry for quest NPCs', () => {
|
||||
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.name).toBe('NPC');
|
||||
@ -33,7 +33,7 @@ test('create geometry for quest NPCs', () => {
|
||||
|
||||
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 geometry = createNpcMesh(npc, cylinder);
|
||||
const geometry = create_npc_mesh(npc, cylinder);
|
||||
npc.position = new Vec3(2, 3, 5).add(npc.position);
|
||||
|
||||
expect(geometry.position).toEqual(new Vector3(19, 22, 28));
|
||||
@ -41,7 +41,7 @@ test('geometry position changes when entity position changes element-wise', () =
|
||||
|
||||
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 geometry = createNpcMesh(npc, cylinder);
|
||||
const geometry = create_npc_mesh(npc, cylinder);
|
||||
npc.position = new Vec3(2, 3, 5);
|
||||
|
||||
expect(geometry.position).toEqual(new Vector3(2, 3, 5));
|
||||
|
||||
@ -9,37 +9,37 @@ export const NPC_COLOR = 0xFF0000;
|
||||
export const NPC_HOVER_COLOR = 0xFF3F5F;
|
||||
export const NPC_SELECTED_COLOR = 0xFF0054;
|
||||
|
||||
export function createObjectMesh(object: QuestObject, geometry: BufferGeometry): Mesh {
|
||||
return createMesh(object, geometry, OBJECT_COLOR, 'Object');
|
||||
export function create_object_mesh(object: QuestObject, geometry: BufferGeometry): Mesh {
|
||||
return create_mesh(object, geometry, OBJECT_COLOR, 'Object');
|
||||
}
|
||||
|
||||
export function createNpcMesh(npc: QuestNpc, geometry: BufferGeometry): Mesh {
|
||||
return createMesh(npc, geometry, NPC_COLOR, 'NPC');
|
||||
export function create_npc_mesh(npc: QuestNpc, geometry: BufferGeometry): Mesh {
|
||||
return create_mesh(npc, geometry, NPC_COLOR, 'NPC');
|
||||
}
|
||||
|
||||
function createMesh(
|
||||
function create_mesh(
|
||||
entity: QuestEntity,
|
||||
geometry: BufferGeometry,
|
||||
color: number,
|
||||
type: string
|
||||
): Mesh {
|
||||
const object3d = new Mesh(
|
||||
const object_3d = new Mesh(
|
||||
geometry,
|
||||
new MeshLambertMaterial({
|
||||
color,
|
||||
side: DoubleSide
|
||||
})
|
||||
);
|
||||
object3d.name = type;
|
||||
object3d.userData.entity = entity;
|
||||
object_3d.name = type;
|
||||
object_3d.userData.entity = entity;
|
||||
|
||||
// TODO: dispose autorun?
|
||||
autorun(() => {
|
||||
const { x, y, z } = entity.position;
|
||||
object3d.position.set(x, y, z);
|
||||
object_3d.position.set(x, y, z);
|
||||
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;
|
||||
}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
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(
|
||||
geometry,
|
||||
new MeshLambertMaterial({
|
||||
|
||||
@ -1,62 +1,86 @@
|
||||
import { observable, action } from 'mobx';
|
||||
import { Object3D } from 'three';
|
||||
import Logger from 'js-logger';
|
||||
import { action, observable } from 'mobx';
|
||||
import { AnimationClip, AnimationMixer, Object3D } from 'three';
|
||||
import { BufferCursor } from '../bin_data/BufferCursor';
|
||||
import { getAreaSections } from '../bin_data/loading/areas';
|
||||
import { getNpcGeometry, getObjectGeometry } from '../bin_data/loading/entities';
|
||||
import { parseNj, parseXj } from '../bin_data/parsing/ninja';
|
||||
import { get_area_sections } from '../bin_data/loading/areas';
|
||||
import { get_npc_geometry, get_object_geometry } from '../bin_data/loading/entities';
|
||||
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 { Area, Quest, QuestEntity, Section, Vec3 } from '../domain';
|
||||
import { createNpcMesh, createObjectMesh } from '../rendering/entities';
|
||||
import { createModelMesh } from '../rendering/models';
|
||||
import Logger from 'js-logger';
|
||||
import { create_animation_clip } from '../rendering/animation';
|
||||
import { create_npc_mesh, create_object_mesh } from '../rendering/entities';
|
||||
import { create_model_mesh } from '../rendering/models';
|
||||
|
||||
const logger = Logger.get('stores/QuestEditorStore');
|
||||
|
||||
class QuestEditorStore {
|
||||
@observable currentModel?: Object3D;
|
||||
@observable currentQuest?: Quest;
|
||||
@observable currentArea?: Area;
|
||||
@observable selectedEntity?: QuestEntity;
|
||||
@observable current_quest?: Quest;
|
||||
@observable current_area?: Area;
|
||||
@observable selected_entity?: QuestEntity;
|
||||
|
||||
setModel = action('setModel', (model?: Object3D) => {
|
||||
this.resetModelAndQuestState();
|
||||
this.currentModel = model;
|
||||
})
|
||||
@observable.ref current_model?: Object3D;
|
||||
@observable.ref animation_mixer?: AnimationMixer;
|
||||
|
||||
setQuest = action('setQuest', (quest?: Quest) => {
|
||||
this.resetModelAndQuestState();
|
||||
this.currentQuest = quest;
|
||||
set_quest = action('set_quest', (quest?: Quest) => {
|
||||
this.reset_model_and_quest_state();
|
||||
this.current_quest = quest;
|
||||
|
||||
if (quest && quest.area_variants.length) {
|
||||
this.currentArea = quest.area_variants[0].area;
|
||||
this.current_area = quest.area_variants[0].area;
|
||||
}
|
||||
})
|
||||
|
||||
private resetModelAndQuestState() {
|
||||
this.currentQuest = undefined;
|
||||
this.currentArea = undefined;
|
||||
this.selectedEntity = undefined;
|
||||
this.currentModel = undefined;
|
||||
set_model = action('set_model', (model?: Object3D) => {
|
||||
this.reset_model_and_quest_state();
|
||||
this.current_model = model;
|
||||
})
|
||||
|
||||
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) => {
|
||||
this.selectedEntity = entity;
|
||||
this.selected_entity = entity;
|
||||
}
|
||||
|
||||
setCurrentAreaId = action('setCurrentAreaId', (areaId?: number) => {
|
||||
this.selectedEntity = undefined;
|
||||
set_current_area_id = action('set_current_area_id', (area_id?: number) => {
|
||||
this.selected_entity = undefined;
|
||||
|
||||
if (areaId == null) {
|
||||
this.currentArea = undefined;
|
||||
} else if (this.currentQuest) {
|
||||
const areaVariant = this.currentQuest.area_variants.find(
|
||||
variant => variant.area.id === areaId
|
||||
if (area_id == null) {
|
||||
this.current_area = undefined;
|
||||
} else if (this.current_quest) {
|
||||
const area_variant = this.current_quest.area_variants.find(
|
||||
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();
|
||||
reader.addEventListener('loadend', () => { this.loadend(file, reader) });
|
||||
reader.readAsArrayBuffer(file);
|
||||
@ -70,25 +94,33 @@ class QuestEditorStore {
|
||||
}
|
||||
|
||||
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')) {
|
||||
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 {
|
||||
const quest = parse_quest(new BufferCursor(reader.result, true));
|
||||
this.setQuest(quest);
|
||||
this.set_quest(quest);
|
||||
|
||||
if (quest) {
|
||||
// Load section data.
|
||||
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;
|
||||
|
||||
// Generate object geometry.
|
||||
for (const object of quest.objects.filter(o => o.area_id === variant.area.id)) {
|
||||
try {
|
||||
const geometry = await getObjectGeometry(object.type);
|
||||
this.setSectionOnVisibleQuestEntity(object, sections);
|
||||
object.object3d = createObjectMesh(object, geometry);
|
||||
const geometry = await get_object_geometry(object.type);
|
||||
this.set_section_on_visible_quest_entity(object, sections);
|
||||
object.object3d = create_object_mesh(object, geometry);
|
||||
} catch (e) {
|
||||
logger.error(e);
|
||||
}
|
||||
@ -97,9 +129,9 @@ class QuestEditorStore {
|
||||
// Generate NPC geometry.
|
||||
for (const npc of quest.npcs.filter(npc => npc.area_id === variant.area.id)) {
|
||||
try {
|
||||
const geometry = await getNpcGeometry(npc.type);
|
||||
this.setSectionOnVisibleQuestEntity(npc, sections);
|
||||
npc.object3d = createNpcMesh(npc, geometry);
|
||||
const geometry = await get_npc_geometry(npc.type);
|
||||
this.set_section_on_visible_quest_entity(npc, sections);
|
||||
npc.object3d = create_npc_mesh(npc, geometry);
|
||||
} catch (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;
|
||||
|
||||
const section = sections.find(s => s.id === entity.section_id);
|
||||
entity.section = section;
|
||||
|
||||
if (section) {
|
||||
const { x: secX, y: secY, z: secZ } = section.position;
|
||||
const rotX = 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;
|
||||
x = rotX + secX;
|
||||
y += secY;
|
||||
z = rotZ + secZ;
|
||||
const { x: sec_x, y: sec_y, z: sec_z } = section.position;
|
||||
const rot_x = section.cos_y_axis_rotation * x + section.sin_y_axis_rotation * z;
|
||||
const rot_z = -section.sin_y_axis_rotation * x + section.cos_y_axis_rotation * z;
|
||||
x = rot_x + sec_x;
|
||||
y += sec_y;
|
||||
z = rot_z + sec_z;
|
||||
} else {
|
||||
logger.warn(`Section ${entity.section_id} not found.`);
|
||||
}
|
||||
@ -131,17 +166,17 @@ class QuestEditorStore {
|
||||
entity.position = new Vec3(x, y, z);
|
||||
}
|
||||
|
||||
saveCurrentQuestToFile = (fileName: string) => {
|
||||
if (this.currentQuest) {
|
||||
const cursor = write_quest_qst(this.currentQuest, fileName);
|
||||
save_current_quest_to_file = (file_name: string) => {
|
||||
if (this.current_quest) {
|
||||
const cursor = write_quest_qst(this.current_quest, file_name);
|
||||
|
||||
if (!fileName.endsWith('.qst')) {
|
||||
fileName += '.qst';
|
||||
if (!file_name.endsWith('.qst')) {
|
||||
file_name += '.qst';
|
||||
}
|
||||
|
||||
const a = document.createElement('a');
|
||||
a.href = URL.createObjectURL(new Blob([cursor.buffer]));
|
||||
a.download = fileName;
|
||||
a.download = file_name;
|
||||
document.body.appendChild(a);
|
||||
a.click();
|
||||
URL.revokeObjectURL(a.href);
|
||||
@ -150,4 +185,4 @@ class QuestEditorStore {
|
||||
}
|
||||
}
|
||||
|
||||
export const questEditorStore = new QuestEditorStore();
|
||||
export const quest_editor_store = new QuestEditorStore();
|
||||
|
||||
@ -3,7 +3,7 @@ import { UploadChangeParam } from "antd/lib/upload";
|
||||
import { UploadFile } from "antd/lib/upload/interface";
|
||||
import { observer } from "mobx-react";
|
||||
import React, { ChangeEvent } from "react";
|
||||
import { questEditorStore } from "../../stores/QuestEditorStore";
|
||||
import { quest_editor_store } from "../../stores/QuestEditorStore";
|
||||
import { EntityInfoComponent } from "./EntityInfoComponent";
|
||||
import './QuestEditorComponent.css';
|
||||
import { QuestInfoComponent } from "./QuestInfoComponent";
|
||||
@ -12,22 +12,22 @@ import { RendererComponent } from "./RendererComponent";
|
||||
@observer
|
||||
export class QuestEditorComponent extends React.Component<{}, {
|
||||
filename?: string,
|
||||
saveDialogOpen: boolean,
|
||||
saveDialogFilename: string
|
||||
save_dialog_open: boolean,
|
||||
save_dialog_filename: string
|
||||
}> {
|
||||
state = {
|
||||
saveDialogOpen: false,
|
||||
saveDialogFilename: 'Untitled',
|
||||
save_dialog_open: false,
|
||||
save_dialog_filename: 'Untitled',
|
||||
};
|
||||
|
||||
render() {
|
||||
const quest = questEditorStore.currentQuest;
|
||||
const model = questEditorStore.currentModel;
|
||||
const area = questEditorStore.currentArea;
|
||||
const quest = quest_editor_store.current_quest;
|
||||
const model = quest_editor_store.current_model;
|
||||
const area = quest_editor_store.current_area;
|
||||
|
||||
return (
|
||||
<div className="qe-QuestEditorComponent">
|
||||
<Toolbar onSaveAsClicked={this.saveAsClicked} />
|
||||
<Toolbar onSaveAsClicked={this.save_as_clicked} />
|
||||
<div className="qe-QuestEditorComponent-main">
|
||||
<QuestInfoComponent quest={quest} />
|
||||
<RendererComponent
|
||||
@ -35,41 +35,41 @@ export class QuestEditorComponent extends React.Component<{}, {
|
||||
area={area}
|
||||
model={model}
|
||||
/>
|
||||
<EntityInfoComponent entity={questEditorStore.selectedEntity} />
|
||||
<EntityInfoComponent entity={quest_editor_store.selected_entity} />
|
||||
</div>
|
||||
<SaveAsForm
|
||||
isOpen={this.state.saveDialogOpen}
|
||||
filename={this.state.saveDialogFilename}
|
||||
onFilenameChange={this.saveDialogFilenameChanged}
|
||||
onOk={this.saveDialogAffirmed}
|
||||
onCancel={this.saveDialogCancelled}
|
||||
is_open={this.state.save_dialog_open}
|
||||
filename={this.state.save_dialog_filename}
|
||||
on_filename_change={this.save_dialog_filename_changed}
|
||||
on_ok={this.save_dialog_affirmed}
|
||||
on_cancel={this.save_dialog_cancelled}
|
||||
/>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
private saveAsClicked = (filename?: string) => {
|
||||
private save_as_clicked = (filename?: string) => {
|
||||
const name = filename
|
||||
? filename.endsWith('.qst') ? filename.slice(0, -4) : filename
|
||||
: this.state.saveDialogFilename;
|
||||
: this.state.save_dialog_filename;
|
||||
|
||||
this.setState({
|
||||
saveDialogOpen: true,
|
||||
saveDialogFilename: name
|
||||
save_dialog_open: true,
|
||||
save_dialog_filename: name
|
||||
});
|
||||
}
|
||||
|
||||
private saveDialogFilenameChanged = (filename: string) => {
|
||||
this.setState({ saveDialogFilename: filename });
|
||||
private save_dialog_filename_changed = (filename: string) => {
|
||||
this.setState({ save_dialog_filename: filename });
|
||||
}
|
||||
|
||||
private saveDialogAffirmed = () => {
|
||||
questEditorStore.saveCurrentQuestToFile(this.state.saveDialogFilename);
|
||||
this.setState({ saveDialogOpen: false });
|
||||
private save_dialog_affirmed = () => {
|
||||
quest_editor_store.save_current_quest_to_file(this.state.save_dialog_filename);
|
||||
this.setState({ save_dialog_open: false });
|
||||
}
|
||||
|
||||
private saveDialogCancelled = () => {
|
||||
this.setState({ saveDialogOpen: false });
|
||||
private save_dialog_cancelled = () => {
|
||||
this.setState({ save_dialog_open: false });
|
||||
}
|
||||
}
|
||||
|
||||
@ -80,17 +80,17 @@ class Toolbar extends React.Component<{ onSaveAsClicked: (filename?: string) =>
|
||||
}
|
||||
|
||||
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 area = questEditorStore.currentArea;
|
||||
const areaId = area && area.id;
|
||||
const area = quest_editor_store.current_area;
|
||||
const area_id = area && area.id;
|
||||
|
||||
return (
|
||||
<div className="qe-QuestEditorComponent-toolbar">
|
||||
<Upload
|
||||
accept=".nj, .qst, .xj"
|
||||
accept=".nj, .njm, .qst, .xj"
|
||||
showUploadList={false}
|
||||
onChange={this.setFilename}
|
||||
onChange={this.set_filename}
|
||||
// Make sure it doesn't do a POST:
|
||||
customRequest={() => false}
|
||||
>
|
||||
@ -98,8 +98,8 @@ class Toolbar extends React.Component<{ onSaveAsClicked: (filename?: string) =>
|
||||
</Upload>
|
||||
{areas && (
|
||||
<Select
|
||||
onChange={questEditorStore.setCurrentAreaId}
|
||||
value={areaId}
|
||||
onChange={quest_editor_store.set_current_area_id}
|
||||
value={area_id}
|
||||
style={{ width: 200 }}
|
||||
>
|
||||
{areas.map(area =>
|
||||
@ -110,39 +110,39 @@ class Toolbar extends React.Component<{ onSaveAsClicked: (filename?: string) =>
|
||||
{quest && (
|
||||
<Button
|
||||
icon="save"
|
||||
onClick={this.saveAsClicked}
|
||||
onClick={this.save_as_clicked}
|
||||
>Save as...</Button>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
private setFilename = (info: UploadChangeParam<UploadFile>) => {
|
||||
private set_filename = (info: UploadChangeParam<UploadFile>) => {
|
||||
if (info.file.originFileObj) {
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
class SaveAsForm extends React.Component<{
|
||||
isOpen: boolean,
|
||||
is_open: boolean,
|
||||
filename: string,
|
||||
onFilenameChange: (name: string) => void,
|
||||
onOk: () => void,
|
||||
onCancel: () => void
|
||||
on_filename_change: (name: string) => void,
|
||||
on_ok: () => void,
|
||||
on_cancel: () => void
|
||||
}> {
|
||||
render() {
|
||||
return (
|
||||
<Modal
|
||||
title={<><Icon type="save" /> Save as...</>}
|
||||
visible={this.props.isOpen}
|
||||
onOk={this.props.onOk}
|
||||
onCancel={this.props.onCancel}
|
||||
visible={this.props.is_open}
|
||||
onOk={this.props.on_ok}
|
||||
onCancel={this.props.on_cancel}
|
||||
>
|
||||
<Form layout="vertical">
|
||||
<Form.Item label="Name">
|
||||
@ -150,7 +150,7 @@ class SaveAsForm extends React.Component<{
|
||||
autoFocus={true}
|
||||
maxLength={12}
|
||||
value={this.props.filename}
|
||||
onChange={this.nameChanged}
|
||||
onChange={this.name_changed}
|
||||
/>
|
||||
</Form.Item>
|
||||
</Form>
|
||||
@ -158,7 +158,7 @@ class SaveAsForm extends React.Component<{
|
||||
);
|
||||
}
|
||||
|
||||
private nameChanged = (e: ChangeEvent<HTMLInputElement>) => {
|
||||
this.props.onFilenameChange(e.currentTarget.value);
|
||||
private name_changed = (e: ChangeEvent<HTMLInputElement>) => {
|
||||
this.props.on_filename_change(e.currentTarget.value);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
import fs from "fs";
|
||||
import { BufferCursor } from "../src/bin_data/BufferCursor";
|
||||
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';
|
||||
|
||||
const logger = Logger.get('static/updateGenericData');
|
||||
@ -21,8 +21,22 @@ update();
|
||||
|
||||
function update() {
|
||||
const buf = fs.readFileSync(`${RESOURCE_DIR}/plymotiondata.rlc`);
|
||||
let i = 0;
|
||||
|
||||
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()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user