From ef04bfc296a41bf563b602d3aa0b524662f33bbf Mon Sep 17 00:00:00 2001 From: David Rose Date: Wed, 16 May 2001 21:50:07 +0000 Subject: [PATCH] *** empty log message *** --- panda/src/sgmanip/nodePath.I | 56 +++++++++++ panda/src/sgmanip/nodePath.cxx | 169 ++++++++++++++++++++++++++++++++- panda/src/sgmanip/nodePath.h | 16 ++++ 3 files changed, 237 insertions(+), 4 deletions(-) diff --git a/panda/src/sgmanip/nodePath.I b/panda/src/sgmanip/nodePath.I index 3d464a6049..cb70e3725b 100644 --- a/panda/src/sgmanip/nodePath.I +++ b/panda/src/sgmanip/nodePath.I @@ -740,6 +740,34 @@ heads_up(float x, float y, float z) { heads_up(LPoint3f(x, y, z)); } +//////////////////////////////////////////////////////////////////// +// Function: NodePath::look_at_preserve_scale +// Access: Public +// Description: Functions like look_at(), but preforms additional +// work to preserve any scales that may already be +// present on the node. Normally, look_at() blows away +// the scale because scale and rotation are represented +// in the same part of the matrix. +//////////////////////////////////////////////////////////////////// +INLINE void NodePath:: +look_at_preserve_scale(float x, float y, float z) { + look_at_preserve_scale(LPoint3f(x, y, z)); +} + +//////////////////////////////////////////////////////////////////// +// Function: NodePath::heads_up_preserve_scale +// Access: Public +// Description: Functions like heads_up(), but preforms additional +// work to preserve any scales that may already be +// present on the node. Normally, heads_up() blows away +// the scale because scale and rotation are represented +// in the same part of the matrix. +//////////////////////////////////////////////////////////////////// +INLINE void NodePath:: +heads_up_preserve_scale(float x, float y, float z) { + heads_up_preserve_scale(LPoint3f(x, y, z)); +} + //////////////////////////////////////////////////////////////////// // Function: NodePath::print_pos // Access: Public @@ -979,6 +1007,34 @@ heads_up(const NodePath &other, float x, float y, float z) { heads_up(other, LPoint3f(x, y, z)); } +//////////////////////////////////////////////////////////////////// +// Function: NodePath::look_at_preserve_scale +// Access: Public +// Description: Functions like look_at(), but preforms additional +// work to preserve any scales that may already be +// present on the node. Normally, look_at() blows away +// the scale because scale and rotation are represented +// in the same part of the matrix. +//////////////////////////////////////////////////////////////////// +INLINE void NodePath:: +look_at_preserve_scale(const NodePath &other, float x, float y, float z) { + look_at_preserve_scale(other, LPoint3f(x, y, z)); +} + +//////////////////////////////////////////////////////////////////// +// Function: NodePath::heads_up_preserve_scale +// Access: Public +// Description: Functions like heads_up(), but preforms additional +// work to preserve any scales that may already be +// present on the node. Normally, heads_up() blows away +// the scale because scale and rotation are represented +// in the same part of the matrix. +//////////////////////////////////////////////////////////////////// +INLINE void NodePath:: +heads_up_preserve_scale(const NodePath &other, float x, float y, float z) { + heads_up_preserve_scale(other, LPoint3f(x, y, z)); +} + //////////////////////////////////////////////////////////////////// // Function: NodePath::print_pos // Access: Public diff --git a/panda/src/sgmanip/nodePath.cxx b/panda/src/sgmanip/nodePath.cxx index 1be782aa5a..e23da54741 100644 --- a/panda/src/sgmanip/nodePath.cxx +++ b/panda/src/sgmanip/nodePath.cxx @@ -1287,9 +1287,19 @@ LVecBase3f NodePath:: get_scale() const { nassertr(has_arcs(), LVecBase3f(1.0, 1.0, 1.0)); LMatrix4f mat = get_mat(); - LVecBase3f scale, hpr, pos; - decompose_matrix(mat, scale, hpr, pos); - return scale; + + // We decompose the scale directly instead of calling + // decompose_matrix(), since we don't care about the hpr and don't + // need to go through all the work of unrolling the axes. + + // Extract the axes from the matrix. + LVector3f x, y, z; + x = mat.get_row3(0); + y = mat.get_row3(1); + z = mat.get_row3(2); + + // Now return the lengths of these axes as the scale. + return LVecBase3f(length(x), length(y), length(z)); } //////////////////////////////////////////////////////////////////// @@ -1425,7 +1435,8 @@ set_mat(const LMatrix4f &mat) { // Description: Sets the transform on this NodePath so that it // rotates to face the indicated point in space. This // will overwrite any previously existing scale on the -// node, although it will preserve any translation. +// node, although it will preserve any translation. See +// also look_at_preserve_scale(). //////////////////////////////////////////////////////////////////// void NodePath:: look_at(const LPoint3f &point, const LVector3f &up) { @@ -1458,6 +1469,76 @@ heads_up(const LPoint3f &point, const LVector3f &up) { set_mat(mat); } +//////////////////////////////////////////////////////////////////// +// Function: NodePath::look_at_preserve_scale +// Access: Public +// Description: Functions like look_at(), but preforms additional +// work to preserve any scales that may already be +// present on the node. Normally, look_at() blows away +// the scale because scale and rotation are represented +// in the same part of the matrix. +//////////////////////////////////////////////////////////////////// +void NodePath:: +look_at_preserve_scale(const LPoint3f &point, const LVector3f &up) { + nassertv(has_arcs()); + + LMatrix4f mat = get_mat(); + + // Extract the axes from the matrix. + LVector3f x, y, z; + x = mat.get_row3(0); + y = mat.get_row3(1); + z = mat.get_row3(2); + + // The lengths of the axes defines the scale. + LVecBase3f scale(length(x), length(y), length(z)); + LPoint3f pos = mat.get_row3(3); + + ::look_at(mat, point - pos, up); + + // Now reapply the scale and position. + mat.set_row(0, mat.get_row3(0) * scale[0]); + mat.set_row(1, mat.get_row3(1) * scale[1]); + mat.set_row(2, mat.get_row3(2) * scale[2]); + mat.set_row(3, pos); + set_mat(mat); +} + +//////////////////////////////////////////////////////////////////// +// Function: NodePath::heads_up_preserve_scale +// Access: Public +// Description: Functions like heads_up(), but preforms additional +// work to preserve any scales that may already be +// present on the node. Normally, heads_up() blows away +// the scale because scale and rotation are represented +// in the same part of the matrix. +//////////////////////////////////////////////////////////////////// +void NodePath:: +heads_up_preserve_scale(const LPoint3f &point, const LVector3f &up) { + nassertv(has_arcs()); + + LMatrix4f mat = get_mat(); + + // Extract the axes from the matrix. + LVector3f x, y, z; + x = mat.get_row3(0); + y = mat.get_row3(1); + z = mat.get_row3(2); + + // The lengths of the axes defines the scale. + LVecBase3f scale(length(x), length(y), length(z)); + LPoint3f pos = mat.get_row3(3); + + ::heads_up(mat, point - pos, up); + + // Now reapply the scale and position. + mat.set_row(0, mat.get_row3(0) * scale[0]); + mat.set_row(1, mat.get_row3(1) * scale[1]); + mat.set_row(2, mat.get_row3(2) * scale[2]); + mat.set_row(3, pos); + set_mat(mat); +} + //////////////////////////////////////////////////////////////////// // Function: NodePath::set_pos // Access: Public @@ -1778,6 +1859,86 @@ heads_up(const NodePath &other, const LPoint3f &point, const LVector3f &up) { set_mat(mat); } +//////////////////////////////////////////////////////////////////// +// Function: NodePath::look_at_preserve_scale +// Access: Public +// Description: Functions like look_at(), but preforms additional +// work to preserve any scales that may already be +// present on the node. Normally, look_at() blows away +// the scale because scale and rotation are represented +// in the same part of the matrix. +//////////////////////////////////////////////////////////////////// +void NodePath:: +look_at_preserve_scale(const NodePath &other, const LPoint3f &point, + const LVector3f &up) { + nassertv(has_arcs()); + + LMatrix4f mat = get_mat(); + + // Extract the axes from the matrix. + LVector3f x, y, z; + x = mat.get_row3(0); + y = mat.get_row3(1); + z = mat.get_row3(2); + + // The lengths of the axes defines the scale. + LVecBase3f scale(length(x), length(y), length(z)); + LPoint3f pos = mat.get_row3(3); + + NodePath parent(*this); + parent.shorten(1); + LPoint3f rel_point = point * other.get_mat(parent); + + ::look_at(mat, rel_point - pos, up); + + // Now reapply the scale and position. + mat.set_row(0, mat.get_row3(0) * scale[0]); + mat.set_row(1, mat.get_row3(1) * scale[1]); + mat.set_row(2, mat.get_row3(2) * scale[2]); + mat.set_row(3, pos); + set_mat(mat); +} + +//////////////////////////////////////////////////////////////////// +// Function: NodePath::heads_up_preserve_scale +// Access: Public +// Description: Functions like heads_up(), but preforms additional +// work to preserve any scales that may already be +// present on the node. Normally, heads_up() blows away +// the scale because scale and rotation are represented +// in the same part of the matrix. +//////////////////////////////////////////////////////////////////// +void NodePath:: +heads_up_preserve_scale(const NodePath &other, const LPoint3f &point, + const LVector3f &up) { + nassertv(has_arcs()); + + LMatrix4f mat = get_mat(); + + // Extract the axes from the matrix. + LVector3f x, y, z; + x = mat.get_row3(0); + y = mat.get_row3(1); + z = mat.get_row3(2); + + // The lengths of the axes defines the scale. + LVecBase3f scale(length(x), length(y), length(z)); + LPoint3f pos = mat.get_row3(3); + + NodePath parent(*this); + parent.shorten(1); + LPoint3f rel_point = point * other.get_mat(parent); + + ::heads_up(mat, rel_point - pos, up); + + // Now reapply the scale and position. + mat.set_row(0, mat.get_row3(0) * scale[0]); + mat.set_row(1, mat.get_row3(1) * scale[1]); + mat.set_row(2, mat.get_row3(2) * scale[2]); + mat.set_row(3, pos); + set_mat(mat); +} + //////////////////////////////////////////////////////////////////// // Function: NodePath::set_color // Access: Public diff --git a/panda/src/sgmanip/nodePath.h b/panda/src/sgmanip/nodePath.h index 983f14e04d..81ace6e7ac 100644 --- a/panda/src/sgmanip/nodePath.h +++ b/panda/src/sgmanip/nodePath.h @@ -306,6 +306,11 @@ PUBLISHED: INLINE void heads_up(float x, float y, float z); void heads_up(const LPoint3f &point, const LVector3f &up = LVector3f::up()); + INLINE void look_at_preserve_scale(float x, float y, float z); + void look_at_preserve_scale(const LPoint3f &point, const LVector3f &up = LVector3f::up()); + INLINE void heads_up_preserve_scale(float x, float y, float z); + void heads_up_preserve_scale(const LPoint3f &point, const LVector3f &up = LVector3f::up()); + INLINE void print_pos() const; INLINE void print_hpr() const; INLINE void print_scale() const; @@ -376,6 +381,17 @@ PUBLISHED: const LPoint3f &point = LPoint3f(0.0, 0.0, 0.0), const LVector3f &up = LVector3f::up()); + INLINE void look_at_preserve_scale(const NodePath &other, + float x, float y, float z); + void look_at_preserve_scale(const NodePath &other, + const LPoint3f &point = LPoint3f(0.0, 0.0, 0.0), + const LVector3f &up = LVector3f::up()); + INLINE void heads_up_preserve_scale(const NodePath &other, + float x, float y, float z); + void heads_up_preserve_scale(const NodePath &other, + const LPoint3f &point = LPoint3f(0.0, 0.0, 0.0), + const LVector3f &up = LVector3f::up()); + INLINE void print_pos(const NodePath &other) const; INLINE void print_hpr(const NodePath &other) const; INLINE void print_scale(const NodePath &other) const;