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

Introduced Block concept to represent a continuous chunk of bytes.

Browse Source
This commit is contained in:
Daan Vanden Bosch 2020-07-17 00:00:17 +02:00
parent 2d4fee542c
commit cd67e214f1
65 changed files with 1352 additions and 1404 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
assets_generation/update_ephinea_data.ts
View File

@ -1,6 +1,6 @@
import { readdirSync, readFileSync, statSync, writeFileSync } from "fs";
import { ASSETS_DIR, RESOURCE_DIR } from ".";
import { BufferCursor } from "../src/core/data_formats/cursor/BufferCursor";
import { BufferCursor } from "../src/core/data_formats/block/cursor/BufferCursor";
import { ItemPmt, parse_item_pmt } from "../src/core/data_formats/parsing/itempmt";
import { parse_qst_to_quest } from "../src/core/data_formats/parsing/quest";
import { parse_unitxt, Unitxt } from "../src/core/data_formats/parsing/unitxt";
@ -8,7 +8,7 @@ import { Difficulties, Difficulty, SectionId, SectionIds } from "../src/core/mod
import { update_drops_from_website } from "./update_drops_ephinea";
import { Episode, EPISODES } from "../src/core/data_formats/parsing/quest/Episode";
import { npc_data, NPC_TYPES, NpcType } from "../src/core/data_formats/parsing/quest/npc_types";
import { Endianness } from "../src/core/data_formats/Endianness";
import { Endianness } from "../src/core/data_formats/block/Endianness";
import { ItemTypeDto } from "../src/core/dto/ItemTypeDto";
import { QuestDto } from "../src/hunt_optimizer/dto/QuestDto";
import { BoxDropDto, EnemyDropDto } from "../src/hunt_optimizer/dto/drops";
@ -112,7 +112,7 @@ function process_quest_dir(path: string, quests: QuestDto[]): void {
function process_quest(path: string, quests: QuestDto[]): void {
try {
const buf = readFileSync(path);
const q = parse_qst_to_quest(new BufferCursor(buf, Endianness.Little), true);
const q = parse_qst_to_quest(new BufferCursor(buf, Endianness.Little), true)?.quest;
if (q) {
logger.trace(`Processing quest "${q.name}".`);

4
assets_generation/update_generic_data.ts
View File

@ -1,9 +1,9 @@
import { readFileSync, writeFileSync } from "fs";
import { ASSETS_DIR, RESOURCE_DIR, SRC_DIR } from ".";
import { BufferCursor } from "../src/core/data_formats/cursor/BufferCursor";
import { BufferCursor } from "../src/core/data_formats/block/cursor/BufferCursor";
import { parse_rlc } from "../src/core/data_formats/parsing/rlc";
import * as yaml from "yaml";
import { Endianness } from "../src/core/data_formats/Endianness";
import { Endianness } from "../src/core/data_formats/block/Endianness";
import { LogManager } from "../src/core/Logger";
import { Severity } from "../src/core/Severity";

62
src/core/data_formats/ResizableBuffer.ts
View File

@ -1,62 +0,0 @@
/**
* Resizable buffer.
*/
export class ResizableBuffer {
private _size: number = 0;
get size(): number {
return this._size;
}
set size(size: number) {
if (size < 0) {
throw new Error("Size should be non-negative.");
}
this.ensure_capacity(size);
this._size = size;
}
get capacity(): number {
return this._buffer.byteLength;
}
private _buffer: ArrayBuffer;
get backing_buffer(): ArrayBuffer {
return this._buffer;
}
private _data_view: DataView;
get view(): DataView {
return this._data_view;
}
constructor(initial_capacity: number = 8192) {
this._buffer = new ArrayBuffer(initial_capacity);
this._data_view = new DataView(this._buffer);
}
sub_view(offset: number, size: number): DataView {
return new DataView(this._buffer, offset, size);
}
/**
* Increases buffer size if necessary.
*/
private ensure_capacity(min_new_size: number): void {
if (min_new_size > this.capacity) {
let new_size = this.capacity || min_new_size;
do {
new_size *= 2;
} while (new_size < min_new_size);
const new_buffer = new ArrayBuffer(new_size);
new Uint8Array(new_buffer).set(new Uint8Array(this._buffer, 0, this.size));
this._buffer = new_buffer;
this._data_view = new DataView(this._buffer);
}
}
}

141
src/core/data_formats/block/AbstractWritableBlock.ts Normal file
View File

@ -0,0 +1,141 @@
import { WritableBlock } from "./WritableBlock";
import { Endianness } from "./Endianness";
export abstract class AbstractWritableBlock implements WritableBlock {
abstract readonly size: number;
protected little_endian!: boolean;
get endianness(): Endianness {
return this.little_endian ? Endianness.Little : Endianness.Big;
}
set endianness(endianness: Endianness) {
this.little_endian = endianness === Endianness.Little;
}
protected abstract readonly buffer: ArrayBuffer;
protected abstract readonly data_view: DataView;
protected constructor(endianness: Endianness) {
this.endianness = endianness;
}
get_u8(offset: number): number {
this.check_offset(offset, 1);
return this.data_view.getUint8(offset);
}
get_u16(offset: number): number {
this.check_offset(offset, 2);
return this.data_view.getUint16(offset, this.little_endian);
}
get_u32(offset: number): number {
this.check_offset(offset, 4);
return this.data_view.getUint32(offset, this.little_endian);
}
get_i8(offset: number): number {
this.check_offset(offset, 1);
return this.data_view.getInt8(offset);
}
get_i16(offset: number): number {
this.check_offset(offset, 2);
return this.data_view.getInt16(offset, this.little_endian);
}
get_i32(offset: number): number {
this.check_offset(offset, 4);
return this.data_view.getInt32(offset, this.little_endian);
}
get_f32(offset: number): number {
this.check_offset(offset, 4);
return this.data_view.getFloat32(offset, this.little_endian);
}
get_string_utf16(offset: number, max_byte_length: number, null_terminated: boolean): string {
const code_points: number[] = [];
const len = Math.floor(max_byte_length / 2);
for (let i = 0; i < len; i++) {
const code_point = this.get_u16(offset + i * 2);
if (null_terminated && code_point === 0) {
break;
}
code_points.push(code_point);
}
return String.fromCodePoint(...code_points);
}
get_array_buffer(offset: number, size: number): ArrayBuffer {
this.check_offset(offset, size);
return this.buffer.slice(offset, offset + size);
}
uint8_view(offset: number, size: number): Uint8Array {
this.check_offset(offset, size);
return new Uint8Array(this.buffer, offset, size);
}
set_u8(offset: number, value: number): this {
this.check_offset(offset, 1);
this.data_view.setUint8(offset, value);
return this;
}
set_u16(offset: number, value: number): this {
this.check_offset(offset, 2);
this.data_view.setUint16(offset, value, this.little_endian);
return this;
}
set_u32(offset: number, value: number): this {
this.check_offset(offset, 4);
this.data_view.setUint32(offset, value, this.little_endian);
return this;
}
set_i8(offset: number, value: number): this {
this.check_offset(offset, 1);
this.data_view.setInt8(offset, value);
return this;
}
set_i16(offset: number, value: number): this {
this.check_offset(offset, 2);
this.data_view.setInt16(offset, value, this.little_endian);
return this;
}
set_i32(offset: number, value: number): this {
this.check_offset(offset, 4);
this.data_view.setInt32(offset, value, this.little_endian);
return this;
}
set_f32(offset: number, value: number): this {
this.check_offset(offset, 4);
this.data_view.setFloat32(offset, value, this.little_endian);
return this;
}
zero(): this {
new Uint8Array(this.buffer).fill(0);
return this;
}
/**
* Checks whether we can read `size` bytes at `offset`.
*/
protected check_offset(offset: number, size: number): void {
if (offset < 0 || offset + size > this.size) {
throw new Error(`Offset ${offset} is out of bounds.`);
}
}
}

18
src/core/data_formats/block/ArrayBufferBlock.ts Normal file
View File

@ -0,0 +1,18 @@
import { Endianness } from "./Endianness";
import { AbstractWritableBlock } from "./AbstractWritableBlock";
export class ArrayBufferBlock extends AbstractWritableBlock {
get size(): number {
return this.data_view.byteLength;
}
protected readonly buffer: ArrayBuffer;
protected readonly data_view: DataView;
constructor(size: number, endianness: Endianness) {
super(endianness);
this.buffer = new ArrayBuffer(size);
this.data_view = new DataView(this.buffer);
}
}

60
src/core/data_formats/block/Block.ts Normal file
View File

@ -0,0 +1,60 @@
import { Endianness } from "./Endianness";
/**
* Represents a continuous block of bytes.
*/
export interface Block {
readonly size: number;
/**
* Byte order mode.
*/
endianness: Endianness;
/**
* Reads an unsigned 8-bit integer at the given offset.
*/
get_u8(offset: number): number;
/**
* Reads an unsigned 16-bit integer at the given offset.
*/
get_u16(offset: number): number;
/**
* Reads an unsigned 32-bit integer at the given offset.
*/
get_u32(offset: number): number;
/**
* Reads a signed 8-bit integer at the given offset.
*/
get_i8(offset: number): number;
/**
* Reads a signed 16-bit integer at the given offset.
*/
get_i16(offset: number): number;
/**
* Reads a signed 32-bit integer at the given offset.
*/
get_i32(offset: number): number;
/**
* Reads a 32-bit floating point number at the given offset.
*/
get_f32(offset: number): number;
/**
* Reads a UTF-16-encoded string at the given offset.
*/
get_string_utf16(offset: number, max_byte_length: number, null_terminated: boolean): string;
/**
* Reads an array buffer of the given size at the given offset.
*/
get_array_buffer(offset: number, size: number): ArrayBuffer;
uint8_view(offset: number, size: number): Uint8Array;
}

0
src/core/data_formats/Endianness.ts → src/core/data_formats/block/Endianness.ts
View File

16
src/core/data_formats/ResizableBuffer.test.ts → src/core/data_formats/block/ResizableBlock.test.ts
View File

@ -1,18 +1,17 @@
import { ResizableBuffer } from "./ResizableBuffer";
import { ResizableBlock } from "./ResizableBlock";
import { Endianness } from "./Endianness";
test("simple properties and invariants", () => {
const capacity = 500;
const rb = new ResizableBuffer(capacity);
const rb = new ResizableBlock(capacity);
expect(rb.size).toBe(0);
expect(rb.capacity).toBe(capacity);
expect(rb.backing_buffer.byteLength).toBe(capacity);
expect(rb.view.byteOffset).toBe(0);
expect(rb.view.byteLength).toBe(capacity);
expect(rb.endianness).toBe(Endianness.Little);
});
test("reallocation of internal buffer when necessary", () => {
const rb = new ResizableBuffer(100);
const rb = new ResizableBlock(100);
expect(rb.size).toBe(0);
expect(rb.capacity).toBe(100);
@ -21,5 +20,8 @@ test("reallocation of internal buffer when necessary", () => {
expect(rb.size).toBe(101);
expect(rb.capacity).toBeGreaterThanOrEqual(101);
expect(rb.view.byteLength).toBeGreaterThanOrEqual(101);
rb.set_u8(100, 0xab);
expect(rb.get_u8(100)).toBe(0xab);
});

54
src/core/data_formats/block/ResizableBlock.ts Normal file
View File

@ -0,0 +1,54 @@
import { Endianness } from "./Endianness";
import { AbstractWritableBlock } from "./AbstractWritableBlock";
/**
* Resizable block backed by an ArrayBuffer which is reallocated when necessary.
*/
export class ResizableBlock extends AbstractWritableBlock {
private _size: number = 0;
get size(): number {
return this._size;
}
set size(size: number) {
if (size < 0) {
throw new Error("Size should be non-negative.");
}
this.ensure_capacity(size);
this._size = size;
}
get capacity(): number {
return this.buffer.byteLength;
}
protected buffer: ArrayBuffer;
protected data_view: DataView;
constructor(initial_capacity: number = 8192, endianness: Endianness = Endianness.Little) {
super(endianness);
this.buffer = new ArrayBuffer(initial_capacity);
this.data_view = new DataView(this.buffer);
}
/**
* Reallocates the underlying ArrayBuffer if necessary.
*/
private ensure_capacity(min_new_size: number): void {
if (min_new_size > this.capacity) {
let new_size = this.capacity || min_new_size;
do {
new_size *= 2;
} while (new_size < min_new_size);
const new_buffer = new ArrayBuffer(new_size);
new Uint8Array(new_buffer).set(new Uint8Array(this.buffer, 0, this.size));
this.buffer = new_buffer;
this.data_view = new DataView(this.buffer);
}
}
}

48
src/core/data_formats/block/WritableBlock.ts Normal file
View File

@ -0,0 +1,48 @@
import { Block } from "./Block";
/**
* Represents a mutable, continuous block of bytes.
*/
export interface WritableBlock extends Block {
readonly size: number;
/**
* Writes an unsigned 8-bit integer at the given offset.
*/
set_u8(offset: number, value: number): this;
/**
* Writes an unsigned 16-bit integer at the given offset.
*/
set_u16(offset: number, value: number): this;
/**
* Writes an unsigned 32-bit integer at the given offset.
*/
set_u32(offset: number, value: number): this;
/**
* Writes a signed 8-bit integer at the given offset.
*/
set_i8(offset: number, value: number): this;
/**
* Writes a signed 16-bit integer at the given offset.
*/
set_i16(offset: number, value: number): this;
/**
* Writes a signed 32-bit integer at the given offset.
*/
set_i32(offset: number, value: number): this;
/**
* Writes a 32-bit floating point number at the given offset.
*/
set_f32(offset: number, value: number): this;
/**
* Writes 0 bytes to the entire block.
*/
zero(): this;
}

212
src/core/data_formats/block/cursor/AbstractArrayBufferCursor.ts Normal file
View File

@ -0,0 +1,212 @@
import { Endianness } from "../Endianness";
import { Cursor } from "./Cursor";
import { AbstractWritableCursor } from "./AbstractWritableCursor";
export abstract class AbstractArrayBufferCursor extends AbstractWritableCursor {
protected little_endian!: boolean;
get endianness(): Endianness {
return this.little_endian ? Endianness.Little : Endianness.Big;
}
set endianness(endianness: Endianness) {
this.little_endian = endianness === Endianness.Little;
}
protected abstract readonly backing_buffer: ArrayBuffer;
protected abstract readonly dv: DataView;
protected constructor(endianness: Endianness, offset: number) {
super(offset);
this.endianness = endianness;
}
u8(): number {
this.check_size(1);
const r = this.dv.getUint8(this.absolute_position);
this._position++;
return r;
}
u16(): number {
this.check_size(2);
const r = this.dv.getUint16(this.absolute_position, this.little_endian);
this._position += 2;
return r;
}
u32(): number {
this.check_size(4);
const r = this.dv.getUint32(this.absolute_position, this.little_endian);
this._position += 4;
return r;
}
i8(): number {
this.check_size(1);
const r = this.dv.getInt8(this.absolute_position);
this._position++;
return r;
}
i16(): number {
this.check_size(2);
const r = this.dv.getInt16(this.absolute_position, this.little_endian);
this._position += 2;
return r;
}
i32(): number {
this.check_size(4);
const r = this.dv.getInt32(this.absolute_position, this.little_endian);
this._position += 4;
return r;
}
f32(): number {
this.check_size(4);
const r = this.dv.getFloat32(this.absolute_position, this.little_endian);
this._position += 4;
return r;
}
u8_array(n: number): number[] {
this.check_size(n);
const array = [];
for (let i = 0; i < n; ++i) {
array.push(this.dv.getUint8(this.absolute_position));
this._position++;
}
return array;
}
u16_array(n: number): number[] {
this.check_size(2 * n);
const array = [];
for (let i = 0; i < n; ++i) {
array.push(this.dv.getUint16(this.absolute_position, this.little_endian));
this._position += 2;
}
return array;
}
u32_array(n: number): number[] {
this.check_size(4 * n);
const array = [];
for (let i = 0; i < n; ++i) {
array.push(this.dv.getUint32(this.absolute_position, this.little_endian));
this._position += 4;
}
return array;
}
i32_array(n: number): number[] {
this.check_size(4 * n);
const array = [];
for (let i = 0; i < n; ++i) {
array.push(this.dv.getInt32(this.absolute_position, this.little_endian));
this._position += 4;
}
return array;
}
abstract take(size: number): Cursor;
array_buffer(size: number = this.size - this.position): ArrayBuffer {
this.check_size(size);
const r = this.backing_buffer.slice(this.absolute_position, this.absolute_position + size);
this._position += size;
return r;
}
copy_to_uint8_array(array: Uint8Array, size: number = this.size - this.position): this {
this.check_size(size);
array.set(new Uint8Array(this.backing_buffer, this.absolute_position, size));
this._position += size;
return this;
}
write_u8(value: number): this {
this.check_size(1);
this.dv.setUint8(this.absolute_position, value);
this._position++;
return this;
}
write_u16(value: number): this {
this.check_size(2);
this.dv.setUint16(this.absolute_position, value, this.little_endian);
this._position += 2;
return this;
}
write_u32(value: number): this {
this.check_size(4);
this.dv.setUint32(this.absolute_position, value, this.little_endian);
this._position += 4;
return this;
}
write_i8(value: number): this {
this.check_size(1);
this.dv.setInt8(this.absolute_position, value);
this._position++;
return this;
}
write_i16(value: number): this {
this.check_size(2);
this.dv.setInt16(this.absolute_position, value, this.little_endian);
this._position += 2;
return this;
}
write_i32(value: number): this {
this.check_size(4);
this.dv.setInt32(this.absolute_position, value, this.little_endian);
this._position += 4;
return this;
}
write_f32(value: number): this {
this.check_size(4);
this.dv.setFloat32(this.absolute_position, value, this.little_endian);
this._position += 4;
return this;
}
write_u8_array(array: ArrayLike<number>): this {
this.check_size(array.length);
new Uint8Array(this.backing_buffer, this.absolute_position, array.length).set(
new Uint8Array(array),
);
this._position += array.length;
return this;
}
write_cursor(other: Cursor): this {
const size = other.size - other.position;
this.check_size(size);
other.copy_to_uint8_array(
new Uint8Array(this.backing_buffer, this.absolute_position, size),
size,
);
this._position += size;
return this;
}
}

260
src/core/data_formats/block/cursor/AbstractWritableCursor.ts Normal file
View File

@ -0,0 +1,260 @@
import { WritableCursor } from "./WritableCursor";
import { Endianness } from "../Endianness";
import { Vec2, Vec3 } from "../../vector";
import { Cursor } from "./Cursor";
export abstract class AbstractWritableCursor implements WritableCursor {
abstract size: number;
protected _position: number = 0;
get position(): number {
return this._position;
}
abstract endianness: Endianness;
get bytes_left(): number {
return this.size - this._position;
}
protected readonly offset: number;
protected get absolute_position(): number {
return this.offset + this._position;
}
protected constructor(offset: number) {
this.offset = offset;
}
seek(offset: number): this {
return this.seek_start(this.position + offset);
}
seek_start(offset: number): this {
if (offset < 0 || offset > this.size) {
throw new Error(`Offset ${offset} is out of bounds.`);
}
this._position = offset;
return this;
}
seek_end(offset: number): this {
if (offset < 0 || offset > this.size) {
throw new Error(`Offset ${offset} is out of bounds.`);
}
this._position = this.size - offset;
return this;
}
abstract u8(): number;
abstract u16(): number;
abstract u32(): number;
abstract i8(): number;
abstract i16(): number;
abstract i32(): number;
abstract f32(): number;
abstract u8_array(n: number): number[];
abstract u16_array(n: number): number[];
abstract u32_array(n: number): number[];
abstract i32_array(n: number): number[];
vec2_f32(): Vec2 {
return { x: this.f32(), y: this.f32() };
}
vec3_f32(): Vec3 {
return { x: this.f32(), y: this.f32(), z: this.f32() };
}
abstract take(size: number): Cursor;
string_ascii(
max_byte_length: number,
null_terminated: boolean,
drop_remaining: boolean,
): string {
const code_points: number[] = [];
for (let i = 0; i < max_byte_length; i++) {
const code_point = this.u8();
if (null_terminated && code_point === 0) {
if (drop_remaining) {
this.seek(max_byte_length - i - 1);
}
break;
}
code_points.push(code_point);
}
return String.fromCodePoint(...code_points);
}
string_utf16(
max_byte_length: number,
null_terminated: boolean,
drop_remaining: boolean,
): string {
const code_points: number[] = [];
const len = Math.floor(max_byte_length / 2);
for (let i = 0; i < len; i++) {
const code_point = this.u16();
if (null_terminated && code_point === 0) {
if (drop_remaining) {
this.seek(2 * (len - i - 1));
}
break;
}
code_points.push(code_point);
}
return String.fromCodePoint(...code_points);
}
abstract array_buffer(size?: number): ArrayBuffer;
abstract copy_to_uint8_array(array: Uint8Array, size?: number): this;
abstract write_u8(value: number): this;
abstract write_u16(value: number): this;
abstract write_u32(value: number): this;
abstract write_i8(value: number): this;
abstract write_i16(value: number): this;
abstract write_i32(value: number): this;
abstract write_f32(value: number): this;
write_u8_array(array: ArrayLike<number>): this {
const len = array.length;
this.check_size(len);
for (let i = 0; i < len; i++) {
this.write_u8(array[i]);
}
return this;
}
write_u16_array(array: ArrayLike<number>): this {
const len = array.length;
this.check_size(2 * len);
for (let i = 0; i < len; i++) {
this.write_u16(array[i]);
}
return this;
}
write_u32_array(array: ArrayLike<number>): this {
const len = array.length;
this.check_size(4 * len);
for (let i = 0; i < len; i++) {
this.write_u32(array[i]);
}
return this;
}
write_i32_array(array: ArrayLike<number>): this {
const len = array.length;
this.check_size(4 * len);
for (let i = 0; i < len; i++) {
this.write_i32(array[i]);
}
return this;
}
write_vec2_f32(value: Vec2): this {
this.check_size(8);
this.write_f32(value.x);
this.write_f32(value.y);
return this;
}
write_vec3_f32(value: Vec3): this {
this.check_size(12);
this.write_f32(value.x);
this.write_f32(value.y);
this.write_f32(value.z);
return this;
}
abstract write_cursor(other: Cursor): this;
write_string_ascii(str: string, byte_length: number): this {
this.check_size(byte_length);
const len = Math.min(byte_length, str.length);
for (let i = 0; i < len; i++) {
this.write_u8(str.codePointAt(i)!);
}
const pad_len = byte_length - len;
for (let i = 0; i < pad_len; i++) {
this.write_u8(0);
}
return this;
}
write_string_utf16(str: string, byte_length: number): this {
this.check_size(byte_length);
const max_len = Math.floor(byte_length / 2);
const len = Math.min(max_len, str.length);
for (let i = 0; i < len; i++) {
this.write_u16(str.codePointAt(i)!);
}
const pad_len = max_len - len;
for (let i = 0; i < pad_len; i++) {
this.write_u16(0);
}
return this;
}
/**
* Throws an error if less than `size` bytes are left at `position`.
*/
protected check_size(size: number): void {
const left = this.size - this._position;
if (size > left) {
throw new Error(`${size} Bytes required but only ${left} available.`);
}
}
}

5
src/core/data_formats/cursor/ArrayBufferCursor.ts → src/core/data_formats/block/cursor/ArrayBufferCursor.ts
View File

@ -1,11 +1,10 @@
import { Endianness } from "../Endianness";
import { AbstractWritableCursor } from "./AbstractWritableCursor";
import { WritableCursor } from "./WritableCursor";
import { AbstractArrayBufferCursor } from "./AbstractArrayBufferCursor";
/**
* A cursor for reading from an array buffer or part of an array buffer.
*/
export class ArrayBufferCursor extends AbstractWritableCursor implements WritableCursor {
export class ArrayBufferCursor extends AbstractArrayBufferCursor {
private _size: number;
get size(): number {

5
src/core/data_formats/cursor/BufferCursor.ts → src/core/data_formats/block/cursor/BufferCursor.ts
View File

@ -1,8 +1,7 @@
import { Endianness } from "../Endianness";
import { AbstractCursor } from "./AbstractCursor";
import { Cursor } from "./Cursor";
import { AbstractArrayBufferCursor } from "./AbstractArrayBufferCursor";
export class BufferCursor extends AbstractCursor implements Cursor {
export class BufferCursor extends AbstractArrayBufferCursor {
readonly size: number;
protected buffer: Buffer;

24
src/core/data_formats/cursor/Cursor.test.ts → src/core/data_formats/block/cursor/Cursor.test.ts
View File

@ -1,10 +1,10 @@
import { Endianness } from "../Endianness";
import { enum_values } from "../../enums";
import { ResizableBuffer } from "../ResizableBuffer";
import { enum_values } from "../../../enums";
import { ResizableBlock } from "../ResizableBlock";
import { ArrayBufferCursor } from "./ArrayBufferCursor";
import { BufferCursor } from "./BufferCursor";
import { Cursor } from "./Cursor";
import { ResizableBufferCursor } from "./ResizableBufferCursor";
import { ResizableBlockCursor } from "./ResizableBlockCursor";
/**
* Run a test on every cursor implementation with every endianness.
@ -20,16 +20,12 @@ function test_all(
): void {
const endiannesses = enum_values<Endianness>(Endianness);
function rbuf(endianness: Endianness): ResizableBuffer {
function block(endianness: Endianness): ResizableBlock {
const byte_array = bytes(endianness);
const rbuf = new ResizableBuffer(byte_array.length);
rbuf.size = byte_array.length;
for (let i = 0; i < byte_array.length; i++) {
rbuf.view.setUint8(i, byte_array[i]);
}
return rbuf;
const block = new ResizableBlock(byte_array.length, endianness);
block.size = byte_array.length;
block.uint8_view(0, byte_array.length).set(byte_array);
return block;
}
const cursors: [string, Endianness, Cursor][] = [
@ -44,9 +40,9 @@ function test_all(
new BufferCursor(Buffer.from(bytes(endianness)), endianness),
]),
...endiannesses.map(endianness => [
ResizableBufferCursor.name,
ResizableBlockCursor.name,
endianness,
new ResizableBufferCursor(rbuf(endianness), endianness),
new ResizableBlockCursor(block(endianness)),
]),
] as any;

47
src/core/data_formats/cursor/Cursor.ts → src/core/data_formats/block/cursor/Cursor.ts
View File

@ -1,5 +1,5 @@
import { Endianness } from "../Endianness";
import { Vec3, Vec2 } from "../vector";
import { Vec3, Vec2 } from "../../vector";
/**
* A cursor for reading binary data.
@ -48,71 +48,36 @@ export interface Cursor {
*/
u8(): number;
/**
* Reads an unsigned 8-bit integer at the given absolute offset. Doesn't increment position.
*/
u8_at(offset: number): number;
/**
* Reads an unsigned 16-bit integer and increments position by 2.
*/
u16(): number;
/**
* Reads an unsigned 16-bit integer at the given absolute offset. Doesn't increment position.
*/
u16_at(offset: number): number;
/**
* Reads an unsigned 32-bit integer and increments position by 4.
*/
u32(): number;
/**
* Reads an unsigned 32-bit integer at the given absolute offset. Doesn't increment position.
*/
u32_at(offset: number): number;
/**
* Reads an signed 8-bit integer and increments position by 1.
*/
i8(): number;
/**
* Reads an unsigned 8-bit integer at the given absolute offset. Doesn't increment position.
*/
i8_at(offset: number): number;
/**
* Reads a signed 16-bit integer and increments position by 2.
*/
i16(): number;
/**
* Reads an unsigned 16-bit integer at the given absolute offset. Doesn't increment position.
*/
i16_at(offset: number): number;
/**
* Reads a signed 32-bit integer and increments position by 4.
*/
i32(): number;
/**
* Reads an unsigned 32-bit integer at the given absolute offset. Doesn't increment position.
*/
i32_at(offset: number): number;
/**
* Reads a 32-bit floating point number and increments position by 4.
*/
f32(): number;
/**
* Reads a 32-bit floating point number. Doesn't increment position.
*/
f32_at(offset: number): number;
/**
* Reads n unsigned 8-bit integers and increments position by n.
*/
@ -169,16 +134,6 @@ export interface Cursor {
drop_remaining: boolean,
): string;
/**
* Reads an ASCII-encoded string at the given absolute offset. Doesn't increment position.
*/
string_ascii_at(offset: number, max_byte_length: number, null_terminated: boolean): string;
/**
* Reads an UTF-16-encoded string at the given absolute offset. Doesn't increment position.
*/
string_utf16_at(offset: number, max_byte_length: number, null_terminated: boolean): string;
array_buffer(size?: number): ArrayBuffer;
copy_to_uint8_array(array: Uint8Array, size?: number): this;

14
src/core/data_formats/cursor/ResizableBufferCursor.test.ts → src/core/data_formats/block/cursor/ResizableBlockCursor.test.ts
View File

@ -1,6 +1,6 @@
import { Endianness } from "../Endianness";
import { ResizableBuffer } from "../ResizableBuffer";
import { ResizableBufferCursor } from "./ResizableBufferCursor";
import { ResizableBlock } from "../ResizableBlock";
import { ResizableBlockCursor } from "./ResizableBlockCursor";
/**
* Writes two integers to a cursor backed with a buffer of size 0.
@ -12,16 +12,16 @@ function test_integer_write(method_name: string): void {
const expected_number_1 = 98749;
const expected_number_2 = 7348942;
const buf = new ResizableBuffer(8);
const cursor = new ResizableBufferCursor(buf, Endianness.Little);
const block = new ResizableBlock(8, Endianness.Little);
const cursor = new ResizableBlockCursor(block);
expect(buf.size).toBe(0);
expect(block.size).toBe(0);
expect(cursor.size).toBe(0);
(cursor as any)[method_name](expected_number_1);
(cursor as any)[method_name](expected_number_2);
expect(buf.size).toBe(2 * byte_count);
expect(block.size).toBe(2 * byte_count);
expect(cursor.position).toBe(2 * byte_count);
expect(cursor.size).toBe(2 * byte_count);
});
@ -33,7 +33,7 @@ test_integer_write("write_u32");
test_integer_write("write_i32");
test("write, seek backwards then take", () => {
const cursor = new ResizableBufferCursor(new ResizableBuffer(0), Endianness.Little);
const cursor = new ResizableBlockCursor(new ResizableBlock(0, Endianness.Little));
cursor.write_u32(1).write_u32(2).write_u32(3).write_u32(4);
cursor.seek(-8);

278
src/core/data_formats/block/cursor/ResizableBlockCursor.ts Normal file
View File

@ -0,0 +1,278 @@
import { Endianness } from "../Endianness";
import { AbstractWritableCursor } from "./AbstractWritableCursor";
import { ResizableBlock } from "../ResizableBlock";
import { Cursor } from "./Cursor";
import { Vec2, Vec3 } from "../../vector";
export class ResizableBlockCursor extends AbstractWritableCursor {
private readonly block: ResizableBlock;
private _size: number;
get size(): number {
return this._size;
}
set size(size: number) {
if (size > this._size) {
this.ensure_size(size - this.position);
} else {
this._size = size;
}
}
get endianness(): Endianness {
return this.block.endianness;
}
/**
* Also sets the underlying block's endianness.
*/
set endianness(endianness: Endianness) {
this.block.endianness = endianness;
}
/**
* @param block The block to read from and write to.
* @param offset The start offset of the part that will be read from.
* @param size The size of the part that will be read from.
*/
constructor(block: ResizableBlock, offset: number = 0, size: number = block.size - offset) {
if (offset < 0 || offset > block.size) {
throw new Error(`Offset ${offset} is out of bounds.`);
}
if (size < 0 || offset + size > block.size) {
throw new Error(`Size ${size} is out of bounds.`);
}
super(offset);
this.block = block;
this._size = size;
}
u8(): number {
const r = this.block.get_u8(this.absolute_position);
this._position++;
return r;
}
u16(): number {
const r = this.block.get_u16(this.absolute_position);
this._position += 2;
return r;
}
u32(): number {
const r = this.block.get_u32(this.absolute_position);
this._position += 4;
return r;
}
i8(): number {
const r = this.block.get_i8(this.absolute_position);
this._position++;
return r;
}
i16(): number {
const r = this.block.get_i16(this.absolute_position);
this._position += 2;
return r;
}
i32(): number {
const r = this.block.get_i32(this.absolute_position);
this._position += 4;
return r;
}
f32(): number {
const r = this.block.get_f32(this.absolute_position);
this._position += 4;
return r;
}
u8_array(n: number): number[] {
this.check_size(n);
const array = [];
for (let i = 0; i < n; ++i) {
array.push(this.block.get_u8(this.absolute_position));
this._position++;
}
return array;
}
u16_array(n: number): number[] {
this.check_size(2 * n);
const array = [];
for (let i = 0; i < n; ++i) {
array.push(this.block.get_u16(this.absolute_position));
this._position += 2;
}
return array;
}
u32_array(n: number): number[] {
this.check_size(4 * n);
const array = [];
for (let i = 0; i < n; ++i) {
array.push(this.block.get_u32(this.absolute_position));
this._position += 4;
}
return array;
}
i32_array(n: number): number[] {
this.check_size(4 * n);
const array = [];
for (let i = 0; i < n; ++i) {
array.push(this.block.get_i32(this.absolute_position));
this._position += 4;
}
return array;
}
take(size: number): ResizableBlockCursor {
const offset = this.absolute_position;
const wrapper = new ResizableBlockCursor(this.block, offset, size);
this._position += size;
return wrapper;
}
array_buffer(size: number = this.size - this.position): ArrayBuffer {
const r = this.block.get_array_buffer(this.absolute_position, size);
this._position += size;
return r;
}
copy_to_uint8_array(array: Uint8Array, size: number = this.size - this.position): this {
array.set(this.block.uint8_view(this.absolute_position, size));
this._position += size;
return this;
}
write_u8(value: number): this {
this.ensure_size(1);
this.block.set_u8(this.absolute_position, value);
this._position++;
return this;
}
write_u16(value: number): this {
this.ensure_size(2);
this.block.set_u16(this.absolute_position, value);
this._position += 2;
return this;
}
write_u32(value: number): this {
this.ensure_size(4);
this.block.set_u32(this.absolute_position, value);
this._position += 4;
return this;
}
write_i8(value: number): this {
this.ensure_size(1);
this.block.set_i8(this.absolute_position, value);
this._position++;
return this;
}
write_i16(value: number): this {
this.ensure_size(2);
this.block.set_i16(this.absolute_position, value);
this._position += 2;
return this;
}
write_i32(value: number): this {
this.ensure_size(4);
this.block.set_i32(this.absolute_position, value);
this._position += 4;
return this;
}
write_f32(value: number): this {
this.ensure_size(4);
this.block.set_f32(this.absolute_position, value);
this._position += 4;
return this;
}
write_u8_array(array: ArrayLike<number>): this {
this.ensure_size(array.length);
return super.write_u8_array(array);
}
write_u16_array(array: ArrayLike<number>): this {
this.ensure_size(2 * array.length);
return super.write_u16_array(array);
}
write_u32_array(array: ArrayLike<number>): this {
this.ensure_size(4 * array.length);
return super.write_u32_array(array);
}
write_i32_array(array: ArrayLike<number>): this {
this.ensure_size(4 * array.length);
return super.write_i32_array(array);
}
write_vec2_f32(value: Vec2): this {
this.ensure_size(8);
return super.write_vec2_f32(value);
}
write_vec3_f32(value: Vec3): this {
this.ensure_size(12);
return super.write_vec3_f32(value);
}
write_cursor(other: Cursor): this {
const size = other.size - other.position;
this.ensure_size(size);
other.copy_to_uint8_array(this.block.uint8_view(this.absolute_position, size), size);
this._position += size;
return this;
}
write_string_ascii(str: string, byte_length: number): this {
this.ensure_size(byte_length);
return super.write_string_ascii(str, byte_length);
}
write_string_utf16(str: string, byte_length: number): this {
this.ensure_size(byte_length);
return super.write_string_utf16(str, byte_length);
}
private ensure_size(size: number): void {
const needed = this._position + size - this._size;
if (needed > 0) {
this._size += needed;
if (this.block.size < this.offset + this._size) {
this.block.size = this.offset + this._size;
}
}
}
}

24
src/core/data_formats/cursor/WritableCursor.test.ts → src/core/data_formats/block/cursor/WritableCursor.test.ts
View File

@ -1,8 +1,8 @@
import { Endianness } from "../Endianness";
import { enum_values } from "../../enums";
import { ResizableBuffer } from "../ResizableBuffer";
import { enum_values } from "../../../enums";
import { ResizableBlock } from "../ResizableBlock";
import { ArrayBufferCursor } from "./ArrayBufferCursor";
import { ResizableBufferCursor } from "./ResizableBufferCursor";
import { ResizableBlockCursor } from "./ResizableBlockCursor";
import { WritableCursor } from "./WritableCursor";
/**
@ -19,16 +19,12 @@ function test_all(
): void {
const endiannesses = enum_values<Endianness>(Endianness);
function rbuf(endianness: Endianness): ResizableBuffer {
function block(endianness: Endianness): ResizableBlock {
const byte_array = bytes(endianness);
const rbuf = new ResizableBuffer(byte_array.length);
rbuf.size = byte_array.length;
for (let i = 0; i < byte_array.length; i++) {
rbuf.view.setUint8(i, byte_array[i]);
}
return rbuf;
const block = new ResizableBlock(byte_array.length, endianness);
block.size = byte_array.length;
block.uint8_view(0, block.size).set(byte_array);
return block;
}
const cursors: [string, Endianness, WritableCursor][] = [
@ -38,9 +34,9 @@ function test_all(
new ArrayBufferCursor(new Uint8Array(bytes(endianness)).buffer, endianness),
]),
...endiannesses.map(endianness => [
ResizableBufferCursor.name,
ResizableBlockCursor.name,
endianness,
new ResizableBufferCursor(rbuf(endianness), endianness),
new ResizableBlockCursor(block(endianness)),
]),
] as any;

89
src/core/data_formats/block/cursor/WritableCursor.ts Normal file
View File

@ -0,0 +1,89 @@
import { Cursor } from "./Cursor";
import { Vec2, Vec3 } from "../../vector";
/**
* A cursor for reading and writing binary data.
*/
export interface WritableCursor extends Cursor {
size: number;
/**
* Writes an unsigned 8-bit integer and increments position by 1.
*/
write_u8(value: number): this;
/**
* Writes an unsigned 16-bit integer and increments position by 2.
*/
write_u16(value: number): this;
/**
* Writes an unsigned 32-bit integer and increments position by 4.
*/
write_u32(value: number): this;
/**
* Writes a signed 8-bit integer and increments position by 1.
*/
write_i8(value: number): this;
/**
* Writes a signed 16-bit integer and increments position by 2.
*/
write_i16(value: number): this;
/**
* Writes a signed 32-bit integer and increments position by 4.
*/
write_i32(value: number): this;
/**
* Writes a 32-bit floating point number and increments position by 4.
*/
write_f32(value: number): this;
/**
* Writes an array of unsigned 8-bit integers and increments position by the array's length.
*/
write_u8_array(array: ArrayLike<number>): this;
/**
* Writes an array of unsigned 16-bit integers and increments position by twice the array's length.
*/
write_u16_array(array: ArrayLike<number>): this;
/**
* Writes an array of unsigned 32-bit integers and increments position by four times the array's length.
*/
write_u32_array(array: ArrayLike<number>): this;
/**
* Writes an array of signed 32-bit integers and increments position by four times the array's length.
*/
write_i32_array(array: ArrayLike<number>): this;
/**
* Writes two 32-bit floating point numbers and increments position by 8.
*/
write_vec2_f32(value: Vec2): this;
/**
* Writes three 32-bit floating point numbers and increments position by 12.
*/
write_vec3_f32(value: Vec3): this;
/**
* Writes the contents of the given cursor from its position to its end. Increments this cursor's and the given cursor's position by the size of the given cursor.
*/
write_cursor(other: Cursor): this;
/**
* Writes byte_length characters of str. If str is shorter than byte_length, nul bytes will be inserted until byte_length bytes have been written.
*/
write_string_ascii(str: string, byte_length: number): this;
/**
* Writes characters of str without writing more than byte_length bytes. If less than byte_length bytes can be written this way, nul bytes will be inserted until byte_length bytes have been written.
*/
write_string_utf16(str: string, byte_length: number): this;
}

29
src/core/data_formats/compression/prs/compress.ts
View File

@ -1,8 +1,8 @@
import { Endianness } from "../../Endianness";
import { Cursor } from "../../cursor/Cursor";
import { ResizableBufferCursor } from "../../cursor/ResizableBufferCursor";
import { WritableCursor } from "../../cursor/WritableCursor";
import { ResizableBuffer } from "../../ResizableBuffer";
import { Endianness } from "../../block/Endianness";
import { Cursor } from "../../block/cursor/Cursor";
import { ResizableBlockCursor } from "../../block/cursor/ResizableBlockCursor";
import { WritableCursor } from "../../block/cursor/WritableCursor";
import { ResizableBlock } from "../../block/ResizableBlock";
import { browser_supports_webassembly } from "../../../util";
import { get_prs_wasm_module } from "./prs_wasm";
@ -29,23 +29,34 @@ export function prs_compress_js(cursor: Cursor): Cursor {
const min_offset = Math.max(0, cursor.position - Math.min(0x800, cursor.bytes_left));
for (let i = cursor.position - 255; i >= min_offset; i--) {
let s1 = cursor.position;
const start_pos = cursor.position;
let s1 = start_pos;
let s2 = i;
let size = 0;
// Optimization: compare 4 bytes at a time while we can.
while (s1 + 3 < cursor.size && size < 252 && cursor.u32_at(s1) === cursor.u32_at(s2)) {
while (
s1 + 3 < cursor.size &&
size < 252 &&
cursor.seek_start(s1).u32() === cursor.seek_start(s2).u32()
) {
size += 4;
s1 += 4;
s2 += 4;
}
while (s1 < cursor.size && size < 255 && cursor.u8_at(s1) === cursor.u8_at(s2)) {
while (
s1 < cursor.size &&
size < 255 &&
cursor.seek_start(s1).u8() === cursor.seek_start(s2).u8()
) {
size++;
s1++;
s2++;
}
cursor.seek_start(start_pos);
if (size >= best_size) {
best_offset = i;
best_size = size;
@ -74,7 +85,7 @@ class Context {
private flag_offset = 0;
constructor(capacity: number, endianness: Endianness) {
this.output = new ResizableBufferCursor(new ResizableBuffer(capacity), endianness);
this.output = new ResizableBlockCursor(new ResizableBlock(capacity, endianness));
}
add_u8(value: number): void {

300
src/core/data_formats/compression/prs/compress_high.ts
View File

@ -1,300 +0,0 @@
import { Cursor } from "../../cursor/Cursor";
import { ResizableBufferCursor } from "../../cursor/ResizableBufferCursor";
import { WritableCursor } from "../../cursor/WritableCursor";
import { ResizableBuffer } from "../../ResizableBuffer";
export function prs_compress_high(src: Cursor): Cursor {
const ctx = new Context(src);
const hash_table = new HashTable();
if (ctx.src.size <= 3) {
// Make a literal copy of the input.
while (ctx.src.bytes_left) {
ctx.set_bit(1);
ctx.copy_literal();
}
} else {
// Add the first two "strings" to the hash table.
hash_table.put(hash_table.hash(ctx.src), 0);
ctx.src.seek(1);
hash_table.put(hash_table.hash(ctx.src), 1);
ctx.src.seek(-1);
// Copy the first two bytes as literals.
ctx.set_bit(1);
ctx.copy_literal();
ctx.set_bit(1);
ctx.copy_literal();
while (ctx.src.bytes_left > 1) {
const match = ctx.find_longest_match(hash_table, false);
const offset = match[0];
let mlen = match[1];
if (mlen > 0) {
ctx.src.seek(1);
const [offset2, mlen2] = ctx.find_longest_match(hash_table, true);
ctx.src.seek(-1);
// Did the "lazy match" produce something more compressed?
if (mlen2 > mlen) {
let copy_literal = true;
// Check if it is a good idea to switch from a short match to a long one.
if (mlen >= 2 && mlen <= 5 && offset2 < offset) {
if (offset >= -256 && offset2 < -256) {
if (mlen2 - mlen < 3) {
copy_literal = false;
}
}
}
if (copy_literal) {
ctx.set_bit(1);
ctx.copy_literal();
continue;
}
}
// What kind of match did we find?
if (mlen >= 2 && mlen <= 5 && offset >= -256) {
// Short match.
ctx.set_bit(0);
ctx.set_bit(0);
ctx.set_bit((mlen - 2) & 0x02);
ctx.set_bit((mlen - 2) & 0x01);
ctx.write_literal(offset & 0xff);
ctx.add_intermediates(hash_table, mlen);
continue;
} else if (mlen >= 3 && mlen <= 9) {
// Long match, short length.
ctx.set_bit(0);
ctx.set_bit(1);
ctx.write_literal(((offset & 0x1f) << 3) | ((mlen - 2) & 0x07));
ctx.write_literal(offset >> 5);
ctx.add_intermediates(hash_table, mlen);
continue;
} else if (mlen > 9) {
// Long match, long length.
if (mlen > 256) {
mlen = 256;
}
ctx.set_bit(0);
ctx.set_bit(1);
ctx.write_literal((offset & 0x1f) << 3);
ctx.write_literal(offset >> 5);
ctx.write_literal(mlen - 1);
ctx.add_intermediates(hash_table, mlen);
continue;
}
}
// If we get here, we didn't find a suitable match, so just we just make a literal copy.
ctx.set_bit(1);
ctx.copy_literal();
}
// If there's a left over byte at the end, make a literal copy.
if (ctx.src.bytes_left) {
ctx.set_bit(1);
ctx.copy_literal();
}
}
ctx.write_eof();
return ctx.dst.seek_start(0);
}
const MAX_WINDOW = 0x2000;
const WINDOW_MASK = MAX_WINDOW - 1;
const HASH_SIZE = 1 << 8;
class Context {
src: Cursor;
dst: WritableCursor;
flags = 0;
flag_bits_left = 0;
flag_offset = 0;
constructor(cursor: Cursor) {
this.src = cursor;
this.dst = new ResizableBufferCursor(new ResizableBuffer(cursor.size), cursor.endianness);
}
set_bit(bit: number): void {
if (!this.flag_bits_left--) {
// Write out the flags to their position in the file, and store the next flags byte position.
const pos = this.dst.position;
this.dst.seek_start(this.flag_offset);
this.dst.write_u8(this.flags);
this.dst.seek_start(pos);
this.dst.write_u8(0); // Placeholder for the next flags byte.
this.flag_offset = pos;
this.flag_bits_left = 7;
}
this.flags >>>= 1;
if (bit) {
this.flags |= 0x80;
}
}
copy_literal(): void {
this.dst.write_u8(this.src.u8());
}
write_literal(value: number): void {
this.dst.write_u8(value);
}
write_final_flags(): void {
this.flags >>>= this.flag_bits_left;
const pos = this.dst.position;
this.dst.seek_start(this.flag_offset);
this.dst.write_u8(this.flags);
this.dst.seek_start(pos);
}
write_eof(): void {
this.set_bit(0);
this.set_bit(1);
this.write_final_flags();
this.write_literal(0);
this.write_literal(0);
}
match_length(s2: number): number {
let len = 0;
let s1 = this.src.position;
const size = this.src.size;
while (s1 < size - 4 && this.src.u32_at(s1) === this.src.u32_at(s2)) {
len += 4;
s1 += 4;
s2 += 4;
}
while (s1 < size && this.src.u8_at(s1) === this.src.u8_at(s2)) {
++len;
++s1;
++s2;
}
return len;
}
find_longest_match(hash_table: HashTable, lazy: boolean): [number, number] {
if (!this.src.bytes_left) {
return [0, 0];
}
// Figure out where we're looking.
const hash = hash_table.hash(this.src);
// If there is nothing in the table at that point, bail out now.
let entry = hash_table.get(hash);
if (entry === -1) {
if (!lazy) {
hash_table.put(hash, this.src.position);
}
return [0, 0];
}
// If we'd go outside the window, truncate the hash chain now.
if (this.src.position - entry > MAX_WINDOW) {
hash_table.hash_to_offset[hash] = -1;
if (!lazy) {
hash_table.put(hash, this.src.position);
}
return [0, 0];
}
// Ok, we have something in the hash table that matches the hash value.
// Follow the chain to see if we have an actual string match, and find the longest match.
let longest_length = 0;
let longest_match = 0;
while (entry !== -1) {
const mlen = this.match_length(entry);
if (mlen > longest_length || mlen >= 256) {
longest_length = mlen;
longest_match = entry;
}
// Follow the chain, making sure not to exceed a difference of MAX_WINDOW.
let entry_2 = hash_table.prev(entry);
if (entry_2 !== -1) {
// If we'd go outside the window, truncate the hash chain now.
if (this.src.position - entry_2 > MAX_WINDOW) {
hash_table.set_prev(entry, -1);
entry_2 = -1;
}
}
entry = entry_2;
}
// Add our current string to the hash.
if (!lazy) {
hash_table.put(hash, this.src.position);
}
// Did we find a match?
const offset = longest_length > 0 ? longest_match - this.src.position : 0;
return [offset, longest_length];
}
add_intermediates(hash_table: HashTable, len: number): void {
this.src.seek(1);
for (let i = 1; i < len; ++i) {
const hash = hash_table.hash(this.src);
hash_table.put(hash, this.src.position);
this.src.seek(1);
}
}
}
class HashTable {
hash_to_offset = new Int32Array(HASH_SIZE).fill(-1);
masked_offset_to_prev = new Int16Array(MAX_WINDOW).fill(-1);
hash(cursor: Cursor): number {
let hash = cursor.u8();
if (cursor.bytes_left) {
hash ^= cursor.u8();
cursor.seek(-1);
}
cursor.seek(-1);
return hash;
}
get(hash: number): number {
return this.hash_to_offset[hash];
}
put(hash: number, offset: number): void {
this.set_prev(offset, this.hash_to_offset[hash]);
this.hash_to_offset[hash] = offset;
}
prev(offset: number): number {
return this.masked_offset_to_prev[offset & WINDOW_MASK];
}
set_prev(offset: number, prev_offset: number): void {
this.masked_offset_to_prev[offset & WINDOW_MASK] = prev_offset;
}
}

13
src/core/data_formats/compression/prs/decompress.ts
View File

@ -1,7 +1,7 @@
import { Cursor } from "../../cursor/Cursor";
import { ResizableBufferCursor } from "../../cursor/ResizableBufferCursor";
import { WritableCursor } from "../../cursor/WritableCursor";
import { ResizableBuffer } from "../../ResizableBuffer";
import { Cursor } from "../../block/cursor/Cursor";
import { ResizableBlockCursor } from "../../block/cursor/ResizableBlockCursor";
import { WritableCursor } from "../../block/cursor/WritableCursor";
import { ResizableBlock } from "../../block/ResizableBlock";
import { LogManager } from "../../../Logger";
import { browser_supports_webassembly } from "../../../util";
import { get_prs_wasm_module } from "./prs_wasm";
@ -78,9 +78,8 @@ class Context {
constructor(cursor: Cursor) {
this.src = cursor;
this.dst = new ResizableBufferCursor(
new ResizableBuffer(Math.floor(1.5 * cursor.size)),
cursor.endianness,
this.dst = new ResizableBlockCursor(
new ResizableBlock(Math.floor(1.5 * cursor.size), cursor.endianness),
);
this.flags = 0;
this.flag_bits_left = 0;

8
src/core/data_formats/compression/prs/index.test.ts
View File

@ -1,10 +1,10 @@
import { readFileSync } from "fs";
import { Endianness } from "../../Endianness";
import { ArrayBufferCursor } from "../../cursor/ArrayBufferCursor";
import { BufferCursor } from "../../cursor/BufferCursor";
import { Endianness } from "../../block/Endianness";
import { ArrayBufferCursor } from "../../block/cursor/ArrayBufferCursor";
import { BufferCursor } from "../../block/cursor/BufferCursor";
import { prs_compress_js } from "./compress";
import { prs_decompress_js } from "./decompress";
import { Cursor } from "../../cursor/Cursor";
import { Cursor } from "../../block/cursor/Cursor";
import { get_prs_wasm_module } from "./prs_wasm";
type CompressionFunction = (cursor: Cursor) => Cursor;

6
src/core/data_formats/compression/prs/prs_wasm.ts
View File

@ -3,9 +3,9 @@
*/
import { browser_supports_webassembly } from "../../../util";
import { Cursor } from "../../cursor/Cursor";
import { ArrayBufferCursor } from "../../cursor/ArrayBufferCursor";
import { Endianness } from "../../Endianness";
import { Cursor } from "../../block/cursor/Cursor";
import { ArrayBufferCursor } from "../../block/cursor/ArrayBufferCursor";
import { Endianness } from "../../block/Endianness";
type PrsRsModule = typeof import("prs-rs");

307
src/core/data_formats/cursor/AbstractCursor.ts
View File

@ -1,307 +0,0 @@
import { Endianness } from "../Endianness";
import { Vec2, Vec3 } from "../vector";
import { Cursor } from "./Cursor";
export abstract class AbstractCursor implements Cursor {
abstract readonly size: number;
protected _position: number = 0;
get position(): number {
return this._position;
}
protected little_endian!: boolean;
get endianness(): Endianness {
return this.little_endian ? Endianness.Little : Endianness.Big;
}
set endianness(endianness: Endianness) {
this.little_endian = endianness === Endianness.Little;
}
get bytes_left(): number {
return this.size - this.position;
}
protected readonly offset: number;
protected abstract readonly backing_buffer: ArrayBuffer;
protected abstract readonly dv: DataView;
constructor(endianness: Endianness, offset: number) {
this.endianness = endianness;
this.offset = offset;
}
seek(offset: number): this {
return this.seek_start(this.position + offset);
}
seek_start(offset: number): this {
if (offset < 0 || offset > this.size) {
throw new Error(`Offset ${offset} is out of bounds.`);
}
this._position = offset;
return this;
}
seek_end(offset: number): this {
if (offset < 0 || offset > this.size) {
throw new Error(`Offset ${offset} is out of bounds.`);
}
this._position = this.size - offset;
return this;
}
u8(): number {
return this.u8_at(this._position++);
}
u8_at(offset: number): number {
this.check_offset(offset, 1);
return this.dv.getUint8(this.offset + offset);
}
u16(): number {
const r = this.u16_at(this.position);
this._position += 2;
return r;
}
u16_at(offset: number): number {
this.check_offset(offset, 2);
return this.dv.getUint16(this.offset + offset, this.little_endian);
}
u32(): number {
const r = this.u32_at(this.position);
this._position += 4;
return r;
}
u32_at(offset: number): number {
this.check_offset(offset, 4);
return this.dv.getUint32(this.offset + offset, this.little_endian);
}
i8(): number {
return this.i8_at(this._position++);
}
i8_at(offset: number): number {
this.check_offset(offset, 1);
return this.dv.getInt8(this.offset + offset);
}
i16(): number {
const r = this.i16_at(this.position);
this._position += 2;
return r;
}
i16_at(offset: number): number {
this.check_offset(offset, 2);
return this.dv.getInt16(this.offset + offset, this.little_endian);
}
i32(): number {
const r = this.i32_at(this.position);
this._position += 4;
return r;
}
i32_at(offset: number): number {
this.check_offset(offset, 4);
return this.dv.getInt32(this.offset + offset, this.little_endian);
}
f32(): number {
const r = this.f32_at(this.position);
this._position += 4;
return r;
}
f32_at(offset: number): number {
this.check_offset(offset, 4);
return this.dv.getFloat32(this.offset + offset, this.little_endian);
}
u8_array(n: number): number[] {
this.check_size("n", n, n);
const array = [];
for (let i = 0; i < n; ++i) {
array.push(this.dv.getUint8(this.offset + this._position++));
}
return array;
}
u16_array(n: number): number[] {
this.check_size("n", n, 2 * n);
const array = [];
for (let i = 0; i < n; ++i) {
array.push(this.dv.getUint16(this.offset + this.position, this.little_endian));
this._position += 2;
}
return array;
}
u32_array(n: number): number[] {
this.check_size("n", n, 4 * n);
const array = [];
for (let i = 0; i < n; ++i) {
array.push(this.dv.getUint32(this.offset + this.position, this.little_endian));
this._position += 4;
}
return array;
}
i32_array(n: number): number[] {
this.check_size("n", n, 4 * n);
const array = [];
for (let i = 0; i < n; ++i) {
array.push(this.dv.getInt32(this.offset + this.position, this.little_endian));
this._position += 4;
}
return array;
}
vec2_f32(): Vec2 {
return { x: this.f32(), y: this.f32() };
}
vec3_f32(): Vec3 {
return { x: this.f32(), y: this.f32(), z: this.f32() };
}
string_ascii(
max_byte_length: number,
null_terminated: boolean,
drop_remaining: boolean,
): string {
const code_points: number[] = [];
for (let i = 0; i < max_byte_length; i++) {
const code_point = this.u8();
if (null_terminated && code_point === 0) {
if (drop_remaining) {
this.seek(max_byte_length - i - 1);
}
break;
}
code_points.push(code_point);
}
return String.fromCodePoint(...code_points);
}
string_utf16(
max_byte_length: number,
null_terminated: boolean,
drop_remaining: boolean,
): string {
const code_points: number[] = [];
const len = Math.floor(max_byte_length / 2);
for (let i = 0; i < len; i++) {
const code_point = this.u16();
if (null_terminated && code_point === 0) {
if (drop_remaining) {
this.seek(2 * (len - i - 1));
}
break;
}
code_points.push(code_point);
}
return String.fromCodePoint(...code_points);
}
string_ascii_at(offset: number, max_byte_length: number, null_terminated: boolean): string {
const code_points: number[] = [];
for (let i = 0; i < max_byte_length; i++) {
const code_point = this.u8_at(offset + i);
if (null_terminated && code_point === 0) {
break;
}
code_points.push(code_point);
}
return String.fromCodePoint(...code_points);
}
string_utf16_at(offset: number, max_byte_length: number, null_terminated: boolean): string {
const code_points: number[] = [];
const len = Math.floor(max_byte_length / 2);
for (let i = 0; i < len; i++) {
const code_point = this.u16_at(offset + i * 2);
if (null_terminated && code_point === 0) {
break;
}
code_points.push(code_point);
}
return String.fromCodePoint(...code_points);
}
array_buffer(size: number = this.size - this.position): ArrayBuffer {
this.check_size("size", size, size);
const r = this.backing_buffer.slice(
this.offset + this.position,
this.offset + this.position + size,
);
this._position += size;
return r;
}
copy_to_uint8_array(array: Uint8Array, size: number = this.size - this.position): this {
this.check_size("size", size, size);
array.set(new Uint8Array(this.backing_buffer, this.offset + this.position, size));
this._position += size;
return this;
}
abstract take(size: number): Cursor;
protected check_size(name: string, value: number, byte_size: number): void {
if (byte_size < 0 || byte_size > this.size - this.position) {
throw new Error(`${name} ${value} is out of bounds.`);
}
}
/**
* Checks whether we can read size bytes at offset.
*/
private check_offset(offset: number, size: number): void {
if (offset < 0 || offset + size > this.size) {
throw new Error(`Offset ${offset} is out of bounds.`);
}
}
}

251
src/core/data_formats/cursor/AbstractWritableCursor.ts
View File

@ -1,251 +0,0 @@
import { Vec2, Vec3 } from "../vector";
import { AbstractCursor } from "./AbstractCursor";
import { Cursor } from "./Cursor";
import { WritableCursor } from "./WritableCursor";
export abstract class AbstractWritableCursor extends AbstractCursor implements WritableCursor {
abstract size: number;
write_u8(value: number): this {
this.write_u8_at(this.position, value);
this._position += 1;
return this;
}
write_u16(value: number): this {
this.write_u16_at(this.position, value);
this._position += 2;
return this;
}
write_u32(value: number): this {
this.write_u32_at(this.position, value);
this._position += 4;
return this;
}
write_i8(value: number): this {
this.write_i8_at(this.position, value);
this._position += 1;
return this;
}
write_i16(value: number): this {
this.write_i16_at(this.position, value);
this._position += 2;
return this;
}
write_i32(value: number): this {
this.write_i32_at(this.position, value);
this._position += 4;
return this;
}
write_f32(value: number): this {
this.write_f32_at(this.position, value);
this._position += 4;
return this;
}
write_u8_array(array: ArrayLike<number>): this {
this.write_u8_array_at(this.position, array);
this._position += array.length;
return this;
}
write_u16_array(array: ArrayLike<number>): this {
this.write_u16_array_at(this.position, array);
this._position += array.length * 2;
return this;
}
write_u32_array(array: ArrayLike<number>): this {
this.write_u32_array_at(this.position, array);
this._position += array.length * 4;
return this;
}
write_i32_array(array: ArrayLike<number>): this {
this.write_i32_array_at(this.position, array);
this._position += array.length * 4;
return this;
}
write_vec2_f32(value: Vec2): this {
this.write_vec2_f32_at(this.position, value);
this._position += 8;
return this;
}
write_vec3_f32(value: Vec3): this {
this.write_vec3_f32_at(this.position, value);
this._position += 12;
return this;
}
write_cursor(other: Cursor): this {
const size = other.size - other.position;
this.ensure_size(size);
other.copy_to_uint8_array(
new Uint8Array(this.backing_buffer, this.offset + this.position, size),
size,
);
this._position += size;
return this;
}
write_string_ascii(str: string, byte_length: number): this {
this.write_string_ascii_at(this.position, str, byte_length);
this._position += byte_length;
return this;
}
write_string_utf16(str: string, byte_length: number): this {
this.write_string_utf16_at(this.position, str, byte_length);
this._position += byte_length;
return this;
}
write_u8_at(offset: number, value: number): this {
this.ensure_size(1, offset);
this.dv.setUint8(offset, value);
return this;
}
write_u16_at(offset: number, value: number): this {
this.ensure_size(2, offset);
this.dv.setUint16(offset, value, this.little_endian);
return this;
}
write_u32_at(offset: number, value: number): this {
this.ensure_size(4, offset);
this.dv.setUint32(offset, value, this.little_endian);
return this;
}
write_i8_at(offset: number, value: number): this {
this.ensure_size(1, offset);
this.dv.setInt8(offset, value);
return this;
}
write_i16_at(offset: number, value: number): this {
this.ensure_size(2, offset);
this.dv.setInt16(offset, value, this.little_endian);
return this;
}
write_i32_at(offset: number, value: number): this {
this.ensure_size(4, offset);
this.dv.setInt32(offset, value, this.little_endian);
return this;
}
write_f32_at(offset: number, value: number): this {
this.ensure_size(4, offset);
this.dv.setFloat32(offset, value, this.little_endian);
return this;
}
write_u8_array_at(offset: number, array: ArrayLike<number>): this {
this.ensure_size(array.length, offset);
new Uint8Array(this.backing_buffer, this.offset + offset).set(new Uint8Array(array));
return this;
}
write_u16_array_at(offset: number, array: ArrayLike<number>): this {
this.ensure_size(2 * array.length, offset);
const len = array.length;
for (let i = 0; i < len; i++) {
this.write_u16_at(offset + i * 2, array[i]);
}
return this;
}
write_u32_array_at(offset: number, array: ArrayLike<number>): this {
this.ensure_size(4 * array.length, offset);
const len = array.length;
for (let i = 0; i < len; i++) {
this.write_u32_at(offset + i * 4, array[i]);
}
return this;
}
write_i32_array_at(offset: number, array: ArrayLike<number>): this {
this.ensure_size(4 * array.length, offset);
const len = array.length;
for (let i = 0; i < len; i++) {
this.write_i32_at(offset + i * 4, array[i]);
}
return this;
}
write_vec2_f32_at(offset: number, value: Vec2): this {
this.ensure_size(8, offset);
this.dv.setFloat32(offset, value.x, this.little_endian);
this.dv.setFloat32(offset + 4, value.y, this.little_endian);
return this;
}
write_vec3_f32_at(offset: number, value: Vec3): this {
this.ensure_size(12, offset);
this.dv.setFloat32(offset, value.x, this.little_endian);
this.dv.setFloat32(offset + 4, value.y, this.little_endian);
this.dv.setFloat32(offset + 8, value.z, this.little_endian);
return this;
}
write_string_ascii_at(offset: number, str: string, byte_length: number): this {
this.ensure_size(byte_length, offset);
const len = Math.min(byte_length, str.length);
for (let i = 0; i < len; i++) {
this.write_u8_at(offset + i, str.codePointAt(i)!);
}
const pad_len = byte_length - len;
for (let i = 0; i < pad_len; i++) {
this.write_u8_at(offset + len + i, 0);
}
return this;
}
write_string_utf16_at(offset: number, str: string, byte_length: number): this {
this.ensure_size(byte_length, offset);
const max_len = Math.floor(byte_length / 2);
const len = Math.min(max_len, str.length);
for (let i = 0; i < len; i++) {
this.write_u16_at(offset + i * 2, str.codePointAt(i)!);
}
const pad_len = max_len - len;
for (let i = 0; i < pad_len; i++) {
this.write_u16_at(offset + len * 2 + i * 2, 0);
}
return this;
}
protected ensure_size(size: number, offset: number = this.position): void {
const left = this.size - offset;
if (size > left) {
throw new Error(`${size} Bytes required but only ${left} available.`);
}
}
}

77
src/core/data_formats/cursor/ResizableBufferCursor.ts
View File

@ -1,77 +0,0 @@
import { Endianness } from "../Endianness";
import { ResizableBuffer } from "../ResizableBuffer";
import { AbstractWritableCursor } from "./AbstractWritableCursor";
import { WritableCursor } from "./WritableCursor";
export class ResizableBufferCursor extends AbstractWritableCursor implements WritableCursor {
protected _size: number;
get size(): number {
return this._size;
}
set size(size: number) {
if (size > this._size) {
this.ensure_size(size - this.position);
} else {
this._size = size;
}
}
protected buffer: ResizableBuffer;
protected get backing_buffer(): ArrayBuffer {
return this.buffer.backing_buffer;
}
protected get dv(): DataView {
return this.buffer.view;
}
/**
* @param buffer The buffer to read from.
* @param endianness Decides in which byte order multi-byte integers and floats will be interpreted.
* @param offset The start offset of the part that will be read from.
* @param size The size of the part that will be read from.
*/
constructor(
buffer: ResizableBuffer,
endianness: Endianness,
offset: number = 0,
size: number = buffer.size - offset,
) {
if (offset < 0 || offset > buffer.size) {
throw new Error(`Offset ${offset} is out of bounds.`);
}
if (size < 0 || offset + size > buffer.size) {
throw new Error(`Size ${size} is out of bounds.`);
}
super(endianness, offset);
this.buffer = buffer;
this._size = size;
}
take(size: number): ResizableBufferCursor {
this.check_size("size", size, size);
const offset = this.offset + this.position;
const wrapper = new ResizableBufferCursor(this.buffer, this.endianness, offset, size);
this._position += size;
return wrapper;
}
protected ensure_size(size: number, offset: number = this.position): void {
const needed = offset + size - this._size;
if (needed > 0) {
this._size += needed;
if (this.buffer.size < this.offset + this._size) {
this.buffer.size = this.offset + this._size;
}
}
}
}

164
src/core/data_formats/cursor/WritableCursor.ts
View File

@ -1,164 +0,0 @@
import { Cursor } from "./Cursor";
import { Vec2, Vec3 } from "../vector";
/**
* A cursor for reading and writing binary data.
*/
export interface WritableCursor extends Cursor {
size: number;
/**
* Writes an unsigned 8-bit integer and increments position by 1.
*/
write_u8(value: number): this;
/**
* Writes an unsigned 16-bit integer and increments position by 2.
*/
write_u16(value: number): this;
/**
* Writes an unsigned 32-bit integer and increments position by 4.
*/
write_u32(value: number): this;
/**
* Writes a signed 8-bit integer and increments position by 1.
*/
write_i8(value: number): this;
/**
* Writes a signed 16-bit integer and increments position by 2.
*/
write_i16(value: number): this;
/**
* Writes a signed 32-bit integer and increments position by 4.
*/
write_i32(value: number): this;
/**
* Writes a 32-bit floating point number and increments position by 4.
*/
write_f32(value: number): this;
/**
* Writes an array of unsigned 8-bit integers and increments position by the array's length.
*/
write_u8_array(array: number[]): this;
/**
* Writes an array of unsigned 16-bit integers and increments position by twice the array's length.
*/
write_u16_array(array: number[]): this;
/**
* Writes an array of unsigned 32-bit integers and increments position by four times the array's length.
*/
write_u32_array(array: number[]): this;
/**
* Writes an array of signed 32-bit integers and increments position by four times the array's length.
*/
write_i32_array(array: readonly number[]): this;
/**
* Writes two 32-bit floating point numbers and increments position by 8.
*/
write_vec2_f32(value: Vec2): this;
/**
* Writes three 32-bit floating point numbers and increments position by 12.
*/
write_vec3_f32(value: Vec3): this;
/**
* Writes the contents of the given cursor from its position to its end. Increments this cursor's and the given cursor's position by the size of the given cursor.
*/
write_cursor(other: Cursor): this;
/**
* Writes byte_length characters of str. If str is shorter than byte_length, nul bytes will be inserted until byte_length bytes have been written.
*/
write_string_ascii(str: string, byte_length: number): this;
/**
* Writes characters of str without writing more than byte_length bytes. If less than byte_length bytes can be written this way, nul bytes will be inserted until byte_length bytes have been written.
*/
write_string_utf16(str: string, byte_length: number): this;
/**
* Writes an unsigned 8-bit integer at the given absolute offset. Doesn't increment position.
*/
write_u8_at(offset: number, value: number): this;
/**
* Writes an unsigned 16-bit integer at the given absolute offset. Doesn't increment position.
*/
write_u16_at(offset: number, value: number): this;
/**
* Writes an unsigned 32-bit integer at the given absolute offset. Doesn't increment position.
*/
write_u32_at(offset: number, value: number): this;
/**
* Writes a signed 8-bit integer at the given absolute offset. Doesn't increment position.
*/
write_i8_at(offset: number, value: number): this;
/**
* Writes a signed 16-bit integer at the given absolute offset. Doesn't increment position.
*/
write_i16_at(offset: number, value: number): this;
/**
* Writes a signed 32-bit integer at the given absolute offset. Doesn't increment position.
*/
write_i32_at(offset: number, value: number): this;
/**
* Writes a 32-bit floating point number at the given absolute offset. Doesn't increment position.
*/
write_f32_at(offset: number, value: number): this;
/**
* Writes an array of unsigned 8-bit integers at the given absolute offset. Doesn't increment position.
*/
write_u8_array_at(offset: number, array: number[]): this;
/**
* Writes an array of unsigned 16-bit integers at the given absolute offset. Doesn't increment position.
*/
write_u16_array_at(offset: number, array: number[]): this;
/**
* Writes an array of unsigned 32-bit integers at the given absolute offset. Doesn't increment position.
*/
write_u32_array_at(offset: number, array: number[]): this;
/**
* Writes an array of signed 32-bit integers at the given absolute offset. Doesn't increment position.
*/
write_i32_array_at(offset: number, array: readonly number[]): this;
/**
* Writes two 32-bit floating point numbers at the given absolute offset. Doesn't increment position.
*/
write_vec2_f32_at(offset: number, value: Vec2): this;
/**
* Writes three 32-bit floating point numbers at the given absolute offset. Doesn't increment position.
*/
write_vec3_f32_at(offset: number, value: Vec3): this;
/**
* Writes byte_length characters of str at the given absolute offset. If str is shorter than byte_length, nul bytes will be inserted until byte_length bytes have been written. Doesn't increment position.
*/
write_string_ascii_at(offset: number, str: string, byte_length: number): this;
/**
* Writes characters of str without writing more than byte_length bytes. If less than byte_length bytes can be written this way, nul bytes will be inserted until byte_length bytes have been written. Doesn't increment position.
*/
write_string_utf16_at(offset: number, str: string, byte_length: number): this;
}

6
src/core/data_formats/encryption/prc.ts
View File

@ -1,6 +1,6 @@
import { Endianness } from "../Endianness";
import { ArrayBufferCursor } from "../cursor/ArrayBufferCursor";
import { Cursor } from "../cursor/Cursor";
import { Endianness } from "../block/Endianness";
import { ArrayBufferCursor } from "../block/cursor/ArrayBufferCursor";
import { Cursor } from "../block/cursor/Cursor";
/**
* Decrypts the bytes left in cursor.

2
src/core/data_formats/parsing/afs.ts
View File

@ -1,4 +1,4 @@
import { Cursor } from "../cursor/Cursor";
import { Cursor } from "../block/cursor/Cursor";
import { LogManager } from "../../Logger";
import { Result, result_builder } from "../../Result";
import { Severity } from "../../Severity";

4
src/core/data_formats/parsing/area_collision_geometry.test.ts
View File

@ -1,7 +1,7 @@
import { readFileSync } from "fs";
import { parse_area_collision_geometry } from "./area_collision_geometry";
import { BufferCursor } from "../cursor/BufferCursor";
import { Endianness } from "../Endianness";
import { BufferCursor } from "../block/cursor/BufferCursor";
import { Endianness } from "../block/Endianness";
test("parse_area_collision_geometry", () => {
const buf = readFileSync("test/resources/map_forest01c.rel");

2
src/core/data_formats/parsing/area_collision_geometry.ts
View File

@ -1,4 +1,4 @@
import { Cursor } from "../cursor/Cursor";
import { Cursor } from "../block/cursor/Cursor";
import { Vec3 } from "../vector";
import { parse_rel } from "./rel";

2
src/core/data_formats/parsing/area_geometry.ts
View File

@ -1,4 +1,4 @@
import { Cursor } from "../cursor/Cursor";
import { Cursor } from "../block/cursor/Cursor";
import { Vec3 } from "../vector";
import { ANGLE_TO_RAD, NjObject, parse_xj_object } from "./ninja";
import { XjModel } from "./ninja/xj";

2
src/core/data_formats/parsing/iff.ts
View File

@ -1,4 +1,4 @@
import { Cursor } from "../cursor/Cursor";
import { Cursor } from "../block/cursor/Cursor";
import { Result, result_builder } from "../../Result";
import { LogManager } from "../../Logger";
import { Severity } from "../../Severity";

4
src/core/data_formats/parsing/itempmt.test.ts
View File

@ -1,7 +1,7 @@
import { parse_item_pmt } from "./itempmt";
import { readFileSync } from "fs";
import { BufferCursor } from "../cursor/BufferCursor";
import { Endianness } from "../Endianness";
import { BufferCursor } from "../block/cursor/BufferCursor";
import { Endianness } from "../block/Endianness";
test("parse_item_pmt", () => {
const buf = readFileSync("test/resources/ItemPMT.bin");

2
src/core/data_formats/parsing/itempmt.ts
View File

@ -1,4 +1,4 @@
import { Cursor } from "../cursor/Cursor";
import { Cursor } from "../block/cursor/Cursor";
import { parse_rel } from "./rel";
export type ItemPmt = {

2
src/core/data_formats/parsing/ninja/index.ts
View File

@ -1,4 +1,4 @@
import { Cursor } from "../../cursor/Cursor";
import { Cursor } from "../../block/cursor/Cursor";
import { Vec3 } from "../../vector";
import { parse_iff } from "../iff";
import { NjcmModel, parse_njcm_model } from "./njcm";

2
src/core/data_formats/parsing/ninja/motion.ts
View File

@ -1,5 +1,5 @@
import { ANGLE_TO_RAD } from "./index";
import { Cursor } from "../../cursor/Cursor";
import { Cursor } from "../../block/cursor/Cursor";
import { Vec3 } from "../../vector";
const NMDM = 0x4d444d4e;

2
src/core/data_formats/parsing/ninja/njcm.ts
View File

@ -1,4 +1,4 @@
import { Cursor } from "../../cursor/Cursor";
import { Cursor } from "../../block/cursor/Cursor";
import { Vec2, Vec3 } from "../../vector";
import { LogManager } from "../../../Logger";

2
src/core/data_formats/parsing/ninja/texture.ts
View File

@ -1,4 +1,4 @@
import { Cursor } from "../../cursor/Cursor";
import { Cursor } from "../../block/cursor/Cursor";
import { parse_iff, parse_iff_headers } from "../iff";
import { LogManager } from "../../../Logger";
import { Result, result_builder } from "../../../Result";

2
src/core/data_formats/parsing/ninja/xj.ts
View File

@ -1,4 +1,4 @@
import { Cursor } from "../../cursor/Cursor";
import { Cursor } from "../../block/cursor/Cursor";
import { Vec2, Vec3 } from "../../vector";
import { LogManager } from "../../../Logger";

2
src/core/data_formats/parsing/prc.ts
View File

@ -1,5 +1,5 @@
import { prs_decompress } from "../compression/prs/decompress";
import { Cursor } from "../cursor/Cursor";
import { Cursor } from "../block/cursor/Cursor";
import { prc_decrypt } from "../encryption/prc";
import { LogManager } from "../../Logger";

6
src/core/data_formats/parsing/quest/bin.test.ts
View File

@ -1,8 +1,8 @@
import { readFileSync } from "fs";
import { Endianness } from "../../Endianness";
import { Endianness } from "../../block/Endianness";
import { prs_decompress } from "../../compression/prs/decompress";
import { ArrayBufferCursor } from "../../cursor/ArrayBufferCursor";
import { BufferCursor } from "../../cursor/BufferCursor";
import { ArrayBufferCursor } from "../../block/cursor/ArrayBufferCursor";
import { BufferCursor } from "../../block/cursor/BufferCursor";
import { parse_bin, write_bin } from "./bin";
import { BinFormat } from "./BinFormat";

6
src/core/data_formats/parsing/quest/bin.ts
View File

@ -1,7 +1,7 @@
import { Endianness } from "../../Endianness";
import { Cursor } from "../../cursor/Cursor";
import { Endianness } from "../../block/Endianness";
import { Cursor } from "../../block/cursor/Cursor";
import { LogManager } from "../../../Logger";
import { ArrayBufferCursor } from "../../cursor/ArrayBufferCursor";
import { ArrayBufferCursor } from "../../block/cursor/ArrayBufferCursor";
import { assert } from "../../../util";
import { BinFormat } from "./BinFormat";

10
src/core/data_formats/parsing/quest/dat.test.ts
View File

@ -1,7 +1,7 @@
import { Endianness } from "../../Endianness";
import { Endianness } from "../../block/Endianness";
import { prs_decompress } from "../../compression/prs/decompress";
import { BufferCursor } from "../../cursor/BufferCursor";
import { ResizableBufferCursor } from "../../cursor/ResizableBufferCursor";
import { BufferCursor } from "../../block/cursor/BufferCursor";
import { ResizableBlockCursor } from "../../block/cursor/ResizableBlockCursor";
import { DatFile, parse_dat, write_dat } from "./dat";
import { readFileSync } from "fs";
@ -11,7 +11,7 @@ import { readFileSync } from "fs";
test("parse_dat and write_dat", () => {
const orig_buffer = readFileSync("test/resources/quest118_e.dat");
const orig_dat = prs_decompress(new BufferCursor(orig_buffer, Endianness.Little));
const test_dat = new ResizableBufferCursor(write_dat(parse_dat(orig_dat)), Endianness.Little);
const test_dat = new ResizableBlockCursor(write_dat(parse_dat(orig_dat)));
orig_dat.seek_start(0);
expect(test_dat.size).toBe(orig_dat.size);
@ -55,7 +55,7 @@ test("parse, modify and write DAT", () => {
}),
};
const test_dat = new ResizableBufferCursor(write_dat(test_updated), Endianness.Little);
const test_dat = new ResizableBlockCursor(write_dat(test_updated));
expect(test_dat.size).toBe(orig_dat.size);

21
src/core/data_formats/parsing/quest/dat.ts
View File

@ -1,12 +1,12 @@
import { groupBy } from "lodash";
import { Endianness } from "../../Endianness";
import { Cursor } from "../../cursor/Cursor";
import { ResizableBufferCursor } from "../../cursor/ResizableBufferCursor";
import { ResizableBuffer } from "../../ResizableBuffer";
import { Vec3 } from "../../vector";
import { WritableCursor } from "../../cursor/WritableCursor";
import { Endianness } from "../../block/Endianness";
import { Cursor } from "../../block/cursor/Cursor";
import { ResizableBlockCursor } from "../../block/cursor/ResizableBlockCursor";
import { ResizableBlock } from "../../block/ResizableBlock";
import { WritableCursor } from "../../block/cursor/WritableCursor";
import { assert } from "../../../util";
import { LogManager } from "../../../Logger";
import { Vec3 } from "../../vector";
const logger = LogManager.get("core/data_formats/parsing/quest/dat");
@ -149,13 +149,14 @@ export function parse_dat(cursor: Cursor): DatFile {
return { objs, npcs, events, unknowns };
}
export function write_dat({ objs, npcs, events, unknowns }: DatFile): ResizableBuffer {
const buffer = new ResizableBuffer(
export function write_dat({ objs, npcs, events, unknowns }: DatFile): ResizableBlock {
const block = new ResizableBlock(
objs.length * (16 + OBJECT_SIZE) +
npcs.length * (16 + NPC_SIZE) +
unknowns.reduce((a, b) => a + b.total_size, 0),
Endianness.Little,
);
const cursor = new ResizableBufferCursor(buffer, Endianness.Little);
const cursor = new ResizableBlockCursor(block);
write_objects(cursor, objs);
@ -177,7 +178,7 @@ export function write_dat({ objs, npcs, events, unknowns }: DatFile): ResizableB
cursor.write_u32(0);
cursor.write_u32(0);
return buffer;
return block;
}
function parse_objects(cursor: Cursor, area_id: number, objs: DatObject[]): void {

6
src/core/data_formats/parsing/quest/index.test.ts
View File

@ -1,8 +1,8 @@
import { readFileSync } from "fs";
import { Endianness } from "../../Endianness";
import { Endianness } from "../../block/Endianness";
import { walk_qst_files } from "../../../../../test/src/utils";
import { ArrayBufferCursor } from "../../cursor/ArrayBufferCursor";
import { BufferCursor } from "../../cursor/BufferCursor";
import { ArrayBufferCursor } from "../../block/cursor/ArrayBufferCursor";
import { BufferCursor } from "../../block/cursor/BufferCursor";
import { parse_qst_to_quest, write_quest_qst } from "./index";
import { ObjectType } from "./object_types";
import {

12
src/core/data_formats/parsing/quest/index.ts
View File

@ -2,10 +2,10 @@ import { InstructionSegment, Segment, SegmentType } from "../../asm/instructions
import { OP_SET_EPISODE } from "../../asm/opcodes";
import { prs_compress } from "../../compression/prs/compress";
import { prs_decompress } from "../../compression/prs/decompress";
import { ArrayBufferCursor } from "../../cursor/ArrayBufferCursor";
import { Cursor } from "../../cursor/Cursor";
import { ResizableBufferCursor } from "../../cursor/ResizableBufferCursor";
import { Endianness } from "../../Endianness";
import { ArrayBufferCursor } from "../../block/cursor/ArrayBufferCursor";
import { Cursor } from "../../block/cursor/Cursor";
import { ResizableBlockCursor } from "../../block/cursor/ResizableBlockCursor";
import { Endianness } from "../../block/Endianness";
import { parse_bin, write_bin } from "./bin";
import { DatNpc, DatObject, DatUnknown, parse_dat, write_dat } from "./dat";
import { QuestEvent, QuestNpc, QuestObject } from "./entities";
@ -193,9 +193,7 @@ export function write_quest_qst(
id: quest.id,
filename: base_file_name + ".dat",
quest_name: quest.name,
data: prs_compress(
new ResizableBufferCursor(dat, Endianness.Little),
).array_buffer(),
data: prs_compress(new ResizableBlockCursor(dat)).array_buffer(),
},
{
id: quest.id,

14
src/core/data_formats/parsing/quest/object_code.ts
View File

@ -10,16 +10,16 @@ import {
SegmentType,
StringSegment,
} from "../../asm/instructions";
import { Cursor } from "../../cursor/Cursor";
import { Cursor } from "../../block/cursor/Cursor";
import { ControlFlowGraph } from "../../asm/data_flow_analysis/ControlFlowGraph";
import { Kind, OP_JMP, OP_RET, Opcode, OPCODES, StackInteraction } from "../../asm/opcodes";
import { get_register_value } from "../../asm/data_flow_analysis/get_register_value";
import { get_stack_value } from "../../asm/data_flow_analysis/get_stack_value";
import { ArrayBufferCursor } from "../../cursor/ArrayBufferCursor";
import { Endianness } from "../../Endianness";
import { ArrayBufferCursor } from "../../block/cursor/ArrayBufferCursor";
import { Endianness } from "../../block/Endianness";
import { LogManager } from "../../../Logger";
import { ResizableBufferCursor } from "../../cursor/ResizableBufferCursor";
import { ResizableBuffer } from "../../ResizableBuffer";
import { ResizableBlockCursor } from "../../block/cursor/ResizableBlockCursor";
import { ResizableBlock } from "../../block/ResizableBlock";
import { BinFormat } from "./BinFormat";
const logger = LogManager.get("core/data_formats/parsing/quest/object_code");
@ -49,8 +49,8 @@ export function write_object_code(
segments: readonly Segment[],
format: BinFormat,
): { object_code: ArrayBuffer; label_offsets: number[] } {
const cursor = new ResizableBufferCursor(
new ResizableBuffer(100 * segments.length),
const cursor = new ResizableBlockCursor(
new ResizableBlock(100 * segments.length),
Endianness.Little,
);
const start_pos = cursor.position;

6
src/core/data_formats/parsing/quest/qst.test.ts
View File

@ -1,8 +1,8 @@
import { walk_qst_files } from "../../../../../test/src/utils";
import { parse_qst, write_qst } from "./qst";
import { Endianness } from "../../Endianness";
import { BufferCursor } from "../../cursor/BufferCursor";
import { ArrayBufferCursor } from "../../cursor/ArrayBufferCursor";
import { Endianness } from "../../block/Endianness";
import { BufferCursor } from "../../block/cursor/BufferCursor";
import { ArrayBufferCursor } from "../../block/cursor/ArrayBufferCursor";
import * as fs from "fs";
import { Version } from "./Version";

17
src/core/data_formats/parsing/quest/qst.ts
View File

@ -1,9 +1,9 @@
import { Endianness } from "../../Endianness";
import { ArrayBufferCursor } from "../../cursor/ArrayBufferCursor";
import { Cursor } from "../../cursor/Cursor";
import { ResizableBufferCursor } from "../../cursor/ResizableBufferCursor";
import { WritableCursor } from "../../cursor/WritableCursor";
import { ResizableBuffer } from "../../ResizableBuffer";
import { Endianness } from "../../block/Endianness";
import { ArrayBufferCursor } from "../../block/cursor/ArrayBufferCursor";
import { Cursor } from "../../block/cursor/Cursor";
import { ResizableBlockCursor } from "../../block/cursor/ResizableBlockCursor";
import { WritableCursor } from "../../block/cursor/WritableCursor";
import { ResizableBlock } from "../../block/ResizableBlock";
import { assert, basename, defined } from "../../../util";
import { LogManager } from "../../../Logger";
import { Version } from "./Version";
@ -329,9 +329,8 @@ function parse_files(
file = {
name: file_name,
expected_size: header?.size,
cursor: new ResizableBufferCursor(
new ResizableBuffer(header?.size ?? 10 * CHUNK_BODY_SIZE),
Endianness.Little,
cursor: new ResizableBlockCursor(
new ResizableBlock(header?.size ?? 10 * CHUNK_BODY_SIZE, Endianness.Little),
),
chunk_nos: new Set(),
};

2
src/core/data_formats/parsing/rel.ts
View File

@ -1,4 +1,4 @@
import { Cursor } from "../cursor/Cursor";
import { Cursor } from "../block/cursor/Cursor";
export type Rel = {
data_offset: number;

4
src/core/data_formats/parsing/rlc.ts
View File

@ -1,5 +1,5 @@
import { Endianness } from "../Endianness";
import { Cursor } from "../cursor/Cursor";
import { Endianness } from "../block/Endianness";
import { Cursor } from "../block/cursor/Cursor";
import { parse_prc } from "./prc";
import { LogManager } from "../../Logger";

2
src/core/data_formats/parsing/unitxt.ts
View File

@ -1,5 +1,5 @@
import { prs_decompress } from "../compression/prs/decompress";
import { Cursor } from "../cursor/Cursor";
import { Cursor } from "../block/cursor/Cursor";
export type Unitxt = string[][];

4
src/quest_editor/controllers/QuestEditorToolBarController.ts
View File

@ -15,8 +15,8 @@ import {
Quest,
write_quest_qst,
} from "../../core/data_formats/parsing/quest";
import { ArrayBufferCursor } from "../../core/data_formats/cursor/ArrayBufferCursor";
import { Endianness } from "../../core/data_formats/Endianness";
import { ArrayBufferCursor } from "../../core/data_formats/block/cursor/ArrayBufferCursor";
import { Endianness } from "../../core/data_formats/block/Endianness";
import { convert_quest_from_model, convert_quest_to_model } from "../stores/model_conversion";
import { LogManager } from "../../core/Logger";
import { basename } from "../../core/util";

4
src/quest_editor/loading/AreaAssetLoader.ts
View File

@ -1,6 +1,6 @@
import { Object3D } from "three";
import { Endianness } from "../../core/data_formats/Endianness";
import { ArrayBufferCursor } from "../../core/data_formats/cursor/ArrayBufferCursor";
import { Endianness } from "../../core/data_formats/block/Endianness";
import { ArrayBufferCursor } from "../../core/data_formats/block/cursor/ArrayBufferCursor";
import {
CollisionObject,
parse_area_collision_geometry,

4
src/quest_editor/loading/EntityAssetLoader.ts
View File

@ -1,7 +1,7 @@
import { BufferGeometry, CylinderBufferGeometry, Texture } from "three";
import { LoadingCache } from "./LoadingCache";
import { Endianness } from "../../core/data_formats/Endianness";
import { ArrayBufferCursor } from "../../core/data_formats/cursor/ArrayBufferCursor";
import { Endianness } from "../../core/data_formats/block/Endianness";
import { ArrayBufferCursor } from "../../core/data_formats/block/cursor/ArrayBufferCursor";
import { ninja_object_to_buffer_geometry } from "../../core/rendering/conversion/ninja_geometry";
import { NjObject, parse_nj, parse_xj } from "../../core/data_formats/parsing/ninja";
import { parse_xvm } from "../../core/data_formats/parsing/ninja/texture";

6
src/quest_editor/scripting/disassembly.test.ts
View File

@ -1,8 +1,8 @@
import { readFileSync } from "fs";
import { Endianness } from "../../core/data_formats/Endianness";
import { Endianness } from "../../core/data_formats/block/Endianness";
import { prs_decompress } from "../../core/data_formats/compression/prs/decompress";
import { ArrayBufferCursor } from "../../core/data_formats/cursor/ArrayBufferCursor";
import { BufferCursor } from "../../core/data_formats/cursor/BufferCursor";
import { ArrayBufferCursor } from "../../core/data_formats/block/cursor/ArrayBufferCursor";
import { BufferCursor } from "../../core/data_formats/block/cursor/BufferCursor";
import { parse_bin, write_bin } from "../../core/data_formats/parsing/quest/bin";
import { assemble } from "./assembly";
import { disassemble } from "./disassembly";

12
src/quest_editor/scripting/vm/Memory.ts
View File

@ -1,12 +0,0 @@
import { ArrayBufferCursor } from "../../../core/data_formats/cursor/ArrayBufferCursor";
import { Endianness } from "../../../core/data_formats/Endianness";
export class Memory extends ArrayBufferCursor {
constructor(size: number, endianness: Endianness) {
super(new ArrayBuffer(size), endianness);
}
public zero(): void {
new Uint32Array(this.backing_buffer).fill(0);
}
}

19
src/quest_editor/scripting/vm/Thread.ts
View File

@ -1,8 +1,8 @@
import { Kind, StackInteraction } from "../../../core/data_formats/asm/opcodes";
import { VirtualMachineIO } from "./io";
import { Memory } from "./Memory";
import { Endianness } from "../../../core/data_formats/Endianness";
import { Endianness } from "../../../core/data_formats/block/Endianness";
import { InstructionPointer } from "./InstructionPointer";
import { ArrayBufferBlock } from "../../../core/data_formats/block/ArrayBufferBlock";
const ARG_STACK_SLOT_SIZE = 4;
const ARG_STACK_LENGTH = 8;
@ -24,7 +24,10 @@ export class Thread {
private static next_id = 0;
private readonly _call_stack: StackFrame[];
private arg_stack = new Memory(ARG_STACK_LENGTH * ARG_STACK_SLOT_SIZE, Endianness.Little);
private arg_stack = new ArrayBufferBlock(
ARG_STACK_LENGTH * ARG_STACK_SLOT_SIZE,
Endianness.Little,
);
private arg_stack_counter: number = 0;
private arg_stack_types: ArgStackTypeList = Array(ARG_STACK_LENGTH).fill(
Kind.Any,
@ -99,7 +102,7 @@ export class Thread {
throw new Error("Argument stack: Stack overflow");
}
this.arg_stack.write_u32_at(this.arg_stack_counter * ARG_STACK_SLOT_SIZE, data);
this.arg_stack.set_u32(this.arg_stack_counter * ARG_STACK_SLOT_SIZE, data);
this.arg_stack_types[this.arg_stack_counter] = type;
this.arg_stack_counter++;
@ -123,21 +126,21 @@ export class Thread {
const arg_slot_offset = i * ARG_STACK_SLOT_SIZE;
switch (param.type.kind) {
case Kind.Byte:
args.push(this.arg_stack.u8_at(arg_slot_offset));
args.push(this.arg_stack.get_u8(arg_slot_offset));
break;
case Kind.Word:
case Kind.ILabel:
case Kind.DLabel:
case Kind.SLabel:
args.push(this.arg_stack.u16_at(arg_slot_offset));
args.push(this.arg_stack.get_u16(arg_slot_offset));
break;
case Kind.DWord:
case Kind.String:
args.push(this.arg_stack.u32_at(arg_slot_offset));
args.push(this.arg_stack.get_u32(arg_slot_offset));
break;
case Kind.RegTupRef:
if (param.type.register_tuples.length > 0) {
args.push(this.arg_stack.u8_at(arg_slot_offset));
args.push(this.arg_stack.get_u8(arg_slot_offset));
}
break;
default:

31
src/quest_editor/scripting/vm/VirtualMachine.ts
View File

@ -100,12 +100,12 @@ import {
} from "./utils";
import { DefaultVirtualMachineIO, VirtualMachineIO } from "./io";
import { Episode } from "../../../core/data_formats/parsing/quest/Episode";
import { Endianness } from "../../../core/data_formats/Endianness";
import { Endianness } from "../../../core/data_formats/block/Endianness";
import { Random } from "./Random";
import { Memory } from "./Memory";
import { InstructionPointer } from "./InstructionPointer";
import { StepMode, Thread } from "./Thread";
import { LogManager } from "../../../core/Logger";
import { ArrayBufferBlock } from "../../../core/data_formats/block/ArrayBufferBlock";
export const REGISTER_COUNT = 256;
@ -172,7 +172,10 @@ export class VirtualMachine {
// VM state.
private readonly registers = new Memory(REGISTER_COUNT * REGISTER_SIZE, Endianness.Little);
private readonly registers = new ArrayBufferBlock(
REGISTER_COUNT * REGISTER_SIZE,
Endianness.Little,
);
private string_arg_store = "";
private threads: Thread[] = [];
private thread_idx = 0;
@ -914,43 +917,43 @@ export class VirtualMachine {
}
public get_register_signed(reg: number): number {
return this.registers.i32_at(REGISTER_SIZE * reg);
return this.registers.get_i32(REGISTER_SIZE * reg);
}
private set_register_signed(reg: number, value: number): void {
this.registers.write_i32_at(REGISTER_SIZE * reg, value);
this.registers.set_i32(REGISTER_SIZE * reg, value);
}
public get_register_unsigned(reg: number): number {
return this.registers.u32_at(REGISTER_SIZE * reg);
return this.registers.get_u32(REGISTER_SIZE * reg);
}
private set_register_unsigned(reg: number, value: number): void {
this.registers.write_u32_at(REGISTER_SIZE * reg, value);
this.registers.set_u32(REGISTER_SIZE * reg, value);
}
public get_register_word(reg: number): number {
return this.registers.u16_at(REGISTER_SIZE * reg);
return this.registers.get_u16(REGISTER_SIZE * reg);
}
private set_register_word(reg: number, value: number): void {
this.registers.write_u16_at(REGISTER_SIZE * reg, value);
this.registers.set_u16(REGISTER_SIZE * reg, value);
}
public get_register_byte(reg: number): number {
return this.registers.u8_at(REGISTER_SIZE * reg);
return this.registers.get_u8(REGISTER_SIZE * reg);
}
public set_register_byte(reg: number, value: number): void {
this.registers.write_u8_at(REGISTER_SIZE * reg, value);
this.registers.set_u8(REGISTER_SIZE * reg, value);
}
public get_register_float(reg: number): number {
return this.registers.f32_at(REGISTER_SIZE * reg);
return this.registers.get_f32(REGISTER_SIZE * reg);
}
private set_register_float(reg: number, value: number): void {
this.registers.write_f32_at(REGISTER_SIZE * reg, value);
this.registers.set_f32(REGISTER_SIZE * reg, value);
}
private do_integer_op_with_register(
@ -1137,7 +1140,7 @@ export class VirtualMachine {
}
if (address > 0 && address < REGISTER_COUNT * REGISTER_SIZE) {
return this.registers.string_utf16_at(address, REGISTER_COUNT * REGISTER_SIZE, true);
return this.registers.get_string_utf16(address, REGISTER_COUNT * REGISTER_SIZE, true);
}
throw new Error(`Failed to dereference string: Invalid address ${address}`);

4
src/viewer/controllers/model/ModelToolBarController.ts
View File

@ -2,8 +2,8 @@ import { Controller } from "../../../core/controllers/Controller";
import { Property } from "../../../core/observable/property/Property";
import { ModelStore } from "../../stores/ModelStore";
import { read_file } from "../../../core/files";
import { ArrayBufferCursor } from "../../../core/data_formats/cursor/ArrayBufferCursor";
import { Endianness } from "../../../core/data_formats/Endianness";
import { ArrayBufferCursor } from "../../../core/data_formats/block/cursor/ArrayBufferCursor";
import { Endianness } from "../../../core/data_formats/block/Endianness";
import { parse_nj, parse_xj } from "../../../core/data_formats/parsing/ninja";
import { parse_njm } from "../../../core/data_formats/parsing/ninja/motion";
import { is_xvm, parse_xvm, XvrTexture } from "../../../core/data_formats/parsing/ninja/texture";

4
src/viewer/controllers/texture/TextureController.ts
View File

@ -2,8 +2,8 @@ import { Controller } from "../../../core/controllers/Controller";
import { filename_extension } from "../../../core/util";
import { read_file } from "../../../core/files";
import { is_xvm, parse_xvm, XvrTexture } from "../../../core/data_formats/parsing/ninja/texture";
import { ArrayBufferCursor } from "../../../core/data_formats/cursor/ArrayBufferCursor";
import { Endianness } from "../../../core/data_formats/Endianness";
import { ArrayBufferCursor } from "../../../core/data_formats/block/cursor/ArrayBufferCursor";
import { Endianness } from "../../../core/data_formats/block/Endianness";
import { parse_afs } from "../../../core/data_formats/parsing/afs";
import { LogManager } from "../../../core/Logger";
import { WritableListProperty } from "../../../core/observable/property/list/WritableListProperty";

4
src/viewer/loading/CharacterClassAssetLoader.ts
View File

@ -1,7 +1,7 @@
import { HttpClient } from "../../core/HttpClient";
import { NjObject, parse_nj } from "../../core/data_formats/parsing/ninja";
import { ArrayBufferCursor } from "../../core/data_formats/cursor/ArrayBufferCursor";
import { Endianness } from "../../core/data_formats/Endianness";
import { ArrayBufferCursor } from "../../core/data_formats/block/cursor/ArrayBufferCursor";
import { Endianness } from "../../core/data_formats/block/Endianness";
import { NjcmModel } from "../../core/data_formats/parsing/ninja/njcm";
import { NjMotion, parse_njm } from "../../core/data_formats/parsing/ninja/motion";
import { Disposable } from "../../core/observable/Disposable";