Entities can now be rotated around their y-axis by right-click dragging.

src/core/data_formats/cursor/AbstractCursor.ts

@@ -182,11 +182,11 @@ export abstract class AbstractCursor implements Cursor {
     }
 
     vec2_f32(): Vec2 {
-        return new Vec2(this.f32(), this.f32());
+        return { x: this.f32(), y: this.f32() };
     }
 
     vec3_f32(): Vec3 {
-        return new Vec3(this.f32(), this.f32(), this.f32());
+        return { x: this.f32(), y: this.f32(), z: this.f32() };
     }
 
     string_ascii(

src/core/data_formats/parsing/area_collision_geometry.ts

@@ -52,11 +52,7 @@ export function parse_area_collision_geometry(cursor: Cursor): CollisionObject {
         cursor.seek_start(vertex_table_offset);
 
         for (let i = 0; i < vertex_count; i++) {
-            const x = cursor.f32();
-            const y = cursor.f32();
-            const z = cursor.f32();
-
-            mesh.vertices.push(new Vec3(x, y, z));
+            mesh.vertices.push(cursor.vec3_f32());
         }
 
         cursor.seek_start(triangle_table_offset);
@@ -66,15 +62,13 @@ export function parse_area_collision_geometry(cursor: Cursor): CollisionObject {
             const v2 = cursor.u16();
             const v3 = cursor.u16();
             const flags = cursor.u16();
-            const n_x = cursor.f32();
-            const n_y = cursor.f32();
-            const n_z = cursor.f32();
+            const normal = cursor.vec3_f32();
             cursor.seek(16);
 
             mesh.triangles.push({
                 indices: [v1, v2, v3],
                 flags,
-                normal: new Vec3(n_x, n_y, n_z),
+                normal,
             });
         }
 

src/core/data_formats/parsing/area_geometry.ts

@@ -15,11 +15,6 @@ export type RenderSection = {
     objects: NjObject<XjModel>[];
 };
 
-export type Vertex = {
-    position: Vec3;
-    normal?: Vec3;
-};
-
 export function parse_area_geometry(cursor: Cursor): RenderObject {
     const sections: RenderSection[] = [];
 
@@ -38,11 +33,11 @@ export function parse_area_geometry(cursor: Cursor): RenderObject {
 
         const section_id = cursor.i32();
         const section_position = cursor.vec3_f32();
-        const section_rotation = new Vec3(
-            cursor.u32() * ANGLE_TO_RAD,
-            cursor.u32() * ANGLE_TO_RAD,
-            cursor.u32() * ANGLE_TO_RAD,
-        );
+        const section_rotation = {
+            x: cursor.u32() * ANGLE_TO_RAD,
+            y: cursor.u32() * ANGLE_TO_RAD,
+            z: cursor.u32() * ANGLE_TO_RAD,
+        };
 
         cursor.seek(4);
 

src/core/data_formats/parsing/ninja/index.ts

@@ -19,12 +19,12 @@ export function is_xj_model(model: NjModel): model is XjModel {
 }
 
 export class NjObject<M extends NjModel = NjModel> {
-    evaluation_flags: NjEvaluationFlags;
-    model: M | undefined;
-    position: Vec3;
-    rotation: Vec3; // Euler angles in radians.
-    scale: Vec3;
-    children: NjObject<M>[];
+    readonly evaluation_flags: NjEvaluationFlags;
+    readonly model: M | undefined;
+    readonly position: Vec3;
+    readonly rotation: Vec3; // Euler angles in radians.
+    readonly scale: Vec3;
+    readonly children: NjObject<M>[];
 
     private bone_cache = new Map<number, NjObject<M> | null>();
     private _bone_count = -1;
@@ -155,15 +155,13 @@ function parse_sibling_objects<M extends NjModel>(
     const shape_skip = (eval_flags & 0b10000000) !== 0;
 
     const model_offset = cursor.u32();
-    const pos_x = cursor.f32();
-    const pos_y = cursor.f32();
-    const pos_z = cursor.f32();
-    const rotation_x = cursor.i32() * ANGLE_TO_RAD;
-    const rotation_y = cursor.i32() * ANGLE_TO_RAD;
-    const rotation_z = cursor.i32() * ANGLE_TO_RAD;
-    const scale_x = cursor.f32();
-    const scale_y = cursor.f32();
-    const scale_z = cursor.f32();
+    const pos = cursor.vec3_f32();
+    const rotation = {
+        x: cursor.i32() * ANGLE_TO_RAD,
+        y: cursor.i32() * ANGLE_TO_RAD,
+        z: cursor.i32() * ANGLE_TO_RAD,
+    };
+    const scale = cursor.vec3_f32();
     const child_offset = cursor.u32();
     const sibling_offset = cursor.u32();
 
@@ -202,9 +200,9 @@ function parse_sibling_objects<M extends NjModel>(
             shape_skip,
         },
         model,
-        new Vec3(pos_x, pos_y, pos_z),
-        new Vec3(rotation_x, rotation_y, rotation_z),
-        new Vec3(scale_x, scale_y, scale_z),
+        pos,
+        rotation,
+        scale,
         children,
     );
 

src/core/data_formats/parsing/ninja/motion.ts

@@ -191,7 +191,7 @@ function parse_motion_data_f(cursor: Cursor, count: number): NjKeyframeF[] {
     for (let i = 0; i < count; ++i) {
         frames.push({
             frame: cursor.u32(),
-            value: new Vec3(cursor.f32(), cursor.f32(), cursor.f32()),
+            value: cursor.vec3_f32(),
         });
     }
 
@@ -209,11 +209,11 @@ function parse_motion_data_a(
     for (let i = 0; i < keyframe_count; ++i) {
         frames.push({
             frame: cursor.u16(),
-            value: new Vec3(
-                cursor.u16() * ANGLE_TO_RAD,
-                cursor.u16() * ANGLE_TO_RAD,
-                cursor.u16() * ANGLE_TO_RAD,
-            ),
+            value: {
+                x: cursor.u16() * ANGLE_TO_RAD,
+                y: cursor.u16() * ANGLE_TO_RAD,
+                z: cursor.u16() * ANGLE_TO_RAD,
+            },
         });
     }
 
@@ -237,11 +237,11 @@ function parse_motion_data_a_wide(cursor: Cursor, keyframe_count: number): NjKey
     for (let i = 0; i < keyframe_count; ++i) {
         frames.push({
             frame: cursor.u32(),
-            value: new Vec3(
-                cursor.i32() * ANGLE_TO_RAD,
-                cursor.i32() * ANGLE_TO_RAD,
-                cursor.i32() * ANGLE_TO_RAD,
-            ),
+            value: {
+                x: cursor.i32() * ANGLE_TO_RAD,
+                y: cursor.i32() * ANGLE_TO_RAD,
+                z: cursor.i32() * ANGLE_TO_RAD,
+            },
         });
     }
 

src/core/data_formats/parsing/ninja/njcm.ts

@@ -173,7 +173,7 @@ export function parse_njcm_model(cursor: Cursor, cached_chunk_offsets: number[])
     if (plist_offset) {
         cursor.seek_start(plist_offset);
 
-        let texture_id: number | undefined;
+        let texture_id: number | undefined = undefined;
 
         for (const chunk of parse_chunks(cursor, cached_chunk_offsets, false)) {
             if (chunk.type === NjcmChunkType.Tiny) {
@@ -372,11 +372,11 @@ function parse_vertex_chunk(
         } else if (48 <= chunk_type_id && chunk_type_id <= 50) {
             // 32-Bit vertex normal in format: reserved(2)|x(10)|y(10)|z(10)
             const normal = cursor.u32();
-            vertex.normal = new Vec3(
-                ((normal >> 20) & 0x3ff) / 0x3ff,
-                ((normal >> 10) & 0x3ff) / 0x3ff,
-                (normal & 0x3ff) / 0x3ff,
-            );
+            vertex.normal = {
+                x: ((normal >> 20) & 0x3ff) / 0x3ff,
+                y: ((normal >> 10) & 0x3ff) / 0x3ff,
+                z: (normal & 0x3ff) / 0x3ff,
+            };
 
             if (chunk_type_id >= 49) {
                 // Skip user flags and material information.
@@ -462,7 +462,7 @@ function parse_triangle_strip_chunk(
             vertices.push(vertex);
 
             if (has_tex_coords) {
-                vertex.tex_coords = new Vec2(cursor.u16() / 255, cursor.u16() / 255);
+                vertex.tex_coords = { x: cursor.u16() / 255, y: cursor.u16() / 255 };
             }
 
             // Ignore ARGB8888 color.
@@ -471,11 +471,11 @@ function parse_triangle_strip_chunk(
             }
 
             if (has_normal) {
-                vertex.normal = new Vec3(
-                    cursor.u16() / 255,
-                    cursor.u16() / 255,
-                    cursor.u16() / 255,
-                );
+                vertex.normal = {
+                    x: cursor.u16() / 255,
+                    y: cursor.u16() / 255,
+                    z: cursor.u16() / 255,
+                };
             }
 
             // Ignore double texture coordinates (Ua, Vb, Ua, Vb).

src/core/data_formats/parsing/quest/dat.test.ts

@@ -37,9 +37,11 @@ test("parse, modify and write DAT", () => {
     const test_parsed = parse_dat(orig_dat);
     orig_dat.seek_start(0);
 
-    test_parsed.objs[9].position.x = 13;
-    test_parsed.objs[9].position.y = 17;
-    test_parsed.objs[9].position.z = 19;
+    test_parsed.objs[9].position = {
+        x: 13,
+        y: 17,
+        z: 19,
+    };
 
     const test_dat = new ResizableBufferCursor(write_dat(test_parsed), Endianness.Little);
 

src/core/data_formats/parsing/quest/dat.ts

@@ -81,11 +81,11 @@ export function parse_dat(cursor: Cursor): DatFile {
                     const section_id = cursor.u16();
                     const unknown2 = cursor.u8_array(2);
                     const position = cursor.vec3_f32();
-                    const rotation = new Vec3(
-                        (cursor.i32() / 0xffff) * 2 * Math.PI,
-                        (cursor.i32() / 0xffff) * 2 * Math.PI,
-                        (cursor.i32() / 0xffff) * 2 * Math.PI,
-                    );
+                    const rotation = {
+                        x: (cursor.i32() / 0xffff) * 2 * Math.PI,
+                        y: (cursor.i32() / 0xffff) * 2 * Math.PI,
+                        z: (cursor.i32() / 0xffff) * 2 * Math.PI,
+                    };
                     const properties = [
                         cursor.f32(),
                         cursor.f32(),
@@ -141,7 +141,7 @@ export function parse_dat(cursor: Cursor): DatFile {
                         type_id,
                         section_id,
                         position,
-                        rotation: new Vec3(rotation_x, rotation_y, rotation_z),
+                        rotation: { x: rotation_x, y: rotation_y, z: rotation_z },
                         scale,
                         npc_id,
                         script_label,

src/core/data_formats/parsing/quest/index.ts

@@ -12,7 +12,6 @@ import { ArrayBufferCursor } from "../../cursor/ArrayBufferCursor";
 import { Cursor } from "../../cursor/Cursor";
 import { ResizableBufferCursor } from "../../cursor/ResizableBufferCursor";
 import { Endianness } from "../../Endianness";
-import { Vec3 } from "../../vector";
 import { BinFile, parse_bin, write_bin } from "./bin";
 import { DatFile, DatNpc, DatObject, DatUnknown, parse_dat, write_dat } from "./dat";
 import { QuestNpc, QuestObject } from "./entities";
@@ -586,14 +585,15 @@ function npcs_to_dat_data(npcs: QuestNpc[]): DatNpc[] {
         const type_data = npc_data(npc.type);
         const type_id =
             type_data.pso_type_id == undefined ? npc.pso_type_id : type_data.pso_type_id;
-        const roaming = type_data.pso_roaming == undefined ? npc.pso_roaming : type_data.pso_roaming;
+        const roaming =
+            type_data.pso_roaming == undefined ? npc.pso_roaming : type_data.pso_roaming;
         const regular = type_data.pso_regular == undefined ? true : type_data.pso_regular;
 
         dv.setFloat32(0, npc.scale.y);
         dv.setUint32(0, (dv.getUint32(0) & ~0x800000) | (regular ? 0 : 0x800000));
         const scale_y = dv.getFloat32(0);
 
-        let scale = new Vec3(npc.scale.x, scale_y, npc.scale.z);
+        const scale = { x: npc.scale.x, y: scale_y, z: npc.scale.z };
 
         return {
             type_id,

src/core/data_formats/vector.ts

@@ -1,63 +1,10 @@
-export class Vec2 {
-    x: number;
-    y: number;
+export type Vec2 = {
+    readonly x: number;
+    readonly y: number;
+};
 
-    constructor(x: number, y: number) {
-        this.x = x;
-        this.y = y;
-    }
-
-    set(x: number, y: number): this {
-        this.x = x;
-        this.y = y;
-        return this;
-    }
-
-    add(v: Vec2): this {
-        this.x += v.x;
-        this.y += v.y;
-        return this;
-    }
-
-    clone(): Vec2 {
-        return new Vec2(this.x, this.y);
-    }
-
-    equals(v: Vec2): boolean {
-        return this.x === v.x && this.y === v.y;
-    }
-}
-
-export class Vec3 {
-    x: number;
-    y: number;
-    z: number;
-
-    constructor(x: number, y: number, z: number) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-    }
-
-    set(x: number, y: number, z: number): this {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-        return this;
-    }
-
-    add(v: Vec3): this {
-        this.x += v.x;
-        this.y += v.y;
-        this.z += v.z;
-        return this;
-    }
-
-    clone(): Vec3 {
-        return new Vec3(this.x, this.y, this.z);
-    }
-
-    equals(v: Vec3): boolean {
-        return this.x === v.x && this.y === v.y && this.z === v.z;
-    }
-}
+export type Vec3 = {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+};

src/quest_editor/actions/RotateEntityAction.ts

@@ -0,0 +1,38 @@
+import { Action } from "../../core/undo/Action";
+import { QuestEntityModel } from "../model/QuestEntityModel";
+import { entity_data } from "../../core/data_formats/parsing/quest/entities";
+import { quest_editor_store } from "../stores/QuestEditorStore";
+import { Euler } from "three";
+
+export class RotateEntityAction implements Action {
+    readonly description: string;
+
+    constructor(
+        private entity: QuestEntityModel,
+        private old_rotation: Euler,
+        private new_rotation: Euler,
+        private world: boolean,
+    ) {
+        this.description = `Rotate ${entity_data(entity.type).name}`;
+    }
+
+    undo(): void {
+        quest_editor_store.set_selected_entity(this.entity);
+
+        if (this.world) {
+            this.entity.set_world_rotation(this.old_rotation);
+        } else {
+            this.entity.set_rotation(this.old_rotation);
+        }
+    }
+
+    redo(): void {
+        quest_editor_store.set_selected_entity(this.entity);
+
+        if (this.world) {
+            this.entity.set_world_rotation(this.new_rotation);
+        } else {
+            this.entity.set_rotation(this.new_rotation);
+        }
+    }
+}

src/quest_editor/actions/TranslateEntityAction.ts

@@ -1,9 +1,9 @@
 import { Action } from "../../core/undo/Action";
 import { QuestEntityModel } from "../model/QuestEntityModel";
-import { Vec3 } from "../../core/data_formats/vector";
 import { entity_data } from "../../core/data_formats/parsing/quest/entities";
 import { quest_editor_store } from "../stores/QuestEditorStore";
 import { SectionModel } from "../model/SectionModel";
+import { Vector3 } from "three";
 
 export class TranslateEntityAction implements Action {
     readonly description: string;
@@ -12,8 +12,8 @@ export class TranslateEntityAction implements Action {
         private entity: QuestEntityModel,
         private old_section: SectionModel | undefined,
         private new_section: SectionModel | undefined,
-        private old_position: Vec3,
-        private new_position: Vec3,
+        private old_position: Vector3,
+        private new_position: Vector3,
         private world: boolean,
     ) {
         this.description = `Move ${entity_data(entity.type).name}`;

src/quest_editor/gui/EntityInfoView.ts

@@ -8,8 +8,8 @@ import "./EntityInfoView.css";
 import { NumberInput } from "../../core/gui/NumberInput";
 import { Disposer } from "../../core/observable/Disposer";
 import { Property } from "../../core/observable/property/Property";
-import { Vec3 } from "../../core/data_formats/vector";
 import { QuestEntityModel } from "../model/QuestEntityModel";
+import { Vector3 } from "three";
 
 export class EntityInfoView extends ResizableWidget {
     readonly element = el.div({ class: "quest_editor_EntityInfoView", tab_index: -1 });
@@ -146,7 +146,7 @@ export class EntityInfoView extends ResizableWidget {
 
     private observe(
         entity: QuestEntityModel,
-        pos: Property<Vec3>,
+        pos: Property<Vector3>,
         world: boolean,
         x_input: NumberInput,
         y_input: NumberInput,
@@ -168,7 +168,7 @@ export class EntityInfoView extends ResizableWidget {
                     entity.section.val,
                     entity.section.val,
                     pos.val,
-                    new Vec3(value, pos.val.y, pos.val.z),
+                    new Vector3(value, pos.val.y, pos.val.z),
                     world,
                 ),
             ),
@@ -179,7 +179,7 @@ export class EntityInfoView extends ResizableWidget {
                     entity.section.val,
                     entity.section.val,
                     pos.val,
-                    new Vec3(pos.val.x, value, pos.val.z),
+                    new Vector3(pos.val.x, value, pos.val.z),
                     world,
                 ),
             ),
@@ -190,7 +190,7 @@ export class EntityInfoView extends ResizableWidget {
                     entity.section.val,
                     entity.section.val,
                     pos.val,
-                    new Vec3(pos.val.x, pos.val.y, value),
+                    new Vector3(pos.val.x, pos.val.y, value),
                     world,
                 ),
             ),

src/quest_editor/gui/entity_dnd.ts

@@ -1,7 +1,7 @@
 import { entity_data, EntityType } from "../../core/data_formats/parsing/quest/entities";
 import { Disposable } from "../../core/observable/Disposable";
-import { Vec2 } from "../../core/data_formats/vector";
 import { el } from "../../core/gui/dom";
+import { Vector2 } from "three";
 
 export type EntityDragEvent = {
     readonly entity_type: EntityType;
@@ -11,7 +11,7 @@ export type EntityDragEvent = {
 
 let dragging_details: Omit<EntityDragEvent, "event"> | undefined = undefined;
 const listeners: Map<(e: EntityDragEvent) => void, (e: DragEvent) => void> = new Map();
-const grab_point = new Vec2(0, 0);
+const grab_point = new Vector2(0, 0);
 let drag_sources = 0;
 
 export function add_entity_dnd_listener(

src/quest_editor/model/QuestEntityModel.ts

@@ -1,9 +1,9 @@
 import { EntityType } from "../../core/data_formats/parsing/quest/entities";
-import { Vec3 } from "../../core/data_formats/vector";
 import { Property } from "../../core/observable/property/Property";
-import { map, property } from "../../core/observable";
+import { property } from "../../core/observable";
 import { WritableProperty } from "../../core/observable/property/WritableProperty";
 import { SectionModel } from "./SectionModel";
+import { Euler, Quaternion, Vector3 } from "three";
 
 export abstract class QuestEntityModel<Type extends EntityType = EntityType> {
     readonly type: Type;
@@ -14,68 +14,33 @@ export abstract class QuestEntityModel<Type extends EntityType = EntityType> {
 
     readonly section: Property<SectionModel | undefined>;
 
-    set_section(section: SectionModel): this {
-        if (section.area_variant.area.id !== this.area_id) {
-            throw new Error(`Quest entities can't be moved across areas.`);
-        }
-
-        this._section.val = section;
-        this._section_id.val = section.id;
-        return this;
-    }
-
     /**
      * Section-relative position
      */
-    readonly position: Property<Vec3>;
-
-    set_position(position: Vec3): void {
-        this._position.val = position;
-    }
-
-    readonly rotation: Property<Vec3>;
-
-    set_rotation(rotation: Vec3): void {
-        this._rotation.val = rotation;
-    }
+    readonly position: Property<Vector3>;
 
     /**
      * World position
      */
-    readonly world_position: Property<Vec3>;
+    readonly world_position: Property<Vector3>;
 
-    set_world_position(pos: Vec3): this {
-        let { x, y, z } = pos;
-        const section = this.section.val;
+    readonly rotation: Property<Euler>;
 
-        if (section) {
-            const rel_x = x - section.position.x;
-            const rel_y = y - section.position.y;
-            const rel_z = z - section.position.z;
-            const sin = -section.sin_y_axis_rotation;
-            const cos = section.cos_y_axis_rotation;
-            const rot_x = cos * rel_x + sin * rel_z;
-            const rot_z = -sin * rel_x + cos * rel_z;
-            x = rot_x;
-            y = rel_y;
-            z = rot_z;
-        }
-
-        this._position.val = new Vec3(x, y, z);
-        return this;
-    }
+    readonly world_rotation: Property<Euler>;
 
     private readonly _section_id: WritableProperty<number>;
     private readonly _section: WritableProperty<SectionModel | undefined> = property(undefined);
-    private readonly _position: WritableProperty<Vec3>;
-    private readonly _rotation: WritableProperty<Vec3>;
+    private readonly _position: WritableProperty<Vector3>;
+    private readonly _world_position: WritableProperty<Vector3>;
+    private readonly _rotation: WritableProperty<Euler>;
+    private readonly _world_rotation: WritableProperty<Euler>;
 
     protected constructor(
         type: Type,
         area_id: number,
         section_id: number,
-        position: Vec3,
-        rotation: Vec3,
+        position: Vector3,
+        rotation: Euler,
     ) {
         if (type == undefined) throw new Error("type is required.");
         if (!Number.isInteger(area_id)) throw new Error("area_id should be an integer.");
@@ -86,32 +51,105 @@ export abstract class QuestEntityModel<Type extends EntityType = EntityType> {
         this.type = type;
         this.area_id = area_id;
         this.section = this._section;
+
         this._section_id = property(section_id);
         this.section_id = this._section_id;
+
         this._position = property(position);
         this.position = this._position;
+
+        this._world_position = property(position);
+        this.world_position = this._world_position;
+
         this._rotation = property(rotation);
         this.rotation = this._rotation;
-        this.world_position = map(this.position_to_world_position, this.section, this.position);
+
+        this._world_rotation = property(rotation);
+        this.world_rotation = this._world_rotation;
     }
 
-    private position_to_world_position = (
-        section: SectionModel | undefined,
-        position: Vec3,
-    ): Vec3 => {
+    set_section(section: SectionModel): this {
+        if (section.area_variant.area.id !== this.area_id) {
+            throw new Error(`Quest entities can't be moved across areas.`);
+        }
+
+        this._section.val = section;
+        this._section_id.val = section.id;
+
+        this.set_position(this.position.val);
+        this.set_rotation(this.rotation.val);
+
+        return this;
+    }
+
+    set_position(pos: Vector3): this {
+        this._position.val = pos;
+
+        const section = this.section.val;
+
         if (section) {
-            let { x: rel_x, y: rel_y, z: rel_z } = position;
-
-            const sin = -section.sin_y_axis_rotation;
-            const cos = section.cos_y_axis_rotation;
-            const rot_x = cos * rel_x - sin * rel_z;
-            const rot_z = sin * rel_x + cos * rel_z;
-            const x = rot_x + section.position.x;
-            const y = rel_y + section.position.y;
-            const z = rot_z + section.position.z;
-            return new Vec3(x, y, z);
+            this._world_position.val = pos
+                .clone()
+                .applyEuler(section.rotation)
+                .add(section.position);
         } else {
-            return position;
+            this._world_position.val = pos;
+        }
+
+        return this;
+    }
+
+    set_world_position(pos: Vector3): this {
+        this._world_position.val = pos;
+
+        const section = this.section.val;
+
+        if (section) {
+            this._position.val = pos
+                .clone()
+                .sub(section.position)
+                .applyEuler(section.inverse_rotation);
+        } else {
+            this._position.val = pos;
+        }
+
+        return this;
+    }
+
+    set_rotation(rot: Euler): this {
+        this._rotation.val = rot;
+
+        const section = this.section.val;
+
+        if (section) {
+            this._world_rotation.val = new Euler().setFromQuaternion(
+                new Quaternion()
+                    .setFromEuler(section.rotation)
+                    .multiply(new Quaternion().setFromEuler(rot)),
+                "ZXY",
+            );
+        } else {
+            this._world_rotation.val = rot;
+        }
+        return this;
+    }
+
+    set_world_rotation(rot: Euler): this {
+        this._world_rotation.val = rot;
+
+        const section = this.section.val;
+
+        if (section) {
+            this._rotation.val = new Euler().setFromQuaternion(
+                new Quaternion()
+                    .setFromEuler(rot)
+                    .multiply(new Quaternion().setFromEuler(section.rotation).inverse()),
+                "ZXY",
+            );
+        } else {
+            this._rotation.val = rot;
+        }
+
+        return this;
     }
-    };
 }

src/quest_editor/model/QuestNpcModel.ts

@@ -1,13 +1,13 @@
 import { QuestEntityModel } from "./QuestEntityModel";
 import { NpcType } from "../../core/data_formats/parsing/quest/npc_types";
-import { Vec3 } from "../../core/data_formats/vector";
+import { Euler, Vector3 } from "three";
 
 export class QuestNpcModel extends QuestEntityModel<NpcType> {
     readonly pso_type_id: number;
     readonly npc_id: number;
     readonly script_label: number;
     readonly pso_roaming: number;
-    readonly scale: Vec3;
+    readonly scale: Vector3;
     /**
      * Data of which the purpose hasn't been discovered yet.
      */
@@ -21,9 +21,9 @@ export class QuestNpcModel extends QuestEntityModel<NpcType> {
         pso_roaming: number,
         area_id: number,
         section_id: number,
-        position: Vec3,
-        rotation: Vec3,
-        scale: Vec3,
+        position: Vector3,
+        rotation: Euler,
+        scale: Vector3,
         unknown: number[][],
     ) {
         if (!Number.isInteger(pso_type_id)) throw new Error("pso_type_id should be an integer.");

src/quest_editor/model/QuestObjectModel.ts

@@ -1,6 +1,6 @@
 import { QuestEntityModel } from "./QuestEntityModel";
 import { ObjectType } from "../../core/data_formats/parsing/quest/object_types";
-import { Vec3 } from "../../core/data_formats/vector";
+import { Euler, Vector3 } from "three";
 
 export class QuestObjectModel extends QuestEntityModel<ObjectType> {
     readonly id: number;
@@ -17,8 +17,8 @@ export class QuestObjectModel extends QuestEntityModel<ObjectType> {
         group_id: number,
         area_id: number,
         section_id: number,
-        position: Vec3,
-        rotation: Vec3,
+        position: Vector3,
+        rotation: Euler,
         properties: Map<string, number>,
         unknown: number[][],
     ) {

src/quest_editor/model/SectionModel.ts

@@ -1,31 +1,24 @@
-import { Vec3 } from "../../core/data_formats/vector";
 import { AreaVariantModel } from "./AreaVariantModel";
+import { Euler, Vector3 } from "three";
 
 export class SectionModel {
     readonly id: number;
-    readonly position: Vec3;
-    readonly y_axis_rotation: number;
-    readonly sin_y_axis_rotation: number;
-    readonly cos_y_axis_rotation: number;
+    readonly position: Vector3;
+    readonly rotation: Euler;
+    readonly inverse_rotation: Euler;
     readonly area_variant: AreaVariantModel;
 
-    constructor(
-        id: number,
-        position: Vec3,
-        y_axis_rotation: number,
-        area_variant: AreaVariantModel,
-    ) {
+    constructor(id: number, position: Vector3, rotation: Euler, area_variant: AreaVariantModel) {
         if (!Number.isInteger(id) || id < -1)
             throw new Error(`Expected id to be an integer greater than or equal to -1, got ${id}.`);
         if (!position) throw new Error("position is required.");
-        if (!Number.isFinite(y_axis_rotation)) throw new Error("y_axis_rotation is required.");
+        if (!rotation) throw new Error("rotation is required.");
         if (!area_variant) throw new Error("area_variant is required.");
 
         this.id = id;
         this.position = position;
-        this.y_axis_rotation = y_axis_rotation;
-        this.sin_y_axis_rotation = Math.sin(this.y_axis_rotation);
-        this.cos_y_axis_rotation = Math.cos(this.y_axis_rotation);
+        this.rotation = rotation;
+        this.inverse_rotation = rotation.clone().reorder("YXZ");
         this.area_variant = area_variant;
     }
 }

src/quest_editor/rendering/QuestEntityControls.ts

@@ -1,6 +1,15 @@
 import { QuestEntityModel } from "../model/QuestEntityModel";
-import { Intersection, Mesh, MeshLambertMaterial, Plane, Raycaster, Vector2, Vector3 } from "three";
-import { Vec3 } from "../../core/data_formats/vector";
+import {
+    Euler,
+    Intersection,
+    Mesh,
+    MeshLambertMaterial,
+    Plane,
+    Quaternion,
+    Raycaster,
+    Vector2,
+    Vector3,
+} from "three";
 import { QuestRenderer } from "./QuestRenderer";
 import { quest_editor_store } from "../stores/QuestEditorStore";
 import { ColorType, EntityUserData, NPC_COLORS, OBJECT_COLORS } from "./conversion/entities";
@@ -16,7 +25,6 @@ import {
     EntityDragEvent,
     remove_entity_dnd_listener,
 } from "../gui/entity_dnd";
-import { vec3_to_threejs } from "../../core/rendering/conversion";
 import { QuestObjectModel } from "../model/QuestObjectModel";
 import { AreaModel } from "../model/AreaModel";
 import { QuestModel } from "../model/QuestModel";
@@ -24,11 +32,9 @@ import { QuestModel } from "../model/QuestModel";
 const ZERO_VECTOR = Object.freeze(new Vector3(0, 0, 0));
 const UP_VECTOR = Object.freeze(new Vector3(0, 1, 0));
 const DOWN_VECTOR = Object.freeze(new Vector3(0, -1, 0));
+const PI2 = 2 * Math.PI;
 
 const raycaster = new Raycaster();
-const plane = new Plane();
-const plane_normal = new Vector3();
-const intersection_point = new Vector3();
 
 export class QuestEntityControls implements Disposable {
     private readonly disposer = new Disposer();
@@ -259,10 +265,6 @@ type Pick = {
 
     mesh: Mesh;
 
-    initial_section?: SectionModel;
-
-    initial_position: Vec3;
-
     /**
      * Vector that points from the grabbing point to the model's origin.
      */
@@ -346,24 +348,27 @@ class IdleState implements State {
             }
 
             case EvtType.MouseDown: {
-                const pick_result = this.pick_entity(evt.pointer_device_position);
+                const pick = this.pick_entity(evt.pointer_device_position);
 
-                if (pick_result) {
+                if (pick) {
                     if (evt.buttons === 1) {
-                        quest_editor_store.set_selected_entity(pick_result.entity);
+                        quest_editor_store.set_selected_entity(pick.entity);
 
                         return new TranslationState(
                             this.renderer,
-                            pick_result.entity,
-                            pick_result.initial_section,
-                            pick_result.initial_position,
-                            pick_result.drag_adjust,
-                            pick_result.grab_offset,
+                            pick.entity,
+                            pick.drag_adjust,
+                            pick.grab_offset,
                         );
                     } else if (evt.buttons === 2) {
-                        quest_editor_store.set_selected_entity(pick_result.entity);
+                        quest_editor_store.set_selected_entity(pick.entity);
 
-                        return new RotationState(this.renderer);
+                        return new RotationState(
+                            this.renderer,
+                            pick.entity,
+                            pick.mesh,
+                            pick.grab_offset,
+                        );
                     }
                 }
 
@@ -434,8 +439,6 @@ class IdleState implements State {
         return {
             mesh: intersection.object as Mesh,
             entity,
-            initial_section: entity.section.val,
-            initial_position: entity.world_position.val,
             grab_offset,
             drag_adjust,
         };
@@ -443,16 +446,18 @@ class IdleState implements State {
 }
 
 class TranslationState implements State {
+    private readonly initial_section: SectionModel | undefined;
+    private readonly initial_position: Vector3;
     private cancelled = false;
 
     constructor(
         private readonly renderer: QuestRenderer,
         private readonly entity: QuestEntityModel,
-        private readonly initial_section: SectionModel | undefined,
-        private readonly initial_position: Vec3,
         private readonly drag_adjust: Vector3,
         private readonly grab_offset: Vector3,
     ) {
+        this.initial_section = entity.section.val;
+        this.initial_position = entity.world_position.val;
         this.renderer.controls.enabled = false;
     }
 
@@ -513,21 +518,68 @@ class TranslationState implements State {
 
 // TODO: make entities rotatable with right mouse button.
 class RotationState implements State {
-    private readonly renderer: QuestRenderer;
+    private readonly initial_rotation: Euler;
+    private readonly grab_point: Vector3;
+    private cancelled = false;
 
-    constructor(renderer: QuestRenderer) {
-        this.renderer = renderer;
-
-        // Disable camera controls while the user is transforming an entity.
+    constructor(
+        private readonly renderer: QuestRenderer,
+        private readonly entity: QuestEntityModel,
+        private readonly mesh: Mesh,
+        grab_offset: Vector3,
+    ) {
+        this.initial_rotation = entity.world_rotation.val;
+        this.grab_point = entity.world_position.val.clone().sub(grab_offset);
         this.renderer.controls.enabled = false;
     }
 
-    process_event(): State {
-        this.renderer.controls.enabled = true;
+    process_event(evt: Evt): State {
+        switch (evt.type) {
+            case EvtType.MouseMove: {
+                if (this.cancelled) {
                     return new IdleState(this.renderer);
                 }
 
-    cancel(): void {}
+                if (evt.moved_since_last_pointer_down) {
+                    rotate_entity(
+                        this.renderer,
+                        this.entity,
+                        this.mesh.quaternion,
+                        this.initial_rotation,
+                        this.grab_point,
+                        evt.pointer_device_position,
+                    );
+                }
+
+                return this;
+            }
+
+            case EvtType.MouseUp: {
+                this.renderer.controls.enabled = true;
+
+                if (!this.cancelled && evt.moved_since_last_pointer_down) {
+                    quest_editor_store.rotate_entity(
+                        this.entity,
+                        this.initial_rotation,
+                        this.entity.world_rotation.val,
+                        true,
+                    );
+                }
+
+                return new IdleState(this.renderer);
+            }
+
+            default:
+                return this.cancelled ? new IdleState(this.renderer) : this;
+        }
+    }
+
+    cancel(): void {
+        this.cancelled = true;
+        this.renderer.controls.enabled = true;
+
+        this.entity.set_world_rotation(this.initial_rotation);
+    }
 }
 
 class CreationState implements State {
@@ -556,9 +608,9 @@ class CreationState implements State {
                 data.pso_roaming!,
                 area.id,
                 0,
-                new Vec3(0, 0, 0),
-                new Vec3(0, 0, 0),
-                new Vec3(1, 1, 1),
+                new Vector3(0, 0, 0),
+                new Euler(0, 0, 0, "ZXY"),
+                new Vector3(1, 1, 1),
                 // TODO: do the following values make sense?
                 [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0]],
             );
@@ -569,8 +621,8 @@ class CreationState implements State {
                 0,
                 area.id,
                 0,
-                new Vec3(0, 0, 0),
-                new Vec3(0, 0, 0),
+                new Vector3(0, 0, 0),
+                new Euler(0, 0, 0, "ZXY"),
                 // TODO: which default properties?
                 new Map(),
                 // TODO: do the following values make sense?
@@ -709,19 +761,27 @@ function translate_entity(
  * If the drag-adjusted pointer is over the ground, translate an entity horizontally across the
  * ground. Otherwise translate the entity over the horizontal plane that intersects its origin.
  */
-function translate_entity_horizontally(
+const translate_entity_horizontally = (() => {
+    const plane = new Plane();
+    const pointer_pos_on_plane = new Vector3();
+
+    return (
         renderer: QuestRenderer,
         entity: QuestEntityModel,
         drag_adjust: Vector3,
         grab_offset: Vector3,
         pointer_device_position: Vector2,
-): void {
+    ): void => {
         // Cast ray adjusted for dragging entities.
-    const { intersection, section } = pick_ground(renderer, pointer_device_position, drag_adjust);
+        const { intersection, section } = pick_ground(
+            renderer,
+            pointer_device_position,
+            drag_adjust,
+        );
 
         if (intersection) {
             entity.set_world_position(
-            new Vec3(
+                new Vector3(
                     intersection.point.x,
                     intersection.point.y + grab_offset.y - drag_adjust.y,
                     intersection.point.z,
@@ -735,51 +795,113 @@ function translate_entity_horizontally(
             // If the pointer is not over the ground, we translate the entity across the horizontal
             // plane in which the entity's origin lies.
             raycaster.setFromCamera(pointer_device_position, renderer.camera);
-        const ray = raycaster.ray;
             plane.set(UP_VECTOR, -entity.world_position.val.y + grab_offset.y);
 
-        if (ray.intersectPlane(plane, intersection_point)) {
+            if (raycaster.ray.intersectPlane(plane, pointer_pos_on_plane)) {
                 entity.set_world_position(
-                new Vec3(
-                    intersection_point.x + grab_offset.x,
+                    new Vector3(
+                        pointer_pos_on_plane.x + grab_offset.x,
                         entity.world_position.val.y,
-                    intersection_point.z + grab_offset.z,
+                        pointer_pos_on_plane.z + grab_offset.z,
                     ),
                 );
             }
         }
-}
+    };
+})();
 
-function translate_entity_vertically(
+const translate_entity_vertically = (() => {
+    const plane_normal = new Vector3();
+    const plane = new Plane();
+    const pointer_pos_on_plane = new Vector3();
+    const grab_point = new Vector3();
+
+    return (
         renderer: QuestRenderer,
         entity: QuestEntityModel,
         drag_adjust: Vector3,
         grab_offset: Vector3,
         pointer_device_position: Vector2,
-): void {
-    // We intersect with a plane that's oriented toward the camera and that's coplanar with the
+    ): void => {
+        // Intersect with a plane that's oriented towards the camera and that's coplanar with the
         // point where the entity was grabbed.
         raycaster.setFromCamera(pointer_device_position, renderer.camera);
-    const ray = raycaster.ray;
 
         renderer.camera.getWorldDirection(plane_normal);
         plane_normal.negate();
         plane_normal.y = 0;
         plane_normal.normalize();
-    plane.setFromNormalAndCoplanarPoint(
-        plane_normal,
-        vec3_to_threejs(entity.world_position.val).sub(grab_offset),
-    );
 
-    if (ray.intersectPlane(plane, intersection_point)) {
-        const y = intersection_point.y + grab_offset.y;
+        grab_point.set(
+            entity.world_position.val.x,
+            entity.world_position.val.y,
+            entity.world_position.val.z,
+        );
+        grab_point.sub(grab_offset);
+        plane.setFromNormalAndCoplanarPoint(plane_normal, grab_point);
+
+        if (raycaster.ray.intersectPlane(plane, pointer_pos_on_plane)) {
+            const y = pointer_pos_on_plane.y + grab_offset.y;
             const y_delta = y - entity.world_position.val.y;
             drag_adjust.y -= y_delta;
             entity.set_world_position(
-            new Vec3(entity.world_position.val.x, y, entity.world_position.val.z),
+                new Vector3(entity.world_position.val.x, y, entity.world_position.val.z),
             );
         }
+    };
+})();
+
+const rotate_entity = (() => {
+    const plane_normal = new Vector3();
+    const plane = new Plane();
+    const pointer_pos_on_plane = new Vector3();
+    const y_intersect = new Vector3();
+    const axis_to_grab = new Vector3();
+    const axis_to_pointer = new Vector3();
+
+    return (
+        renderer: QuestRenderer,
+        entity: QuestEntityModel,
+        rotation: Quaternion,
+        initial_rotation: Euler,
+        grab_point: Vector3,
+        pointer_device_position: Vector2,
+    ): void => {
+        // Intersect with a plane that's oriented along the entity's y-axis and that's coplanar with
+        // the point where the entity was grabbed.
+        plane_normal.copy(UP_VECTOR);
+        plane_normal.applyQuaternion(rotation);
+
+        plane.setFromNormalAndCoplanarPoint(plane_normal, grab_point);
+
+        raycaster.setFromCamera(pointer_device_position, renderer.camera);
+
+        if (raycaster.ray.intersectPlane(plane, pointer_pos_on_plane)) {
+            plane.projectPoint(entity.world_position.val, y_intersect);
+
+            // Calculate vector from the entity's y-axis to the original grab point.
+            axis_to_grab.subVectors(y_intersect, grab_point);
+
+            // Calculate vector from the entity's y-axis to the new pointer position.
+            axis_to_pointer.subVectors(y_intersect, pointer_pos_on_plane);
+
+            // Calculate the angle between the two vectors and rotate the entity around its y-axis
+            // by that angle.
+            const cos = axis_to_grab.dot(axis_to_pointer);
+            const sin = plane_normal.dot(axis_to_grab.cross(axis_to_pointer));
+            const angle = Math.atan2(sin, cos);
+
+            entity.set_world_rotation(
+                new Euler(
+                    initial_rotation.x,
+                    (initial_rotation.y + angle) % PI2,
+                    initial_rotation.z,
+                    "ZXY",
+                ),
+            );
         }
+    };
+})();
 
 /**
  * @param renderer

src/quest_editor/rendering/QuestModelManager.ts

@@ -282,13 +282,13 @@ class EntityModelManager {
         this.loaded_entities.push({
             entity,
             disposer: new Disposer(
-                entity.world_position.observe(({ value: { x, y, z } }) => {
-                    model.position.set(x, y, z);
+                entity.world_position.observe(({ value }) => {
+                    model.position.copy(value);
                     this.renderer.schedule_render();
                 }),
 
-                entity.rotation.observe(({ value: { x, y, z } }) => {
-                    model.rotation.set(x, y, z);
+                entity.world_rotation.observe(({ value }) => {
+                    model.rotation.copy(value);
                     this.renderer.schedule_render();
                 }),
             ),

src/quest_editor/rendering/conversion/areas.ts

@@ -1,6 +1,7 @@
 import {
     Color,
     DoubleSide,
+    Euler,
     Face3,
     Geometry,
     Group,
@@ -16,6 +17,7 @@ import { GeometryBuilder } from "../../../core/rendering/conversion/GeometryBuil
 import { ninja_object_to_geometry_builder } from "../../../core/rendering/conversion/ninja_geometry";
 import { SectionModel } from "../../model/SectionModel";
 import { AreaVariantModel } from "../../model/AreaVariantModel";
+import { vec3_to_threejs } from "../../../core/rendering/conversion";
 
 const materials = [
     // Wall
@@ -148,8 +150,8 @@ export function area_geometry_to_sections_and_object_3d(
         if (section.id >= 0) {
             const sec = new SectionModel(
                 section.id,
-                section.position,
-                section.rotation.y,
+                vec3_to_threejs(section.position),
+                new Euler(section.rotation.x, section.rotation.y, section.rotation.z, "ZXY"),
                 area_variant,
             );
             sections.push(sec);

src/quest_editor/rendering/conversion/entities.ts

@@ -66,10 +66,8 @@ export function create_entity_mesh(
 
     (mesh.userData as EntityUserData).entity = entity;
 
-    const { x, y, z } = entity.world_position.val;
-    mesh.position.set(x, y, z);
-    const rot = entity.rotation.val;
-    mesh.rotation.set(rot.x, rot.y, rot.z);
+    mesh.position.copy(entity.world_position.val);
+    mesh.rotation.copy(entity.world_rotation.val);
 
     return mesh;
 }

src/quest_editor/stores/QuestEditorStore.ts

@@ -12,7 +12,6 @@ import { AreaModel } from "../model/AreaModel";
 import { area_store } from "./AreaStore";
 import { SectionModel } from "../model/SectionModel";
 import { QuestEntityModel } from "../model/QuestEntityModel";
-import { Vec3 } from "../../core/data_formats/vector";
 import { Disposable } from "../../core/observable/Disposable";
 import { Disposer } from "../../core/observable/Disposer";
 import { gui_store, GuiTool } from "../../core/stores/GuiStore";
@@ -26,6 +25,9 @@ import { Episode } from "../../core/data_formats/parsing/quest/Episode";
 import { create_new_quest } from "./quest_creation";
 import { CreateEntityAction } from "../actions/CreateEntityAction";
 import { RemoveEntityAction } from "../actions/RemoveEntityAction";
+import { Euler, Vector3 } from "three";
+import { vec3_to_threejs } from "../../core/rendering/conversion";
+import { RotateEntityAction } from "../actions/RotateEntityAction";
 import Logger = require("js-logger");
 
 const logger = Logger.get("quest_editor/gui/QuestEditorStore");
@@ -125,8 +127,13 @@ export class QuestEditorStore implements Disposable {
                                     obj.group_id,
                                     obj.area_id,
                                     obj.section_id,
-                                    obj.position,
-                                    obj.rotation,
+                                    vec3_to_threejs(obj.position),
+                                    new Euler(
+                                        obj.rotation.x,
+                                        obj.rotation.y,
+                                        obj.rotation.z,
+                                        "ZXY",
+                                    ),
                                     obj.properties,
                                     obj.unknown,
                                 ),
@@ -141,9 +148,14 @@ export class QuestEditorStore implements Disposable {
                                     npc.pso_roaming,
                                     npc.area_id,
                                     npc.section_id,
-                                    npc.position,
-                                    npc.rotation,
-                                    npc.scale,
+                                    vec3_to_threejs(npc.position),
+                                    new Euler(
+                                        npc.rotation.x,
+                                        npc.rotation.y,
+                                        npc.rotation.z,
+                                        "ZXY",
+                                    ),
+                                    vec3_to_threejs(npc.scale),
                                     npc.unknown,
                                 ),
                         ),
@@ -253,8 +265,8 @@ export class QuestEditorStore implements Disposable {
         entity: QuestEntityModel,
         old_section: SectionModel | undefined,
         new_section: SectionModel | undefined,
-        old_position: Vec3,
-        new_position: Vec3,
+        old_position: Vector3,
+        new_position: Vector3,
         world: boolean,
     ) => {
         this.undo
@@ -271,6 +283,15 @@ export class QuestEditorStore implements Disposable {
             .redo();
     };
 
+    rotate_entity = (
+        entity: QuestEntityModel,
+        old_rotation: Euler,
+        new_rotation: Euler,
+        world: boolean,
+    ) => {
+        this.undo.push(new RotateEntityAction(entity, old_rotation, new_rotation, world)).redo();
+    };
+
     push_create_entity_action = (entity: QuestEntityModel) => {
         this.undo.push(new CreateEntityAction(entity));
     };

src/quest_editor/stores/quest_creation.ts

@@ -3,10 +3,10 @@ import { QuestModel } from "../model/QuestModel";
 import { Instruction, SegmentType } from "../scripting/instructions";
 import { ObjectType } from "../../core/data_formats/parsing/quest/object_types";
 import { NpcType } from "../../core/data_formats/parsing/quest/npc_types";
-import { Vec3 } from "../../core/data_formats/vector";
 import { Opcode } from "../scripting/opcodes";
 import { QuestObjectModel } from "../model/QuestObjectModel";
 import { QuestNpcModel } from "../model/QuestNpcModel";
+import { Euler, Vector3 } from "three";
 
 export function create_new_quest(episode: Episode): QuestModel {
     if (episode === Episode.II) throw new Error("Episode II not yet supported.");
@@ -89,8 +89,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(-16.313568115234375, 3, -579.5118408203125),
-            new Vec3(0.0009587526218325454, 0, 0),
+            new Vector3(-16.313568115234375, 3, -579.5118408203125),
+            new Euler(0.0009587526218325454, 0, 0, "ZXY"),
             new Map([
                 ["property_0", 1],
                 ["property_1", 1],
@@ -108,8 +108,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(-393.07318115234375, 10, -12.964752197265625),
-            new Vec3(0, 0, 0),
+            new Vector3(-393.07318115234375, 10, -12.964752197265625),
+            new Euler(0, 0, 0, "ZXY"),
             new Map([
                 ["property_0", 9.183549615799121e-41],
                 ["property_1", 1.0000011920928955],
@@ -127,8 +127,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(-458.60699462890625, 10, -51.270660400390625),
-            new Vec3(0, 0, 0),
+            new Vector3(-458.60699462890625, 10, -51.270660400390625),
+            new Euler(0, 0, 0, "ZXY"),
             new Map([
                 ["property_0", 1],
                 ["property_1", 1],
@@ -146,8 +146,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(-430.19696044921875, 10, -24.490447998046875),
-            new Vec3(0, 0, 0),
+            new Vector3(-430.19696044921875, 10, -24.490447998046875),
+            new Euler(0, 0, 0, "ZXY"),
             new Map([
                 ["property_0", 1],
                 ["property_1", 1],
@@ -165,8 +165,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(0.995330810546875, 0, -37.0010986328125),
-            new Vec3(0, 4.712460886831327, 0),
+            new Vector3(0.995330810546875, 0, -37.0010986328125),
+            new Euler(0, 4.712460886831327, 0, "ZXY"),
             new Map([
                 ["property_0", 0],
                 ["property_1", 1],
@@ -184,8 +184,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(3.0009307861328125, 0, -23.99688720703125),
-            new Vec3(0, 4.859725289544806, 0),
+            new Vector3(3.0009307861328125, 0, -23.99688720703125),
+            new Euler(0, 4.859725289544806, 0, "ZXY"),
             new Map([
                 ["property_0", 1.000000238418579],
                 ["property_1", 1],
@@ -203,8 +203,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(2.0015106201171875, 0, -50.00386047363281),
-            new Vec3(0, 4.565196484117848, 0),
+            new Vector3(2.0015106201171875, 0, -50.00386047363281),
+            new Euler(0, 4.565196484117848, 0, "ZXY"),
             new Map([
                 ["property_0", 2.000002384185791],
                 ["property_1", 1],
@@ -222,8 +222,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(4.9973907470703125, 0, -61.99664306640625),
-            new Vec3(0, 4.368843947166543, 0),
+            new Vector3(4.9973907470703125, 0, -61.99664306640625),
+            new Euler(0, 4.368843947166543, 0, "ZXY"),
             new Map([
                 ["property_0", 3.0000007152557373],
                 ["property_1", 1],
@@ -241,8 +241,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(132.00314331054688, 1.000000238418579, -265.002197265625),
-            new Vec3(0, 0.49088134237826325, 0),
+            new Vector3(132.00314331054688, 1.000000238418579, -265.002197265625),
+            new Euler(0, 0.49088134237826325, 0, "ZXY"),
             new Map([
                 ["property_0", 1.000000238418579],
                 ["property_1", 1],
@@ -260,8 +260,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(-228, 0, -2020.99951171875),
-            new Vec3(0, 2.9452880542695796, 0),
+            new Vector3(-228, 0, -2020.99951171875),
+            new Euler(0, 2.9452880542695796, 0, "ZXY"),
             new Map([
                 ["property_0", -10.000004768371582],
                 ["property_1", 0],
@@ -279,8 +279,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(-41.000030517578125, 0, 42.37322998046875),
-            new Vec3(0, 0, 0),
+            new Vector3(-41.000030517578125, 0, 42.37322998046875),
+            new Euler(0, 0, 0, "ZXY"),
             new Map([
                 ["property_0", 1],
                 ["property_1", 1],
@@ -298,8 +298,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(-479.21673583984375, 8.781256675720215, -322.465576171875),
-            new Vec3(6.28328118244177, 0.0009587526218325454, 0),
+            new Vector3(-479.21673583984375, 8.781256675720215, -322.465576171875),
+            new Euler(6.28328118244177, 0.0009587526218325454, 0, "ZXY"),
             new Map([
                 ["property_0", 1],
                 ["property_1", 1],
@@ -317,8 +317,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(-228, 0, -351.0015869140625),
-            new Vec3(0, 0, 0),
+            new Vector3(-228, 0, -351.0015869140625),
+            new Euler(0, 0, 0, "ZXY"),
             new Map([
                 ["property_0", 10.000006675720215],
                 ["property_1", 0],
@@ -336,8 +336,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(-561.88232421875, 0, -406.8829345703125),
-            new Vec3(0, 0, 0),
+            new Vector3(-561.88232421875, 0, -406.8829345703125),
+            new Euler(0, 0, 0, "ZXY"),
             new Map([
                 ["property_0", 1],
                 ["property_1", 1],
@@ -355,8 +355,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(-547.8557739257812, 0, -444.8822326660156),
-            new Vec3(0, 0, 0),
+            new Vector3(-547.8557739257812, 0, -444.8822326660156),
+            new Euler(0, 0, 0, "ZXY"),
             new Map([
                 ["property_0", 1],
                 ["property_1", 1],
@@ -374,8 +374,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(-486.441650390625, 0, -497.4501647949219),
-            new Vec3(0, 0, 0),
+            new Vector3(-486.441650390625, 0, -497.4501647949219),
+            new Euler(0, 0, 0, "ZXY"),
             new Map([
                 ["property_0", 9.183549615799121e-41],
                 ["property_1", 1.0000011920928955],
@@ -393,8 +393,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(-522.4052734375, 0, -474.1882629394531),
-            new Vec3(0, 0, 0),
+            new Vector3(-522.4052734375, 0, -474.1882629394531),
+            new Euler(0, 0, 0, "ZXY"),
             new Map([
                 ["property_0", 1],
                 ["property_1", 1],
@@ -412,8 +412,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(-34.49853515625, 0, -384.4951171875),
-            new Vec3(0, 5.497871034636549, 0),
+            new Vector3(-34.49853515625, 0, -384.4951171875),
+            new Euler(0, 5.497871034636549, 0, "ZXY"),
             new Map([
                 ["property_0", 3.0000007152557373],
                 ["property_1", 1],
@@ -431,8 +431,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(-393.0031433105469, 0, -143.49981689453125),
-            new Vec3(0, 3.141640591220885, 0),
+            new Vector3(-393.0031433105469, 0, -143.49981689453125),
+            new Euler(0, 3.141640591220885, 0, "ZXY"),
             new Map([
                 ["property_0", 3.0000007152557373],
                 ["property_1", 1],
@@ -450,8 +450,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(-355.17462158203125, 0, -43.15193176269531),
-            new Vec3(0, 0, 0),
+            new Vector3(-355.17462158203125, 0, -43.15193176269531),
+            new Euler(0, 0, 0, "ZXY"),
             new Map([
                 ["property_0", 1.000000238418579],
                 ["property_1", 1],
@@ -469,8 +469,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(-43.00239562988281, 0, -118.00120544433594),
-            new Vec3(0, 3.141640591220885, 0),
+            new Vector3(-43.00239562988281, 0, -118.00120544433594),
+            new Euler(0, 3.141640591220885, 0, "ZXY"),
             new Map([
                 ["property_0", 3.0000007152557373],
                 ["property_1", 1],
@@ -488,8 +488,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(26.000823974609375, 0, -265.99810791015625),
-            new Vec3(0, 3.141640591220885, 0),
+            new Vector3(26.000823974609375, 0, -265.99810791015625),
+            new Euler(0, 3.141640591220885, 0, "ZXY"),
             new Map([
                 ["property_0", 3.0000007152557373],
                 ["property_1", 1],
@@ -507,8 +507,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(57.81005859375, 0, -268.5472412109375),
-            new Vec3(0, 4.712460886831327, 0),
+            new Vector3(57.81005859375, 0, -268.5472412109375),
+            new Euler(0, 4.712460886831327, 0, "ZXY"),
             new Map([
                 ["property_0", 0],
                 ["property_1", 1],
@@ -526,8 +526,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(66.769287109375, 0, -252.3748779296875),
-            new Vec3(0, 4.712460886831327, 0),
+            new Vector3(66.769287109375, 0, -252.3748779296875),
+            new Euler(0, 4.712460886831327, 0, "ZXY"),
             new Map([
                 ["property_0", 1.000000238418579],
                 ["property_1", 1],
@@ -545,8 +545,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(67.36819458007812, 0, -284.9297180175781),
-            new Vec3(0, 4.712460886831327, 0),
+            new Vector3(67.36819458007812, 0, -284.9297180175781),
+            new Euler(0, 4.712460886831327, 0, "ZXY"),
             new Map([
                 ["property_0", 2.000000476837158],
                 ["property_1", 1],
@@ -564,8 +564,8 @@ function create_default_objects(): QuestObjectModel[] {
             0,
             0,
             10,
-            new Vec3(77.10488891601562, 0, -269.2830505371094),
-            new Vec3(0, 4.712460886831327, 0),
+            new Vector3(77.10488891601562, 0, -269.2830505371094),
+            new Euler(0, 4.712460886831327, 0, "ZXY"),
             new Map([
                 ["property_0", 3.0000007152557373],
                 ["property_1", 1],
@@ -590,9 +590,9 @@ function create_default_npcs(): QuestNpcModel[] {
             0,
             0,
             10,
-            new Vec3(-49.0010986328125, 0, 50.996429443359375),
-            new Vec3(0, 2.3562304434156633, 0),
-            new Vec3(0, 0, 0),
+            new Vector3(-49.0010986328125, 0, 50.996429443359375),
+            new Euler(0, 2.3562304434156633, 0, "ZXY"),
+            new Vector3(0, 0, 0),
             [[0, 0, 7, 86, 0, 0, 0, 0, 23, 87], [0, 0, 0, 0, 0, 0], [128, 238, 223, 176]],
         ),
         new QuestNpcModel(
@@ -603,9 +603,9 @@ function create_default_npcs(): QuestNpcModel[] {
             1,
             0,
             20,
-            new Vec3(167.99769592285156, 0, 83.99686431884766),
-            new Vec3(0, 3.927050739026106, 0),
-            new Vec3(24.000009536743164, 0, 0),
+            new Vector3(167.99769592285156, 0, 83.99686431884766),
+            new Euler(0, 3.927050739026106, 0, "ZXY"),
+            new Vector3(24.000009536743164, 0, 0),
             [[0, 0, 7, 88, 0, 0, 0, 0, 23, 89], [0, 0, 0, 0, 0, 0], [128, 238, 232, 48]],
         ),
         new QuestNpcModel(
@@ -616,9 +616,9 @@ function create_default_npcs(): QuestNpcModel[] {
             1,
             0,
             20,
-            new Vec3(156.0028839111328, 0, -49.99967575073242),
-            new Vec3(0, 5.497871034636549, 0),
-            new Vec3(30.000009536743164, 0, 0),
+            new Vector3(156.0028839111328, 0, -49.99967575073242),
+            new Euler(0, 5.497871034636549, 0, "ZXY"),
+            new Vector3(30.000009536743164, 0, 0),
             [[0, 0, 7, 89, 0, 0, 0, 0, 23, 90], [0, 0, 0, 0, 0, 0], [128, 238, 236, 176]],
         ),
         new QuestNpcModel(
@@ -629,9 +629,9 @@ function create_default_npcs(): QuestNpcModel[] {
             0,
             0,
             20,
-            new Vec3(237.9988250732422, 0, -14.0001220703125),
-            new Vec3(0, 5.497871034636549, 0),
-            new Vec3(0, 0, 0),
+            new Vector3(237.9988250732422, 0, -14.0001220703125),
+            new Euler(0, 5.497871034636549, 0, "ZXY"),
+            new Vector3(0, 0, 0),
             [[0, 0, 7, 90, 0, 0, 0, 0, 23, 91], [0, 0, 0, 0, 0, 0], [128, 238, 241, 48]],
         ),
         new QuestNpcModel(
@@ -642,9 +642,9 @@ function create_default_npcs(): QuestNpcModel[] {
             0,
             0,
             20,
-            new Vec3(238.00379943847656, 0, 63.00413513183594),
-            new Vec3(0, 3.927050739026106, 0),
-            new Vec3(0, 0, 0),
+            new Vector3(238.00379943847656, 0, 63.00413513183594),
+            new Euler(0, 3.927050739026106, 0, "ZXY"),
+            new Vector3(0, 0, 0),
             [[0, 0, 7, 91, 0, 0, 0, 0, 23, 92], [0, 0, 0, 0, 0, 0], [128, 238, 245, 176]],
         ),
         new QuestNpcModel(
@@ -655,9 +655,9 @@ function create_default_npcs(): QuestNpcModel[] {
             1,
             0,
             20,
-            new Vec3(-2.001882553100586, 0, 35.0036506652832),
-            new Vec3(0, 3.141640591220885, 0),
-            new Vec3(26.000009536743164, 0, 0),
+            new Vector3(-2.001882553100586, 0, 35.0036506652832),
+            new Euler(0, 3.141640591220885, 0, "ZXY"),
+            new Vector3(26.000009536743164, 0, 0),
             [[0, 0, 7, 92, 0, 0, 0, 0, 23, 93], [0, 0, 0, 0, 0, 0], [128, 238, 250, 48]],
         ),
         new QuestNpcModel(
@@ -668,9 +668,9 @@ function create_default_npcs(): QuestNpcModel[] {
             1,
             0,
             20,
-            new Vec3(-147.0000457763672, 0, -7.996537208557129),
-            new Vec3(0, 2.577127047485882, 0),
-            new Vec3(30.000009536743164, 0, 0),
+            new Vector3(-147.0000457763672, 0, -7.996537208557129),
+            new Euler(0, 2.577127047485882, 0, "ZXY"),
+            new Vector3(30.000009536743164, 0, 0),
             [[0, 0, 7, 93, 0, 0, 0, 0, 23, 94], [0, 0, 0, 0, 0, 0], [128, 238, 254, 176]],
         ),
         new QuestNpcModel(
@@ -681,9 +681,9 @@ function create_default_npcs(): QuestNpcModel[] {
             1,
             0,
             20,
-            new Vec3(-219.99710083007812, 0, -100.0008316040039),
-            new Vec3(0, 0, 0),
-            new Vec3(30.000011444091797, 0, 0),
+            new Vector3(-219.99710083007812, 0, -100.0008316040039),
+            new Euler(0, 0, 0, "ZXY"),
+            new Vector3(30.000011444091797, 0, 0),
             [[0, 0, 7, 94, 0, 0, 0, 0, 23, 95], [0, 0, 0, 0, 0, 0], [128, 239, 3, 48]],
         ),
         new QuestNpcModel(
@@ -694,9 +694,9 @@ function create_default_npcs(): QuestNpcModel[] {
             0,
             0,
             20,
-            new Vec3(-262.5099792480469, 0, -24.53999900817871),
-            new Vec3(0, 1.963525369513053, 0),
-            new Vec3(0, 0, 0),
+            new Vector3(-262.5099792480469, 0, -24.53999900817871),
+            new Euler(0, 1.963525369513053, 0, "ZXY"),
+            new Vector3(0, 0, 0),
             [[0, 0, 7, 95, 0, 0, 0, 0, 23, 106], [0, 0, 0, 0, 0, 0], [128, 239, 100, 192]],
         ),
         new QuestNpcModel(
@@ -707,9 +707,9 @@ function create_default_npcs(): QuestNpcModel[] {
             0,
             0,
             30,
-            new Vec3(-43.70983123779297, 2.5999999046325684, -52.78248596191406),
-            new Vec3(0, 0.7854101478052212, 0),
-            new Vec3(0, 0, 0),
+            new Vector3(-43.70983123779297, 2.5999999046325684, -52.78248596191406),
+            new Euler(0, 0.7854101478052212, 0, "ZXY"),
+            new Vector3(0, 0, 0),
             [[0, 0, 7, 97, 0, 0, 0, 0, 23, 98], [0, 0, 0, 0, 0, 0], [128, 239, 16, 176]],
         ),
         new QuestNpcModel(
@@ -720,9 +720,9 @@ function create_default_npcs(): QuestNpcModel[] {
             0,
             0,
             30,
-            new Vec3(0.33990478515625, 2.5999999046325684, -84.71995544433594),
-            new Vec3(0, 0, 0),
-            new Vec3(0, 0, 0),
+            new Vector3(0.33990478515625, 2.5999999046325684, -84.71995544433594),
+            new Euler(0, 0, 0, "ZXY"),
+            new Vector3(0, 0, 0),
             [[0, 0, 7, 98, 0, 0, 0, 0, 23, 99], [0, 0, 0, 0, 0, 0], [128, 239, 21, 48]],
         ),
         new QuestNpcModel(
@@ -733,9 +733,9 @@ function create_default_npcs(): QuestNpcModel[] {
             0,
             0,
             30,
-            new Vec3(43.87113952636719, 2.5999996662139893, -74.80299377441406),
-            new Vec3(0, -0.5645135437350027, 0),
-            new Vec3(0, 0, 0),
+            new Vector3(43.87113952636719, 2.5999996662139893, -74.80299377441406),
+            new Euler(0, -0.5645135437350027, 0, "ZXY"),
+            new Vector3(0, 0, 0),
             [[0, 0, 7, 99, 0, 0, 0, 0, 23, 100], [0, 0, 0, 0, 0, 0], [128, 239, 25, 176]],
         ),
         new QuestNpcModel(
@@ -746,9 +746,9 @@ function create_default_npcs(): QuestNpcModel[] {
             0,
             0,
             30,
-            new Vec3(75.88380432128906, 2.5999996662139893, -42.69328308105469),
-            new Vec3(0, -1.0308508189943528, 0),
-            new Vec3(0, 0, 0),
+            new Vector3(75.88380432128906, 2.5999996662139893, -42.69328308105469),
+            new Euler(0, -1.0308508189943528, 0, "ZXY"),
+            new Vector3(0, 0, 0),
             [[0, 0, 7, 100, 0, 0, 0, 0, 23, 101], [0, 0, 0, 0, 0, 0], [128, 239, 30, 48]],
         ),
         new QuestNpcModel(
@@ -759,9 +759,9 @@ function create_default_npcs(): QuestNpcModel[] {
             1,
             0,
             30,
-            new Vec3(16.003997802734375, 0, 5.995697021484375),
-            new Vec3(0, -1.1781152217078317, 0),
-            new Vec3(22.000009536743164, 0, 0),
+            new Vector3(16.003997802734375, 0, 5.995697021484375),
+            new Euler(0, -1.1781152217078317, 0, "ZXY"),
+            new Vector3(22.000009536743164, 0, 0),
             [[0, 0, 7, 101, 0, 0, 0, 0, 23, 102], [0, 0, 0, 0, 0, 0], [128, 239, 34, 176]],
         ),
         new QuestNpcModel(
@@ -772,9 +772,9 @@ function create_default_npcs(): QuestNpcModel[] {
             0,
             0,
             40,
-            new Vec3(0.3097381591796875, 3, -105.3865966796875),
-            new Vec3(0, 0, 0),
-            new Vec3(0, 0, 0),
+            new Vector3(0.3097381591796875, 3, -105.3865966796875),
+            new Euler(0, 0, 0, "ZXY"),
+            new Vector3(0, 0, 0),
             [[0, 0, 7, 102, 0, 0, 0, 0, 23, 103], [0, 0, 0, 0, 0, 0], [128, 239, 39, 48]],
         ),
         new QuestNpcModel(
@@ -785,9 +785,9 @@ function create_default_npcs(): QuestNpcModel[] {
             1,
             0,
             40,
-            new Vec3(53.499176025390625, 0, -26.496688842773438),
-            new Vec3(0, 5.497871034636549, 0),
-            new Vec3(18.000009536743164, 0, 0),
+            new Vector3(53.499176025390625, 0, -26.496688842773438),
+            new Euler(0, 5.497871034636549, 0, "ZXY"),
+            new Vector3(18.000009536743164, 0, 0),
             [[0, 0, 7, 103, 0, 0, 0, 0, 23, 104], [0, 0, 0, 0, 0, 0], [128, 239, 43, 176]],
         ),
     ];