historical/toontown-classic.git/panda/include/eggNode.I

288 lines
6.7 KiB
Text
Raw Normal View History

2024-01-16 11:20:27 -06:00
/**
* PANDA 3D SOFTWARE
* Copyright (c) Carnegie Mellon University. All rights reserved.
*
* All use of this software is subject to the terms of the revised BSD
* license. You should have received a copy of this license along
* with this source code in a file named "LICENSE."
*
* @file eggNode.I
* @author drose
* @date 1999-02-10
*/
/**
*
*/
INLINE EggNode::
EggNode(const std::string &name) : EggNamedObject(name) {
_parent = nullptr;
_depth = 0;
_under_flags = 0;
}
/**
*
*/
INLINE EggNode::
EggNode(const EggNode &copy) : EggNamedObject(copy) {
_parent = nullptr;
_depth = 0;
_under_flags = 0;
}
/**
*
*/
INLINE EggNode &EggNode::
operator = (const EggNode &copy) {
EggNamedObject::operator = (copy);
update_under(0);
return *this;
}
/**
*
*/
INLINE EggGroupNode *EggNode::
get_parent() const {
return _parent;
}
/**
* Returns the number of nodes above this node in the egg hierarchy.
*/
INLINE int EggNode::
get_depth() const {
return _depth;
}
/**
* Returns true if there is an <Instance> node somewhere in the egg tree at or
* above this node, false otherwise.
*/
INLINE bool EggNode::
is_under_instance() const {
return (_under_flags & UF_under_instance) != 0;
}
/**
* Returns true if there is a <Transform> entry somewhere in the egg tree at
* or above this node, false otherwise.
*/
INLINE bool EggNode::
is_under_transform() const {
return (_under_flags & UF_under_transform) != 0;
}
/**
* Returns true if this node's vertices are not in the global coordinate
* space. This will be the case if there was an <Instance> node under a
* transform at or above this node.
*/
INLINE bool EggNode::
is_local_coord() const {
return (_under_flags & UF_local_coord) != 0;
}
/**
* Returns the coordinate frame of the vertices referenced by primitives at or
* under this node. This is not the same as get_node_frame().
*
* Generally, vertices in an egg file are stored in the global coordinate
* space, regardless of the transforms defined at each node. Thus,
* get_vertex_frame() will usually return the identity transform (global
* coordinate space). However, primitives under an <Instance> entry reference
* their vertices in the coordinate system under effect at the time of the
* <Instance>. Thus, nodes under an <Instance> entry may return this non-
* identity matrix.
*
* Specifically, this may return a non-identity matrix only if
* is_local_coord() is true.
*/
INLINE const LMatrix4d &EggNode::
get_vertex_frame() const {
if (_vertex_frame == nullptr) {
return LMatrix4d::ident_mat();
} else {
return *_vertex_frame;
}
}
/**
* Returns the coordinate frame of the node itself. This is simply the net
* product of all transformations up to the root.
*/
INLINE const LMatrix4d &EggNode::
get_node_frame() const {
if (_node_frame == nullptr) {
return LMatrix4d::ident_mat();
} else {
return *_node_frame;
}
}
/**
* Returns the inverse of the matrix returned by get_vertex_frame(). See
* get_vertex_frame().
*/
INLINE const LMatrix4d &EggNode::
get_vertex_frame_inv() const {
if (_vertex_frame_inv == nullptr) {
return LMatrix4d::ident_mat();
} else {
return *_vertex_frame_inv;
}
}
/**
* Returns the inverse of the matrix returned by get_node_frame(). See
* get_node_frame().
*/
INLINE const LMatrix4d &EggNode::
get_node_frame_inv() const {
if (_node_frame_inv == nullptr) {
return LMatrix4d::ident_mat();
} else {
return *_node_frame_inv;
}
}
/**
* Returns the transformation matrix suitable for converting the vertices as
* read from the egg file into the coordinate space of the node. This is the
* same thing as:
*
* get_vertex_frame() * get_node_frame_inv()
*
*/
INLINE const LMatrix4d &EggNode::
get_vertex_to_node() const {
if (_vertex_to_node == nullptr) {
return LMatrix4d::ident_mat();
} else {
return *_vertex_to_node;
}
}
/**
* Returns the transformation matrix suitable for converting vertices in the
* coordinate space of the node to the appropriate coordinate space for
* storing in the egg file. This is the same thing as:
*
* get_node_frame() * get_vertex_frame_inv()
*
*/
INLINE const LMatrix4d &EggNode::
get_node_to_vertex() const {
if (_node_to_vertex == nullptr) {
return LMatrix4d::ident_mat();
} else {
return *_node_to_vertex;
}
}
/**
* Returns either a NULL pointer or a unique pointer shared by nodes with the
* same get_vertex_frame() matrix.
*/
INLINE const LMatrix4d *EggNode::
get_vertex_frame_ptr() const {
return _vertex_frame;
}
/**
* Returns either a NULL pointer or a unique pointer shared by nodes with the
* same get_node_frame() matrix.
*/
INLINE const LMatrix4d *EggNode::
get_node_frame_ptr() const {
return _node_frame;
}
/**
* Returns either a NULL pointer or a unique pointer shared by nodes with the
* same get_vertex_frame_inv() matrix.
*/
INLINE const LMatrix4d *EggNode::
get_vertex_frame_inv_ptr() const {
return _vertex_frame_inv;
}
/**
* Returns either a NULL pointer or a unique pointer shared by nodes with the
* same get_node_frame_inv() matrix.
*/
INLINE const LMatrix4d *EggNode::
get_node_frame_inv_ptr() const {
return _node_frame_inv;
}
/**
* Returns either a NULL pointer or a unique pointer shared by nodes with the
* same get_vertex_to_node() matrix.
*/
INLINE const LMatrix4d *EggNode::
get_vertex_to_node_ptr() const {
return _vertex_to_node;
}
/**
* Returns either a NULL pointer or a unique pointer shared by nodes with the
* same get_node_to_vertex() matrix.
*/
INLINE const LMatrix4d *EggNode::
get_node_to_vertex_ptr() const {
return _node_to_vertex;
}
/**
* Applies the indicated transformation to the node and all of its
* descendants.
*/
INLINE void EggNode::
transform(const LMatrix4d &mat) {
LMatrix4d inv = invert(mat);
r_transform(mat, inv, CS_default);
r_transform_vertices(mat);
// Now we have to recompute the under_flags to ensure that all the cached
// relative matrices are correct.
update_under(0);
}
/**
* Applies the indicated transformation only to vertices that appear in global
* space within vertex pools at this node and below. Joints and other
* transforms are not affected, nor are local vertices.
*/
INLINE void EggNode::
transform_vertices_only(const LMatrix4d &mat) {
r_transform_vertices(mat);
}
/**
* Removes any transform and instance records from this node in the scene
* graph and below. If an instance node is encountered, removes the instance
* and applies the transform to its vertices, duplicating vertices if
* necessary.
*
* Since this function may result in duplicated vertices, it may be a good
* idea to call remove_unused_vertices() after calling this.
*/
INLINE void EggNode::
flatten_transforms() {
r_flatten_transforms();
update_under(0);
}