diff --git a/panda/src/parametrics/curve.cxx b/panda/src/parametrics/curve.cxx index b30afc6bc3..8852b51af3 100644 --- a/panda/src/parametrics/curve.cxx +++ b/panda/src/parametrics/curve.cxx @@ -44,6 +44,23 @@ ParametricCurve() { _num_dimensions = 3; } +//////////////////////////////////////////////////////////////////// +// Function: ParametricCurve::Destructor +// Access: Protected +// Description: +//////////////////////////////////////////////////////////////////// +ParametricCurve:: +~ParametricCurve() { + // We must disable each of the drawers that were registered to us, + // so they don't try to access our pointers any more. + DrawerList::iterator d; + + for (d = _drawers.begin(); + d != _drawers.end(); + ++d) { + (*d)->disable(this); + } +} //////////////////////////////////////////////////////////////////// // Function: ParametricCurve::is_valid @@ -168,7 +185,7 @@ calc_length() const { float ParametricCurve:: calc_length(double from, double to) const { double t1, t2; - LVector3f p1, p2; + LPoint3f p1, p2; // Normally we expect from < to. If they came in backwards, reverse // them. @@ -289,7 +306,7 @@ convert_to_hermite(HermiteCurve &hc) const { n = hc.append_cv(HC_SMOOTH, bz_segs[0]._v[0]); hc.set_cv_out(n, 3.0 * (bz_segs[0]._v[1] - bz_segs[0]._v[0]) / scale_out); - for (i = 0; i < bz_segs.size()-1; i++) { + for (i = 0; i < (int)bz_segs.size()-1; i++) { scale_in = scale_out; scale_out = bz_segs[i+1]._t - bz_segs[i]._t; @@ -353,11 +370,11 @@ convert_to_nurbs(NurbsCurve &nc) const { nc.set_order(4); if (!bz_segs.empty()) { int i; - for (i = 0; i=0 && r=0 && cdisable(this); - } -} - //////////////////////////////////////////////////////////////////// // Function: ParametricCurve::invalidate @@ -558,7 +558,7 @@ invalidate_all() { // has the length seglength. //////////////////////////////////////////////////////////////////// float ParametricCurve:: -r_calc_length(double t1, double t2, const LVector3f &p1, const LVector3f &p2, +r_calc_length(double t1, double t2, const LPoint3f &p1, const LPoint3f &p2, float seglength) const { static const float length_tolerance = 0.0000001; static const double t_tolerance = 0.000001; @@ -569,7 +569,7 @@ r_calc_length(double t1, double t2, const LVector3f &p1, const LVector3f &p2, return 0.0; } else { double tmid; - LVector3f pmid; + LPoint3f pmid; float left, right; // Calculate the point on the curve midway between the two @@ -615,6 +615,16 @@ PiecewiseCurve() { _last_ti = 0; } +//////////////////////////////////////////////////////////////////// +// Function: PiecewiseCurve::Destructor +// Access: Protected +// Description: +//////////////////////////////////////////////////////////////////// +PiecewiseCurve:: +~PiecewiseCurve() { + remove_all_curvesegs(); +} + //////////////////////////////////////////////////////////////////// // Function: PiecewiseCurve::is_valid @@ -651,7 +661,7 @@ get_max_t() const { // end (whichever is nearer) and returns false. //////////////////////////////////////////////////////////////////// bool PiecewiseCurve:: -get_point(double t, LVector3f &point) const { +get_point(double t, LVecBase3f &point) const { const ParametricCurve *curve; bool result = find_curve(curve, t); @@ -667,7 +677,7 @@ get_point(double t, LVector3f &point) const { // point t. //////////////////////////////////////////////////////////////////// bool PiecewiseCurve:: -get_tangent(double t, LVector3f &tangent) const { +get_tangent(double t, LVecBase3f &tangent) const { const ParametricCurve *curve; bool result = find_curve(curve, t); @@ -683,7 +693,7 @@ get_tangent(double t, LVector3f &tangent) const { // curve at the point t. //////////////////////////////////////////////////////////////////// bool PiecewiseCurve:: -get_2ndtangent(double t, LVector3f &tangent2) const { +get_2ndtangent(double t, LVecBase3f &tangent2) const { const ParametricCurve *curve; bool result = find_curve(curve, t); @@ -709,10 +719,10 @@ adjust_point(double t, return false; } - rebuild_curveseg(RT_CV | RT_KEEP_ORIG, 0.0, LVector4f(), - RT_POINT, t, LVector4f(px, py, pz, 1.0), - RT_TANGENT | RT_KEEP_ORIG, t, LVector4f(), - RT_CV | RT_KEEP_ORIG, 0.0, LVector4f()); + rebuild_curveseg(RT_CV | RT_KEEP_ORIG, 0.0, LVecBase4f(), + RT_POINT, t, LVecBase4f(px, py, pz, 1.0), + RT_TANGENT | RT_KEEP_ORIG, t, LVecBase4f(), + RT_CV | RT_KEEP_ORIG, 0.0, LVecBase4f()); return true; } @@ -734,10 +744,10 @@ adjust_tangent(double t, return false; } - rebuild_curveseg(RT_CV | RT_KEEP_ORIG, 0.0, LVector4f(), - RT_POINT | RT_KEEP_ORIG, t, LVector4f(), - RT_TANGENT, t, LVector4f(tx, ty, tz, 0.0), - RT_CV | RT_KEEP_ORIG, 0.0, LVector4f()); + rebuild_curveseg(RT_CV | RT_KEEP_ORIG, 0.0, LVecBase4f(), + RT_POINT | RT_KEEP_ORIG, t, LVecBase4f(), + RT_TANGENT, t, LVecBase4f(tx, ty, tz, 0.0), + RT_CV | RT_KEEP_ORIG, 0.0, LVecBase4f()); return true; } @@ -759,10 +769,10 @@ adjust_pt(double t, return false; } - rebuild_curveseg(RT_CV | RT_KEEP_ORIG, 0.0, LVector4f(), - RT_POINT, t, LVector4f(px, py, pz, 1.0), - RT_TANGENT, t, LVector4f(tx, ty, tz, 0.0), - RT_CV | RT_KEEP_ORIG, 0.0, LVector4f()); + rebuild_curveseg(RT_CV | RT_KEEP_ORIG, 0.0, LVecBase4f(), + RT_POINT, t, LVecBase4f(px, py, pz, 1.0), + RT_TANGENT, t, LVecBase4f(tx, ty, tz, 0.0), + RT_CV | RT_KEEP_ORIG, 0.0, LVecBase4f()); return true; } @@ -774,7 +784,7 @@ adjust_pt(double t, // curve at a given parametric point t. //////////////////////////////////////////////////////////////////// bool PiecewiseCurve:: -get_pt(double t, LVector3f &point, LVector3f &tangent) const { +get_pt(double t, LVecBase3f &point, LVecBase3f &tangent) const { const ParametricCurve *curve; bool result = find_curve(curve, t); @@ -802,7 +812,7 @@ get_num_segs() const { //////////////////////////////////////////////////////////////////// ParametricCurve *PiecewiseCurve:: get_curveseg(int ti) { - assert(ti>=0 && ti<_segs.size()); + assert(ti >= 0 && ti < (int)_segs.size()); return _segs[ti]._curve; } @@ -822,11 +832,11 @@ get_curveseg(int ti) { //////////////////////////////////////////////////////////////////// bool PiecewiseCurve:: insert_curveseg(int ti, ParametricCurve *seg, double tlength) { - if (ti<0 || ti>_segs.size()) { + if (ti < 0 || ti > (int)_segs.size()) { return false; } - if (ti==_segs.size()) { + if (ti == (int)_segs.size()) { _segs.push_back(Curveseg(seg, get_max_t() + tlength)); } else if (ti==0) { @@ -851,16 +861,16 @@ insert_curveseg(int ti, ParametricCurve *seg, double tlength) { //////////////////////////////////////////////////////////////////// bool PiecewiseCurve:: remove_curveseg(int ti) { - if (ti<0 || ti>=_segs.size()) { + if (ti < 0 || ti >= (int)_segs.size()) { return false; } - int tlength = get_tlength(ti); + double tlength = get_tlength(ti); _segs.erase(_segs.begin() + ti); // Now update the _tend figures for everything after the one we // removed. - while (ti < _segs.size()) { + while (ti < (int)_segs.size()) { _segs[ti]._tend -= tlength; ti++; } @@ -888,7 +898,7 @@ remove_all_curvesegs() { //////////////////////////////////////////////////////////////////// double PiecewiseCurve:: get_tlength(int ti) const { - assert(ti>=0 && ti<_segs.size()); + assert(ti >= 0 && ti < (int)_segs.size()); return (ti==0) ? _segs[ti]._tend : _segs[ti]._tend - _segs[ti-1]._tend; } @@ -900,7 +910,7 @@ get_tlength(int ti) const { //////////////////////////////////////////////////////////////////// double PiecewiseCurve:: get_tstart(int ti) const { - assert(ti>=0 && ti<=_segs.size()); + assert(ti >= 0 && ti <= (int)_segs.size()); return (ti==0) ? 0.0 : _segs[ti-1]._tend; } @@ -912,7 +922,7 @@ get_tstart(int ti) const { //////////////////////////////////////////////////////////////////// double PiecewiseCurve:: get_tend(int ti) const { - assert(ti>=0 && ti<_segs.size()); + assert(ti >= 0 && ti < (int)_segs.size()); return _segs[ti]._tend; } @@ -927,7 +937,7 @@ get_tend(int ti) const { //////////////////////////////////////////////////////////////////// bool PiecewiseCurve:: set_tlength(int ti, double tlength) { - if (ti<0 || ti>=_segs.size()) { + if (ti < 0 || ti >= (int)_segs.size()) { return false; } @@ -953,7 +963,7 @@ set_tlength(int ti, double tlength) { //////////////////////////////////////////////////////////////////// void PiecewiseCurve:: make_nurbs(int order, int num_cvs, - const double knots[], const LVector4f cvs[]) { + const double knots[], const LVecBase4f cvs[]) { remove_all_curvesegs(); for (int i=0; iGetBezierSeg(seg)) { return false; } @@ -1003,24 +1013,14 @@ GetBezierSegs(BezierSegs &bz_segs) const { // possible, false if something goes horribly wrong. //////////////////////////////////////////////////////////////////// bool PiecewiseCurve:: -rebuild_curveseg(int, double, const LVector4f &, - int, double, const LVector4f &, - int, double, const LVector4f &, - int, double, const LVector4f &) { +rebuild_curveseg(int, double, const LVecBase4f &, + int, double, const LVecBase4f &, + int, double, const LVecBase4f &, + int, double, const LVecBase4f &) { cerr << "rebuild_curveseg not implemented for this curve type.\n"; return false; } -//////////////////////////////////////////////////////////////////// -// Function: PiecewiseCurve::Destructor -// Access: Protected -// Description: -//////////////////////////////////////////////////////////////////// -PiecewiseCurve:: -~PiecewiseCurve() { - remove_all_curvesegs(); -} - //////////////////////////////////////////////////////////////////// // Function: PiecewiseCurve::find_curve // Access: Protected @@ -1053,13 +1053,13 @@ find_curve(const ParametricCurve *&curve, double &t) const { } int ti; - for (ti = _last_ti; ti<_segs.size(); ti++) { + for (ti = _last_ti; ti < (int)_segs.size(); ti++) { if (_segs[ti]._tend+0.00001 > t) { break; } } - if (ti < _segs.size()) { + if (ti < (int)_segs.size()) { // Adjust t to the range [0,1). if (ti > 0) { t = (t - _segs[ti-1]._tend) / (_segs[ti]._tend - _segs[ti-1]._tend); @@ -1075,8 +1075,8 @@ find_curve(const ParametricCurve *&curve, double &t) const { return false; } - if (ti >= _segs.size() || !_segs[ti]._curve->is_valid()) { - assert(ti <= _segs.size()); + if (ti >= (int)_segs.size() || !_segs[ti]._curve->is_valid()) { + assert(ti <= (int)_segs.size()); // If we're out of bounds, or the curve is undefined, we're probably // screwed. There's one exception: if we were right on a border between @@ -1087,7 +1087,7 @@ find_curve(const ParametricCurve *&curve, double &t) const { t = 1.0; } - if (ti >= _segs.size()) { + if (ti >= (int)_segs.size()) { if (_segs.empty()) { curve = NULL; t = 0.0; @@ -1132,7 +1132,7 @@ double PiecewiseCurve:: current_seg_range(double t) const { int ti = _last_ti; - assert(ti < _segs.size()); + assert(ti < (int)_segs.size()); // Adjust t to the range [0,1). if (ti > 0) { @@ -1187,10 +1187,19 @@ CubicCurveseg(const BezierSeg &seg) { // nurbs_basis for a description of the parameters. //////////////////////////////////////////////////////////////////// CubicCurveseg:: -CubicCurveseg(int order, const double knots[], const LVector4f cvs[]) { +CubicCurveseg(int order, const double knots[], const LVecBase4f cvs[]) { nurbs_basis(order, knots, cvs); } +//////////////////////////////////////////////////////////////////// +// Function: CubicCurveseg::Destructor +// Access: Protected +// Description: +//////////////////////////////////////////////////////////////////// +CubicCurveseg:: +~CubicCurveseg() { +} + //////////////////////////////////////////////////////////////////// @@ -1200,8 +1209,8 @@ CubicCurveseg(int order, const double knots[], const LVector4f cvs[]) { // point t. //////////////////////////////////////////////////////////////////// bool CubicCurveseg:: -get_point(double t, LVector3f &point) const { - evaluate_point(LVector4f(t*t*t, t*t, t, 1.0), point); +get_point(double t, LVecBase3f &point) const { + evaluate_point(LVecBase4f(t*t*t, t*t, t, 1.0), point); return true; } @@ -1212,8 +1221,8 @@ get_point(double t, LVector3f &point) const { // point t. //////////////////////////////////////////////////////////////////// bool CubicCurveseg:: -get_tangent(double t, LVector3f &tangent) const { - evaluate_vector(LVector4f(3.0*t*t, 2.0*t, 1.0, 0.0), tangent); +get_tangent(double t, LVecBase3f &tangent) const { + evaluate_vector(LVecBase4f(3.0*t*t, 2.0*t, 1.0, 0.0), tangent); return true; } @@ -1224,9 +1233,9 @@ get_tangent(double t, LVector3f &tangent) const { // the given parametric point. //////////////////////////////////////////////////////////////////// bool CubicCurveseg:: -get_pt(double t, LVector3f &point, LVector3f &tangent) const { - evaluate_point(LVector4f(t*t*t, t*t, t, 1.0), point); - evaluate_vector(LVector4f(3.0*t*t, 2.0*t, 1.0, 0.0), tangent); +get_pt(double t, LVecBase3f &point, LVecBase3f &tangent) const { + evaluate_point(LVecBase4f(t*t*t, t*t, t, 1.0), point); + evaluate_vector(LVecBase4f(3.0*t*t, 2.0*t, 1.0, 0.0), tangent); return true; } @@ -1237,8 +1246,8 @@ get_pt(double t, LVector3f &point, LVector3f &tangent) const { // parametric point t. //////////////////////////////////////////////////////////////////// bool CubicCurveseg:: -get_2ndtangent(double t, LVector3f &tangent2) const { - evaluate_vector(LVector4f(6.0*t, 2.0, 0.0, 0.0), tangent2); +get_2ndtangent(double t, LVecBase3f &tangent2) const { + evaluate_vector(LVecBase4f(6.0*t, 2.0, 0.0, 0.0), tangent2); return true; } @@ -1260,11 +1269,11 @@ hermite_basis(const HermiteCurveCV &cv0, 1, -2, 1, 0, 1, -1, 0, 0); - LVector4f Gx(cv0._p[0], cv1._p[0], + LVecBase4f Gx(cv0._p[0], cv1._p[0], cv0._out[0]*tlength, cv1._in[0]*tlength); - LVector4f Gy(cv0._p[1], cv1._p[1], + LVecBase4f Gy(cv0._p[1], cv1._p[1], cv0._out[1]*tlength, cv1._in[1]*tlength); - LVector4f Gz(cv0._p[2], cv1._p[2], + LVecBase4f Gz(cv0._p[2], cv1._p[2], cv0._out[2]*tlength, cv1._in[2]*tlength); Bx = Gx * Mh; @@ -1288,9 +1297,9 @@ bezier_basis(const BezierSeg &seg) { -3, 3, 0, 0, 1, 0, 0, 0); - LVector4f Gx(seg._v[0][0], seg._v[1][0], seg._v[2][0], seg._v[3][0]); - LVector4f Gy(seg._v[0][1], seg._v[1][1], seg._v[2][1], seg._v[3][1]); - LVector4f Gz(seg._v[0][2], seg._v[1][2], seg._v[2][2], seg._v[3][2]); + LVecBase4f Gx(seg._v[0][0], seg._v[1][0], seg._v[2][0], seg._v[3][0]); + LVecBase4f Gy(seg._v[0][1], seg._v[1][1], seg._v[2][1], seg._v[3][1]); + LVecBase4f Gz(seg._v[0][2], seg._v[1][2], seg._v[2][2], seg._v[3][2]); Bx = Gx * Mb; By = Gy * Mb; @@ -1298,11 +1307,11 @@ bezier_basis(const BezierSeg &seg) { rational = false; } -static LVector4f +static LVecBase4f nurbs_blending_function(int order, int i, int j, const double knots[]) { // This is doubly recursive. Ick. - LVector4f r; + LVecBase4f r; if (j==1) { if (i==order-1 && knots[i] < knots[i+1]) { @@ -1312,8 +1321,8 @@ nurbs_blending_function(int order, int i, int j, } } else { - LVector4f bi0 = nurbs_blending_function(order, i, j-1, knots); - LVector4f bi1 = nurbs_blending_function(order, i+1, j-1, knots); + LVecBase4f bi0 = nurbs_blending_function(order, i, j-1, knots); + LVecBase4f bi1 = nurbs_blending_function(order, i+1, j-1, knots); float d0 = knots[i+j-1] - knots[i]; float d1 = knots[i+j] - knots[i+1]; @@ -1379,7 +1388,7 @@ compute_nurbs_basis(int order, } - LVector4f b[4]; + LVecBase4f b[4]; for (i = 0; i=1 && order<=4); LMatrix4f B; @@ -1412,15 +1421,15 @@ nurbs_basis(int order, const double knots[], const LVector4f cvs[]) { // Create a local copy of our CV's, so we can zero out the unused // elements. - LVector4f c[4]; + LVecBase4f c[4]; for (int i = 0; i < 4; i++) { - c[i] = (i BezierSegs; - ParametricCurve(); - virtual void write_datagram(BamWriter *, Datagram &); virtual bool GetBezierSegs(BezierSegs &) const { @@ -135,13 +136,11 @@ public: void unregister_drawer(ParametricCurveDrawer *drawer); protected: - virtual ~ParametricCurve(); - void invalidate(double t1, double t2); void invalidate_all(); float r_calc_length(double t1, double t2, - const LVector3f &p1, const LVector3f &p2, + const LPoint3f &p1, const LPoint3f &p2, float seglength) const; typedef list< ParametricCurveDrawer * > DrawerList; @@ -155,7 +154,11 @@ public: return _type_handle; } static void init_type() { - register_type(_type_handle, "ParametricCurve"); + TypedWriteableReferenceCount::init_type(); + Namable::init_type(); + register_type(_type_handle, "ParametricCurve", + TypedWriteableReferenceCount::get_class_type(), + Namable::get_class_type()); } virtual TypeHandle get_type() const { return get_class_type(); @@ -176,13 +179,16 @@ private: //////////////////////////////////////////////////////////////////// class EXPCL_PANDA PiecewiseCurve : public ParametricCurve { PUBLISHED: + PiecewiseCurve(); + ~PiecewiseCurve(); + virtual bool is_valid() const; virtual double get_max_t() const; - virtual bool get_point(double t, LVector3f &point) const; - virtual bool get_tangent(double t, LVector3f &tangent) const; - virtual bool get_pt(double t, LVector3f &point, LVector3f &tangent) const; - virtual bool get_2ndtangent(double t, LVector3f &tangent2) const; + virtual bool get_point(double t, LVecBase3f &point) const; + virtual bool get_tangent(double t, LVecBase3f &tangent) const; + virtual bool get_pt(double t, LVecBase3f &point, LVecBase3f &tangent) const; + virtual bool get_2ndtangent(double t, LVecBase3f &tangent2) const; bool adjust_point(double t, float px, float py, float pz); @@ -193,8 +199,6 @@ PUBLISHED: float tx, float ty, float tz); public: - PiecewiseCurve(); - int get_num_segs() const; ParametricCurve *get_curveseg(int ti); @@ -209,19 +213,17 @@ public: bool set_tlength(int ti, double tlength); void make_nurbs(int order, int num_cvs, - const double knots[], const LVector4f cvs[]); + const double knots[], const LVecBase4f cvs[]); virtual bool GetBezierSegs(BezierSegs &bz_segs) const; virtual bool - rebuild_curveseg(int rtype0, double t0, const LVector4f &v0, - int rtype1, double t1, const LVector4f &v1, - int rtype2, double t2, const LVector4f &v2, - int rtype3, double t3, const LVector4f &v3); + rebuild_curveseg(int rtype0, double t0, const LVecBase4f &v0, + int rtype1, double t1, const LVecBase4f &v1, + int rtype2, double t2, const LVecBase4f &v2, + int rtype3, double t3, const LVecBase4f &v3); protected: - ~PiecewiseCurve(); - bool find_curve(const ParametricCurve *&curve, double &t) const; double current_seg_range(double t) const; @@ -289,22 +291,24 @@ private: //////////////////////////////////////////////////////////////////// class EXPCL_PANDA CubicCurveseg : public ParametricCurve { PUBLISHED: - virtual bool get_point(double t, LVector3f &point) const; - virtual bool get_tangent(double t, LVector3f &tangent) const; - virtual bool get_pt(double t, LVector3f &point, LVector3f &tangent) const; - virtual bool get_2ndtangent(double t, LVector3f &tangent2) const; + virtual bool get_point(double t, LVecBase3f &point) const; + virtual bool get_tangent(double t, LVecBase3f &tangent) const; + virtual bool get_pt(double t, LVecBase3f &point, LVecBase3f &tangent) const; + virtual bool get_2ndtangent(double t, LVecBase3f &tangent2) const; public: CubicCurveseg(); CubicCurveseg(const LMatrix4f &basis); CubicCurveseg(const BezierSeg &seg); - CubicCurveseg(int order, const double knots[], const LVector4f cvs[]); + CubicCurveseg(int order, const double knots[], const LVecBase4f cvs[]); + + virtual ~CubicCurveseg(); void hermite_basis(const HermiteCurveCV &cv0, const HermiteCurveCV &cv1, double tlength = 1.0); void bezier_basis(const BezierSeg &seg); - void nurbs_basis(int order, const double knots[], const LVector4f cvs[]); + void nurbs_basis(int order, const double knots[], const LVecBase4f cvs[]); // evaluate_point() and evaluate_vector() both evaluate the curve at // a given point by applying the basis vector against the vector @@ -317,14 +321,14 @@ public: // points, and will never scale by the homogeneous coordinate (which // would be zero anyway). - void evaluate_point(const LVector4f &tv, LVector3f &result) const { + void evaluate_point(const LVecBase4f &tv, LVecBase3f &result) const { double h = (rational) ? tv.dot(Bw) : 1.0; result.set(tv.dot(Bx) / h, tv.dot(By) / h, tv.dot(Bz) / h); } - void evaluate_vector(const LVector4f &tv, LVector3f &result) const { + void evaluate_vector(const LVecBase4f &tv, LVecBase3f &result) const { result.set(tv.dot(Bx), tv.dot(By), tv.dot(Bz)); @@ -332,21 +336,17 @@ public: virtual bool GetBezierSeg(BezierSeg &seg) const; - static bool compute_seg(int rtype0, double t0, const LVector4f &v0, - int rtype1, double t1, const LVector4f &v1, - int rtype2, double t2, const LVector4f &v2, - int rtype3, double t3, const LVector4f &v3, + static bool compute_seg(int rtype0, double t0, const LVecBase4f &v0, + int rtype1, double t1, const LVecBase4f &v1, + int rtype2, double t2, const LVecBase4f &v2, + int rtype3, double t3, const LVecBase4f &v3, const LMatrix4f &B, const LMatrix4f &Bi, LMatrix4f &G); - LVector4f Bx, By, Bz, Bw; + LVecBase4f Bx, By, Bz, Bw; bool rational; -protected: - virtual ~CubicCurveseg(); - - public: static TypeHandle get_class_type() { return _type_handle; diff --git a/panda/src/parametrics/curveDrawer.cxx b/panda/src/parametrics/curveDrawer.cxx index 5463fac0a2..809ccd8bf5 100644 --- a/panda/src/parametrics/curveDrawer.cxx +++ b/panda/src/parametrics/curveDrawer.cxx @@ -298,11 +298,11 @@ draw() { } // Otherwise, let's go to town! - int total_segs = floor(_curve->get_max_t() * _num_segs + 0.5); + int total_segs = (int)floor(_curve->get_max_t() * _num_segs + 0.5); double scale = _curve->get_max_t() / (double)(total_segs-1); double t; - LVector3f point, tangent; + LVecBase3f point, tangent; bool last_in, next_in; last_in = false; @@ -316,7 +316,7 @@ draw() { next_in = _curve->get_pt(t, point, tangent); - LVector3f p = _mapper(point, tangent, t); + LVecBase3f p = _mapper(point, tangent, t); if (!next_in || !last_in) { _lines.move_to(p); @@ -331,8 +331,8 @@ draw() { // Now draw the time tick marks. if (_num_ticks > 0) { - LVector3f tangent2; - int total_ticks = floor(_curve->get_max_t() * _num_ticks + 0.5); + LVecBase3f tangent2; + int total_ticks = (int)floor(_curve->get_max_t() * _num_ticks + 0.5); scale = get_max_t() / (double)(total_ticks-1); for (i = 0; iget_pt(t, point, tangent); _curve->get_2ndtangent(t, tangent2); - LVector3f pt = _mapper(point, tangent, t); - LVector3f t1, t2; + LVecBase3f pt = _mapper(point, tangent, t); + LVecBase3f t1, t2; get_tick_marks(_mapper(tangent, tangent2, t + 1.0), t1, t2); _ticks.move_to(pt - t1 * _tick_scale); @@ -397,13 +397,13 @@ recompute(double t1, double t2, ParametricCurve *curve) { int n1, n2, i; double scale, t; - LVector3f point, tangent; + LVecBase3f point, tangent; if (redraw_curve) { // Compute the number of total segments we will draw. This is based // on the parametric length of the curve, _curve->get_max_t(). - int total_segs = floor(_curve->get_max_t() * _num_segs + 0.5); + int total_segs = (int)floor(_curve->get_max_t() * _num_segs + 0.5); n1 = (int)floor(t1 * (total_segs-1)); n2 = (int)ceil(t2 * (total_segs-1)); @@ -419,14 +419,14 @@ recompute(double t1, double t2, ParametricCurve *curve) { _curve->get_pt(t, point, tangent); - LVector3f p = _mapper(point, tangent, t); + LVecBase3f p = _mapper(point, tangent, t); _lines.set_vertex(i, p); } } if (_num_ticks > 0) { - LVector3f tangent2; - int total_ticks = floor(_curve->get_max_t() * _num_ticks + 0.5); + LVecBase3f tangent2; + int total_ticks = (int)floor(_curve->get_max_t() * _num_ticks + 0.5); n1 = (int)floor(t1 * (total_ticks-1)); n2 = (int)ceil(t2 * (total_ticks-1)); @@ -442,8 +442,8 @@ recompute(double t1, double t2, ParametricCurve *curve) { _curve->get_pt(t, point, tangent); _curve->get_2ndtangent(t, tangent2); - LVector3f pt = _mapper(point, tangent, t); - LVector3f t1, t2; + LVecBase3f pt = _mapper(point, tangent, t); + LVecBase3f t1, t2; get_tick_marks(_mapper(tangent, tangent2, t + 1.0), t1, t2); @@ -583,7 +583,7 @@ disable(ParametricCurve *curve) { // it to a three-dimensional representation. //////////////////////////////////////////////////////////////////// void ParametricCurveDrawer:: -set_mapper(LVector3fMapper *mapper) { +set_mapper(LVecBase3fMapper *mapper) { // If the mapper hasn't changed, don't force a redraw. if (_mapper != mapper) { _mapper = mapper; @@ -601,9 +601,9 @@ set_mapper(LVector3fMapper *mapper) { // each point, showing the line's three-dimensional // shape. //////////////////////////////////////////////////////////////////// -LVector3f ParametricCurveDrawer:: -DefaultMap(const LVector3f &point, const LVector3f &, double) { - return LVector3f(point[0], point[1], point[2]); +LVecBase3f ParametricCurveDrawer:: +DefaultMap(const LVecBase3f &point, const LVecBase3f &, double) { + return LVecBase3f(point[0], point[1], point[2]); } @@ -613,9 +613,9 @@ DefaultMap(const LVector3f &point, const LVector3f &, double) { // Description: This mapping function shows a graph of X(t), with the // x along the Y axis and t along the X axis. //////////////////////////////////////////////////////////////////// -LVector3f ParametricCurveDrawer:: -XvsT(const LVector3f &point, const LVector3f &, double t) { - return LVector3f(t, point[0], 0.0); +LVecBase3f ParametricCurveDrawer:: +XvsT(const LVecBase3f &point, const LVecBase3f &, double t) { + return LVecBase3f(t, point[0], 0.0); } //////////////////////////////////////////////////////////////////// @@ -624,9 +624,9 @@ XvsT(const LVector3f &point, const LVector3f &, double t) { // Description: This mapping function shows a graph of X(t), with the // x along the X axis and t along the Y axis. //////////////////////////////////////////////////////////////////// -LVector3f ParametricCurveDrawer:: -iXvsT(const LVector3f &point, const LVector3f &, double t) { - return LVector3f(point[0], t, 0.0); +LVecBase3f ParametricCurveDrawer:: +iXvsT(const LVecBase3f &point, const LVecBase3f &, double t) { + return LVecBase3f(point[0], t, 0.0); } //////////////////////////////////////////////////////////////////// @@ -635,9 +635,9 @@ iXvsT(const LVector3f &point, const LVector3f &, double t) { // Description: This mapping function shows a graph of Y(t), with the // y along the Y axis and t along the X axis. //////////////////////////////////////////////////////////////////// -LVector3f ParametricCurveDrawer:: -YvsT(const LVector3f &point, const LVector3f &, double t) { - return LVector3f(t, point[1], 0.0); +LVecBase3f ParametricCurveDrawer:: +YvsT(const LVecBase3f &point, const LVecBase3f &, double t) { + return LVecBase3f(t, point[1], 0.0); } //////////////////////////////////////////////////////////////////// @@ -646,9 +646,9 @@ YvsT(const LVector3f &point, const LVector3f &, double t) { // Description: This mapping function shows a graph of Y(t), with the // y along the X axis and t along the Y axis. //////////////////////////////////////////////////////////////////// -LVector3f ParametricCurveDrawer:: -iYvsT(const LVector3f &point, const LVector3f &, double t) { - return LVector3f(point[1], t, 0.0); +LVecBase3f ParametricCurveDrawer:: +iYvsT(const LVecBase3f &point, const LVecBase3f &, double t) { + return LVecBase3f(point[1], t, 0.0); } //////////////////////////////////////////////////////////////////// @@ -657,9 +657,9 @@ iYvsT(const LVector3f &point, const LVector3f &, double t) { // Description: This mapping function shows a graph of Z(t), with the // z along the Y axis and t along the X axis. //////////////////////////////////////////////////////////////////// -LVector3f ParametricCurveDrawer:: -ZvsT(const LVector3f &point, const LVector3f &, double t) { - return LVector3f(t, point[2], 0.0); +LVecBase3f ParametricCurveDrawer:: +ZvsT(const LVecBase3f &point, const LVecBase3f &, double t) { + return LVecBase3f(t, point[2], 0.0); } @@ -669,9 +669,9 @@ ZvsT(const LVector3f &point, const LVector3f &, double t) { // Description: This mapping function shows a graph of dX(t), the // derivative of X(t). //////////////////////////////////////////////////////////////////// -LVector3f ParametricCurveDrawer:: -dXvsT(const LVector3f &, const LVector3f &tangent, double t) { - return LVector3f(t, tangent[0], 0.0); +LVecBase3f ParametricCurveDrawer:: +dXvsT(const LVecBase3f &, const LVecBase3f &tangent, double t) { + return LVecBase3f(t, tangent[0], 0.0); } //////////////////////////////////////////////////////////////////// @@ -680,9 +680,9 @@ dXvsT(const LVector3f &, const LVector3f &tangent, double t) { // Description: This mapping function shows a graph of dY(t), the // derivative of Y(t). //////////////////////////////////////////////////////////////////// -LVector3f ParametricCurveDrawer:: -dYvsT(const LVector3f &, const LVector3f &tangent, double t) { - return LVector3f(t, tangent[1], 0.0); +LVecBase3f ParametricCurveDrawer:: +dYvsT(const LVecBase3f &, const LVecBase3f &tangent, double t) { + return LVecBase3f(t, tangent[1], 0.0); } //////////////////////////////////////////////////////////////////// @@ -691,9 +691,9 @@ dYvsT(const LVector3f &, const LVector3f &tangent, double t) { // Description: This mapping function shows a graph of dZ(t), the // derivative of Z(t). //////////////////////////////////////////////////////////////////// -LVector3f ParametricCurveDrawer:: -dZvsT(const LVector3f &, const LVector3f &tangent, double t) { - return LVector3f(t, tangent[2], 0.0); +LVecBase3f ParametricCurveDrawer:: +dZvsT(const LVecBase3f &, const LVecBase3f &tangent, double t) { + return LVecBase3f(t, tangent[2], 0.0); } //////////////////////////////////////////////////////////////////// @@ -704,7 +704,7 @@ dZvsT(const LVector3f &, const LVector3f &tangent, double t) { // drawing as tick marks. //////////////////////////////////////////////////////////////////// void ParametricCurveDrawer:: -get_tick_marks(const LVector3f &tangent, LVector3f &t1, LVector3f &t2) { +get_tick_marks(const LVecBase3f &tangent, LVecBase3f &t1, LVecBase3f &t2) { LVector3f tn = tangent; tn.normalize(); diff --git a/panda/src/parametrics/curveDrawer.h b/panda/src/parametrics/curveDrawer.h index 9b164eb001..cfc9b497a5 100644 --- a/panda/src/parametrics/curveDrawer.h +++ b/panda/src/parametrics/curveDrawer.h @@ -22,12 +22,14 @@ #include "curve.h" #include "lineSegs.h" +#include + //////////////////////////////////////////////////////////////////// // Defines //////////////////////////////////////////////////////////////////// -typedef LVector3f LVector3fMapper(const LVector3f &point, - const LVector3f &tangent, +typedef LVecBase3f LVecBase3fMapper(const LVecBase3f &point, + const LVecBase3f &tangent, double t); BEGIN_PUBLISH //[ @@ -50,7 +52,7 @@ class ParametricSurface; // Description : Draws a 3-d parametric curve in the scene by creating // a series of line segments to approximate the curve. //////////////////////////////////////////////////////////////////// -class EXPCL_PANDA ParametricCurveDrawer { +class EXPCL_PANDA ParametricCurveDrawer : public TypedObject { //////////////////////////////////////////////////////////////////// // Member functions visible to Scheme @@ -101,20 +103,20 @@ public: void disable(ParametricCurve *curve); - void set_mapper(LVector3fMapper *mapper); + void set_mapper(LVecBase3fMapper *mapper); - static LVector3f DefaultMap(const LVector3f &point, const LVector3f &, double); - static LVector3f XvsT(const LVector3f &point, const LVector3f &, double t); - static LVector3f iXvsT(const LVector3f &point, const LVector3f &, double t); - static LVector3f YvsT(const LVector3f &point, const LVector3f &, double t); - static LVector3f iYvsT(const LVector3f &point, const LVector3f &, double t); - static LVector3f ZvsT(const LVector3f &point, const LVector3f &, double t); - static LVector3f dXvsT(const LVector3f &, const LVector3f &tangent, double t); - static LVector3f dYvsT(const LVector3f &, const LVector3f &tangent, double t); - static LVector3f dZvsT(const LVector3f &, const LVector3f &tangent, double t); + static LVecBase3f DefaultMap(const LVecBase3f &point, const LVecBase3f &, double); + static LVecBase3f XvsT(const LVecBase3f &point, const LVecBase3f &, double t); + static LVecBase3f iXvsT(const LVecBase3f &point, const LVecBase3f &, double t); + static LVecBase3f YvsT(const LVecBase3f &point, const LVecBase3f &, double t); + static LVecBase3f iYvsT(const LVecBase3f &point, const LVecBase3f &, double t); + static LVecBase3f ZvsT(const LVecBase3f &point, const LVecBase3f &, double t); + static LVecBase3f dXvsT(const LVecBase3f &, const LVecBase3f &tangent, double t); + static LVecBase3f dYvsT(const LVecBase3f &, const LVecBase3f &tangent, double t); + static LVecBase3f dZvsT(const LVecBase3f &, const LVecBase3f &tangent, double t); protected: - static void get_tick_marks(const LVector3f &tangent, LVector3f &t1, LVector3f &t2); + static void get_tick_marks(const LVecBase3f &tangent, LVecBase3f &t1, LVecBase3f &t2); PT(GeomNode) _geom_node; int _num_segs; @@ -124,7 +126,7 @@ protected: int _num_ticks; double _tick_scale; bool _frame_accurate; - LVector3fMapper *_mapper; + LVecBase3fMapper *_mapper; public: @@ -132,7 +134,8 @@ public: return _type_handle; } static void init_type() { - register_type(_type_handle, "ParametricCurveDrawer"); + register_type(_type_handle, "ParametricCurveDrawer", + TypedObject::get_class_type()); } virtual TypeHandle get_type() const { return get_class_type(); diff --git a/panda/src/parametrics/curveFitter.cxx b/panda/src/parametrics/curveFitter.cxx index b3c6f7d79e..a509791b6f 100644 --- a/panda/src/parametrics/curveFitter.cxx +++ b/panda/src/parametrics/curveFitter.cxx @@ -23,6 +23,24 @@ TypeHandle CurveFitter::_type_handle; +//////////////////////////////////////////////////////////////////// +// Function: CurveFitter::Constructor +// Access: Public +// Description: +//////////////////////////////////////////////////////////////////// +CurveFitter:: +CurveFitter() { +} + +//////////////////////////////////////////////////////////////////// +// Function: CurveFitter::Destructor +// Access: Public +// Description: +//////////////////////////////////////////////////////////////////// +CurveFitter:: +~CurveFitter() { +} + //////////////////////////////////////////////////////////////////// // Function: CurveFitter::reset // Access: Public @@ -40,7 +58,7 @@ reset() { // Description: Adds a single sample point. //////////////////////////////////////////////////////////////////// void CurveFitter:: -add_point(double t, const LVector3f &point) { +add_point(double t, const LVecBase3f &point) { DataPoint dp; dp._t = t; dp._point = point; @@ -117,8 +135,8 @@ generate_even(int count, double net_distance, double net_time) { void CurveFitter:: wrap_hpr() { Data::iterator di; - LVector3f last(0.0, 0.0, 0.0); - LVector3f net(0.0, 0.0, 0.0); + LVecBase3f last(0.0, 0.0, 0.0); + LVecBase3f net(0.0, 0.0, 0.0); for (di = _data.begin(); di != _data.end(); ++di) { int i; @@ -167,14 +185,14 @@ compute_timewarp(const ParametricCurve *xyz) { /* // Special HPR computation { - LVector3f tangent; + LVecBase3f tangent; LMatrix4f mat; pfCoord c; static double last_h = 0.0; static double h_net = 0.0; xyz->get_tangent(t, tangent); - look_at(mat, tangent, LVector3f(0.0, 0.0, 1.0)); + look_at(mat, tangent, LVecBase3f(0.0, 0.0, 1.0)); mat.getOrthoCoord(&c); cerr << "Replacing R " << c.hpr[2] << " with " << (*di)._point[1] << "\n"; c.hpr[2] = (*di)._point[1]; @@ -232,7 +250,7 @@ desample(double factor) { double count = factor; out = 0; - for (in = 0; in < _data.size()-1; in++) { + for (in = 0; in < (int)_data.size()-1; in++) { if (count >= factor) { _data[out] = _data[in]; out++; @@ -296,9 +314,9 @@ compute_tangents(double scale) { // Description: Converts the current set of data points into a // Hermite curve. //////////////////////////////////////////////////////////////////// -HermiteCurve *CurveFitter:: +PT(HermiteCurve) CurveFitter:: make_hermite() const { - HermiteCurve *hc = new HermiteCurve; + PT(HermiteCurve) hc = new HermiteCurve; Data::const_iterator di; for (di = _data.begin(); di != _data.end(); ++di) { @@ -319,30 +337,30 @@ make_hermite() const { // NURBS curve. This gives a smoother curve than // produced by MakeHermite(). //////////////////////////////////////////////////////////////////// -NurbsCurve *CurveFitter:: +PT(NurbsCurve) CurveFitter:: make_nurbs() const { if (_data.size() < 2) { return NULL; } #if 0 - NurbsCurve *nc = new NurbsCurve; + PT(NurbsCurve) nc = new NurbsCurve; nc->set_order(4); // First, we need four CV's to get started. - nc->append_cv(LVector3f(0.0, 0.0, 0.0)); - nc->append_cv(LVector3f(0.0, 0.0, 0.0)); - nc->append_cv(LVector3f(0.0, 0.0, 0.0)); - nc->append_cv(LVector3f(0.0, 0.0, 0.0)); + nc->append_cv(LVecBase3f(0.0, 0.0, 0.0)); + nc->append_cv(LVecBase3f(0.0, 0.0, 0.0)); + nc->append_cv(LVecBase3f(0.0, 0.0, 0.0)); + nc->append_cv(LVecBase3f(0.0, 0.0, 0.0)); nc->set_knot(4, _data[1]._t); nc->recompute(); - LVector3f junk; + LVecBase3f junk; nc->get_point(nc->get_max_t(), junk); // Reference the last segment. - const LVector3f &p0 = _data[0]._point; - LVector3f t0 = _data[0]._tangent * 2.0; - LVector3f t1 = _data[1]._tangent * 2.0; - const LVector3f &p1 = _data[1]._point; + const LVecBase3f &p0 = _data[0]._point; + LVecBase3f t0 = _data[0]._tangent * 2.0; + LVecBase3f t1 = _data[1]._tangent * 2.0; + const LVecBase3f &p1 = _data[1]._point; nc->rebuild_curveseg(RT_POINT, 0.0, pfVec4(p0[0], p0[1], p0[2], 1.0), RT_TANGENT, 0.0, pfVec4(t0[0], t0[1], t0[2], 0.0), @@ -352,16 +370,16 @@ make_nurbs() const { int i; for (i = 2; i < _data.size(); i++) { cerr << "Adding point " << i << "\n"; - nc->append_cv(LVector3f(0.0, 0.0, 0.0)); + nc->append_cv(LVecBase3f(0.0, 0.0, 0.0)); nc->set_knot(i + 3, _data[i]._t); nc->recompute(); nc->get_point(nc->get_max_t(), junk); /* - const LVector3f &p0 = _data[i-1]._point; - const LVector3f &t0 = _data[i-1]._tangent; - const LVector3f &p1 = _data[i]._point; - const LVector3f &t1 = _data[i]._tangent; + const LVecBase3f &p0 = _data[i-1]._point; + const LVecBase3f &t0 = _data[i-1]._tangent; + const LVecBase3f &p1 = _data[i]._point; + const LVecBase3f &t1 = _data[i]._tangent; nc->rebuild_curveseg(RT_POINT, 0.0, pfVec4(p0[0], p0[1], p0[2], 1.0), RT_TANGENT, 0.0, pfVec4(t0[0], t0[1], t0[2], 0.0), @@ -369,7 +387,7 @@ make_nurbs() const { RT_POINT, 1.0, pfVec4(p1[0], p1[1], p1[2], 1.0)); */ - const LVector3f &pi = _data[i]._point; + const LVecBase3f &pi = _data[i]._point; nc->rebuild_curveseg(RT_CV | RT_KEEP_ORIG, 0.0, pfVec4(), RT_CV | RT_KEEP_ORIG, 0.0, pfVec4(), RT_CV | RT_KEEP_ORIG, 0.0, pfVec4(), @@ -377,10 +395,10 @@ make_nurbs() const { } /* - nc->append_cv(LVector3f(0.0, 0.0, 0.0)); + nc->append_cv(LVecBase3f(0.0, 0.0, 0.0)); nc->recompute(); nc->get_point(nc->get_max_t(), junk); - const LVector3f &pi = _data[_data.size()-1]._point; + const LVecBase3f &pi = _data[_data.size()-1]._point; nc->rebuild_curveseg(RT_CV | RT_KEEP_ORIG, 0.0, pfVec4(), RT_CV | RT_KEEP_ORIG, 0.0, pfVec4(), RT_CV | RT_KEEP_ORIG, 0.0, pfVec4(), @@ -394,8 +412,8 @@ make_nurbs() const { // We start with the HermiteCurve produced above, then convert it to // NURBS form. - PT(HermiteCurve) hc = new HermiteCurve(); - NurbsCurve *nc = new NurbsCurve(*hc); + PT(HermiteCurve) hc = make_hermite(); + PT(NurbsCurve) nc = new NurbsCurve(*hc); // Now we even out the knots to smooth out the curve and make // everything c2 continuous. diff --git a/panda/src/parametrics/curveFitter.h b/panda/src/parametrics/curveFitter.h index d42a79504c..888b7ac200 100644 --- a/panda/src/parametrics/curveFitter.h +++ b/panda/src/parametrics/curveFitter.h @@ -30,8 +30,11 @@ class ParametricCurve; //////////////////////////////////////////////////////////////////// class CurveFitter { PUBLISHED: + CurveFitter(); + ~CurveFitter(); + void reset(); - void add_point(double t, const LVector3f &point); + void add_point(double t, const LVecBase3f &point); void sample(ParametricCurve *curve, int count, bool even); void generate_even(int count, double net_distance, double net_time); @@ -42,8 +45,8 @@ PUBLISHED: void desample(double factor); void compute_tangents(double scale); - HermiteCurve *make_hermite() const; - NurbsCurve *make_nurbs() const; + PT(HermiteCurve) make_hermite() const; + PT(NurbsCurve) make_nurbs() const; void print() const; @@ -62,8 +65,8 @@ public: } double _t; - LVector3f _point; - LVector3f _tangent; + LVecBase3f _point; + LVecBase3f _tangent; }; typedef vector Data; @@ -76,10 +79,6 @@ public: static void init_type() { register_type(_type_handle, "CurveFitter"); } - virtual TypeHandle get_type() const { - return get_class_type(); - } - virtual TypeHandle force_init_type() {init_type(); return get_class_type();} private: static TypeHandle _type_handle; diff --git a/panda/src/parametrics/hermiteCurve.cxx b/panda/src/parametrics/hermiteCurve.cxx index 4b6a006b2d..750e6db83e 100644 --- a/panda/src/parametrics/hermiteCurve.cxx +++ b/panda/src/parametrics/hermiteCurve.cxx @@ -28,7 +28,7 @@ //////////////////////////////////////////////////////////////////// TypeHandle HermiteCurve::_type_handle; -static const LVector3f zero = LVector3f(0.0, 0.0, 0.0); +static const LVecBase3f zero = LVecBase3f(0.0, 0.0, 0.0); // This is returned occasionally from some of the functions, and is // used from time to time as an initializer. @@ -49,11 +49,11 @@ Indent(ostream &out, int indent) { //////////////////////////////////////////////////////////////////// // Function: show_vec3 -// Description: This function writes a LVector3f, with a specified +// Description: This function writes a LVecBase3f, with a specified // number of significant dimensions. //////////////////////////////////////////////////////////////////// static ostream & -show_vec3(ostream &out, int indent, const LVector3f &v, int num_dimensions) { +show_vec3(ostream &out, int indent, const LVecBase3f &v, int num_dimensions) { Indent(out, indent) << v[0]; for (int i = 1; i=_points.size()) { + if (n < 0 || n >= (int)_points.size()) { return false; } @@ -428,7 +437,7 @@ remove_all_cvs() { //////////////////////////////////////////////////////////////////// bool HermiteCurve:: set_cv_type(int n, int type) { - if (n<0 || n>=_points.size()) { + if (n < 0 || n >= (int)_points.size()) { return false; } @@ -451,10 +460,10 @@ set_cv_type(int n, int type) { //////////////////////////////////////////////////////////////////// bool HermiteCurve:: set_cv_point(int n, float x, float y, float z) { - if (n<0 || n>=_points.size()) { + if (n < 0 || n >= (int)_points.size()) { return false; } - _points[n].set_point(LVector3f(x, y, z)); + _points[n].set_point(LVecBase3f(x, y, z)); invalidate_cv(n, false); return true; } @@ -468,10 +477,10 @@ set_cv_point(int n, float x, float y, float z) { //////////////////////////////////////////////////////////////////// bool HermiteCurve:: set_cv_in(int n, float x, float y, float z) { - if (n<0 || n>=_points.size()) { + if (n < 0 || n >= (int)_points.size()) { return false; } - _points[n].set_in(LVector3f(x, y, z)); + _points[n].set_in(LVecBase3f(x, y, z)); invalidate_cv(n, false); return true; } @@ -485,10 +494,10 @@ set_cv_in(int n, float x, float y, float z) { //////////////////////////////////////////////////////////////////// bool HermiteCurve:: set_cv_out(int n, float x, float y, float z) { - if (n<0 || n>=_points.size()) { + if (n < 0 || n >= (int)_points.size()) { return false; } - _points[n].set_out(LVector3f(x, y, z)); + _points[n].set_out(LVecBase3f(x, y, z)); invalidate_cv(n, false); return true; } @@ -501,7 +510,7 @@ set_cv_out(int n, float x, float y, float z) { //////////////////////////////////////////////////////////////////// bool HermiteCurve:: set_cv_tstart(int n, double tstart) { - if (n<=0 || n>=_points.size()) { + if (n <= 0 || n >= (int)_points.size()) { return false; } if (fabs(tstart - get_cv_tstart(n)) > 0.0001) { @@ -520,7 +529,7 @@ set_cv_tstart(int n, double tstart) { //////////////////////////////////////////////////////////////////// bool HermiteCurve:: set_cv_name(int n, const char *name) { - if (n<0 || n>=_points.size()) { + if (n < 0 || n >= (int)_points.size()) { return false; } _points[n].set_name(name); @@ -538,7 +547,7 @@ set_cv_name(int n, const char *name) { //////////////////////////////////////////////////////////////////// int HermiteCurve:: get_cv_type(int n) const { - if (n<0 || n>=_points.size()) { + if (n < 0 || n >= (int)_points.size()) { return 0; } @@ -551,16 +560,16 @@ get_cv_type(int n) const { // Access: Public, Scheme // Description: Returns the position of the given CV. //////////////////////////////////////////////////////////////////// -const LVector3f &HermiteCurve:: +const LVecBase3f &HermiteCurve:: get_cv_point(int n) const { - if (n<0 || n>=_points.size()) { + if (n < 0 || n >= (int)_points.size()) { return zero; } return _points[n]._p; } void HermiteCurve:: -get_cv_point(int n, LVector3f &v) const { +get_cv_point(int n, LVecBase3f &v) const { v = get_cv_point(n); } @@ -570,16 +579,16 @@ get_cv_point(int n, LVector3f &v) const { // Access: Public, Scheme // Description: Returns the in tangent of the given CV. //////////////////////////////////////////////////////////////////// -const LVector3f &HermiteCurve:: +const LVecBase3f &HermiteCurve:: get_cv_in(int n) const { - if (n<0 || n>=_points.size() || _points[n-1]._type==HC_CUT) { + if (n < 0 || n >= (int)_points.size() || _points[n-1]._type==HC_CUT) { return zero; } return _points[n]._in; } void HermiteCurve:: -get_cv_in(int n, LVector3f &v) const { +get_cv_in(int n, LVecBase3f &v) const { v = get_cv_in(n); } @@ -589,16 +598,16 @@ get_cv_in(int n, LVector3f &v) const { // Access: Public, Scheme // Description: Returns the out tangent of the given CV. //////////////////////////////////////////////////////////////////// -const LVector3f &HermiteCurve:: +const LVecBase3f &HermiteCurve:: get_cv_out(int n) const { - if (n<0 || n>=_points.size() || _points[n]._type==HC_CUT) { + if (n < 0 || n >= (int)_points.size() || _points[n]._type==HC_CUT) { return zero; } return _points[n]._out; } void HermiteCurve:: -get_cv_out(int n, LVector3f &v) const { +get_cv_out(int n, LVecBase3f &v) const { v = get_cv_out(n); } @@ -613,7 +622,7 @@ double HermiteCurve:: get_cv_tstart(int n) const { if (n<0) { return 0.0; - } else if (n>=_points.size()) { + } else if (n >= (int)_points.size()) { return get_max_t(); } @@ -627,7 +636,7 @@ get_cv_tstart(int n) const { //////////////////////////////////////////////////////////////////// const char *HermiteCurve:: get_cv_name(int n) const { - if (n<0 || n>=_points.size()) { + if (n < 0 || n >= (int)_points.size()) { return NULL; } @@ -784,10 +793,10 @@ write_egg(ostream &out, const char *basename) { // possible, false if something goes horribly wrong. //////////////////////////////////////////////////////////////////// bool HermiteCurve:: -rebuild_curveseg(int, double, const LVector4f &, - int, double, const LVector4f &, - int, double, const LVector4f &, - int, double, const LVector4f &) { +rebuild_curveseg(int, double, const LVecBase4f &, + int, double, const LVecBase4f &, + int, double, const LVecBase4f &, + int, double, const LVecBase4f &) { cerr << "rebuild_curveseg not implemented for this curve type.\n"; return false; } @@ -803,9 +812,9 @@ Output(ostream &out, int indent) const { << " " << get_name() << ".pool {\n"; int i; - for (i = 0; i<_points.size(); i++) { - bool show_in = (i!=0); - bool show_out = (i!=_points.size()-1); + for (i = 0; i < (int)_points.size(); i++) { + bool show_in = (i != 0); + bool show_out = (i != (int)_points.size()-1); _points[i].Output(out, indent+2, _num_dimensions, show_in, show_out, show_in ? get_tlength(i-1) : 0.0, @@ -835,7 +844,7 @@ Output(ostream &out, int indent) const { Indent(out, indent+2) << " {"; if (_points.size() > 1) { - for (i = 0; i<_segs.size(); i++) { + for (i = 0; i < (int)_segs.size(); i++) { if (i%10 == 1) { out << "\n"; Indent(out, indent+3); @@ -847,7 +856,7 @@ Output(ostream &out, int indent) const { Indent(out, indent+2) << "}\n"; Indent(out, indent+2) << " {"; - for (i = 1; i<=_points.size() * 3 - 2; i++) { + for (i = 1; i <= (int)_points.size() * 3 - 2; i++) { if (i%10 == 1) { out << "\n"; Indent(out, indent+3); @@ -862,17 +871,8 @@ Output(ostream &out, int indent) const { } -//////////////////////////////////////////////////////////////////// -// Function: HermiteCurve::Destructor -// Access: Protected -// Description: -//////////////////////////////////////////////////////////////////// -HermiteCurve:: -~HermiteCurve() { -} - static void -wrap_hpr(const LVector3f &hpr1, LVector3f &hpr2) { +wrap_hpr(const LVecBase3f &hpr1, LVecBase3f &hpr2) { for (int i = 0; i < 3; i++) { while ((hpr2[i] - hpr1[i]) > 180.0) { hpr2[i] -= 360.0; @@ -903,7 +903,7 @@ invalidate_cv(int n, bool redo_all) { t1 = get_cv_tstart(n-1); } - if (n+1 < _points.size()) { + if (n+1 < (int)_points.size()) { if (_points[n]._type==HC_CUT) { BezierSeg seg; seg._v[0] = seg._v[1] = seg._v[2] = seg._v[3] = _points[n]._p; @@ -941,7 +941,7 @@ find_cv(double t) { nassertr(is_valid(), 0); int n; - for (n = 0; n<_segs.size(); n++) { + for (n = 0; n < (int)_segs.size(); n++) { if (_segs[n]._tend+0.00001 > t) { break; } @@ -962,7 +962,7 @@ find_cv(double t) { void HermiteCurve:: recompute_basis() { int n; - for (n = 0; n<_segs.size(); n++) { + for (n = 0; n < (int)_segs.size(); n++) { if (_points[n]._type==HC_CUT) { BezierSeg seg; seg._v[0] = seg._v[1] = seg._v[2] = seg._v[3] = _points[n]._p; diff --git a/panda/src/parametrics/hermiteCurve.h b/panda/src/parametrics/hermiteCurve.h index d457349e48..2b7daeb32b 100644 --- a/panda/src/parametrics/hermiteCurve.h +++ b/panda/src/parametrics/hermiteCurve.h @@ -64,9 +64,9 @@ public: HermiteCurveCV(const HermiteCurveCV &c); ~HermiteCurveCV(); - void set_point(const LVector3f &point) { _p = point; } - void set_in(const LVector3f &in); - void set_out(const LVector3f &out); + void set_point(const LVecBase3f &point) { _p = point; } + void set_in(const LVecBase3f &in); + void set_out(const LVecBase3f &out); void set_type(int type); void set_name(const char *name); @@ -74,7 +74,7 @@ public: bool show_in, bool show_out, double scale_in, double scale_out) const; - LVector3f _p, _in, _out; + LVecBase3f _p, _in, _out; int _type; char *_name; }; @@ -95,12 +95,13 @@ class HermiteCurve : public PiecewiseCurve { PUBLISHED: HermiteCurve(); HermiteCurve(const ParametricCurve &pc); + virtual ~HermiteCurve(); int get_num_cvs() const; int insert_cv(double t); int append_cv(int type, float x, float y, float z); - inline int append_cv(int type, const LVector3f &v) { + inline int append_cv(int type, const LVecBase3f &v) { return append_cv(type, v[0], v[1], v[2]); } @@ -109,15 +110,15 @@ PUBLISHED: bool set_cv_type(int n, int type); bool set_cv_point(int n, float x, float y, float z); - inline bool set_cv_point(int n, const LVector3f &v) { + inline bool set_cv_point(int n, const LVecBase3f &v) { return set_cv_point(n, v[0], v[1], v[2]); } bool set_cv_in(int n, float x, float y, float z); - inline bool set_cv_in(int n, const LVector3f &v) { + inline bool set_cv_in(int n, const LVecBase3f &v) { return set_cv_in(n, v[0], v[1], v[2]); } bool set_cv_out(int n, float x, float y, float z); - inline bool set_cv_out(int n, const LVector3f &v) { + inline bool set_cv_out(int n, const LVecBase3f &v) { return set_cv_out(n, v[0], v[1], v[2]); } bool set_cv_tstart(int n, double tstart); @@ -125,12 +126,12 @@ PUBLISHED: int get_cv_type(int n) const; - const LVector3f &get_cv_point(int n) const; - void get_cv_point(int n, LVector3f &v) const; - const LVector3f &get_cv_in(int n) const; - void get_cv_in(int n, LVector3f &v) const; - const LVector3f &get_cv_out(int n) const; - void get_cv_out(int n, LVector3f &v) const; + const LVecBase3f &get_cv_point(int n) const; + void get_cv_point(int n, LVecBase3f &v) const; + const LVecBase3f &get_cv_in(int n) const; + void get_cv_in(int n, LVecBase3f &v) const; + const LVecBase3f &get_cv_out(int n) const; + void get_cv_out(int n, LVecBase3f &v) const; double get_cv_tstart(int n) const; const char *get_cv_name(int n) const; @@ -147,14 +148,13 @@ public: } virtual bool - rebuild_curveseg(int rtype0, double t0, const LVector4f &v0, - int rtype1, double t1, const LVector4f &v1, - int rtype2, double t2, const LVector4f &v2, - int rtype3, double t3, const LVector4f &v3); + rebuild_curveseg(int rtype0, double t0, const LVecBase4f &v0, + int rtype1, double t1, const LVecBase4f &v1, + int rtype2, double t2, const LVecBase4f &v2, + int rtype3, double t3, const LVecBase4f &v3); void Output(ostream &out, int indent=0) const; - virtual ~HermiteCurve();//// protected: void invalidate_cv(int n, bool redo_all); diff --git a/panda/src/parametrics/nurbsCurve.cxx b/panda/src/parametrics/nurbsCurve.cxx index 6e2f58ca6e..eaa3a3d32f 100644 --- a/panda/src/parametrics/nurbsCurve.cxx +++ b/panda/src/parametrics/nurbsCurve.cxx @@ -21,7 +21,7 @@ TypeHandle NurbsCurve::_type_handle; -static const LVector3f zero = LVector3f(0.0, 0.0, 0.0); +static const LVecBase3f zero = LVecBase3f(0.0, 0.0, 0.0); // This is returned occasionally from some of the functions, and is // used from time to time as an initializer. @@ -75,7 +75,7 @@ NurbsCurve(const ParametricCurve &pc) { //////////////////////////////////////////////////////////////////// NurbsCurve:: NurbsCurve(int order, int num_cvs, - const double knots[], const LVector4f cvs[]) { + const double knots[], const LVecBase4f cvs[]) { _order = order; int i; @@ -92,6 +92,15 @@ NurbsCurve(int order, int num_cvs, recompute(); } +//////////////////////////////////////////////////////////////////// +// Function: NurbsCurve::Destructor +// Access: Protected +// Description: +//////////////////////////////////////////////////////////////////// +NurbsCurve:: +~NurbsCurve() { +} + //////////////////////////////////////////////////////////////////// // Function: NurbsCurve::set_order @@ -168,7 +177,7 @@ insert_cv(double t) { // First, get the new values of all the CV's that will change. // These are the CV's in the range [k - (_order-1), k-1]. - LVector4f new_cvs[3]; + LVecBase4f new_cvs[3]; int i; for (i = 0; i < _order-1; i++) { int nk = i + k - (_order-1); @@ -206,7 +215,7 @@ insert_cv(double t) { //////////////////////////////////////////////////////////////////// int NurbsCurve:: append_cv(float x, float y, float z) { - return append_cv(LVector4f(x, y, z, 1.0)); + return append_cv(LVecBase4f(x, y, z, 1.0)); } @@ -218,7 +227,7 @@ append_cv(float x, float y, float z) { //////////////////////////////////////////////////////////////////// bool NurbsCurve:: remove_cv(int n) { - if (n < 0 || n >= _cvs.size()) { + if (n < 0 || n >= (int)_cvs.size()) { return false; } @@ -245,7 +254,7 @@ remove_all_cvs() { //////////////////////////////////////////////////////////////////// bool NurbsCurve:: set_cv_point(int n, float x, float y, float z) { - if (n < 0 || n >= _cvs.size()) { + if (n < 0 || n >= (int)_cvs.size()) { return false; } @@ -260,11 +269,11 @@ set_cv_point(int n, float x, float y, float z) { // Description: Returns the position of the indicated CV. //////////////////////////////////////////////////////////////////// void NurbsCurve:: -get_cv_point(int n, LVector3f &v) const { - if (n < 0 || n >= _cvs.size()) { +get_cv_point(int n, LVecBase3f &v) const { + if (n < 0 || n >= (int)_cvs.size()) { v = zero; } else { - v = (const LVector3f &)_cvs[n]._p / _cvs[n]._p[3]; + v = (const LVecBase3f &)_cvs[n]._p / _cvs[n]._p[3]; } } @@ -273,13 +282,13 @@ get_cv_point(int n, LVector3f &v) const { // Access: Public, Scheme // Description: Returns the position of the indicated CV. //////////////////////////////////////////////////////////////////// -const LVector3f &NurbsCurve:: +const LVecBase3f &NurbsCurve:: get_cv_point(int n) const { - if (n < 0 || n >= _cvs.size()) { + if (n < 0 || n >= (int)_cvs.size()) { return zero; } else { - static LVector3f result; - result = (LVector3f &)_cvs[n]._p / _cvs[n]._p[3]; + static LVecBase3f result; + result = (LVecBase3f &)_cvs[n]._p / _cvs[n]._p[3]; return result; } } @@ -292,7 +301,7 @@ get_cv_point(int n) const { //////////////////////////////////////////////////////////////////// bool NurbsCurve:: set_cv_weight(int n, float w) { - if (n < 0 || n >= _cvs.size()) { + if (n < 0 || n >= (int)_cvs.size()) { return false; } @@ -307,7 +316,7 @@ set_cv_weight(int n, float w) { //////////////////////////////////////////////////////////////////// float NurbsCurve:: get_cv_weight(int n) const { - if (n < 0 || n >= _cvs.size()) { + if (n < 0 || n >= (int)_cvs.size()) { return 0.0; } @@ -326,7 +335,7 @@ get_cv_weight(int n) const { //////////////////////////////////////////////////////////////////// bool NurbsCurve:: set_knot(int n, double t) { - if (n < _order || n-1 >= _cvs.size()) { + if (n < _order || n-1 >= (int)_cvs.size()) { return false; } @@ -374,13 +383,13 @@ print() const { cout << "CV's:\n"; int i; - for (i = 0; i < _cvs.size(); i++) { - LVector3f p = (const LVector3f &)_cvs[i]._p / _cvs[i]._p[3]; + for (i = 0; i < (int)_cvs.size(); i++) { + LVecBase3f p = (const LVecBase3f &)_cvs[i]._p / _cvs[i]._p[3]; cout << i << ") " << p << ", weight " << _cvs[i]._p[3] << "\n"; } cout << "Knots: "; - for (i = 0; i < _cvs.size()+_order; i++) { + for (i = 0; i < (int)_cvs.size()+_order; i++) { cout << " " << GetKnot(i); } cout << "\n" << flush; @@ -393,10 +402,10 @@ print() const { //////////////////////////////////////////////////////////////////// void NurbsCurve:: print_cv(int n) const { - if (n < 0 || n >= _cvs.size()) { + if (n < 0 || n >= (int)_cvs.size()) { cout << "No such CV: " << n << "\n"; } else { - LVector3f p = (const LVector3f &)_cvs[n]._p / _cvs[n]._p[3]; + LVecBase3f p = (const LVecBase3f &)_cvs[n]._p / _cvs[n]._p[3]; cout << "CV " << n << ": " << p << ", weight " << _cvs[n]._p[3] << "\n"; } @@ -419,10 +428,10 @@ recompute() { _segs.erase(_segs.begin(), _segs.end()); double knots[8]; - LVector4f cvs[4]; + LVecBase4f cvs[4]; - if (_cvs.size() > _order-1) { - for (int cv = 0; cv < _cvs.size()-(_order-1); cv++) { + if ((int)_cvs.size() > _order-1) { + for (int cv = 0; cv < (int)_cvs.size()-(_order-1); cv++) { if (GetKnot(cv+_order-1) < GetKnot(cv+_order)) { // There are _order consecutive CV's that define each segment, // beginning at cv. Collect the CV's and knot values that define @@ -520,11 +529,11 @@ adjust_pt(double t, // Now copy the cvs and knots in question. double knots[8]; - LVector4f cvs[4]; + LVecBase4f cvs[4]; int c; for (c = 0; c < 4; c++) { - cvs[c] = (c < _order) ? _cvs[c+cv]._p : LVector4f(0.0, 0.0, 0.0, 0.0); + cvs[c] = (c < _order) ? _cvs[c+cv]._p : LVecBase4f(0.0, 0.0, 0.0, 0.0); } for (c = 0; c < _order+_order; c++) { knots[c] = GetKnot(c+cv); @@ -592,7 +601,7 @@ adjust_pt(double t, // Now extract the new CV's from the new G matrix, and restore them // to the curve. for (c = 0; c < _order; c++) { - LVector4f &s = _cvs[c+cv]._p; + LVecBase4f &s = _cvs[c+cv]._p; G.getCol(c, &s[0], &s[1], &s[2], &s[3]); } } @@ -608,17 +617,17 @@ adjust_pt(double t, // possible, false if something goes horribly wrong. //////////////////////////////////////////////////////////////////// bool NurbsCurve:: -rebuild_curveseg(int rtype0, double t0, const LVector4f &v0, - int rtype1, double t1, const LVector4f &v1, - int rtype2, double t2, const LVector4f &v2, - int rtype3, double t3, const LVector4f &v3) { +rebuild_curveseg(int rtype0, double t0, const LVecBase4f &v0, + int rtype1, double t1, const LVecBase4f &v1, + int rtype2, double t2, const LVecBase4f &v2, + int rtype3, double t3, const LVecBase4f &v3) { // Figure out which CV's contributed to this segment. int seg = 0; - nassertr(_cvs.size() > _order-1, false); + nassertr((int)_cvs.size() > _order-1, false); int cv = 0; - for (cv = 0; cv < _cvs.size()-(_order-1); cv++) { + for (cv = 0; cv < (int)_cvs.size()-(_order-1); cv++) { if (GetKnot(cv+_order-1) < GetKnot(cv+_order)) { if (seg == _last_ti) { break; @@ -637,8 +646,8 @@ rebuild_curveseg(int rtype0, double t0, const LVector4f &v0, // properties depends on the original value. if ((rtype0 | rtype1 | rtype2 | rtype3) & RT_KEEP_ORIG) { for (c = 0; c < 4; c++) { - static const LVector4f zero(0.0, 0.0, 0.0, 0.0); - const LVector4f &s = (c < _order) ? _cvs[c+cv]._p : zero; + static const LVecBase4f zero(0.0, 0.0, 0.0, 0.0); + const LVecBase4f &s = (c < _order) ? _cvs[c+cv]._p : zero; G.set_col(c, s); } @@ -775,7 +784,7 @@ splice(double t, const NurbsCurve &other) { // Now add all the new CV's. int cv; - for (cv = 0; cv < other._cvs.size(); cv++) { + for (cv = 0; cv < (int)other._cvs.size(); cv++) { CV new_cv(other._cvs[cv]); if (cv+1 < _order) { @@ -805,7 +814,7 @@ Output(ostream &out, int indent) const { << " " << get_name() << ".pool {\n"; int cv; - for (cv = 0; cv < _cvs.size(); cv++) { + for (cv = 0; cv < (int)_cvs.size(); cv++) { Indent(out, indent+2) << " " << cv << " { " << _cvs[cv]._p << " }\n"; } @@ -848,7 +857,7 @@ Output(ostream &out, int indent) const { Indent(out, indent+2) << "}\n"; Indent(out, indent+2) << " {"; - for (cv = 0; cv < _cvs.size(); cv++) { + for (cv = 0; cv < (int)_cvs.size(); cv++) { if (cv%10 == 1) { out << "\n"; Indent(out, indent+3); @@ -862,15 +871,6 @@ Output(ostream &out, int indent) const { Indent(out, indent) << "}\n"; } -//////////////////////////////////////////////////////////////////// -// Function: NurbsCurve::Destructor -// Access: Protected -// Description: -//////////////////////////////////////////////////////////////////// -NurbsCurve:: -~NurbsCurve() { -} - //////////////////////////////////////////////////////////////////// // Function: NurbsCurve::FindCV // Access: Protected @@ -880,7 +880,7 @@ NurbsCurve:: int NurbsCurve:: FindCV(double t) { int i; - for (i = _order-1; i < _cvs.size(); i++) { + for (i = _order-1; i < (int)_cvs.size(); i++) { if (_cvs[i]._t >= t) { return i+1; } diff --git a/panda/src/parametrics/nurbsCurve.h b/panda/src/parametrics/nurbsCurve.h index dda1d68ff9..ff978e6d21 100644 --- a/panda/src/parametrics/nurbsCurve.h +++ b/panda/src/parametrics/nurbsCurve.h @@ -24,8 +24,8 @@ // Defines //////////////////////////////////////////////////////////////////// -////#define LVector3f pfVec3 -//typedef pfVec3 LVector3f; +////#define LVecBase3f pfVec3 +//typedef pfVec3 LVecBase3f; class HermiteCurve; @@ -50,7 +50,8 @@ PUBLISHED: NurbsCurve(); NurbsCurve(const ParametricCurve &hc); NurbsCurve(int order, int num_cvs, - const double knots[], const LVector4f cvs[]); + const double knots[], const LVecBase4f cvs[]); + virtual ~NurbsCurve(); void set_order(int order); int get_order() const; @@ -62,10 +63,10 @@ PUBLISHED: int insert_cv(double t); int append_cv(float x, float y, float z); - inline int append_cv(const LVector3f &v) { - return append_cv(LVector4f(v[0], v[1], v[2], 1.0)); + inline int append_cv(const LVecBase3f &v) { + return append_cv(LVecBase4f(v[0], v[1], v[2], 1.0)); } - inline int append_cv(const LVector4f &v) { + inline int append_cv(const LVecBase4f &v) { _cvs.push_back(CV(v, GetKnot(_cvs.size())+1.0)); return _cvs.size()-1; } @@ -74,11 +75,11 @@ PUBLISHED: void remove_all_cvs(); bool set_cv_point(int n, float x, float y, float z); - inline bool set_cv_point(int n, const LVector3f &v) { + inline bool set_cv_point(int n, const LVecBase3f &v) { return set_cv_point(n, v[0], v[1], v[2]); } - void get_cv_point(int n, LVector3f &v) const; - const LVector3f &get_cv_point(int n) const; + void get_cv_point(int n, LVecBase3f &v) const; + const LVecBase3f &get_cv_point(int n) const; bool set_cv_weight(int n, float w); float get_cv_weight(int n) const; @@ -103,10 +104,10 @@ PUBLISHED: //////////////////////////////////////////////////////////////////// public: virtual bool - rebuild_curveseg(int rtype0, double t0, const LVector4f &v0, - int rtype1, double t1, const LVector4f &v1, - int rtype2, double t2, const LVector4f &v2, - int rtype3, double t3, const LVector4f &v3); + rebuild_curveseg(int rtype0, double t0, const LVecBase4f &v0, + int rtype1, double t1, const LVecBase4f &v1, + int rtype2, double t2, const LVecBase4f &v2, + int rtype3, double t3, const LVecBase4f &v3); CubicCurveseg *get_curveseg(int ti) { return (CubicCurveseg *)PiecewiseCurve::get_curveseg(ti); @@ -116,7 +117,7 @@ public: GetKnot(int n) const { if (n < _order || _cvs.empty()) { return 0.0; - } else if (n-1 >= _cvs.size()) { + } else if (n-1 >= (int)_cvs.size()) { return _cvs.back()._t; } else { return _cvs[n-1]._t; @@ -126,8 +127,6 @@ public: void Output(ostream &out, int indent=0) const; protected: - virtual ~NurbsCurve(); - int FindCV(double t); int _order; @@ -135,8 +134,8 @@ protected: class CV { public: CV() {} - CV(const LVector4f &p, double t) : _p(p), _t(t) {} - LVector4f _p; + CV(const LVecBase4f &p, double t) : _p(p), _t(t) {} + LVecBase4f _p; double _t; }; diff --git a/panda/src/parametrics/nurbsCurveDrawer.cxx b/panda/src/parametrics/nurbsCurveDrawer.cxx index 9b3445d149..7e4958ed34 100644 --- a/panda/src/parametrics/nurbsCurveDrawer.cxx +++ b/panda/src/parametrics/nurbsCurveDrawer.cxx @@ -128,7 +128,7 @@ draw() { double t = nurbs->GetKnot(i); if (t != lt) { lt = t; - LVector3f knot_pos, knot_tan; + LVecBase3f knot_pos, knot_tan; nurbs->get_pt(nurbs->GetKnot(i), knot_pos, knot_tan); _knots.move_to(_mapper(knot_pos, knot_tan, t)); ki++; @@ -142,7 +142,7 @@ draw() { if (_show_cvs) { _num_cvs = nurbs->get_num_cvs(); for (i = 0; i < _num_cvs; i++) { - _cvs.move_to(_mapper(nurbs->get_cv_point(i), LVector3f(0.0, 0.0, 0.0), + _cvs.move_to(_mapper(nurbs->get_cv_point(i), LVecBase3f(0.0, 0.0, 0.0), nurbs->GetKnot(i+1))); } @@ -152,7 +152,7 @@ draw() { if (_show_hull) { _num_cvs = nurbs->get_num_cvs(); for (i = 0; i < _num_cvs; i++) { - _hull.draw_to(_mapper(nurbs->get_cv_point(i), LVector3f(0.0, 0.0, 0.0), + _hull.draw_to(_mapper(nurbs->get_cv_point(i), LVecBase3f(0.0, 0.0, 0.0), nurbs->GetKnot(i+1))); } @@ -264,7 +264,7 @@ hilight(int n, float hr, float hg, float hb) { return false; } - NurbsCurve *nurbs = (NurbsCurve *)_curve; + // NurbsCurve *nurbs = (NurbsCurve *)_curve; if (_show_cvs) { _cvs.set_vertex_color(n, hr, hg, hb); } @@ -292,7 +292,7 @@ unhilight(int n) { return false; } - NurbsCurve *nurbs = (NurbsCurve *)_curve; + // NurbsCurve *nurbs = (NurbsCurve *)_curve; if (_show_cvs) { _cvs.set_vertex_color(n, _cv_color[0], _cv_color[1], _cv_color[2]); } diff --git a/panda/src/parametrics/nurbsCurveDrawer.h b/panda/src/parametrics/nurbsCurveDrawer.h index 685cdec1c8..10ea36ef86 100644 --- a/panda/src/parametrics/nurbsCurveDrawer.h +++ b/panda/src/parametrics/nurbsCurveDrawer.h @@ -65,7 +65,7 @@ PUBLISHED: // Member functions not visible to Scheme //////////////////////////////////////////////////////////////////// protected: - LVector3f _cv_color, _hull_color, _knot_color; + LVecBase3f _cv_color, _hull_color, _knot_color; int _num_cvs, _num_hull, _num_knots; LineSegs _hull, _knots, _cvs; vector _knotnums;