NurbsMatrixVector -> NurbsBasisVector

panda/src/parametrics/Sources.pp

@@ -19,7 +19,7 @@
     nurbsCurveEvaluator.I nurbsCurveEvaluator.h \
     nurbsCurveInterface.I nurbsCurveInterface.h \
     nurbsCurveResult.I nurbsCurveResult.h \
-    nurbsMatrixVector.I nurbsMatrixVector.h \
+    nurbsBasisVector.I nurbsBasisVector.h \
     nurbsVertex.h nurbsVertex.I \
     parametricCurve.h  \
     parametricCurveCollection.I parametricCurveCollection.h  \
@@ -35,7 +35,7 @@
     nurbsCurveEvaluator.cxx \
     nurbsCurveResult.cxx \
     nurbsCurveInterface.cxx  \
-    nurbsMatrixVector.cxx \
+    nurbsBasisVector.cxx \
     nurbsVertex.cxx \
     parametricCurve.cxx parametricCurveCollection.cxx  \
     piecewiseCurve.cxx \
@@ -53,7 +53,7 @@
     nurbsCurveEvaluator.I nurbsCurveEvaluator.h \
     nurbsCurveInterface.I nurbsCurveInterface.h \
     nurbsCurveResult.I nurbsCurveResult.h \
-    nurbsMatrixVector.I nurbsMatrixVector.h \
+    nurbsBasisVector.I nurbsBasisVector.h \
     nurbsVertex.h nurbsVertex.I \
     nurbsPPCurve.h \
     parametricCurve.h \

panda/src/parametrics/nurbsMatrixVector.I → panda/src/parametrics/nurbsBasisVector.I

@@ -1,4 +1,4 @@
-// Filename: nurbsMatrixVector.I
+// Filename: nurbsBasisVector.I
 // Created by:  drose (04Dec02)
 //
 ////////////////////////////////////////////////////////////////////
@@ -18,125 +18,125 @@
 
 
 ////////////////////////////////////////////////////////////////////
-//     Function: NurbsMatrixVector::Constructor
+//     Function: NurbsBasisVector::Constructor
 //       Access: Public
 //  Description:
 ////////////////////////////////////////////////////////////////////
-INLINE NurbsMatrixVector::
-NurbsMatrixVector() {
+INLINE NurbsBasisVector::
+NurbsBasisVector() {
   _order = 0;
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: NurbsMatrixVector::Destructor
+//     Function: NurbsBasisVector::Destructor
 //       Access: Public
 //  Description:
 ////////////////////////////////////////////////////////////////////
-INLINE NurbsMatrixVector::
-~NurbsMatrixVector() {
+INLINE NurbsBasisVector::
+~NurbsBasisVector() {
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: NurbsMatrixVector::get_order
+//     Function: NurbsBasisVector::get_order
 //       Access: Public
 //  Description: Returns the order of the segments in the curve.
 ////////////////////////////////////////////////////////////////////
-INLINE int NurbsMatrixVector::
+INLINE int NurbsBasisVector::
 get_order() const {
   return _order;
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: NurbsMatrixVector::get_num_segments
+//     Function: NurbsBasisVector::get_num_segments
 //       Access: Public
 //  Description: Returns the number of piecewise continuous segments
 //               in the curve.
 ////////////////////////////////////////////////////////////////////
-INLINE int NurbsMatrixVector::
+INLINE int NurbsBasisVector::
 get_num_segments() const {
   return _segments.size();
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: NurbsMatrixVector::get_start_t
+//     Function: NurbsBasisVector::get_start_t
 //       Access: Public
 //  Description: Returns the first legal value of t on the curve.
 //               Usually this is 0.0.
 ////////////////////////////////////////////////////////////////////
-INLINE float NurbsMatrixVector::
+INLINE float NurbsBasisVector::
 get_start_t() const {
   nassertr(!_segments.empty(), 0.0f);
   return _segments.front()._from;
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: NurbsMatrixVector::get_end_t
+//     Function: NurbsBasisVector::get_end_t
 //       Access: Public
 //  Description: Returns the last legal value of t on the curve.
 ////////////////////////////////////////////////////////////////////
-INLINE float NurbsMatrixVector::
+INLINE float NurbsBasisVector::
 get_end_t() const {
   nassertr(!_segments.empty(), 0.0f);
   return _segments.back()._to;
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: NurbsMatrixVector::get_vertex_index
+//     Function: NurbsBasisVector::get_vertex_index
 //       Access: Public
 //  Description: Returns the vertex index of the nth segment.  This is
 //               the index number of the first associated control
 //               vertex within the source NurbsCurveEvaluator object.
 ////////////////////////////////////////////////////////////////////
-INLINE int NurbsMatrixVector::
+INLINE int NurbsBasisVector::
 get_vertex_index(int segment) const {
   nassertr(segment >= 0 && segment < (int)_segments.size(), 0);
   return _segments[segment]._vertex_index;
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: NurbsMatrixVector::get_from
+//     Function: NurbsBasisVector::get_from
 //       Access: Public
 //  Description: Returns the t value of the beginning of this segment.
 ////////////////////////////////////////////////////////////////////
-INLINE float NurbsMatrixVector::
+INLINE float NurbsBasisVector::
 get_from(int segment) const {
   nassertr(segment >= 0 && segment < (int)_segments.size(), 0.0f);
   return _segments[segment]._from;
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: NurbsMatrixVector::get_to
+//     Function: NurbsBasisVector::get_to
 //       Access: Public
 //  Description: Returns the t value of the end of this segment.
 ////////////////////////////////////////////////////////////////////
-INLINE float NurbsMatrixVector::
+INLINE float NurbsBasisVector::
 get_to(int segment) const {
   nassertr(segment >= 0 && segment < (int)_segments.size(), 0.0f);
   return _segments[segment]._to;
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: NurbsMatrixVector::get_basis
+//     Function: NurbsBasisVector::get_basis
 //       Access: Public
 //  Description: Returns the basis matrix associated with the nth
 //               segment.  This is the pure matrix based on the knot
 //               vector over the segment; it does not depend on the
 //               control vertices.
 ////////////////////////////////////////////////////////////////////
-INLINE const LMatrix4f &NurbsMatrixVector::
+INLINE const LMatrix4f &NurbsBasisVector::
 get_basis(int segment) const {
   nassertr(segment >= 0 && segment < (int)_segments.size(), LMatrix4f::ident_mat());
   return _segments[segment]._basis;
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: NurbsMatrixVector::scale_t
+//     Function: NurbsBasisVector::scale_t
 //       Access: Public
 //  Description: Scales the value of t into the range [0, 1]
 //               corresponding to [from, to].  Returns the scaled
 //               value.
 ////////////////////////////////////////////////////////////////////
-INLINE float NurbsMatrixVector::
+INLINE float NurbsBasisVector::
 scale_t(int segment, float t) const {
   nassertr(segment >= 0 && segment < (int)_segments.size(), 0.0f);
   float from = _segments[segment]._from;

panda/src/parametrics/nurbsMatrixVector.cxx → panda/src/parametrics/nurbsBasisVector.cxx

@@ -1,4 +1,4 @@
-// Filename: nurbsMatrixVector.cxx
+// Filename: nurbsBasisVector.cxx
 // Created by:  drose (03Dec02)
 //
 ////////////////////////////////////////////////////////////////////
@@ -16,26 +16,26 @@
 //
 ////////////////////////////////////////////////////////////////////
 
-#include "nurbsMatrixVector.h"
+#include "nurbsBasisVector.h"
 
 ////////////////////////////////////////////////////////////////////
-//     Function: NurbsMatrixVector::clear
+//     Function: NurbsBasisVector::clear
 //       Access: Public
 //  Description: Removes all the segments from the curve.
 ////////////////////////////////////////////////////////////////////
-void NurbsMatrixVector::
+void NurbsBasisVector::
 clear(int order) {
   _order = order;
   _segments.clear();
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: NurbsMatrixVector::append_segment
+//     Function: NurbsBasisVector::append_segment
 //       Access: Public
 //  Description: Computes a NURBS basis for one segment of the curve
 //               and appends it to the set of basis matrices.
 ////////////////////////////////////////////////////////////////////
-void NurbsMatrixVector::
+void NurbsBasisVector::
 append_segment(int vertex_index, const float knots[]) {
   int i;
 
@@ -67,12 +67,12 @@ append_segment(int vertex_index, const float knots[]) {
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: NurbsMatrixVector::nurbs_blending_function
+//     Function: NurbsBasisVector::nurbs_blending_function
 //       Access: Private, Static
 //  Description: Recursively computes the appropriate blending
 //               function for the indicated knot vector.
 ////////////////////////////////////////////////////////////////////
-LVecBase4f NurbsMatrixVector::
+LVecBase4f NurbsBasisVector::
 nurbs_blending_function(int order, int i, int j, const float knots[]) {
   // This is doubly recursive.  Ick.
   LVecBase4f r;

panda/src/parametrics/nurbsMatrixVector.h → panda/src/parametrics/nurbsBasisVector.h

@@ -1,4 +1,4 @@
-// Filename: nurbsMatrixVector.h
+// Filename: nurbsBasisVector.h
 // Created by:  drose (03Dec02)
 //
 ////////////////////////////////////////////////////////////////////
@@ -16,8 +16,8 @@
 //
 ////////////////////////////////////////////////////////////////////
 
-#ifndef NURBSMATRIXVECTOR_H
-#define NURBSMATRIXVECTOR_H
+#ifndef NURBSBASISVECTOR_H
+#define NURBSBASISVECTOR_H
 
 #include "pandabase.h"
 #include "luse.h"
@@ -27,7 +27,7 @@
 class NurbsVertex;
 
 ////////////////////////////////////////////////////////////////////
-//       Class : NurbsMatrixVector
+//       Class : NurbsBasisVector
 // Description : This encapsulates a series of matrices that are used
 //               to represent the sequential segments of a
 //               NurbsCurveEvaluator.
@@ -39,10 +39,10 @@ class NurbsVertex;
 //               eventually replace the whole ParametricCurve class
 //               hierarchy.
 ////////////////////////////////////////////////////////////////////
-class NurbsMatrixVector {
+class EXPCL_PANDA NurbsBasisVector {
 public:
-  INLINE NurbsMatrixVector();
-  INLINE ~NurbsMatrixVector();
+  INLINE NurbsBasisVector();
+  INLINE ~NurbsBasisVector();
 
   INLINE int get_order() const;
 
@@ -78,7 +78,7 @@ private:
   Segments _segments;
 };
 
-#include "nurbsMatrixVector.I"
+#include "nurbsBasisVector.I"
 
 #endif
 

panda/src/parametrics/nurbsCurveEvaluator.h

@@ -20,7 +20,7 @@
 #define NURBSCURVEEVALUATOR_H
 
 #include "pandabase.h"
-#include "nurbsMatrixVector.h"
+#include "nurbsBasisVector.h"
 #include "nurbsCurveResult.h"
 #include "nurbsVertex.h"
 #include "pointerTo.h"
@@ -91,7 +91,7 @@ private:
   Knots _knots;
 
   bool _basis_dirty;
-  NurbsMatrixVector _basis;
+  NurbsBasisVector _basis;
 };
 
 #include "nurbsCurveEvaluator.I"

panda/src/parametrics/nurbsCurveResult.cxx

@@ -27,7 +27,7 @@
 //               and the indicated table of control vertex positions.
 ////////////////////////////////////////////////////////////////////
 NurbsCurveResult::
-NurbsCurveResult(const NurbsMatrixVector &basis,
+NurbsCurveResult(const NurbsBasisVector &basis,
                  const LVecBase4f vecs[], const NurbsVertex *verts,
                  int num_vertices) :
   _basis(basis),

panda/src/parametrics/nurbsCurveResult.h

@@ -21,7 +21,7 @@
 
 #include "pandabase.h"
 #include "referenceCount.h"
-#include "nurbsMatrixVector.h"
+#include "nurbsBasisVector.h"
 
 class NurbsVertex;
 
@@ -41,7 +41,7 @@ class NurbsVertex;
 ////////////////////////////////////////////////////////////////////
 class EXPCL_PANDA NurbsCurveResult : public ReferenceCount {
 public:
-  NurbsCurveResult(const NurbsMatrixVector &basis, 
+  NurbsCurveResult(const NurbsBasisVector &basis, 
                    const LVecBase4f vecs[], const NurbsVertex *verts,
                    int num_vertices);
 
@@ -65,7 +65,7 @@ private:
   int find_segment(float t);
   int r_find_segment(float t, int top, int bot) const;
 
-  NurbsMatrixVector _basis;
+  NurbsBasisVector _basis;
   const NurbsVertex *_verts;
 
   // We pre-compose the basis matrix and the geometry vectors, so we

panda/src/parametrics/parametrics_composite2.cxx

@@ -5,6 +5,6 @@
 #include "parametricCurveDrawer.cxx"
 #include "nurbsCurveEvaluator.cxx"
 #include "nurbsCurveResult.cxx"
-#include "nurbsMatrixVector.cxx"
+#include "nurbsBasisVector.cxx"
 #include "nurbsVertex.cxx"
 #include "ropeNode.cxx"