# The contents of this file are subject to the Common Public Attribution License
# Version 1.0 (the “License”); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
# https://myou.dev/licenses/LICENSE-CPAL. The License is based on the Mozilla
# Public License Version 1.1 but Sections 14 and 15 have been added to cover use
# of software over a computer network and provide for limited attribution for
# the Original Developer. In addition, Exhibit A has been modified to be
# consistent with Exhibit B.
#
# Software distributed under the License is distributed on an “AS IS” basis,
# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
# the specific language governing rights and limitations under the License.
#
# The Original Code is Myou Engine.
#
# the Original Developer is the Initial Developer.
#
# The Initial Developer of the Original Code is the Myou Engine developers.
# All portions of the code written by the Myou Engine developers are Copyright
# (c) 2024. All Rights Reserved.
#
# Alternatively, the contents of this file may be used under the terms of the
# GNU Affero General Public License version 3 (the [AGPL-3] License), in which
# case the provisions of [AGPL-3] License are applicable instead of those above.
#
# If you wish to allow use of your version of this file only under the terms of
# the [AGPL-3] License and not to allow others to use your version of this file
# under the CPAL, indicate your decision by deleting the provisions above and
# replace them with the notice and other provisions required by the [AGPL-3]
# License. If you do not delete the provisions above, a recipient may use your
# version of this file under either the CPAL or the [AGPL-3] License.

import ../types
import vmath except Quat, quat
import ../quat

when defined(nimdoc):
    type TYPES* = ObjectType | GameObject

# Forward declarations and ob type methods
proc initGameObject*(self: GameObject, engine: MyouEngine, name: string="", scene: Scene=nil): GameObject
proc newGameObject*(engine: MyouEngine, name: string="", scene: Scene=nil): GameObject
proc show*(self: GameObject, recursive: static[bool] = true)
proc hide*(self: GameObject, recursive: static[bool] = true)
proc set_visibility*(self: GameObject, visible: bool, recursive: static[bool] = true)
proc update_matrices*(self: GameObject)
proc update_matrices_recursive(self: GameObject)
proc set_rotation_order*(self: GameObject, order: RotationOrder)
proc get_world_matrix*(self: GameObject): Mat4
proc get_local_matrix*(self: GameObject): Mat4
proc get_world_position*(self: GameObject): Vec3
proc get_world_rotation*(self: GameObject): Quat
proc get_world_position_rotation*(self: GameObject): (Vec3, Quat)
proc translate*(self: GameObject, vector: Vec3, relative_object: GameObject=nil): GameObject {.discardable.}
proc translate_x*(self: GameObject, x: SomeFloat, relative_object: GameObject=nil): GameObject {.discardable.}
proc translate_y*(self: GameObject, y: SomeFloat, relative_object: GameObject=nil): GameObject {.discardable.}
proc translate_z*(self: GameObject, z: SomeFloat, relative_object: GameObject=nil): GameObject {.discardable.}
proc rotate_quat*(self: GameObject, q: Quat, relative_object: GameObject=nil): GameObject {.discardable.}
proc rotate_x*(self: GameObject, angle: SomeFloat, relative_object: GameObject=nil)
proc rotate_y*(self: GameObject, angle: SomeFloat, relative_object: GameObject=nil)
proc rotate_z*(self: GameObject, angle: SomeFloat, relative_object: GameObject=nil)
proc rotate_x_deg*(self: GameObject, angle: SomeFloat, relative_object: GameObject=nil)
proc rotate_y_deg*(self: GameObject, angle: SomeFloat, relative_object: GameObject=nil)
proc rotate_z_deg*(self: GameObject, angle: SomeFloat, relative_object: GameObject=nil)
proc set_world_position_rotation*(
        self: GameObject,
        position: Vec3,
        rotation: Quat)
proc set_world_position*(self: GameObject, position: Vec3)
proc set_world_rotation*(self: GameObject, rotation: Quat)
proc clone*(self: GameObject, 
        recursive: bool=true,
        with_behaviours: bool=true,
        name: string=self.name,
        new_parent: GameObject=self.parent,
        scene: Scene=self.scene,
        instance_body: bool=true
    ): GameObject
proc clone_impl*(self: GameObject, n: var GameObject, recursive: bool,
        with_behaviours: bool, name: string, new_parent: GameObject,
        scene: Scene, instance_body: bool): GameObject
proc set_parent*(self: GameObject, parent: GameObject, keep_transform: bool=true)
proc parent_to*(self: GameObject, parent: GameObject, keep_transform: bool=true)
proc clear_parent*(self: GameObject, keep_transform: bool=true)
proc get_top_ancestor*(self: GameObject, top_level_parents: seq[GameObject] = @[]): GameObject
proc remove*(self: GameObject, recursive: bool = true)
proc destroy*(self: GameObject, recursive: bool = true)
proc convert_bone_child_to_bone_parent*(self: GameObject)
proc get_local_X_vector*(self: GameObject): Vec3
proc get_local_Y_vector*(self: GameObject): Vec3
proc get_local_Z_vector*(self: GameObject): Vec3
proc get_world_X_vector*(self: GameObject): Vec3
proc get_world_Y_vector*(self: GameObject): Vec3
proc get_world_Z_vector*(self: GameObject): Vec3
proc get_local_dimensions*(self: GameObject): Vec3
proc get_world_dimensions*(self: GameObject): Vec3
proc get_world_scale*(self: GameObject): float
proc get_world_scale_vector*(self: GameObject): Vec3
proc get_local_size*(self: GameObject): float
proc set_local_size*(self: GameObject, size: SomeFloat)
proc get_world_size*(self: GameObject): float
proc set_world_size*(self: GameObject, size: SomeFloat)
proc set_name*(self: GameObject, name: string)
proc local_to_world*(self: GameObject, point: Vec3): Vec3
proc world_to_local*(self: GameObject, point: Vec3): Vec3
# End forward declarations

import json
import std/math
import std/tables
import ../incomplete
import ../util
import ../graphics/ubo
import ../scene
import ./mesh
import ./armature

proc initGameObject*(self: GameObject, engine: MyouEngine, name: string="", scene: Scene=nil): GameObject =
    # Remember to add any new mutable reference to clone()
    self.engine = engine
    self.name = name
    self.rotation.quat = quat()
    self.rotation_order = EulerXYZ
    self.scale = vec3(1, 1, 1)
    self.object_color = vec4(1, 1, 1, 1)
    # self.alpha = 1
    self.visible = true
    self.auto_update_matrix = true
    self.world_matrix = mat4()
    self.bone_matrix_inverse = mat4()
    self.parent_bone_index = -1
    self.zindex = 1 # ??
    self.world_center = vec4(0, 0, 0, 1)
    self.sqscale = 1
    self.object_render_ubo = self.engine.newUBO("ObjectRenderUniform", ObjectRenderUniform, 1)
    self.object_ubo = self.engine.newUBO("ObjectUniform", ObjectUniform, 1)
    # self.camera_render_ubo = self.engine.newUBO("CameraRenderUniform", CameraRenderUniform, 1)
    if scene != nil:
        scene.add_object(self, name=name)
    return self

proc newGameObject*(engine: MyouEngine, name: string="", scene: Scene=nil): GameObject =
    ## Create a new GameObject. If you supply `scene` it will be added to that
    ## scene.
    new(result)
    return initGameObject(result, engine, name, scene)

proc show*(self: GameObject, recursive: static[bool] = true) =
    ## Enable visibility of the object, its children, their children and so on.
    ## If you set `recursive = false`, only the visibility of the object will be
    ## changed.
    self.visible = true
    when recursive:
        for c in self.children:
            c.show(recursive)

proc hide*(self: GameObject, recursive: static[bool] = true) =
    ## Disable visibility of the object, its children, their children and so on.
    ## If you set `recursive = false`, only the visibility of the object will be
    ## changed.
    self.visible = false
    when recursive:
        for c in self.children:
            c.hide(recursive)

proc set_visibility*(self: GameObject, visible: bool, recursive: static[bool] = true) =
    ## Set the visibility of the object and its descendants to the value of the
    ## argument `visible`. If you set `recursive = false`, only the visibility of
    ## the object will be changed.
    if visible: self.show(recursive)
    else: self.hide(recursive)

proc update_matrices*(self: GameObject) =
    ## Calculate the matrices of the object from its position, rotation, scale,
    ## and parent matrix. It assumes the parent object and/or bone has its world
    ## matrix already up to date.
    var q = if self.rotation_order == Quaternion:
        self.rotation.quat
    else:
        to_quat(self.rotation.euler, self.rotation_order)
    # var q = self.rotation
    q = normalize(q)
    let (x,y,z,w) = q.toTuple
    let scl = self.scale
    self.flip = false
    self.sqscale = length_sq(scl)
    if self.parent != nil:
        self.flip = self.parent.flip
        self.sqscale *= self.parent.sqscale
    if scl.x * scl.y * scl.z < 0:
        self.flip = not self.flip
    let pos = self.position
    var wm = mat4(
        (w * w + x * x - y * y - z * z) * scl.x,
        (2 * (x * y + z * w)) * scl.x,
        (2 * (x * z - y * w)) * scl.x,
        0.0,
        (2 * (x * y - z * w)) * scl.y,
        (w * w - x * x + y * y - z * z) * scl.y,
        (2 * (z * y + x * w)) * scl.y,
        0.0,
        (2 * (x * z + y * w)) * scl.z,
        (2 * (y * z - x * w)) * scl.z,
        (w * w - x * x - y * y + z * z) * scl.z,
        0.0,
        pos.x,
        pos.y,
        pos.z,
        1.0
    )
    if self.parent != nil:
        wm = self.matrix_parent_inverse * wm
        var bi = self.parent_bone_index
        if bi >= 0:
            let bone = self.parent.get_armature.bone_list[bi]
            # In Blender, matrix_parent_inverse is relative to the
            # TIP of the bone, while bone.matrix is relative to the BASE
            # so we need to add the bone length
            wm[3,1] = wm[3,1] + bone.blength
            self.world_matrix = bone.matrix * self.world_matrix
        wm = self.parent.world_matrix * wm
    self.world_matrix = wm
    self.world_center.xyz = wm * self.center
    return

proc update_matrices_recursive(self: GameObject) =
    ## Calculate the matrices of the object from its position, rotation, scale,
    ## and parent. It will update the parent matrices first if it has a parent.
    if self != nil:
        self.parent.update_matrices_recursive()
        self.update_matrices()

proc set_rotation_order*(self: GameObject, order: RotationOrder) =
    ## Change the rotation mode and order of the object.
    if order == self.rotation_order:
        return
    var q = if self.rotation_order != Quaternion:
        self.rotation.euler.to_quat(self.rotation_order)
    else:
        self.rotation.quat
    self.rotation = case order:
        of Quaternion: Rotation(quat: q)
        of EulerXYZ: Rotation(euler: q.to_euler_XYZ)
        of EulerXZY: Rotation(euler: q.to_euler_XZY)
        of EulerYXZ: Rotation(euler: q.to_euler_YXZ)
        of EulerYZX: Rotation(euler: q.to_euler_YZX)
        of EulerZXY: Rotation(euler: q.to_euler_ZXY)
        of EulerZYX: Rotation(euler: q.to_euler_ZYX)
        of AxisAngle:
            raise newException(ValueError, "axis angle not supported yet")
    self.rotation_order = order

proc get_world_matrix*(self: GameObject): Mat4 =
    ## Calculates and returns the world matrix.
    # TODO: use dirty flag
    self.update_matrices_recursive()
    return self.world_matrix

proc get_local_matrix*(self: GameObject): Mat4 =
    ## Calculates and returns the transformation matrix in local space. If the
    ## object has no parent, this is equivalent to the world matrix.
    var q = if self.rotation_order == Quaternion:
        self.rotation.quat
    else:
        to_quat(self.rotation.euler, self.rotation_order)
    q = normalize(q)
    var (x,y,z,w) = q.toTuple
    let scl = self.scale
    # TODO: test negative scales
    let pos = self.position
    return mat4(
        (w * w + x * x - y * y - z * z) * scl.x,
        (2 * (x * y + z * w)) * scl.x,
        (2 * (x * z - y * w)) * scl.x,
        0,
        (2 * (x * y - z * w)) * scl.y,
        (w * w - x * x + y * y - z * z) * scl.y,
        (2 * (z * y + x * w)) * scl.y,
        0,
        (2 * (x * z + y * w)) * scl.z,
        (2 * (y * z - x * w)) * scl.z,
        (w * w - x * x - y * y + z * z) * scl.z,
        0,
        pos.x,
        pos.y,
        pos.z,
        1
    )

proc get_world_position*(self: GameObject): Vec3 =
    ## Calculates and returns the position in world space.
    if self.parent == nil:
        return self.position
    return self.get_world_matrix[3].xyz

proc get_world_rotation*(self: GameObject): Quat =
    ## Calculates and returns the rotation in world space as a quaternion.
    let wm = self.get_world_matrix
    # TODO: Calculate rotation matrix more efficiently (dirty flag?)
    return wm.to_mat3_rotation.to_quat

proc get_world_position_rotation*(self: GameObject): (Vec3, Quat) =
    ## Calculates and returns the position and rotation in world space.
    let wm = self.get_world_matrix
    let position: Vec3 = wm[3].xyz
    # TODO: Calculate rotation matrix more efficiently (dirty flag?)
    # TODO: handle negative scales
    let rotation: Quat = wm.to_mat3_rotation.to_quat
    return (position, rotation)

proc translate*(self: GameObject, vector: Vec3, relative_object: GameObject=nil): GameObject {.discardable.} =
    ## Translate (move) the object by adding the vector `vector` to its position,
    ## either relative to the scene, or relative to the specified object in
    ## `relative_object`
    var vector = vector
    if relative_object != nil:
        vector = relative_object.get_world_rotation() * vector
    if self.parent != nil:
        let m = self.parent.get_world_matrix * self.matrix_parent_inverse
        vector = m.to_mat3_rotation.transpose * vector
    self.position = self.position + vector
    return self

proc translate_x*(self: GameObject, x: SomeFloat, relative_object: GameObject=nil): GameObject {.discardable.} =
    ## Translate (move) the object along the X axis of the scene, or the X axis
    ## of the specified object in `relative_object`
    return self.translate(vec3(x, 0, 0), relative_object)

proc translate_y*(self: GameObject, y: SomeFloat, relative_object: GameObject=nil): GameObject {.discardable.} =
    ## Translate (move) the object along the Y axis of the scene, or the Y axis
    ## of the specified object in `relative_object`
    return self.translate(vec3(0, y, 0), relative_object)

proc translate_z*(self: GameObject, z: SomeFloat, relative_object: GameObject=nil): GameObject {.discardable.} =
    ## Translate (move) the object along the Z axis of the scene, or the Z axis
    ## of the specified object in `relative_object`
    return self.translate(vec3(0, 0, z), relative_object)

# proc rotate_euler*(self: GameObject, vector: Vec3, relative_object: GameObject=nil): GameObject =
#     let q = fromEulerOrder(vector, order)
#     self.rotate_quat(q, relative_object)

# proc rotate_euler_deg*(self: GameObject, vector: Vec3, relative_object: GameObject=nil): GameObject =
#     let v = vector * 0.017453292519943295 # PI*2 / 360
#     let q = fromEulerOrder(v, order)
#     self.rotate_quat(q, relative_object)

proc rotate_quat*(self: GameObject, q: Quat, relative_object: GameObject=nil): GameObject {.discardable.} =
    # Rotate the object by applying (multiplying) the quaternion `q`, either
    # relative to the scene, or relative to the specified object in
    # `relative_object`

    # TODO: optimize (dirty flag?)
    var rel = quat()
    var inv_rel = quat()
    var par = quat()
    var inv_par = quat()
    if relative_object != nil:
        rel = relative_object.get_world_rotation
        inv_rel = inverse(rel)
    if self.parent != nil:
        var m = self.parent.get_world_matrix * self.matrix_parent_inverse
        par = m.to_mat3_rotation.to_quat
        inv_par = inverse(par)
    let rotation_order = self.rotation_order
    if rotation_order != Quaternion:
        self.set_rotation_order(Quaternion)
    self.rotation.quat = inv_par * rel * q * inv_rel * par * self.rotation.quat
    if rotation_order != Quaternion:
        self.set_rotation_order(rotation_order)
    return self

proc rotate_x*(self: GameObject, angle: SomeFloat, relative_object: GameObject=nil) =
    ## Rotate the object around the X axis of the scene, or the X axis of the
    ## specified object in `relative_object`. The angle is in radians.
    self.rotate_quat(rotateX(angle.float32).to_mat3.to_quat, relative_object)

proc rotate_y*(self: GameObject, angle: SomeFloat, relative_object: GameObject=nil) =
    ## Rotate the object around the Y axis of the scene, or the Y axis of the
    ## specified object in `relative_object`. The angle is in radians.
    self.rotate_quat(rotateY(angle.float32).to_mat3.to_quat, relative_object)

proc rotate_z*(self: GameObject, angle: SomeFloat, relative_object: GameObject=nil) =
    ## Rotate the object around the Z axis of the scene, or the Z axis of the
    ## specified object in `relative_object`. The angle is in radians.
    self.rotate_quat(rotateZ(angle.float32).to_mat3.to_quat, relative_object)

proc rotate_x_deg*(self: GameObject, angle: SomeFloat, relative_object: GameObject=nil) =
    ## Rotate the object around the X axis of the scene, or the X axis of the
    ## specified object in `relative_object`. The angle is in degrees.
    self.rotate_quat(rotateX(angle.float32.to_radians).to_mat3.to_quat, relative_object)

proc rotate_y_deg*(self: GameObject, angle: SomeFloat, relative_object: GameObject=nil) =
    ## Rotate the object around the Y axis of the scene, or the Y axis of the
    ## specified object in `relative_object`. The angle is in degrees.
    self.rotate_quat(rotateY(angle.float32.to_radians).to_mat3.to_quat, relative_object)

proc rotate_z_deg*(self: GameObject, angle: SomeFloat, relative_object: GameObject=nil) =
    ## Rotate the object around the Z axis of the scene, or the Z axis of the
    ## specified object in `relative_object`. The angle is in degrees.
    self.rotate_quat(rotateZ(angle.float32.to_radians).to_mat3.to_quat, relative_object)

proc set_world_position_rotation*(
        self: GameObject,
        position: Vec3,
        rotation: Quat) =
    ## Changes the position and the rotation of the object to match the supplied
    ## position and rotation in world space.

    if self.parent != nil:
        # TODO: optimize and use less memory?
        # TODO: does it work well with parents?
        let wm = inverse(self.parent.get_world_matrix * self.matrix_parent_inverse)
        self.position = wm * position
        self.rotation.quat = wm.to_mat3_rotation.to_quat * rotation
    else:
        self.position = position
        self.rotation.quat = rotation
    self.rotation_order = Quaternion

proc set_world_position*(self: GameObject, position: Vec3) =
    ## Changes the position of the object to match the supplied position in world
    ## space.
    self.set_world_position_rotation(position, self.get_world_rotation())

proc set_world_rotation*(self: GameObject, rotation: Quat) =
    ## Changes the rotation of the object to match the supplied rotation in world
    ## space.
    self.set_world_position_rotation(self.get_world_position(), rotation)

type LookAtAxis* = enum
    AxisX = 0
    AxisY
    AxisZ
    AxisMinusX
    AxisMinusY
    AxisMinusZ

proc clone*(self: GameObject, 
        recursive: bool=true,
        with_behaviours: bool=true,
        name: string=self.name,
        new_parent: GameObject=self.parent,
        scene: Scene=self.scene,
        instance_body: bool=true
    ): GameObject =
    ## Makes a clone of the object and its children (unless `recursive` is
    ## false).

    case self.otype:
    of TGameObject:
        var n = new GameObject
        n[] = self[]
        return self.clone_impl(n, recursive, with_behaviours, name, new_parent, scene, instance_body)
    of TMesh:
        var n = new Mesh
        var ob = cast[Mesh](self)
        n[] = ob[]
        discard self.clone_impl(n.GameObject, recursive, with_behaviours, name, new_parent, scene, instance_body)
        return ob.clone_impl(n)
    of TCamera:
        discard
    of TLight:
        discard
    of TArmature:
        discard
    
proc clone_impl*(self: GameObject, n: var GameObject, recursive: bool,
        with_behaviours: bool, name: string, new_parent: GameObject,
        scene: Scene, instance_body: bool): GameObject =

    n.children = @[]
    for k,v in n.properties.pairs:
        n.properties[k] = v.copy
    # n.behaviours = @[]

    # TODO: lods
    # TODO: physics version of a mesh
    
    if new_parent != nil:
        n.parent = new_parent
        n.parent.children.add(n)
    
    # self.body = self.body.clone # TODO

    n.scene = nil
    if scene != nil:
        scene.add_object(n, name=name)

    # Adding children afterwards ensures objects don't need to be sorted
    if recursive:
        for i,child in self.children:
            self.children[i] = child.clone(recursive, with_behaviours, name, new_parent=n, scene, instance_body=false)
        # TODO: instance children bodies
    return n

proc set_parent*(self: GameObject, parent: GameObject, keep_transform: bool=true) =
    ## Sets the parent of the object, while keeping the same transform in world
    ## space (unless you set `keep_transform` to false).
    
    # TODO: there should be no distinction between this and parent_to
    self.scene.make_parent(parent, self, keep_transform=keep_transform)

proc parent_to*(self: GameObject, parent: GameObject, keep_transform: bool=true) =
    ## Sets the parent of the object, while adding it to the same scene if
    ## needed, as well as keeping the same transform in world space (unless you
    ## set `keep_transform` to false).
    
    # TODO move this to make_parent
    if self.scene == nil:
        parent.scene.add_object(self)
    self.scene.make_parent(parent, self, keep_transform=keep_transform)

proc clear_parent*(self: GameObject, keep_transform: bool=true) =
    self.scene.clear_parent(self, keep_transform=keep_transform)

proc get_top_ancestor*(self: GameObject, top_level_parents: seq[GameObject] = @[]): GameObject =
    ## Find the topmost ancestor (e.g. parent of parent of parent...) or an 
    ## object contained in `top_level_parents`, whatever happens first.
    var ob = self
    while ob.parent != nil and ob.parent notin top_level_parents:
        ob = ob.parent
    return ob

iterator children_recursive*(self: GameObject, include_self: static[bool] = false): GameObject =
    ## Iterate all the descendants of the object, i.e. its children, the
    ## children's children an so on.

    # NOTE: This was written before the knowledge of closure iterators
    # (by default iterators are inline and don't allow recursion)
    when include_self:
        yield self
    var ob = self
    var stack: seq[int]
    var pos = 0
    var children = ob.children
    while true:
        while pos < children.len:
            let c = children[pos]
            yield c
            inc(pos)
            if c.children.len != 0:
                ob = c
                stack.add pos
                pos = 0
                children = c.children
        if stack.len != 0:
            ob = ob.parent
            pos = stack.pop()
            children = ob.children
        else:
            break

template children_recursive_and_self*(self: GameObject): GameObject =
    ## Iterate all the descendants of the object, and include itself in the
    ## iteration.
    children_recursive(self, include_self = true)

proc remove*(self: GameObject, recursive: bool = true) =
    ## Remove the object from the scene it is in, without destroying it.
    ## It will also remove its children unless you set `recursive` to false.
    if self.scene.nonNil:
        self.scene.remove_object(self, recursive)

proc destroy*(self: GameObject, recursive: bool = true) =
    ## Destroy the object and free all unused resources previously used by it.
    ## It will also destroy its children unless you set `recursive` to false.
    if self.is_mesh and self.get_mesh.data.nonNil:
        self.get_mesh.data.gpu_buffers_delete()
        self.get_mesh.materials.setLen 0
    self.body.destroy()
    self.remove(recursive)
    if recursive:
        for child in self.children:
            var child = child
            child.destroy(true)
    self.engine.objects.del(self.name)
    self.object_render_ubo.destroy()
    self.object_ubo.destroy()

proc convert_bone_child_to_bone_parent*(self: GameObject) =
    ## Turns an object that is parented to a bone, into the parent of the same
    ## bone. It disconnects the bone from its former parent, if any. Used
    ## internally to create ragdolls.
    assert self.parent == nil or self.parent.is_armature, "An armature parent is required"
    var parent = self.parent.get_armature
    if not (parent != nil and (self.parent_bone_index) >= 0):
        return
    var bone = parent.bone_list[self.parent_bone_index]
    self.parent = nil
    var m = self.matrix_parent_inverse * self.get_world_matrix
    m[3,1] = m[3,1] + bone.blength
    self.bone_matrix_inverse = inverse(m)
    self.parent = parent
    self.clear_parent()
    bone.parent_object = self

proc get_local_X_vector*(self: GameObject): Vec3 =
    ## Get the vector of the X axis of the object in local space.
    return self.get_local_matrix[0].xyz

proc get_local_Y_vector*(self: GameObject): Vec3 =
    ## Get the vector of the Y axis of the object in local space.
    return self.get_local_matrix[1].xyz

proc get_local_Z_vector*(self: GameObject): Vec3 =
    ## Get the vector of the Z axis of the object in local space.
    return self.get_local_matrix[2].xyz

proc get_world_X_vector*(self: GameObject): Vec3 =
    ## Get the vector of the X axis of the object in world space.
    return self.get_world_matrix[0].xyz

proc get_world_Y_vector*(self: GameObject): Vec3 =
    ## Get the vector of the Y axis of the object in world space.
    return self.get_world_matrix[1].xyz

proc get_world_Z_vector*(self: GameObject): Vec3 =
    ## Get the vector of the Z axis of the object in world space.
    return self.get_world_matrix[2].xyz

proc get_local_dimensions*(self: GameObject): Vec3 =
    ## Calculate the local dimensions of the object, i.e. the size of the
    ## bounding box with the scale of the object.
    let (a,b) = self.bound_box
    return (b-a) * self.scale

proc get_world_dimensions*(self: GameObject): Vec3 =
    ## Calculate the world dimensions of the object, i.e. the size of the
    ## bounding box in world scale.
    let (a,b) = self.bound_box
    return (b-a) * self.get_world_scale_vector

proc get_world_scale*(self: GameObject): float =
    # TODO: use the diagonal of a sphere instead?
    #       i.e. length((wm*vec3(1).normalize,0).xyz)
    var s = self.scale.z
    var p = self.parent
    while p != nil:
        s *= p.scale.z
        p = p.parent
    return s

proc get_world_scale_vector*(self: GameObject): Vec3 =
    ## Gets the world scale vector in local coordinates (i.e. relative to the
    ## current object orientation).
    let rotation = self.get_world_rotation
    let wm = self.world_matrix
    let rot_inv = inverse(rotation)
    var wm3 = wm.to_mat3
    let wm3_b = rot_inv.to_mat3
    wm3 = wm3_b * wm3
    return vec3(
        copy_sign(wm[0].xyz.length, wm3[0,0]), 
        copy_sign(wm[1].xyz.length, wm3[1,1]), 
        copy_sign(wm[2].xyz.length, wm3[2,2]), 
    )

proc get_local_size*(self: GameObject): float =
    ## Calculates the size of the largest dimension of the object in local
    ## coordinates.
    let d = self.get_local_dimensions()
    return max(max(d.x, d.y), d.z)

proc set_local_size*(self: GameObject, size: SomeFloat) =
    ## Sets the size of the object in local cordinates, given by the desired
    ## largest dimension of the object. The other two dimensions are scaled
    ## proportionally. If the object dimensions are zero, no action is taken.
    let current_size = self.get_local_size
    if abs(current_size) > 1e-8:
        self.scale = self.scale * size / current_size
    return

proc get_world_size*(self: GameObject): float =
    ## Calculates the size of the largest dimension of the object in world
    ## coordinates.
    let d = self.get_world_dimensions()
    return max(max(d.x, d.y), d.z)

proc set_world_size*(self: GameObject, size: SomeFloat) =
    ## Sets the size of the object in world cordinates, given by the desired
    ## largest dimension of the object. The other two dimensions are scaled
    ## proportionally. If the object dimensions are zero, no action is taken.
    let current_size = self.get_world_size
    if abs(current_size) > 1e-8:
        self.scale = self.scale * size / current_size
    return

proc set_name*(self: GameObject, name: string) =
    ## Rename the object and update the tables that use it.
    assert self.scene != nil, "Object has no scene"
    self.engine.objects.del(self.name)
    self.scene.objects.del(self.name)
    self.name = name
    self.scene.set_ob_name(self, name)

proc local_to_world*(self: GameObject, point: Vec3): Vec3 =
    ## Transforms a point in local coordinates to world coordinates.
    return self.get_world_matrix * point

proc world_to_local*(self: GameObject, point: Vec3): Vec3 =
    ## Transforms a point in world coordinates to local coordinates. If the
    ## object has a scale of 0, the point is not transformed.
    let wm = self.get_world_matrix
    if wm.determinant != 0.0:
        return wm.inverse * point
    return point