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

Refactored area collision detection geometry parsing code.

Browse Source
This commit is contained in:
Daan Vanden Bosch 2019-07-07 01:16:12 +02:00
parent 9c71c3deb8
commit 4e540acf0c
10 changed files with 253 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
src/data_formats/BufferCursor.ts
View File

@ -32,10 +32,14 @@ export class BufferCursor {
this._size = size;
}
private _position: number;
/**
* The position from where bytes will be read or written.
*/
position: number;
get position(): number {
return this._position;
}
private _little_endian: boolean = false;
@ -66,33 +70,37 @@ export class BufferCursor {
return this.buffer.byteLength;
}
buffer: ArrayBuffer;
private _buffer: ArrayBuffer;
get buffer(): ArrayBuffer {
return this._buffer;
}
private dv: DataView;
private utf16_decoder: TextDecoder = UTF_16BE_DECODER;
private utf16_encoder: TextEncoder = UTF_16BE_ENCODER;
/**
* @param buffer_or_capacity - If an ArrayBuffer or Buffer is given, writes to the cursor will be reflected in this buffer and vice versa until a cursor write that requires allocating a new internal buffer happens
* @param little_endian - Decides in which byte order multi-byte integers and floats will be interpreted
* @param buffer_or_capacity - If an ArrayBuffer or Buffer is given, writes to the cursor will be reflected in this buffer and vice versa until a cursor write that requires allocating a new internal buffer happens.
* @param little_endian - Decides in which byte order multi-byte integers and floats will be interpreted.
*/
constructor(buffer_or_capacity: ArrayBuffer | Buffer | number, little_endian: boolean = false) {
if (typeof buffer_or_capacity === "number") {
this.buffer = new ArrayBuffer(buffer_or_capacity);
this._buffer = new ArrayBuffer(buffer_or_capacity);
this.size = 0;
} else if (buffer_or_capacity instanceof ArrayBuffer) {
this.buffer = buffer_or_capacity;
this._buffer = buffer_or_capacity;
this.size = buffer_or_capacity.byteLength;
} else if (buffer_or_capacity instanceof Buffer) {
// Use the backing ArrayBuffer.
this.buffer = buffer_or_capacity.buffer;
this._buffer = buffer_or_capacity.buffer;
this.size = buffer_or_capacity.byteLength;
} else {
throw new Error("buffer_or_capacity should be an ArrayBuffer, a Buffer or a number.");
}
this.little_endian = little_endian;
this.position = 0;
this._position = 0;
this.dv = new DataView(this.buffer);
}
@ -115,7 +123,7 @@ export class BufferCursor {
throw new Error(`Offset ${offset} is out of bounds.`);
}
this.position = offset;
this._position = offset;
return this;
}
@ -129,7 +137,7 @@ export class BufferCursor {
throw new Error(`Offset ${offset} is out of bounds.`);
}
this.position = this.size - offset;
this._position = this.size - offset;
return this;
}
@ -137,7 +145,7 @@ export class BufferCursor {
* Reads an unsigned 8-bit integer and increments position by 1.
*/
u8(): number {
return this.dv.getUint8(this.position++);
return this.dv.getUint8(this._position++);
}
/**
@ -145,7 +153,7 @@ export class BufferCursor {
*/
u16(): number {
const r = this.dv.getUint16(this.position, this.little_endian);
this.position += 2;
this._position += 2;
return r;
}
@ -154,7 +162,7 @@ export class BufferCursor {
*/
u32(): number {
const r = this.dv.getUint32(this.position, this.little_endian);
this.position += 4;
this._position += 4;
return r;
}
@ -162,7 +170,7 @@ export class BufferCursor {
* Reads an signed 8-bit integer and increments position by 1.
*/
i8(): number {
return this.dv.getInt8(this.position++);
return this.dv.getInt8(this._position++);
}
/**
@ -170,7 +178,7 @@ export class BufferCursor {
*/
i16(): number {
const r = this.dv.getInt16(this.position, this.little_endian);
this.position += 2;
this._position += 2;
return r;
}
@ -179,7 +187,7 @@ export class BufferCursor {
*/
i32(): number {
const r = this.dv.getInt32(this.position, this.little_endian);
this.position += 4;
this._position += 4;
return r;
}
@ -188,7 +196,7 @@ export class BufferCursor {
*/
f32(): number {
const r = this.dv.getFloat32(this.position, this.little_endian);
this.position += 4;
this._position += 4;
return r;
}
@ -197,7 +205,7 @@ export class BufferCursor {
*/
u8_array(n: number): number[] {
const array = [];
for (let i = 0; i < n; ++i) array.push(this.dv.getUint8(this.position++));
for (let i = 0; i < n; ++i) array.push(this.dv.getUint8(this._position++));
return array;
}
@ -209,7 +217,7 @@ export class BufferCursor {
for (let i = 0; i < n; ++i) {
array.push(this.dv.getUint16(this.position, this.little_endian));
this.position += 2;
this._position += 2;
}
return array;
@ -223,7 +231,7 @@ export class BufferCursor {
for (let i = 0; i < n; ++i) {
array.push(this.dv.getUint32(this.position, this.little_endian));
this.position += 4;
this._position += 4;
}
return array;
@ -240,7 +248,7 @@ export class BufferCursor {
throw new Error(`Size ${size} out of bounds.`);
}
this.position += size;
this._position += size;
return new BufferCursor(
this.buffer.slice(this.position - size, this.position),
this.little_endian
@ -260,7 +268,7 @@ export class BufferCursor {
: max_byte_length;
const r = ASCII_DECODER.decode(new DataView(this.buffer, this.position, string_length));
this.position += drop_remaining
this._position += drop_remaining
? max_byte_length
: Math.min(string_length + 1, max_byte_length);
return r;
@ -281,7 +289,7 @@ export class BufferCursor {
const r = this.utf16_decoder.decode(
new DataView(this.buffer, this.position, string_length)
);
this.position += drop_remaining
this._position += drop_remaining
? max_byte_length
: Math.min(string_length + 2, max_byte_length);
return r;
@ -293,7 +301,7 @@ export class BufferCursor {
write_u8(value: number): BufferCursor {
this.ensure_capacity(this.position + 1);
this.dv.setUint8(this.position++, value);
this.dv.setUint8(this._position++, value);
if (this.position > this.size) {
this.size = this.position;
@ -309,7 +317,7 @@ export class BufferCursor {
this.ensure_capacity(this.position + 2);
this.dv.setUint16(this.position, value, this.little_endian);
this.position += 2;
this._position += 2;
if (this.position > this.size) {
this.size = this.position;
@ -325,7 +333,7 @@ export class BufferCursor {
this.ensure_capacity(this.position + 4);
this.dv.setUint32(this.position, value, this.little_endian);
this.position += 4;
this._position += 4;
if (this.position > this.size) {
this.size = this.position;
@ -341,7 +349,7 @@ export class BufferCursor {
this.ensure_capacity(this.position + 4);
this.dv.setInt32(this.position, value, this.little_endian);
this.position += 4;
this._position += 4;
if (this.position > this.size) {
this.size = this.position;
@ -357,7 +365,7 @@ export class BufferCursor {
this.ensure_capacity(this.position + 4);
this.dv.setFloat32(this.position, value, this.little_endian);
this.position += 4;
this._position += 4;
if (this.position > this.size) {
this.size = this.position;
@ -373,7 +381,7 @@ export class BufferCursor {
this.ensure_capacity(this.position + array.length);
new Uint8Array(this.buffer, this.position).set(new Uint8Array(array));
this.position += array.length;
this._position += array.length;
if (this.position > this.size) {
this.size = this.position;
@ -389,7 +397,7 @@ export class BufferCursor {
this.ensure_capacity(this.position + other.size);
new Uint8Array(this.buffer, this.position).set(new Uint8Array(other.buffer));
this.position += other.size;
this._position += other.size;
if (this.position > this.size) {
this.size = this.position;
@ -460,7 +468,7 @@ export class BufferCursor {
const new_buffer = new ArrayBuffer(new_size);
new Uint8Array(new_buffer).set(new Uint8Array(this.buffer, 0, this.size));
this.buffer = new_buffer;
this._buffer = new_buffer;
this.dv = new DataView(this.buffer);
}
}

2
src/data_formats/encryption/prc.ts
View File

@ -43,7 +43,7 @@ class PrcDecryptor {
out_cursor.write_u32(this.decrypt_u32(u32));
}
out_cursor.position = 0;
out_cursor.seek_start(0);
out_cursor.size = actual_size;
return out_cursor;
}

85
src/data_formats/parsing/area_collision_geometry.ts Normal file
View File

@ -0,0 +1,85 @@
import { BufferCursor } from "../BufferCursor";
import { Vec3 } from "../Vec3";
export type CollisionObject = {
meshes: CollisionMesh[];
};
export type CollisionMesh = {
vertices: Vec3[];
triangles: CollisionTriangle[];
};
export type CollisionTriangle = {
indices: [number, number, number];
flags: number;
normal: Vec3;
};
export function parse_area_collision_geometry(cursor: BufferCursor): CollisionObject {
cursor.seek_end(16);
const main_block_offset = cursor.u32();
cursor.seek_start(main_block_offset);
const main_offset_table_offset = cursor.u32();
cursor.seek_start(main_offset_table_offset);
const object: CollisionObject = {
meshes: [],
};
while (cursor.bytes_left) {
const start_pos = cursor.position;
const block_trailer_offset = cursor.u32();
if (block_trailer_offset === 0) {
break;
}
const mesh: CollisionMesh = {
vertices: [],
triangles: [],
};
object.meshes.push(mesh);
cursor.seek_start(block_trailer_offset);
const vertex_count = cursor.u32();
const vertex_table_offset = cursor.u32();
const triangle_count = cursor.u32();
const triangle_table_offset = cursor.u32();
cursor.seek_start(vertex_table_offset);
for (let i = 0; i < vertex_count; i++) {
const x = cursor.f32();
const y = cursor.f32();
const z = cursor.f32();
mesh.vertices.push(new Vec3(x, y, z));
}
cursor.seek_start(triangle_table_offset);
for (let i = 0; i < triangle_count; i++) {
const v1 = cursor.u16();
const v2 = cursor.u16();
const v3 = cursor.u16();
const flags = cursor.u16();
const n_x = cursor.f32();
const n_y = cursor.f32();
const n_z = cursor.f32();
cursor.seek(16);
mesh.triangles.push({
indices: [v1, v2, v3],
flags,
normal: new Vec3(n_x, n_y, n_z),
});
}
cursor.seek_start(start_pos + 24);
}
return object;
}

116
src/data_formats/parsing/geometry.ts → src/data_formats/parsing/area_geometry.ts
View File

@ -2,131 +2,19 @@ import Logger from "js-logger";
import {
BufferGeometry,
DoubleSide,
Face3,
Float32BufferAttribute,
Geometry,
Mesh,
MeshBasicMaterial,
MeshLambertMaterial,
Object3D,
TriangleStripDrawMode,
Uint16BufferAttribute,
Vector3,
} from "three";
import { Section } from "../../domain";
import { Vec3 } from "../Vec3";
const logger = Logger.get("data_formats/parsing/geometry");
const logger = Logger.get("data_formats/parsing/area_geometry");
export function parse_c_rel(array_buffer: ArrayBuffer): Object3D {
const dv = new DataView(array_buffer);
const object = new Object3D();
const materials = [
// Wall
new MeshBasicMaterial({
color: 0x80c0d0,
transparent: true,
opacity: 0.25,
}),
// Ground
new MeshLambertMaterial({
color: 0x50d0d0,
side: DoubleSide,
}),
// Vegetation
new MeshLambertMaterial({
color: 0x50b070,
side: DoubleSide,
}),
// Section transition zone
new MeshLambertMaterial({
color: 0x604080,
side: DoubleSide,
}),
];
const wireframe_materials = [
// Wall
new MeshBasicMaterial({
color: 0x90d0e0,
wireframe: true,
transparent: true,
opacity: 0.3,
}),
// Ground
new MeshBasicMaterial({
color: 0x60f0f0,
wireframe: true,
}),
// Vegetation
new MeshBasicMaterial({
color: 0x60c080,
wireframe: true,
}),
// Section transition zone
new MeshBasicMaterial({
color: 0x705090,
wireframe: true,
}),
];
const main_block_offset = dv.getUint32(dv.byteLength - 16, true);
const main_offset_table_offset = dv.getUint32(main_block_offset, true);
for (
let i = main_offset_table_offset;
i === main_offset_table_offset || dv.getUint32(i) !== 0;
i += 24
) {
const block_geometry = new Geometry();
const block_trailer_offset = dv.getUint32(i, true);
const vertex_count = dv.getUint32(block_trailer_offset, true);
const vertex_table_offset = dv.getUint32(block_trailer_offset + 4, true);
const vertex_table_end = vertex_table_offset + 12 * vertex_count;
const triangle_count = dv.getUint32(block_trailer_offset + 8, true);
const triangle_table_offset = dv.getUint32(block_trailer_offset + 12, true);
const triangle_table_end = triangle_table_offset + 36 * triangle_count;
for (let j = vertex_table_offset; j < vertex_table_end; j += 12) {
const x = dv.getFloat32(j, true);
const y = dv.getFloat32(j + 4, true);
const z = dv.getFloat32(j + 8, true);
block_geometry.vertices.push(new Vector3(x, y, z));
}
for (let j = triangle_table_offset; j < triangle_table_end; j += 36) {
const v1 = dv.getUint16(j, true);
const v2 = dv.getUint16(j + 2, true);
const v3 = dv.getUint16(j + 4, true);
const flags = dv.getUint16(j + 6, true);
const n = new Vector3(
dv.getFloat32(j + 8, true),
dv.getFloat32(j + 12, true),
dv.getFloat32(j + 16, true)
);
const is_section_transition = flags & 0b1000000;
const is_vegetation = flags & 0b10000;
const is_ground = flags & 0b1;
const color_index = is_section_transition ? 3 : is_vegetation ? 2 : is_ground ? 1 : 0;
block_geometry.faces.push(new Face3(v1, v2, v3, n, undefined, color_index));
}
const mesh = new Mesh(block_geometry, materials);
mesh.renderOrder = 1;
object.add(mesh);
const wireframe_mesh = new Mesh(block_geometry, wireframe_materials);
wireframe_mesh.renderOrder = 2;
object.add(wireframe_mesh);
}
return object;
}
export function parse_n_rel(
export function parse_area_geometry(
array_buffer: ArrayBuffer
): { sections: Section[]; object_3d: Object3D } {
const dv = new DataView(array_buffer);

10
src/data_formats/parsing/ninja/njcm.ts
View File

@ -3,7 +3,7 @@ import { BufferCursor } from "../../BufferCursor";
import { Vec3 } from "../../Vec3";
import { NjVertex } from ".";
const logger = Logger.get("data_formats/parsing/ninja/nj");
const logger = Logger.get("data_formats/parsing/ninja/njcm");
// TODO:
// - textures
@ -20,8 +20,8 @@ export type NjcmModel = {
vertices: NjVertex[];
meshes: NjcmTriangleStrip[];
// materials: [],
bounding_sphere_center: Vec3;
bounding_sphere_radius: number;
collision_sphere_center: Vec3;
collision_sphere_radius: number;
};
enum NjcmChunkType {
@ -169,8 +169,8 @@ export function parse_njcm_model(cursor: BufferCursor, cached_chunk_offsets: num
type: "njcm",
vertices,
meshes,
bounding_sphere_center,
bounding_sphere_radius,
collision_sphere_center: bounding_sphere_center,
collision_sphere_radius: bounding_sphere_radius,
};
}

101
src/rendering/areas.ts Normal file
View File

@ -0,0 +1,101 @@
import {
DoubleSide,
Face3,
Geometry,
Group,
Mesh,
MeshBasicMaterial,
MeshLambertMaterial,
Object3D,
Vector3,
} from "three";
import { CollisionObject } from "../data_formats/parsing/area_collision_geometry";
const materials = [
// Wall
new MeshBasicMaterial({
color: 0x80c0d0,
transparent: true,
opacity: 0.25,
}),
// Ground
new MeshLambertMaterial({
color: 0x50d0d0,
side: DoubleSide,
}),
// Vegetation
new MeshLambertMaterial({
color: 0x50b070,
side: DoubleSide,
}),
// Section transition zone
new MeshLambertMaterial({
color: 0x604080,
side: DoubleSide,
}),
];
const wireframe_materials = [
// Wall
new MeshBasicMaterial({
color: 0x90d0e0,
wireframe: true,
transparent: true,
opacity: 0.3,
}),
// Ground
new MeshBasicMaterial({
color: 0x60f0f0,
wireframe: true,
}),
// Vegetation
new MeshBasicMaterial({
color: 0x60c080,
wireframe: true,
}),
// Section transition zone
new MeshBasicMaterial({
color: 0x705090,
wireframe: true,
}),
];
export function area_collision_geometry_to_object_3d(object: CollisionObject): Object3D {
const group = new Group();
for (const collision_mesh of object.meshes) {
// Use Geometry and not BufferGeometry for better raycaster performance.
const geom = new Geometry();
for (const { x, y, z } of collision_mesh.vertices) {
geom.vertices.push(new Vector3(x, y, z));
}
for (const { indices, flags, normal } of collision_mesh.triangles) {
const is_section_transition = flags & 0b1000000;
const is_vegetation = flags & 0b10000;
const is_ground = flags & 0b1;
const color_index = is_section_transition ? 3 : is_vegetation ? 2 : is_ground ? 1 : 0;
geom.faces.push(
new Face3(
indices[0],
indices[1],
indices[2],
new Vector3(normal.x, normal.y, normal.z),
undefined,
color_index
)
);
}
const mesh = new Mesh(geom, materials);
mesh.renderOrder = 1;
group.add(mesh);
const wireframe_mesh = new Mesh(geom, wireframe_materials);
wireframe_mesh.renderOrder = 2;
group.add(wireframe_mesh);
}
return group;
}

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

@ -1,7 +1,7 @@
import { CylinderBufferGeometry, MeshLambertMaterial, Object3D, Vector3 } from "three";
import { CylinderBufferGeometry, MeshLambertMaterial, Object3D } from "three";
import { DatNpc, DatObject } from "../data_formats/parsing/quest/dat";
import { NpcType, ObjectType, QuestNpc, QuestObject } from "../domain";
import { Vec3 } from "../data_formats/Vec3";
import { NpcType, ObjectType, QuestNpc, QuestObject } from "../domain";
import { create_npc_mesh, create_object_mesh, NPC_COLOR, OBJECT_COLOR } from "./entities";
const cylinder = new CylinderBufferGeometry(3, 3, 20).translate(0, 10, 0);
@ -45,33 +45,3 @@ test("create geometry for quest NPCs", () => {
expect(geometry.position.z).toBe(23);
expect((geometry.material as MeshLambertMaterial).color.getHex()).toBe(NPC_COLOR);
});
test("geometry position changes when entity position changes element-wise", () => {
const npc = new QuestNpc(
7,
13,
new Vec3(17, 19, 23),
new Vec3(0, 0, 0),
NpcType.Booma,
{} as DatNpc
);
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));
});
test("geometry position changes when entire entity position changes", () => {
const npc = new QuestNpc(
7,
13,
new Vec3(17, 19, 23),
new Vec3(0, 0, 0),
NpcType.Booma,
{} as DatNpc
);
const geometry = create_npc_mesh(npc, cylinder);
npc.position = new Vec3(2, 3, 5);
expect(geometry.position).toEqual(new Vector3(2, 3, 5));
});

5
src/rendering/entities.ts
View File

@ -32,5 +32,10 @@ function create_mesh(
mesh.name = type;
mesh.userData.entity = entity;
const { x, y, z } = entity.position;
mesh.position.set(x, y, z);
const rot = entity.rotation;
mesh.rotation.set(rot.x, rot.y, rot.z);
return mesh;
}

1
src/rendering/models.ts
View File

@ -102,7 +102,6 @@ class Object3DCreator {
geom.addAttribute("normal", new Float32BufferAttribute(this.normals, 3));
geom.setIndex(new Uint16BufferAttribute(this.indices, 1));
// The bounding spheres from the object seem be too small.
geom.computeBoundingSphere();
return geom;

19
src/stores/AreaStore.ts
View File

@ -1,7 +1,10 @@
import { Area, AreaVariant, Section } from "../domain";
import { Object3D } from "three";
import { parse_c_rel, parse_n_rel } from "../data_formats/parsing/geometry";
import { get_area_render_data, get_area_collision_data } from "./binary_assets";
import { BufferCursor } from "../data_formats/BufferCursor";
import { parse_area_collision_geometry } from "../data_formats/parsing/area_collision_geometry";
import { parse_area_geometry } from "../data_formats/parsing/area_geometry";
import { Area, AreaVariant, Section } from "../domain";
import { area_collision_geometry_to_object_3d } from "../rendering/areas";
import { get_area_collision_data, get_area_render_data } from "./binary_assets";
function area(id: number, name: string, order: number, variants: number): Area {
const area = new Area(id, name, order, []);
@ -137,8 +140,10 @@ class AreaStore {
if (object_3d) {
return object_3d;
} else {
const object_3d = get_area_collision_data(episode, area_id, area_variant).then(
parse_c_rel
const object_3d = get_area_collision_data(episode, area_id, area_variant).then(buffer =>
area_collision_geometry_to_object_3d(
parse_area_collision_geometry(new BufferCursor(buffer, true))
)
);
collision_geometry_cache.set(`${area_id}-${area_variant}`, object_3d);
return object_3d;
@ -150,7 +155,9 @@ class AreaStore {
area_id: number,
area_variant: number
): Promise<{ sections: Section[]; object_3d: Object3D }> {
const promise = get_area_render_data(episode, area_id, area_variant).then(parse_n_rel);
const promise = get_area_render_data(episode, area_id, area_variant).then(
parse_area_geometry
);
const sections = new Promise<Section[]>((resolve, reject) => {
promise.then(({ sections }) => resolve(sections)).catch(reject);