node.go

package tetra3d

import (
	"fmt"
	"math"
	"slices"
	"strconv"
	"strings"
)

type SectorType int

const (
	SectorTypeObject SectorType = iota
	SectorTypeSector
	SectorTypeStandalone
)

// NodeType represents a Node's type. Node types are categorized, and can be said to extend or "be of" more general types.
// For example, a ColliderSphere has a type of NodeTypeColliderSphere. That type can also be said to be NodeTypeCollider
// (because it is a collider-type object). However, it is not of type NodeTypeColliderTriangles, as that is a different category.
type NodeType uint32

const (
	NodeTypeNode      NodeType = 1 << iota              // NodeTypeNode represents specifically a node
	NodeTypeModel              = 1<<iota + NodeTypeNode // NodeTypeModel represents specifically a Model
	NodeTypeCamera                                      // NodeTypeCamera represents specifically a Camera
	NodeTypePath                                        // NodeTypePath represents specifically a Path
	NodeTypeGrid                                        // NodeTypeGrid represents specifically a Grid
	NodeTypeGridPoint                                   // NodeTypeGrid represents specifically a GridPoint (note the extra underscore to ensure !NodeTypeGridPoint.Is(NodeTypeGrid))

	NodeTypeCollider          = 1<<iota + NodeTypeNode     // Represents any generic collider object (e.g. anything that can collide)
	NodeTypeColliderAABB      = 1<<iota + NodeTypeCollider // Represents specifically a ColliderAABB
	NodeTypeColliderCapsule                                // Represents specifically a ColliderCapsule
	NodeTypeColliderTriangles                              // Represents specifically a ColliderTriangles object
	NodeTypeColliderSphere                                 // Represents specifically a ColliderSphere

	NodeTypeLight            = 1<<iota + NodeTypeNode  // NodeTypeLight represents any generic light
	NodeTypeAmbientLight     = 1<<iota + NodeTypeLight // NodeTypeAmbientLight represents specifically an ambient light
	NodeTypePointLight                                 // NodeTypePointLight represents specifically a point light
	NodeTypeDirectionalLight                           // NodeTypeDirectionalLight represents specifically a directional (sun) light
	NodeTypeCubeLight                                  // NodeTypeCubeLight represents, specifically, a cube light
	NodeTypeLightVolume                                // NodeTypeLightVolume represents, specifically, a light volume

)

// Is returns true if a NodeType satisfies another NodeType category. A specific node type can be said to
// contain a more general one, but not vice-versa. For example, a Model (which has type NodeTypeModel) can be
// said to be a Node (NodeTypeNode), but the reverse is not true (a NodeTypeNode is not a NodeTypeModel).
func (nt NodeType) Is(other NodeType) bool {
	if nt == other {
		return true
	}
	return nt&other == other
}

func (nt NodeType) String() string {
	switch nt {
	case NodeTypeNode:
		return "Node"
	case NodeTypeModel:
		return "Model"
	case NodeTypeCamera:
		return "Camera"
	case NodeTypePath:
		return "Path"
	case NodeTypeGrid:
		return "Grid"
	case NodeTypeGridPoint:
		return "GridPoint"
	case NodeTypeCollider:
		return "ColliderObject"
	case NodeTypeColliderAABB:
		return "ColliderAABB"
	case NodeTypeColliderCapsule:
		return "ColliderCapsule"
	case NodeTypeColliderTriangles:
		return "ColliderTriangles"
	case NodeTypeColliderSphere:
		return "ColliderSphere"
	// case NodeTypeLight: // No object has "light" as a type, because it's a generic type
	// 	return "Light"
	case NodeTypeAmbientLight:
		return "AmbientLight"
	case NodeTypePointLight:
		return "PointLight"
	case NodeTypeDirectionalLight:
		return "DirectionalLight"
	case NodeTypeCubeLight:
		return "CubeLight"
	case NodeTypeLightVolume:
		return "LightVolume"
	}
	panic("This should never happen")
}

// Represents a bit set of boolean values.
// This, for example, provides faster filtering for Nodes than checking properties' names or values.
type Bitfield uint32

func (b Bitfield) String() string {
	return fmt.Sprintf("%d", b)
}

// Converts the bit of the given index to a Bitfield value (e.g. ToBitfield(0) == 2, ToBitfield(1) == 4).
func ToBitfield(index int) Bitfield {
	return 2 << index
}

// Returns true if the object contains the given bit value.
func (b Bitfield) Contains(value Bitfield) bool {
	if value == 0 {
		return false
	}
	if b == value {
		return true
	}
	return b&value == value
}

func (b Bitfield) Add(value Bitfield) Bitfield {
	if int(b)+int(value) < math.MaxUint32 {
		b += value
	} else {
		b = 0
	}
	return b
}

func (b Bitfield) Sub(value Bitfield) Bitfield {
	if int(b)-int(value) > 0 {
		b -= value
	} else {
		b = 0
	}
	return b
}

// INode represents an object that exists in 3D space and can be positioned relative to an origin point.
// By default, this origin point is {0, 0, 0} (or world origin), but Nodes can be parented
// to other Nodes to change this origin (making their movements relative and their transforms
// successive). Models and Cameras are two examples of objects that fully implement the INode interface
// by means of embedding Node.
type INode interface {
	// Name returns the object's name.
	Name() string
	// String returns the object as a string.
	String() string
	// ID returns the object's unique ID.
	ID() uint32
	// SetName sets the object's name.
	SetName(name string)
	// Clone returns a clone of the specified INode implementer.
	Clone() INode
	// SetData sets user-customizeable data that could be usefully stored on this node.
	SetData(data any)
	// Data returns a pointer to user-customizeable data that could be usefully stored on this node.
	Data() any
	// Type returns the NodeType for this object.
	Type() NodeType
	setLibrary(lib *Library)
	// Library returns the source Library from which this Node was instantiated. If it was created through code, this will be nil.
	Library() *Library

	setParent(INode)

	// Parent returns the Node's parent. If the Node has no parent, this will return nil.
	Parent() INode
	// Unparent unparents the Node from its parent, removing it from the scenegraph.
	// Beware of using this in a hierarchical loop!
	Unparent()
	getOwner() INode
	// DescendantOf returns if a Node is a descendant child of a parent Node.
	DescendantOf(parent INode) bool
	// Scene looks for the Node's parents recursively to return what scene it exists in.
	// If the node is not within a tree (i.e. unparented), this will return nil.
	Scene() *Scene
	// Root returns the root node in this tree by recursively traversing this node's hierarchy of
	// parents upwards.
	Root() *Node
	InSceneTree() bool // Returns if this node is in the scene tree.
	setCachedSceneRoot(root *Node)
	cachedSceneRoot() *Node

	// ReindexChild moves the child in the calling Node's children slice to the specified newPosition.
	// The function returns the old index where the child Node was, or -1 if it wasn't a child of the calling Node.
	// The newPosition is clamped to the size of the node's children slice.
	ReindexChild(child INode, newPosition int) int

	// Index returns the index of the Node in its parent's children list.
	// If the node doesn't have a parent, its index will be -1.
	Index() int

	// Returns the Node's children as a NodeCollectionSet.
	Children(recursive bool) NodeList

	// Returns the number of children under the Node.
	// When recursive, it traverses the entire tree underneath the Node;
	// otherwise, it just returns the number of children directly beneath the Node.
	ChildrenCount(recursive bool) int

	// ForEachChild() runs a callback for each child in the Node's children set.
	// If the callback returns false, then the execution stops with the current child.
	ForEachChild(recursive bool, forEach func(node INode, index int) bool)

	// AddChildren parents the provided children Nodes to the passed parent Node, inheriting its transformations and being under it in the scenegraph
	// hierarchy. If the children are already parented to other Nodes, they are unparented before doing so.
	AddChildren(...INode)
	// RemoveChildren removes the provided children from this object.
	// Beware of using this in a hierarchical loop!
	RemoveChildren(...INode)

	// Replaces the node with the other target node.
	ReplaceWith(other INode)

	// updateLocalTransform(newParent INode)
	dirtyTransform()

	// ClearLocalTransform clears the local transform properties (position, scale, and rotation) for the Node, reverting it to essentially an
	// identity matrix (0, 0, 0 for position, 1, 1, 1 for scale, and an identity Matrix4 for rotation, indicating no rotation).
	// This can be useful because by default, when you parent one Node to another, the local transform properties (position,
	// scale, and rotation) are altered to keep the object in the same absolute location, even though the origin changes.
	ClearLocalTransform()

	// ResetWorldTransform resets the local transform properties (position, scale, and rotation) for the Node to the original transform when
	// the Node was first created / cloned / instantiated in the Scene.
	ResetWorldTransform()

	// ResetWorldPosition resets the Node's local position to the value the Node had when
	// it was first instantiated in the Scene or cloned.
	ResetWorldPosition()

	// ResetWorldScale resets the Node's local scale to the value the Node had when
	// it was first instantiated in the Scene or cloned.
	ResetWorldScale()

	// ResetWorldRotation resets the Node's local rotation to the value the Node had when
	// it was first instantiated in the Scene or cloned.
	ResetWorldRotation()

	getOriginalTransform() Matrix4
	setOriginalTransform()

	// SetWorldTransform sets the Node's global (world) transform to the full 4x4 transformation matrix provided.
	SetWorldTransform(transform Matrix4)

	// LocalRotation returns the object's local rotation Matrix4.
	LocalRotation() Matrix4
	// SetLocalRotation sets the object's local rotation Matrix4 (relative to any parent).
	SetLocalRotation(rotation Matrix4)

	// LocalPosition returns the object's local position as a Vector.
	LocalPosition() Vector3
	// SetLocalPosition sets the object's local position (position relative to its parent). If this object has no parent, the position should be
	// relative to world origin (0, 0, 0).
	SetLocalPositionVec(position Vector3)
	// SetLocalPosition sets the object's local position (position relative to its parent). If this object has no parent, the position should be
	// relative to world origin (0, 0, 0).
	SetLocalPosition(x, y, z float32)

	// LocalScale returns the object's local scale (scale relative to its parent). If this object has no parent, the scale will be absolute.
	LocalScale() Vector3
	// SetLocalScale sets the object's local scale (scale relative to its parent). If this object has no parent, the scale would be absolute.
	// scale should be a 3D vector (i.e. X, Y, and Z components).
	SetLocalScaleVec(scale Vector3)
	SetLocalScale(w, h, d float32)

	// WorldRotation returns an absolute rotation Matrix4 representing the object's rotation.
	WorldRotation() Matrix4
	// SetWorldRotation sets an object's global, world rotation to the provided rotation Matrix4.
	SetWorldRotation(rotation Matrix4)
	// WorldPosition returns the node's world position, taking into account its parenting hierarchy.
	WorldPosition() Vector3
	// SetWorldPositionVec sets the world position of the given object using the provided position vector.
	// Note that this isn't as performant as setting the position locally.
	SetWorldPositionVec(position Vector3)
	// SetWorldPosition sets the world position of the given object using the provided position arguments.
	// Note that this isn't as performant as setting the position locally.
	SetWorldPosition(x, y, z float32)
	// SetWorldX sets the x component of the Node's world position.
	SetWorldX(x float32)
	// SetWorldY sets the y component of the Node's world position.
	SetWorldY(x float32)
	// SetWorldZ sets the z component of the Node's world position.
	SetWorldZ(x float32)
	// WorldScale returns the object's absolute world scale as a 3D vector (i.e. X, Y, and Z components).
	WorldScale() Vector3
	// SetWorldScaleVec sets the object's absolute world scale. scale should be a 3D vector (i.e. X, Y, and Z components).
	SetWorldScaleVec(scale Vector3)
	// SetWorldScale sets the object's absolute world scale. scale should be three float32 values signifying the scale on the X, Y, and Z components.
	SetWorldScale(x, y, z float32)

	// Move moves a Node in local space by the x, y, and z values provided.
	Move(x, y, z float32)
	// MoveVec moves a Node in local space using the vector provided.
	MoveVec(moveVec Vector3)
	// Moves a Node in local space, by the object's world orientation, by the x, y, and z values provided.
	MoveByOrientation(x, y, z float32)
	// Moves a Node in local space, by the object's world orientation, using the vector provided.
	MoveByOrientationVec(moveVec Vector3)
	// Moves a Node towards the node provided by the distance given in world space.
	MoveTowardsNode(target INode, distance float32)
	// Linearly interpolates movement of the node towards the target location by the given percentage.
	MoveTowardsNodeLerp(target INode, percentage float32)
	// Moves a Node towards the node provided by the distance given in world space.
	MoveTowardsVec(target Vector3, distance float32)
	// Linearly interpolates movement of the node towards the target location by the given percentage.
	MoveTowardsVecLerp(target Vector3, percentage float32)
	// Moves a Node towards the node provided by the distance given in world space.
	MoveTowards(x, y, z, distance float32)
	// Linearly interpolates movement of the node towards the target location by the given percentage.
	MoveTowardsLerp(x, y, z, percentage float32)
	// Rotate rotates a Node on its local orientation on a vector composed of the given x, y, and z values, by the angle provided in radians.
	Rotate(x, y, z, angle float32)
	// RotateVec rotates a Node on its local orientation on the given vector, by the angle provided in radians.
	RotateVec(vec Vector3, angle float32)
	// Rotates a Node on its local orientation using a rotation Matrix4.
	RotateMatrix4(mat Matrix4)
	// Grow scales the object additively (i.e. calling Node.Grow(1, 0, 0) will scale it +1 on the X-axis).
	Grow(x, y, z float32)
	// GrowVec scales the object additively (i.e. calling Node.Grow(1, 0, 0) will scale it +1 on the X-axis).
	GrowVec(vec Vector3)

	// Transform returns a Matrix4 indicating the global position, rotation, and scale of the object, transforming it by any parents'.
	// If there's no change between the previous Transform() call and this one, Transform() will return a cached version of the
	// transform for efficiency.
	Transform() Matrix4

	// IsVisible returns whether the Object is visible.
	IsVisible() bool
	// SetVisible sets the object's visibility. If recursive is true, all recursive children of this Node will have their visibility set the same way.
	SetVisible(visible, recursive bool)

	// Get searches a node's hierarchy using a string to find a specified node. The path is in the format of names of nodes, separated by forward
	// slashes ('/'), and is relative to the node you use to call Get. As an example of Get, if you had a cup parented to a desk, which was
	// parented to a room, that was finally parented to the root of the scene, it would be found at "Room/Desk/Cup". Note also that you can use "../" to
	// "go up one" in the hierarchy (so cup.Get("../") would return the Desk node).
	// Since Get uses forward slashes as path separation, it would be good to avoid using forward slashes in your Node names. Also note that Get()
	// trims the extra spaces from the beginning and end of Node Names, so avoid using spaces at the beginning or end of your Nodes' names.
	Get(path string) INode

	// Search searches a node's hierarchy using a string to find the specified Node.
	Search() SearchOptions

	// HierarchyAsString returns a string displaying the hierarchy of this Node, and all recursive children.
	// This is a useful function to debug the layout of a node tree, for example.
	HierarchyAsString() string

	// Path returns a string indicating the hierarchical path to get this Node from the root. The path returned will be absolute, such that
	// passing it to Get() called on the scene root node will return this node. The path returned will not contain the root node's name ("Root").
	Path() string

	// Properties returns this object's game Properties struct.
	Properties() *Properties

	// Returns if the Node contains a property that has a bit flipped that is named in the Node's Scene by the given name.
	PropertiesContainsBitByName(bitfieldBitName string) bool

	// IsBone returns if the Node is a "bone" (a node that was a part of an armature and so can play animations back to influence a skinned mesh).
	IsBone() bool
	// IsRootBone() bool

	// AnimationPlayer returns the object's animation player - every object has an AnimationPlayer by default.
	AnimationPlayer() *AnimationPlayer

	// Sector returns the Sector this Node is in.
	Sector() *Sector
	sectorHierarchy() *Sector
	isInVisibleSector(sectorsModels []*Model) bool

	SetSectorType(sectorType SectorType)
	SectorType() SectorType

	// DistanceTo returns the distance between the given Nodes' centers.
	// Quick syntactic sugar for Node.WorldPosition().Distance(otherNode.WorldPosition()).
	DistanceTo(otherNode INode) float32

	// DistanceSquared returns the squared distance between the given Nodes' centers.
	// Quick syntactic sugar for Node.WorldPosition().DistanceSquared(otherNode.WorldPosition()).
	DistanceSquaredTo(otherNode INode) float32

	// VectorTo returns a vector from one Node to another.
	// Quick syntactic sugar for other.WorldPosition().Sub(node.WorldPosition()).
	VectorTo(otherNode INode) Vector3

	// Callbacks returns a Node's callbacks object. This object represents the callbacks that a Node has access to when events happen.
	Callbacks() *NodeCallbacks
}

// There is no zero ID; this is to make it so that systems that reference nodes by id can use 0 as an invalid reference.
var nodeID uint32 = 1

// Node represents a minimal struct that fully implements the Node interface. Model and Camera embed Node
// into their structs to automatically easily implement Node.
type Node struct {
	id                uint32 // Unique ID for this node
	owner             INode  // The owner; nil if this is a Node, set to the "owning" node type otherwise (e.g. node.owner = nil, model.owner (or model.Node.owner) = model)
	name              string
	position          Vector3
	scale             Vector3
	rotation          Matrix4
	originalTransform Matrix4
	visible           bool
	data              any // A place to store a pointer to something if you need it
	children          []INode
	parent            INode
	cachedTransform   Matrix4
	isTransformDirty  bool
	props             *Properties // Properties is an unordered set of properties, representing a means of identifying and setting game properties on Nodes.
	animationPlayer   *AnimationPlayer
	inverseBindMatrix Matrix4 // Specifically for bones in an armature used for animating skinned meshes
	isBone            bool
	collectionObjects []INode // Returns if the node is a collection instance
	boneInfluence     Matrix4
	library           *Library // The Library this Node was instantiated from (nil if it wasn't instantiated with a library at all)
	scene             *Scene
	onTransformUpdate func()
	sectorType        SectorType

	cachedSceneRootNode *Node

	cachedSector *Sector

	callbacks *NodeCallbacks
}

// NewNode returns a new Node.
func NewNode(name string) *Node {

	nb := &Node{
		id:   nodeID,
		name: name,
		// position:         NewVectorZero(),
		scale:            Vector3{1, 1, 1},
		rotation:         NewMatrix4(),
		children:         []INode{},
		visible:          true,
		isTransformDirty: true,
		props:            NewProperties(),
		// We set this just in case we call a transform property getter before setting it and caching anything
		cachedTransform: NewMatrix4(),
		callbacks:       &NodeCallbacks{},
		// originalLocalPosition: NewVectorZero(),
	}

	nodeID++

	nb.animationPlayer = NewAnimationPlayer(nb)

	return nb
}

// Callbacks returns a Node's callbacks object. This object represents the callbacks that a Node has access to when events happen.
func (node *Node) Callbacks() *NodeCallbacks {
	return node.callbacks
}

// ID returns the object's unique ID.
func (node *Node) ID() uint32 {
	return node.id
}

// Name returns the object's name.
func (node *Node) Name() string {
	return node.name
}

// SetName sets the object's name.
func (node *Node) SetName(name string) {
	node.name = name
}

// Type returns the NodeType for this object.
func (node *Node) Type() NodeType {
	return NodeTypeNode
}

// Library returns the Library from which this Node was instantiated. If it was created through code, this will be nil.
func (node *Node) Library() *Library {
	return node.library
}

func (node *Node) setLibrary(library *Library) {
	node.library = library
}

// Clone returns a new Node.
func (node *Node) Clone() INode {
	return node.clone(nil)
}

func (node *Node) clone(newOwner INode) INode {

	newNode := NewNode(node.name)
	newNode.owner = newOwner
	newNode.scene = node.scene
	newNode.position = node.position
	newNode.scale = node.scale
	newNode.rotation = node.rotation.Clone()
	newNode.setOriginalTransform()
	newNode.visible = node.visible
	newNode.data = node.data
	newNode.sectorType = node.sectorType
	newNode.cachedSector = node.cachedSector
	newNode.library = node.library

	// Clone the callbacks as well.
	newCallbacks := *node.callbacks
	newNode.callbacks = &newCallbacks

	newNode.props = node.props.Clone()
	newNode.animationPlayer = node.animationPlayer.Clone()

	if node.animationPlayer.RootNode == node {
		newNode.animationPlayer.SetRoot(newNode)
	}

	newNode.children = slices.Grow(newNode.children, len(node.children))

	for _, child := range node.children {
		childClone := child.Clone()
		childClone.setParent(newNode)
		newNode.children = append(newNode.children, childClone)
	}

	for _, child := range newNode.children {
		if model, isModel := child.(*Model); isModel && model.SkinRoot == node {
			model.ReassignBones(newNode)
		}
	}

	newNode.dirtyTransform()

	newNode.isBone = node.isBone
	if newNode.isBone {
		newNode.inverseBindMatrix = node.inverseBindMatrix.Clone()
	}

	// If newOwner != nil, then that object that is cloning will call the callback
	if runCallbacks && newOwner == nil && newNode.Callbacks().OnClone != nil {
		newNode.Callbacks().OnClone(newNode)
	}

	return newNode
}

// SetData sets user-customizeable data that could be usefully stored on this node.
func (node *Node) SetData(data any) {
	node.data = data
}

// Data returns a pointer to user-customizeable data that could be usefully stored on this node.
func (node *Node) Data() any {
	return node.data
}

// Transform returns a Matrix4 indicating the global position, rotation, and scale of the object, transforming it by any parents'.
// If there's no change between the previous Transform() call and this one, Transform() will return a cached version of the
// transform for efficiency.
func (node *Node) Transform() Matrix4 {

	// T * R * S * O

	if !node.isTransformDirty {
		return node.cachedTransform
	}

	// TODO: I think I could speed up this area considerably.
	transform := NewMatrix4Scale(node.scale.X, node.scale.Y, node.scale.Z)
	transform = transform.Mult(node.rotation)
	transform = transform.Mult(NewMatrix4Translate(node.position.X, node.position.Y, node.position.Z))

	if node.parent != nil {
		transform = transform.Mult(node.parent.Transform())
	}

	node.cachedTransform = transform
	node.isTransformDirty = false

	if node.isBone {
		node.boneInfluence = node.inverseBindMatrix.Mult(transform)
	}

	if node.onTransformUpdate != nil {
		node.onTransformUpdate()
	}

	// We want to call child.Transform() here to ensure the children also rebuild their transforms as necessary; otherwise,
	// children (i.e. ColliderAABBs) may not be rotating along with their owning Nodes (as they don't get rendered).
	for _, child := range node.children {
		child.Transform()
	}

	return transform

}

// SetWorldTransform sets the Node's global (world) transform to the full 4x4 transformation matrix provided.
func (node *Node) SetWorldTransform(transform Matrix4) {
	position, scale, rotationMatrix := transform.Decompose()
	node.SetWorldPositionVec(position)
	node.SetWorldScaleVec(scale)
	node.SetWorldRotation(rotationMatrix)
}

// dirtyTransform sets this Node and all recursive children's isTransformDirty flags to be true, indicating that they need to be
// rebuilt. This should be called when modifying the transformation properties (position, scale, rotation) of the Node.
func (node *Node) dirtyTransform() {

	for _, child := range node.children {
		child.dirtyTransform()
	}

	node.isTransformDirty = true
	node.cachedSector = nil

}

// updateLocalTransform updates the local transform properties for a Node given a change in parenting. This is done so that, for example,
// parenting an object with a given postiion, scale, and rotation keeps those visual properties when parenting (by updating them to take into
// account the parent's transforms as well).
// func (node *Node) updateLocalTransform(newParent INode) {

// 	if newParent != nil {

// 		parentTransform := newParent.Transform()
// 		parentPos, parentScale, parentRot := parentTransform.Decompose()

// 		diff := node.position.Sub(parentPos)
// 		diff[0] /= parentScale[0]
// 		diff[1] /= parentScale[1]
// 		diff[2] /= parentScale[2]
// 		node.position = parentRot.Transposed().MultVec(diff)
// 		node.rotation = node.rotation.Mult(parentRot.Transposed())

// 		node.scale[0] /= parentScale[0]
// 		node.scale[1] /= parentScale[1]
// 		node.scale[2] /= parentScale[2]

// 	} else {

// 		// Reverse

// 		parentTransform := node.Parent().Transform()
// 		parentPos, parentScale, parentRot := parentTransform.Decompose()

// 		pr := parentRot.MultVec(node.position)
// 		pr[0] *= parentScale[0]
// 		pr[1] *= parentScale[1]
// 		pr[2] *= parentScale[2]
// 		node.position = parentPos.Add(pr)
// 		node.rotation = node.rotation.Mult(parentRot)

// 		node.scale[0] *= parentScale[0]
// 		node.scale[1] *= parentScale[1]
// 		node.scale[2] *= parentScale[2]

// 	}

// 	node.dirtyTransform()

// }

// LocalPosition returns a 3D Vector consisting of the object's local position (position relative to its parent). If this object has no parent, the position will be
// relative to world origin (0, 0, 0).
func (node *Node) LocalPosition() Vector3 {
	return node.position
}

// ClearLocalTransform clears the local transform properties (position, scale, and rotation) for the Node, reverting it to essentially an
// identity matrix (0, 0, 0 for position, 1, 1, 1 for scale, and an identity Matrix4 for rotation, indicating no rotation).
// This can be useful because by default, when you parent one Node to another, the local transform properties (position,
// scale, and rotation) are altered to keep the object in the same absolute location, even though the origin changes.
func (node *Node) ClearLocalTransform() {
	node.position.X = 0
	node.position.Y = 0
	node.position.Z = 0
	node.scale.X = 1
	node.scale.Y = 1
	node.scale.Z = 1
	node.rotation = NewMatrix4()
	node.dirtyTransform()
}

// ResetWorldTransform resets the Node's world transform properties (position, scale, and rotation) for the Node to the original
// values when the Node was first instantiated in the Scene or cloned.
func (node *Node) ResetWorldTransform() {
	node.SetWorldTransform(node.originalTransform)
	node.dirtyTransform()
}

// ResetWorldPosition resets the Node's local position to the value the Node had when
// it was first instantiated in the Scene or cloned.
func (node *Node) ResetWorldPosition() {
	p, _, _ := node.originalTransform.Decompose()
	node.SetWorldPositionVec(p)
	node.dirtyTransform()
}

// ResetWorldScale resets the Node's local scale to the value the Node had when
// it was first instantiated in the Scene or cloned.
func (node *Node) ResetWorldScale() {
	_, s, _ := node.originalTransform.Decompose()
	node.SetWorldScaleVec(s)
	node.dirtyTransform()
}

// ResetWorldRotation resets the Node's local rotation to the value the Node had when
// it was first instantiated in the Scene or cloned.
func (node *Node) ResetWorldRotation() {
	_, _, r := node.originalTransform.Decompose()
	node.SetWorldRotation(r)
	node.dirtyTransform()
}

func (node *Node) setOriginalTransform() {
	node.originalTransform = node.Transform()
}

func (node *Node) getOriginalTransform() Matrix4 {
	return node.originalTransform
}

// WorldPosition returns a 3D Vector consisting of the object's world position (position relative to the world origin point of {0, 0, 0}).
func (node *Node) WorldPosition() Vector3 {
	return node.Transform().RowAsVector3(3) // We don't want to have to decompose if we don't have to
}

// SetLocalPosition sets the object's local position (position relative to its parent). If this object has no parent, the position should be
// relative to world origin (0, 0, 0). position should be a 3D vector (i.e. X, Y, and Z components).
func (node *Node) SetLocalPosition(x, y, z float32) {
	node.position.X = x
	node.position.Y = y
	node.position.Z = z
	node.dirtyTransform()
}

// SetLocalPositionVec sets the object's local position (position relative to its parent). If this object has no parent, the position should be
// relative to world origin (0, 0, 0). position should be a 3D vector (i.e. X, Y, and Z components).
func (node *Node) SetLocalPositionVec(position Vector3) {
	node.SetLocalPosition(position.X, position.Y, position.Z)
}

// SetLocalX sets the X component of the object's local position.
func (node *Node) SetLocalX(x float32) {
	node.position.X = x
	node.dirtyTransform()
}

// SetLocalY sets the Y component of the object's local position.
func (node *Node) SetLocalY(y float32) {
	node.position.Y = y
	node.dirtyTransform()
}

// SetLocalZ sets the Z component of the object's local position.
func (node *Node) SetLocalZ(z float32) {
	node.position.Z = z
	node.dirtyTransform()
}

// SetWorldPositionVec sets the object's world position (position relative to the world origin point of {0, 0, 0}).
// position needs to be a 3D vector (i.e. X, Y, and Z components).
func (node *Node) SetWorldPosition(x, y, z float32) {

	if node.parent != nil {

		parentTransform := node.parent.Transform()
		parentPos, parentScale, parentRot := parentTransform.Decompose()

		pr := parentRot.Transposed().MultVec(Vector3{X: x, Y: y, Z: z}.Sub(parentPos))
		pr.X /= parentScale.X
		pr.Y /= parentScale.Y
		pr.Z /= parentScale.Z

		node.position = pr

	} else {
		node.position.X = x
		node.position.Y = y
		node.position.Z = z
	}

	node.dirtyTransform()

}

// SetWorldPosition sets the object's world position (position relative to the world origin point of {0, 0, 0}).
func (node *Node) SetWorldPositionVec(vec Vector3) {
	node.SetWorldPosition(vec.X, vec.Y, vec.Z)
}

// SetWorldX sets the X component of the object's world position.
func (node *Node) SetWorldX(x float32) {
	v := node.WorldPosition()
	v.X = x
	node.SetWorldPositionVec(v)
}

// SetWorldY sets the Y component of the object's world position.
func (node *Node) SetWorldY(y float32) {
	v := node.WorldPosition()
	v.Y = y
	node.SetWorldPositionVec(v)
}

// SetWorldZ sets the Z component of the object's world position.
func (node *Node) SetWorldZ(z float32) {
	v := node.WorldPosition()
	v.Z = z
	node.SetWorldPositionVec(v)
}

// LocalScale returns the object's local scale (scale relative to its parent). If this object has no parent, the scale will be absolute.
func (node *Node) LocalScale() Vector3 {
	return node.scale
}

// SetLocalScaleVec sets the object's local scale (scale relative to its parent). If this object has no parent, the scale would be absolute.
// scale should be a 3D vector (i.e. X, Y, and Z components).
func (node *Node) SetLocalScaleVec(scale Vector3) {
	node.SetLocalScale(scale.X, scale.Y, scale.Z)
}

// SetLocalScale sets the object's local scale (scale relative to its parent). If this object has no parent, the scale would be absolute.
func (node *Node) SetLocalScale(w, h, d float32) {
	node.scale.X = w
	node.scale.Y = h
	node.scale.Z = d
	node.dirtyTransform()
}

// WorldScale returns the object's absolute world scale as a 3D vector (i.e. X, Y, and Z components). Note that this is a bit slow as it
// requires decomposing the node's world transform, so you want to use node.LocalScale() if you can and performacne is a concern.
func (node *Node) WorldScale() Vector3 {

	needToDecompose := false

	parent := node.parent
	for parent != nil {

		if scale := parent.LocalScale(); scale.X != 1 || scale.Y != 1 || scale.Z != 1 {
			needToDecompose = true
			break
		}

		parent = parent.Parent()
	}

	// Only decompose if we absolutely need to
	if needToDecompose {
		return node.Transform().DecomposeScale()
	}

	return node.LocalScale()

}

// SetWorldScaleVec sets the object's absolute world scale. scale should be a 3D vector (i.e. X, Y, and Z components).
func (node *Node) SetWorldScaleVec(scale Vector3) {
	node.SetWorldScale(scale.X, scale.Y, scale.Z)
}

// SetWorldScale sets the object's absolute world scale.
func (node *Node) SetWorldScale(w, h, d float32) {

	if node.parent != nil {

		parentTransform := node.parent.Transform()
		_, parentScale, _ := parentTransform.Decompose()

		node.scale = Vector3{
			w / parentScale.X,
			h / parentScale.Y,
			d / parentScale.Z,
		}

	} else {
		node.scale.X = w
		node.scale.Y = h
		node.scale.Z = d
	}

	node.dirtyTransform()

}

// LocalRotation returns the object's local rotation Matrix4.
func (node *Node) LocalRotation() Matrix4 {
	return node.rotation.Clone()
}

// SetLocalRotation sets the object's local rotation Matrix4 (relative to any parent).
func (node *Node) SetLocalRotation(rotation Matrix4) {
	if rotation.IsZero() {
		return
	}
	node.rotation.Set(rotation)
	node.dirtyTransform()
}

// WorldRotation returns an absolute rotation Matrix4 representing the object's rotation. Note that this is a bit slow as it
// requires decomposing the node's world transform, so you want to use node.LocalRotation() if you can and performacne is a concern.
func (node *Node) WorldRotation() Matrix4 {

	needToDecompose := false

	parent := node.parent
	for parent != nil {

		if rot := parent.LocalRotation(); !rot.IsIdentity() {
			needToDecompose = true
			break
		}

		parent = parent.Parent()
	}

	// Only decompose if we absolutely need to
	if needToDecompose {
		return node.Transform().DecomposeRotation()
	}

	return node.LocalRotation()

}

// SetWorldRotation sets an object's rotation to the provided rotation Matrix4.
func (node *Node) SetWorldRotation(rotation Matrix4) {

	if node.parent != nil {

		parentTransform := node.parent.Transform()
		_, _, parentRot := parentTransform.Decompose()
		node.rotation.Set(parentRot.Transposed().Mult(rotation))

	} else {
		node.rotation.Set(rotation)
	}

	node.dirtyTransform()
}

// Move moves a Node in local space by the x, y, and z values provided.
func (node *Node) Move(x, y, z float32) {
	if x == 0 && y == 0 && z == 0 {
		return
	}
	node.position.X += x
	node.position.Y += y
	node.position.Z += z
	node.dirtyTransform()
}

// MoveVec moves a Node in local space using the vector provided.
func (node *Node) MoveVec(vec Vector3) {
	node.Move(vec.X, vec.Y, vec.Z)
}

// MoveByOrientation moves a Node in local space by the x, y, and z values provided.
func (node *Node) MoveByOrientation(x, y, z float32) {

	if x == 0 && y == 0 && z == 0 {
		return
	}

	rot := node.WorldRotation()
	right := rot.Right().Scale(x)
	up := rot.Up().Scale(y)
	forward := rot.Forward().Scale(z)

	node.position.X += right.X
	node.position.Y += right.Y
	node.position.Z += right.Z

	node.position.X += up.X
	node.position.Y += up.Y
	node.position.Z += up.Z

	node.position.X += forward.X
	node.position.Y += forward.Y
	node.position.Z += forward.Z

	node.dirtyTransform()

}

// MoveByOrientationVec moves a Node in local space using the vector provided.
func (node *Node) MoveByOrientationVec(vec Vector3) {
	node.MoveByOrientation(vec.X, vec.Y, vec.Z)
}

// MoveTowardsNode moves the node towards the specified target Node in world space by the distance provided.
// The movement is capped to the distance to the target location.
func (node *Node) MoveTowardsNode(target INode, distance float32) {
	node.SetWorldPositionVec(node.WorldPosition().MoveTowards(target.WorldPosition(), distance))
}

// Linearly interpolates the node moving towards the target vector in world space by the percentage provided.
func (node *Node) MoveTowardsNodeLerp(target INode, percentage float32) {
	node.SetWorldPositionVec(node.WorldPosition().Lerp(target.WorldPosition(), percentage))
}

// MoveTowards moves the node towards a given location in world space by the distance provided.
// The movement is capped to the distance to the target location.
func (node *Node) MoveTowards(x, y, z float32, distance float32) {
	node.SetWorldPositionVec(node.WorldPosition().MoveTowards(NewVector3(x, y, z), distance))
}

// Linearly interpolates the node moving towards the target position in world space by the percentage provided.
func (node *Node) MoveTowardsLerp(x, y, z float32, percentage float32) {
	node.SetWorldPositionVec(node.WorldPosition().Lerp(NewVector3(x, y, z), percentage))
}

// MoveTowardsVec moves the node towards the target vector in world space by the distance provided.
// The movement is capped to the distance to the target location.
func (node *Node) MoveTowardsVec(vec Vector3, distance float32) {
	node.SetWorldPositionVec(node.WorldPosition().MoveTowards(vec, distance))
}

// Linearly interpolates the node moving towards the target vector in world space by the percentage provided.
func (node *Node) MoveTowardsVecLerp(vec Vector3, percentage float32) {
	node.SetWorldPositionVec(node.WorldPosition().Lerp(vec, percentage))
}

// Rotate rotates a Node on its local orientation on a vector composed of the given x, y, and z values, by the angle provided in radians.
func (node *Node) Rotate(x, y, z, angle float32) {
	if x == 0 && y == 0 && z == 0 {
		return
	}
	localRot := node.LocalRotation()
	localRot = localRot.Rotated(x, y, z, angle)
	node.SetLocalRotation(localRot)
}

// RotateVec rotates a Node on its local orientation on the given vector, by the angle provided in radians.
func (node *Node) RotateVec(vec Vector3, angle float32) {
	node.Rotate(vec.X, vec.Y, vec.Z, angle)
}

// Rotate rotates a Node on its local orientation using a Matrix4.
func (node *Node) RotateMatrix4(mat Matrix4) {
	localRot := node.LocalRotation()
	// localRot = localRot.Mult(mat) // Rotate kinda globally
	localRot = mat.Mult(localRot) // Rotate locally
	node.SetLocalRotation(localRot)
}

// Grow scales the object additively using the x, y, and z arguments provided (i.e. calling
// Node.Grow(1, 0, 0) will scale it +1 on the X-axis).
func (node *Node) Grow(x, y, z float32) {
	if x == 0 && y == 0 && z == 0 {
		return
	}
	scale := node.LocalScale()
	scale.X += x
	scale.Y += y
	scale.Z += z
	node.SetLocalScale(scale.X, scale.Y, scale.Z)
}

// GrowVec scales the object additively using the scaling vector provided (i.e. calling
// Node.GrowVec(Vector{1, 0, 0}) will scale it +1 on the X-axis).
func (node *Node) GrowVec(vec Vector3) {
	node.Grow(vec.X, vec.Y, vec.Z)
}

// Parent returns the Node's parent. If the Node has no parent, this will return nil.
func (node *Node) Parent() INode {
	if node.parent != nil {
		return node.parent.getOwner()
	}
	return nil
}

// setParent sets the Node's parent.
func (node *Node) setParent(parent INode) {
	// fmt.Println(node, "parent:", parent, parent != nil)
	if parent != nil {
		node.parent = parent.getOwner()
		node.cachedSceneRootNode = parent.Root()
	} else {
		node.parent = nil
		node.cachedSceneRootNode = nil
	}
	for _, child := range node.children {
		child.setParent(node)
	}
	node.ForEachChild(true, func(child INode, index int) bool {
		child.setCachedSceneRoot(node.cachedSceneRootNode)
		return true
	})
}

func (node *Node) setCachedSceneRoot(root *Node) {
	node.cachedSceneRootNode = root
}

func (node *Node) cachedSceneRoot() *Node {
	return node.cachedSceneRootNode
}

// Scene looks for the Node's parents recursively to return what scene it exists in.
// If the node is not within a tree (i.e. unparented), this will return nil.
func (node *Node) Scene() *Scene {
	root := node.Root()
	if root != nil {
		return root.scene
	}
	return nil
}

// AddChildren parents the provided children Nodes to the passed parent Node, inheriting its transformations and being under it in the scenegraph
// hierarchy. If the children are already parented to other Nodes, they are unparented before doing so.
func (node *Node) AddChildren(children ...INode) {

	me := node.getOwner()

	for _, child := range children {

		if child == me {
			continue
		}

		prevParent := child.Parent()
		if prevParent != nil {

			if prevParent == me {
				continue
			}

			runningCallbacks := runCallbacks

			// If they are running, set it to false specifically for removing children because they should just get the "reparented" callback, not
			// the "removed" callback
			runCallbacks = false
			prevParent.RemoveChildren(child.getOwner())

			// set it back to original value
			runCallbacks = runningCallbacks
		}

		child.setParent(me)
		child.dirtyTransform()
		node.children = append(node.children, child.getOwner())

		if runCallbacks && child.Callbacks().OnReparent != nil {
			child.Callbacks().OnReparent(child, prevParent, me)
		}

	}

}

// getOwner returns either this Node or the Node that owns the Node, in cases where it is embedded (e.g. Model, Camera, etc).
// We do this so that parenting works as expected (parenting to and from the owning Node (the Model, camera, etc)
// rather than the Node that it embeds (e.g. Model.Node, Camera.Node, etc)).
func (node *Node) getOwner() INode {
	if node.owner != nil {
		return node.owner
	}
	return node
}

// RemoveChildren immediately removes the provided children from this object.
// Beware of using this in a hierarchical loop!
func (node *Node) RemoveChildren(children ...INode) {

	for _, c1 := range children {

		child1 := c1.getOwner()

		for i, c2 := range node.children {

			child2 := c2.getOwner()

			if child2 == child1 {
				// child.updateLocalTransform(nil)
				prevParent := child1.Parent()
				child1.setParent(nil)
				child1.dirtyTransform()

				node.children[i] = nil
				node.children = append(node.children[:i], node.children[i+1:]...)

				if runCallbacks && child1.Callbacks().OnReparent != nil {
					child1.Callbacks().OnReparent(child1, prevParent, nil)
				}
				break
			}
		}

	}

}

// Unparent unparents the Node from its parent, removing it from the scenegraph.
// Beware of using this in a hierarchical loop!
func (node *Node) Unparent() {
	if node.parent != nil {
		node.parent.RemoveChildren(node)
	}
}

// ReindexChild moves the child in the calling Node's children slice to the specified newPosition.
// The function returns the old index where the child Node was, or -1 if it wasn't a child of the calling Node.
// The newPosition is clamped to the size of the node's children slice.
func (node *Node) ReindexChild(child INode, newIndex int) int {

	oldIndex := child.Index()

	if oldIndex >= 0 {

		if newIndex < 0 {
			newIndex = 0
		} else if newIndex > len(node.children)-1 {
			newIndex = len(node.children) - 1
		}

		node.children = append(node.children[:oldIndex], node.children[oldIndex+1:]...)

		node.children = append(node.children, nil)
		copy(node.children[newIndex+1:], node.children[newIndex:])
		node.children[newIndex] = child

	}

	return oldIndex

}

// Index returns the index of the Node in its parent's children list.
// If the node doesn't have a parent, its index will be -1.
func (node *Node) Index() int {
	var index = -1
	if node.parent != nil {
		node.parent.ForEachChild(false, func(child INode, i int) bool {
			if child == node {
				index = i
				return false
			}
			return true
		})
	}
	return index
}

// Replaces a node with the other node specified.
func (node *Node) ReplaceWith(other INode) {
	if parent := node.Parent(); parent != nil {
		ogIndex := node.Index()
		parent.AddChildren(other)
		parent.ReindexChild(other, ogIndex)
	}
	other.SetWorldTransform(node.Transform())
	node.Unparent()
}

// Children returns the Node's children as a slice of INodes.
// recursive controls whether it returns all nodes recursive moving down the Node's hierarchy or not.
// If recursive is true, it's syntactic sugar for Node.FindNodes(FindNodeOptions{}).
func (node *Node) Children(recursive bool) NodeList {
	if recursive {
		return node.Search().WithStartingNode(false).GetNodeList()
	}
	return append(make([]INode, 0, len(node.children)), node.children...)
}

// ForEachChild runs the provided callback function for each child in the node's children slice.
// If the callback returns false, then it stops execution with the current child.
// Beware of removing children from a node in this loop (it's better to make a copy of children through
// a node.Search call if you're going to remove some).
func (node *Node) ForEachChild(recursive bool, forEach func(node INode, index int) bool) {
	for i := 0; i < len(node.children); i++ {
		if !forEach(node.children[i], i) {
			return
		}
		if recursive {
			node.children[i].ForEachChild(recursive, forEach)
		}
	}
}

// Returns the number of children under the Node.
// When recursive, it traverses the entire tree underneath the Node;
// otherwise, it just returns the number of the Node's direct descendants.
func (node *Node) ChildrenCount(recursive bool) int {
	count := 0
	node.ForEachChild(recursive, func(child INode, index int) bool {
		count++
		return true
	})
	return count
}

// IsVisible returns whether the Object is visible.
func (node *Node) IsVisible() bool {
	return node.visible
}

// SetVisible sets the object's visibility. If recursive is true, all recursive children of this Node will have their visibility set the same way.
func (node *Node) SetVisible(visible bool, recursive bool) {
	if recursive {
		for _, child := range node.children {
			child.SetVisible(visible, recursive)
		}
	}
	node.visible = visible
}

// Properties represents an ordered set of game properties that can be used to identify this object.
func (node *Node) Properties() *Properties {
	return node.props
}

// Returns if the Node contains a property that has a bit flipped that is named in the Node's Scene by the given name.
func (node *Node) PropertiesContainsBitByName(bitfieldBitName string) bool {
	bv := node.Scene().BitfieldValueByName(bitfieldBitName)
	for _, p := range node.props.data {
		return p.IsBitfield() && p.AsBitfield().Contains(bv)
	}
	return false
}

// HierarchyAsString returns a string displaying the hierarchy of this Node, and all recursive children.
// This is a useful function to debug the layout of a node tree, for example.
// All Nodes except for the top-level Node will show their type by means of a prefix ("MODEL" for Models, for example).
// All Nodes listed in the hierarchy will also show their world positions, truncated to the first 2 decimals.

func (node *Node) HierarchyAsString() string {

	var printNode func(node INode, level int) string

	printNode = func(node INode, level int) string {

		prefix := ""

		// We do this because calling Node.HierarchyAsString() will always return the base Node's
		// type, which is NodeTypeNode, unless we override this function, essentially, for each
		// "more specific type". To avoid doing this, I'm just going to have the first level node
		// look like : [-] .
		if level == 0 {
			prefix = "ROOT"
		} else {

			nodeType := node.Type()

			if nodeType.Is(NodeTypeCamera) {
				prefix = "CAM"
			} else if nodeType.Is(NodeTypePath) {
				prefix = "PATH"
			} else if nodeType.Is(NodeTypeGrid) {
				prefix = "GRID"
			} else if nodeType.Is(NodeTypeGridPoint) {
				prefix = "GPOINT"
			} else if nodeType.Is(NodeTypeAmbientLight) {
				prefix = "AMB"
			} else if nodeType.Is(NodeTypeDirectionalLight) {
				prefix = "DIR"
			} else if nodeType.Is(NodeTypePointLight) {
				prefix = "POINT"
			} else if nodeType.Is(NodeTypeCubeLight) {
				prefix = "CUBE"
			} else if nodeType.Is(NodeTypeColliderSphere) {
				prefix = "BS"
			} else if nodeType.Is(NodeTypeColliderAABB) {
				prefix = "AABB"
			} else if nodeType.Is(NodeTypeColliderCapsule) {
				prefix = "CAP"
			} else if nodeType.Is(NodeTypeColliderTriangles) {
				prefix = "TRI"
			} else if nodeType.Is(NodeTypeModel) {
				prefix = "MODEL"
			} else if nodeType.Is(NodeTypeLightVolume) {
				prefix = "LIGHTVOLUME"
			} else {
				prefix = "NODE"
			}

		}

		str := ""

		if node.Parent() != nil {
			for i := 0; i < level; i++ {
				str += "    |"
			}
			str += "\n"
		}

		for i := 0; i < level; i++ {
			str += "    |"
		}

		wp := node.WorldPosition()
		floatTruncation := 2
		wpStr := "[" + strconv.FormatFloat(float64(wp.X), 'f', floatTruncation, 64) + ", " + strconv.FormatFloat(float64(wp.Y), 'f', floatTruncation, 64) + ", " + strconv.FormatFloat(float64(wp.Z), 'f', floatTruncation, 64) + "]"

		if level > 0 {
			str += "-"
		}
		str += " [" + prefix + "] " + node.Name() + fmt.Sprintf(" : %d : ", node.ID()) + wpStr + "\n"

		node.ForEachChild(false, func(node INode, index int) bool {
			str += printNode(node, level+1)
			return true
		})

		return str
	}

	return printNode(node, 0)
}

// If enabled, Nodes, Materials, and other object types will be represented by their names when
// printed directly. Otherwise, they will be represented by their pointer locations, like default.
var ReadableReferences = true

func (node *Node) String() string {
	if ReadableReferences {
		path := node.Path()
		if path == "" {
			path = "No path"
		}
		return "Node { Name: " + node.Name() + ", Path: " + path + ", ID: " + fmt.Sprintf("%d", node.id) + " }"
	} else {
		return fmt.Sprintf("%p", node)
	}
}

// Get searches a node's hierarchy using a string to find a specified node. The path is in the format of names of nodes, separated by forward
// slashes ('/'), and is relative to the node you use to call Get. As an example of Get, if you had a cup parented to a desk, which was
// parented to a room, that was finally parented to the root of the scene, it would be found at "Room/Desk/Cup". Note also that you can use "../" to
// "go up one" in the hierarchy (so cup.Get("../") would return the Desk node).
// Since Get uses forward slashes as path separation, it would be good to avoid using forward slashes in your Node names. Also note that Get()
// trims the extra spaces from the beginning and end of Node Names, so avoid using spaces at the beginning or end of your Nodes' names.
func (node *Node) Get(path string) INode {

	var search func(node INode) INode

	split := []string{}

	for _, s := range strings.Split(path, `/`) {
		if len(strings.TrimSpace(s)) > 0 {
			split = append(split, s)
		}
	}

	search = func(node INode) INode {

		if node == nil {
			return nil
		} else if len(split) == 0 {
			return node
		}

		if split[0] == ".." {
			split = split[1:]
			return search(node.Parent())
		}

		var foundNode INode

		node.ForEachChild(false, func(child INode, index int) bool {

			if child.Name() == split[0] {

				if len(split) <= 1 {
					foundNode = child
					return false
				} else {
					split = split[1:]
					foundNode = search(child)
					return false
				}

			}

			return true
		})

		return foundNode

	}

	return search(node)

}

// Path returns a string indicating the hierarchical path to get this Node from the root. The path returned will be absolute, such that
// passing it to Get() called on the scene root node will return this node. The path returned will not contain the root node's name ("Root").
// If the Node is not in a scene tree (i.e. does not have a path to a root node), Path() will return a blank string.
func (node *Node) Path() string {

	root := node.Root()

	if root == nil {
		return ""
	}

	parent := node.Parent()
	path := node.Name()

	for parent != nil && parent != root {
		path = parent.Name() + "/" + path
		parent = parent.Parent()
	}

	return path

}

// Root returns the root node in the scene by recursively traversing this node's hierarchy of
// parents upwards. If, instead, the node this is called on is the root (and so has no parents), this function
// returns the node itself. If the node has no path to the scene root, this function returns nil.
func (node *Node) Root() *Node {

	if node.cachedSceneRootNode != nil {
		return node.cachedSceneRootNode
	}

	if node.parent != nil {
		parent := node.parent
		for parent != nil {
			if parent == parent.cachedSceneRoot() {
				node.cachedSceneRootNode = parent.(*Node)
				return node.cachedSceneRootNode
			}
			parent = parent.Parent()
		}
	}

	return nil

}

// InSceneTree returns if a Node is connected to the scene's root node through hierarchy.
func (node *Node) InSceneTree() bool {
	return node.Root() != nil
}

// DescendantOf returns if a Node is a descendant of a parent Node.
func (node *Node) DescendantOf(parent INode) bool {
	p := node.Parent()
	for p != nil {
		if p == parent {
			return true
		}
		p = p.Parent()
	}
	return false
}

// IsBone returns if the Node is a "bone" (a node that was a part of an armature and so can play animations back to influence a skinned mesh).
func (node *Node) IsBone() bool {
	return node.isBone
}

// // IsRootBone returns if the Node SHOULD be the root of an Armature (a Node that was the base of an armature).
// func (node *Node) IsRootBone() bool {
// 	return node.IsBone() && (node.parent == nil || !node.parent.IsBone())
// }

// AnimationPlayer returns the object's animation player - every object has an AnimationPlayer by default.
func (node *Node) AnimationPlayer() *AnimationPlayer {
	return node.animationPlayer
}

func (node *Node) sectorHierarchy() *Sector {

	if node.parent != nil {
		model, ok := node.parent.(*Model)
		if ok && model.sector != nil {
			return model.sector
		} else {
			parentSector := node.parent.sectorHierarchy()
			if parentSector != nil {
				return parentSector
			}
		}
	}

	return nil

}

// Sector returns the Sector this node is in hierarchically. If that fails, then
// Sector() will search the scene tree spatially to see which of the sectors the
// calling Node lies in.
func (node *Node) Sector() *Sector {

	if node.cachedSector != nil {
		return node.cachedSector
	}

	if sectorHierarchy := node.sectorHierarchy(); sectorHierarchy != nil {
		node.cachedSector = sectorHierarchy
	} else {

		root := node.Root()

		if root == nil {
			node.cachedSector = nil
		} else {

			pos := node.WorldPosition()

			root.ForEachChild(true, func(child INode, index int) bool {
				if model, ok := child.(*Model); ok && model.sector != nil {
					if model.sector.dimensions.Contains(pos) {
						node.cachedSector = model.sector
					}
				}
				return true
			})

		}

	}

	return node.cachedSector

}

func (node *Node) isInVisibleSector(sectorModels []*Model) bool {
	for _, model := range sectorModels {
		if model.sector.rendering && model.sector.dimensions.Contains(node.WorldPosition()) {
			return true
		}
	}
	return false
}

// SectorType returns the current SectorType of the Node.
func (node *Node) SectorType() SectorType {
	return node.sectorType
}

// SetSectorType sets the current SectorType of the Node. Note that setting this to Sector won't work.
func (node *Node) SetSectorType(sectorType SectorType) {
	node.sectorType = sectorType
}

// DistanceTo returns the distance between the given Nodes' centers.
// Quick syntactic sugar for Node.WorldPosition().Distance(otherNode.WorldPosition()).
func (node *Node) DistanceTo(other INode) float32 {
	return node.WorldPosition().DistanceTo(other.WorldPosition())
}

// DistanceSquaredTo returns the squared distance between the given Nodes' centers.
// Quick syntactic sugar for Node.WorldPosition().DistanceSquared(otherNode.WorldPosition()).
func (node *Node) DistanceSquaredTo(other INode) float32 {
	return node.WorldPosition().DistanceSquaredTo(other.WorldPosition())
}

// VectorTo returns a vector from one Node to another.
// Quick syntactic sugar for other.WorldPosition().Sub(node.WorldPosition()).
func (node *Node) VectorTo(other INode) Vector3 {
	return other.WorldPosition().Sub(node.WorldPosition())
}