1412103920
2 2
16 libp3parametrics 4 UKlv 12 panda3d.core 
243
268 8 is_valid 0 6 511 25 ParametricCurve::is_valid 0 1 1 415
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::is_valid
//       Access: Published, Virtual
//  Description: Returns true if the curve is defined.  This base
//               class function always returns true; derived classes
//               might override this to sometimes return false.
////////////////////////////////////////////////////////////////////
51
virtual bool ParametricCurve::is_valid(void) const;

269 9 get_max_t 0 6 511 26 ParametricCurve::get_max_t 0 1 2 522
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::get_max_t
//       Access: Published, Virtual
//  Description: Returns the upper bound of t for the entire curve.
//               The curve is defined in the range 0.0f <= t <=
//               get_max_t().  This base class function always returns
//               1.0f; derived classes might override this to return
//               something else.
////////////////////////////////////////////////////////////////////
53
virtual float ParametricCurve::get_max_t(void) const;

270 14 set_curve_type 0 4 511 31 ParametricCurve::set_curve_type 0 1 3 731
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::set_curve_type
//       Access: Published
//  Description: Sets the flag indicating the use to which the curve
//               is intended to be put.  This flag is optional and
//               only serves to provide a hint to the egg reader and
//               writer code; it has no effect on the curve's
//               behavior.
//
//               Setting the curve type also sets the num_dimensions
//               to 3 or 1 according to the type.
//
//               THis flag may have one of the values PCT_XYZ,
//               PCT_HPR, or PCT_T.
////////////////////////////////////////////////////////////////////
47
void ParametricCurve::set_curve_type(int type);

271 14 get_curve_type 0 4 511 31 ParametricCurve::get_curve_type 0 1 4 325
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::get_curve_type
//       Access: Published
//  Description: Returns the flag indicating the use to which the curve
//               is intended to be put.
////////////////////////////////////////////////////////////////////
48
int ParametricCurve::get_curve_type(void) const;

272 18 set_num_dimensions 0 4 511 35 ParametricCurve::set_num_dimensions 0 1 5 622
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::set_num_dimensions
//       Access: Published
//  Description: Specifies the number of significant dimensions in the
//               curve's vertices.  This should be one of 1, 2, or 3.
//               Normally, XYZ and HPR curves have three dimensions;
//               time curves should always have one dimension.  This
//               only serves as a hint to the mopath editor, and also
//               controls how the curve is written out.
////////////////////////////////////////////////////////////////////
50
void ParametricCurve::set_num_dimensions(int num);

273 18 get_num_dimensions 0 4 511 35 ParametricCurve::get_num_dimensions 0 1 6 550
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::get_num_dimensions
//       Access: Published
//  Description: Returns the number of significant dimensions in the
//               curve's vertices, as set by a previous call to
//               set_num_dimensions().  This is only a hint as to how
//               the curve is intended to be used; the actual number
//               of dimensions of any curve is always three.
////////////////////////////////////////////////////////////////////
52
int ParametricCurve::get_num_dimensions(void) const;

274 11 calc_length 0 4 511 28 ParametricCurve::calc_length 0 2 7 8 653
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::calc_length
//       Access: Published
//  Description: Approximates the length of the entire curve to within
//               a few decimal places.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::calc_length
//       Access: Published
//  Description: Approximates the length of the curve segment from
//               parametric time 'from' to time 'to'.
////////////////////////////////////////////////////////////////////
111
float ParametricCurve::calc_length(void) const;
float ParametricCurve::calc_length(float from, float to) const;

275 11 find_length 0 4 511 28 ParametricCurve::find_length 0 1 9 717
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::find_length
//       Access: Published
//  Description: Returns the parametric value corresponding to the
//               indicated distance along the curve from the starting
//               parametric value.
//
//               This is the inverse of calc_length(): rather than
//               determining the length along the curve between two
//               parametric points, it determines the position in
//               parametric time of a point n units along the curve.
//
//               The search distance must not be negative.
////////////////////////////////////////////////////////////////////
77
float ParametricCurve::find_length(float start_t, float length_offset) const;

276 9 get_point 0 6 511 26 ParametricCurve::get_point 0 1 10 0
78
virtual bool ParametricCurve::get_point(float t, LVecBase3f &point) const = 0;

277 11 get_tangent 0 6 511 28 ParametricCurve::get_tangent 0 1 11 0
82
virtual bool ParametricCurve::get_tangent(float t, LVecBase3f &tangent) const = 0;

278 6 get_pt 0 6 511 23 ParametricCurve::get_pt 0 1 12 0
96
virtual bool ParametricCurve::get_pt(float t, LVecBase3f &point, LVecBase3f &tangent) const = 0;

279 14 get_2ndtangent 0 6 511 31 ParametricCurve::get_2ndtangent 0 1 13 0
86
virtual bool ParametricCurve::get_2ndtangent(float t, LVecBase3f &tangent2) const = 0;

280 12 adjust_point 0 6 511 29 ParametricCurve::adjust_point 0 1 14 402
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::adjust_point
//       Access: Published, Virtual
//  Description: Recomputes the curve such that it passes through the
//               point (px, py, pz) at time t, but keeps the same
//               tangent value at that point.
////////////////////////////////////////////////////////////////////
82
virtual bool ParametricCurve::adjust_point(float t, float px, float py, float pz);

281 14 adjust_tangent 0 6 511 31 ParametricCurve::adjust_tangent 0 1 15 389
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::adjust_tangent
//       Access: Published, Virtual
//  Description: Recomputes the curve such that it has the tangent
//               (tx, ty, tz) at time t, but keeps the same position
//               at the point.
////////////////////////////////////////////////////////////////////
84
virtual bool ParametricCurve::adjust_tangent(float t, float tx, float ty, float tz);

282 9 adjust_pt 0 6 511 26 ParametricCurve::adjust_pt 0 1 16 354
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::adjust_pt
//       Access: Published, Virtual
//  Description: Recomputes the curve such that it passes through the
//               point (px, py, pz) with the tangent (tx, ty, tz).
////////////////////////////////////////////////////////////////////
109
virtual bool ParametricCurve::adjust_pt(float t, float px, float py, float pz, float tx, float ty, float tz);

283 9 recompute 0 6 511 26 ParametricCurve::recompute 0 1 17 370
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::recompute
//       Access: Published, Virtual
//  Description: Recalculates the curve, if necessary.  Returns
//               true if the resulting curve is valid, false
//               otherwise.
////////////////////////////////////////////////////////////////////
46
virtual bool ParametricCurve::recompute(void);

284 6 stitch 0 6 511 23 ParametricCurve::stitch 0 1 18 537
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::stitch
//       Access: Published, Virtual
//  Description: Regenerates this curve as one long curve: the first
//               curve connected end-to-end with the second one.
//               Either a or b may be the same as 'this'.
//
//               Returns true if successful, false on failure or if
//               the curve type does not support stitching.
////////////////////////////////////////////////////////////////////
89
virtual bool ParametricCurve::stitch(ParametricCurve const *a, ParametricCurve const *b);

285 9 write_egg 0 4 511 26 ParametricCurve::write_egg 0 3 19 20 21 774
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::write_egg
//       Access: Published
//  Description: Writes an egg description of the nurbs curve to the
//               specified output file.  Returns true if the file is
//               successfully written.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::write_egg
//       Access: Published
//  Description: Writes an egg description of the nurbs curve to the
//               specified output stream.  Returns true if the file is
//               successfully written.
////////////////////////////////////////////////////////////////////
181
bool ParametricCurve::write_egg(Filename filename, CoordinateSystem cs = (CS_default));
bool ParametricCurve::write_egg(ostream &out, Filename const &filename, CoordinateSystem cs);

286 14 get_class_type 0 4 511 31 ParametricCurve::get_class_type 0 1 22 0
56
static TypeHandle ParametricCurve::get_class_type(void);

287 14 get_class_type 0 4 513 29 CubicCurveseg::get_class_type 0 1 23 0
54
static TypeHandle CubicCurveseg::get_class_type(void);

288 25 ParametricCurveCollection 0 4 514 52 ParametricCurveCollection::ParametricCurveCollection 0 1 24 237
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
59
ParametricCurveCollection::ParametricCurveCollection(void);

289 9 add_curve 0 4 514 36 ParametricCurveCollection::add_curve 0 2 25 26 604
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::add_curve
//       Access: Published
//  Description: Adds a new ParametricCurve to the collection.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::add_curve
//       Access: Published
//  Description: Adds a new ParametricCurve to the collection at the
//               indicated index.
////////////////////////////////////////////////////////////////////
144
void ParametricCurveCollection::add_curve(ParametricCurve *curve);
void ParametricCurveCollection::add_curve(ParametricCurve *curve, int index);

290 10 add_curves 0 4 514 37 ParametricCurveCollection::add_curves 0 1 27 378
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::add_curves
//       Access: Published
//  Description: Adds all the curves found in the scene graph rooted
//               at the given node.  Returns the number of curves
//               found.
////////////////////////////////////////////////////////////////////
59
int ParametricCurveCollection::add_curves(PandaNode *node);

291 12 remove_curve 0 4 514 39 ParametricCurveCollection::remove_curve 0 2 28 29 756
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::remove_curve
//       Access: Published
//  Description: Removes the indicated ParametricCurve from the
//               collection.  Returns true if the curve was removed,
//               false if it was not a member of the collection.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::remove_curve
//       Access: Published
//  Description: Removes the indicated ParametricCurve from the
//               collection, by its index number.
////////////////////////////////////////////////////////////////////
126
bool ParametricCurveCollection::remove_curve(ParametricCurve *curve);
void ParametricCurveCollection::remove_curve(int index);

292 9 has_curve 0 4 514 36 ParametricCurveCollection::has_curve 0 1 30 343
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::has_curve
//       Access: Published
//  Description: Returns true if the indicated ParametricCurve appears in
//               this collection, false otherwise.
////////////////////////////////////////////////////////////////////
72
bool ParametricCurveCollection::has_curve(ParametricCurve *curve) const;

293 5 clear 0 4 514 32 ParametricCurveCollection::clear 0 1 31 281
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::clear
//       Access: Published
//  Description: Removes all ParametricCurves from the collection.
////////////////////////////////////////////////////////////////////
44
void ParametricCurveCollection::clear(void);

294 15 clear_timewarps 0 4 514 42 ParametricCurveCollection::clear_timewarps 0 1 32 294
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::clear_timewarps
//       Access: Published
//  Description: Removes all the timewarp curves from the collection.
////////////////////////////////////////////////////////////////////
54
void ParametricCurveCollection::clear_timewarps(void);

295 14 get_num_curves 0 4 514 41 ParametricCurveCollection::get_num_curves 0 1 33 298
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::get_num_curves
//       Access: Published
//  Description: Returns the number of ParametricCurves in the collection.
////////////////////////////////////////////////////////////////////
65
inline int ParametricCurveCollection::get_num_curves(void) const;

296 9 get_curve 0 4 514 36 ParametricCurveCollection::get_curve 0 1 34 286
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::get_curve
//       Access: Published
//  Description: Returns the nth ParametricCurve in the collection.
////////////////////////////////////////////////////////////////////
78
inline ParametricCurve *ParametricCurveCollection::get_curve(int index) const;

297 13 get_xyz_curve 0 4 514 40 ParametricCurveCollection::get_xyz_curve 0 1 35 338
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::get_xyz_curve
//       Access: Published
//  Description: Returns the first XYZ curve in the collection, if
//               any, or NULL if there are none.
////////////////////////////////////////////////////////////////////
70
ParametricCurve *ParametricCurveCollection::get_xyz_curve(void) const;

298 13 get_hpr_curve 0 4 514 40 ParametricCurveCollection::get_hpr_curve 0 1 36 338
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::get_hpr_curve
//       Access: Published
//  Description: Returns the first HPR curve in the collection, if
//               any, or NULL if there are none.
////////////////////////////////////////////////////////////////////
70
ParametricCurve *ParametricCurveCollection::get_hpr_curve(void) const;

299 17 get_default_curve 0 4 514 44 ParametricCurveCollection::get_default_curve 0 1 37 458
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::get_default_curve
//       Access: Published
//  Description: If there is an XYZ curve in the collection, returns
//               it; otherwise, returns the first curve whose type is
//               unspecified.  Returns NULL if no curve meets the
//               criteria.
////////////////////////////////////////////////////////////////////
74
ParametricCurve *ParametricCurveCollection::get_default_curve(void) const;

300 17 get_num_timewarps 0 4 514 44 ParametricCurveCollection::get_num_timewarps 0 1 38 317
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::get_num_timewarps
//       Access: Published
//  Description: Returns the number of timewarp curves in the
//               collection.
////////////////////////////////////////////////////////////////////
61
int ParametricCurveCollection::get_num_timewarps(void) const;

301 18 get_timewarp_curve 0 4 514 45 ParametricCurveCollection::get_timewarp_curve 0 1 39 294
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::get_timewarp_curve
//       Access: Published
//  Description: Returns the nth timewarp curve in the collection.
////////////////////////////////////////////////////////////////////
76
ParametricCurve *ParametricCurveCollection::get_timewarp_curve(int n) const;

302 9 get_max_t 0 4 514 36 ParametricCurveCollection::get_max_t 0 1 40 423
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::get_max_t
//       Access: Published
//  Description: Returns the maximum T value associated with the
//               *last* curve in the collection.  Normally, this will
//               be either the XYZ or HPR curve, or a timewarp curve.
////////////////////////////////////////////////////////////////////
62
inline float ParametricCurveCollection::get_max_t(void) const;

303 9 make_even 0 4 514 36 ParametricCurveCollection::make_even 0 1 41 913
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::make_even
//       Access: Published
//  Description: Discards all existing timewarp curves and recomputes
//               a new timewarp curve that maps distance along the
//               curve to parametric time, so that the distance
//               between any two points in parametric time is
//               proportional to the approximate distance of those
//               same two points along the XYZ curve.
//
//               segments_per_unit represents the number of segments to
//               take per each unit of parametric time of the original
//               XYZ curve.
//
//               The new timewarp curve (and thus, the apparent range
//               of the collection) will range from 0 to max_t.
////////////////////////////////////////////////////////////////////
80
void ParametricCurveCollection::make_even(float max_t, float segments_per_unit);

304 12 face_forward 0 4 514 39 ParametricCurveCollection::face_forward 0 1 42 452
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::face_forward
//       Access: Published
//  Description: Discards the existing HPR curve and generates a new
//               one that looks in the direction of travel along the
//               XYZ curve, based on the XYZ curve's tangent at each
//               point.
////////////////////////////////////////////////////////////////////
70
void ParametricCurveCollection::face_forward(float segments_per_unit);

305 11 reset_max_t 0 4 514 38 ParametricCurveCollection::reset_max_t 0 1 43 563
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::reset_max_t
//       Access: Published
//  Description: Adjusts the apparent length of the curve by applying
//               a new timewarp that maps the range [0..max_t] to the
//               range [0..get_max_t()].  After this call, the curve
//               collection will contain one more timewarp curve, and
//               get_max_t() will return the given max_t value.
////////////////////////////////////////////////////////////////////
57
void ParametricCurveCollection::reset_max_t(float max_t);

306 8 evaluate 0 4 514 35 ParametricCurveCollection::evaluate 0 3 44 45 46 1656
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::evaluate
//       Access: Published
//  Description: Computes the position and rotation represented by the
//               first XYZ and HPR curves in the collection at the
//               given point t, after t has been modified by all the
//               timewarp curves in the collection applied in
//               sequence, from back to front.
//
//               Returns true if the point is valid (i.e. t is within
//               the bounds indicated by all the timewarp curves and
//               within the bounds of the curves themselves), or false
//               otherwise.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::evaluate
//       Access: Published
//  Description: Computes the transform matrix representing
//               translation to the position indicated by the first
//               XYZ curve in the collection and the rotation
//               indicated by the first HPR curve in the collection,
//               after t has been modified by all the timewarp curves
//               in the collection applied in sequence, from back to
//               front.
//
//               Returns true if the point is valid (i.e. t is within
//               the bounds indicated by all the timewarp curves and
//               within the bounds of the curves themselves), or false
//               otherwise.
////////////////////////////////////////////////////////////////////
202
bool ParametricCurveCollection::evaluate(float t, LVecBase3f &xyz, LVecBase3f &hpr) const;
bool ParametricCurveCollection::evaluate(float t, LMatrix4f &result, CoordinateSystem cs = (CS_default)) const;

307 10 evaluate_t 0 4 514 37 ParametricCurveCollection::evaluate_t 0 1 47 490
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::evaluate_t
//       Access: Published
//  Description: Determines the value of t that should be passed to
//               the XYZ and HPR curves, after applying the given
//               value of t to all the timewarps.  Return -1.0f if the
//               value of t exceeds one of the timewarps' ranges.
////////////////////////////////////////////////////////////////////
59
float ParametricCurveCollection::evaluate_t(float t) const;

308 12 evaluate_xyz 0 4 514 39 ParametricCurveCollection::evaluate_xyz 0 1 48 314
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::evaluate_xyz
//       Access: Published
//  Description: Computes only the XYZ part of the curves.  See
//               evaluate().
////////////////////////////////////////////////////////////////////
84
inline bool ParametricCurveCollection::evaluate_xyz(float t, LVecBase3f &xyz) const;

309 12 evaluate_hpr 0 4 514 39 ParametricCurveCollection::evaluate_hpr 0 1 49 314
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::evaluate_hpr
//       Access: Published
//  Description: Computes only the HPR part of the curves.  See
//               evaluate().
////////////////////////////////////////////////////////////////////
84
inline bool ParametricCurveCollection::evaluate_hpr(float t, LVecBase3f &hpr) const;

310 10 adjust_xyz 0 4 514 37 ParametricCurveCollection::adjust_xyz 0 2 50 51 958
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::adjust_xyz
//       Access: Published
//  Description: Adjust the XYZ curve at the indicated time to the new
//               value.  The curve shape will change correspondingly.
//               Returns true if successful, false if unable to make
//               the adjustment for some reason.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::adjust_xyz
//       Access: Published
//  Description: Adjust the XYZ curve at the indicated time to the new
//               value.  The curve shape will change correspondingly.
//               Returns true if successful, false if unable to make
//               the adjustment for some reason.
////////////////////////////////////////////////////////////////////
162
inline bool ParametricCurveCollection::adjust_xyz(float t, float x, float y, float z);
bool ParametricCurveCollection::adjust_xyz(float t, LVecBase3f const &xyz);

311 10 adjust_hpr 0 4 514 37 ParametricCurveCollection::adjust_hpr 0 2 52 53 958
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::adjust_hpr
//       Access: Published
//  Description: Adjust the HPR curve at the indicated time to the new
//               value.  The curve shape will change correspondingly.
//               Returns true if successful, false if unable to make
//               the adjustment for some reason.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::adjust_hpr
//       Access: Published
//  Description: Adjust the HPR curve at the indicated time to the new
//               value.  The curve shape will change correspondingly.
//               Returns true if successful, false if unable to make
//               the adjustment for some reason.
////////////////////////////////////////////////////////////////////
162
inline bool ParametricCurveCollection::adjust_hpr(float t, float h, float p, float r);
bool ParametricCurveCollection::adjust_hpr(float t, LVecBase3f const &xyz);

312 9 recompute 0 4 514 36 ParametricCurveCollection::recompute 0 1 54 409
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::recompute
//       Access: Published
//  Description: Ensures all the curves are freshly computed and
//               up-to-date.  Returns true if everything is valid,
//               false if at least one curve is incorrect.
////////////////////////////////////////////////////////////////////
48
bool ParametricCurveCollection::recompute(void);

313 6 stitch 0 4 514 33 ParametricCurveCollection::stitch 0 1 55 541
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::stitch
//       Access: Published
//  Description: Regenerates this curve as one long curve: the first
//               curve connected end-to-end with the second one.
//               Either a or b may be the same as 'this'.  This will
//               lose any timewarps on the input curves.
//
//               Returns true if successful, false on failure.
////////////////////////////////////////////////////////////////////
111
bool ParametricCurveCollection::stitch(ParametricCurveCollection const *a, ParametricCurveCollection const *b);

314 6 output 0 4 514 33 ParametricCurveCollection::output 0 1 56 350
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::output
//       Access: Published
//  Description: Writes a brief one-line description of the
//               ParametricCurveCollection to the indicated output stream.
////////////////////////////////////////////////////////////////////
59
void ParametricCurveCollection::output(ostream &out) const;

315 5 write 0 4 514 32 ParametricCurveCollection::write 0 2 57 58 354
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::write
//       Access: Published
//  Description: Writes a complete multi-line description of the
//               ParametricCurveCollection to the indicated output stream.
////////////////////////////////////////////////////////////////////
82
void ParametricCurveCollection::write(ostream &out, int indent_level = (0)) const;

316 9 write_egg 0 4 514 36 ParametricCurveCollection::write_egg 0 3 59 60 61 840
////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::write_egg
//       Access: Published
//  Description: Writes an egg description of all the nurbs curves in
//               the collection to the specified output file.  Returns
//               true if the file is successfully written.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::write_egg
//       Access: Published
//  Description: Writes an egg description of all the nurbs curves in
//               the collection to the specified output stream.  Returns
//               true if the file is successfully written.
////////////////////////////////////////////////////////////////////
201
bool ParametricCurveCollection::write_egg(Filename filename, CoordinateSystem cs = (CS_default));
bool ParametricCurveCollection::write_egg(ostream &out, Filename const &filename, CoordinateSystem cs);

317 11 CurveFitter 0 4 516 24 CurveFitter::CurveFitter 0 1 62 220
////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
31
CurveFitter::CurveFitter(void);

318 12 ~CurveFitter 0 4 516 25 CurveFitter::~CurveFitter 0 0 219
////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::Destructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
32
CurveFitter::~CurveFitter(void);

319 5 reset 0 4 516 18 CurveFitter::reset 0 1 63 332
////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::reset
//       Access: Public
//  Description: Removes all the data points previously added to the
//               CurveFitter, and initializes it for a new curve.
////////////////////////////////////////////////////////////////////
30
void CurveFitter::reset(void);

320 7 add_xyz 0 4 516 20 CurveFitter::add_xyz 0 1 64 242
////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::add_xyz
//       Access: Public
//  Description: Adds a single sample xyz.
////////////////////////////////////////////////////////////////////
58
void CurveFitter::add_xyz(float t, LVecBase3f const &xyz);

321 7 add_hpr 0 4 516 20 CurveFitter::add_hpr 0 1 65 242
////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::add_hpr
//       Access: Public
//  Description: Adds a single sample hpr.
////////////////////////////////////////////////////////////////////
58
void CurveFitter::add_hpr(float t, LVecBase3f const &hpr);

322 11 add_xyz_hpr 0 4 516 24 CurveFitter::add_xyz_hpr 0 1 66 267
////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::add_xyz_hpr
//       Access: Public
//  Description: Adds a single sample xyz & hpr simultaneously.
////////////////////////////////////////////////////////////////////
85
void CurveFitter::add_xyz_hpr(float t, LVecBase3f const &xyz, LVecBase3f const &hpr);

323 15 get_num_samples 0 4 516 28 CurveFitter::get_num_samples 0 1 67 299
////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::get_num_samples
//       Access: Public
//  Description: Returns the number of sample points that have been
//               added.
////////////////////////////////////////////////////////////////////
45
int CurveFitter::get_num_samples(void) const;

324 12 get_sample_t 0 4 516 25 CurveFitter::get_sample_t 0 1 68 275
////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::get_sample_t
//       Access: Public
//  Description: Returns the parametric value of the nth sample added.
////////////////////////////////////////////////////////////////////
45
float CurveFitter::get_sample_t(int n) const;

325 14 get_sample_xyz 0 4 516 27 CurveFitter::get_sample_xyz 0 1 69 275
////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::get_sample_xyz
//       Access: Public
//  Description: Returns the point in space of the nth sample added.
////////////////////////////////////////////////////////////////////
52
LVecBase3f CurveFitter::get_sample_xyz(int n) const;

326 14 get_sample_hpr 0 4 516 27 CurveFitter::get_sample_hpr 0 1 70 272
////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::get_sample_hpr
//       Access: Public
//  Description: Returns the orientation of the nth sample added.
////////////////////////////////////////////////////////////////////
52
LVecBase3f CurveFitter::get_sample_hpr(int n) const;

327 18 get_sample_tangent 0 4 516 31 CurveFitter::get_sample_tangent 0 1 71 391
////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::get_sample_tangent
//       Access: Public
//  Description: Returns the tangent associated with the nth sample
//               added.  This is only meaningful if compute_tangents()
//               has already been called.
////////////////////////////////////////////////////////////////////
56
LVecBase3f CurveFitter::get_sample_tangent(int n) const;

328 14 remove_samples 0 4 516 27 CurveFitter::remove_samples 0 1 72 335
////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::remove_samples
//       Access: Public
//  Description: Eliminates all samples from index begin, up to but not
//               including index end, from the database.
////////////////////////////////////////////////////////////////////
53
void CurveFitter::remove_samples(int begin, int end);

329 6 sample 0 4 516 19 CurveFitter::sample 0 1 73 473
////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::sample
//       Access: Public
//  Description: Generates a series of data points by sampling the
//               given curve (or xyz/hpr curves) the indicated number
//               of times.  The sampling is made evenly in parametric
//               time, and then the timewarps, if any, are applied.
////////////////////////////////////////////////////////////////////
71
void CurveFitter::sample(ParametricCurveCollection *curves, int count);

330 8 wrap_hpr 0 4 516 21 CurveFitter::wrap_hpr 0 1 74 400
////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::wrap_hpr
//       Access: Public
//  Description: Resets each HPR data point so that the maximum delta
//               between any two consecutive points is 180 degrees,
//               which should prevent incorrect HPR wrapping.
////////////////////////////////////////////////////////////////////
33
void CurveFitter::wrap_hpr(void);

331 11 sort_points 0 4 516 24 CurveFitter::sort_points 0 1 75 339
////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::sort_points
//       Access: Public
//  Description: Sorts all the data points in order by parametric
//               time, in case they were added in an incorrect order.
////////////////////////////////////////////////////////////////////
36
void CurveFitter::sort_points(void);

332 8 desample 0 4 516 21 CurveFitter::desample 0 1 76 428
////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::desample
//       Access: Public
//  Description: Removes sample points in order to reduce the
//               complexity of a sampled curve.  Keeps one out of
//               every factor samples.  Also keeps the first and the
//               last samples.
////////////////////////////////////////////////////////////////////
41
void CurveFitter::desample(float factor);

333 16 compute_tangents 0 4 516 29 CurveFitter::compute_tangents 0 1 77 508
////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::compute_tangents
//       Access: Public
//  Description: Once a set of points has been built, and prior to
//               calling MakeHermite() or MakeNurbs(),
//               ComputeTangents() must be called to set up the
//               tangents correctly (unless the tangents were defined
//               as the points were added).
////////////////////////////////////////////////////////////////////
48
void CurveFitter::compute_tangents(float scale);

334 12 make_hermite 0 4 516 25 CurveFitter::make_hermite 0 1 78 300
////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::make_hermite
//       Access: Public
//  Description: Converts the current set of data points into a
//               Hermite curve.
////////////////////////////////////////////////////////////////////
77
PointerTo< ParametricCurveCollection > CurveFitter::make_hermite(void) const;

335 10 make_nurbs 0 4 516 23 CurveFitter::make_nurbs 0 1 79 374
////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::make_nurbs
//       Access: Public
//  Description: Converts the current set of data points into a
//               NURBS curve.  This gives a smoother curve than
//               produced by MakeHermite().
////////////////////////////////////////////////////////////////////
75
PointerTo< ParametricCurveCollection > CurveFitter::make_nurbs(void) const;

336 6 output 0 4 516 19 CurveFitter::output 0 1 80 215
////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::output
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
45
void CurveFitter::output(ostream &out) const;

337 5 write 0 4 516 18 CurveFitter::write 0 1 81 214
////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::write
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
44
void CurveFitter::write(ostream &out) const;

338 14 get_class_type 0 4 516 27 CurveFitter::get_class_type 0 1 82 0
52
static TypeHandle CurveFitter::get_class_type(void);

339 14 PiecewiseCurve 0 4 517 30 PiecewiseCurve::PiecewiseCurve 0 1 83 223
////////////////////////////////////////////////////////////////////
//     Function: PiecewiseCurve::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
37
PiecewiseCurve::PiecewiseCurve(void);

340 14 get_class_type 0 4 517 30 PiecewiseCurve::get_class_type 0 1 84 0
55
static TypeHandle PiecewiseCurve::get_class_type(void);

341 12 HermiteCurve 0 4 518 26 HermiteCurve::HermiteCurve 0 2 85 86 542
////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::Copy Constructor
//       Access: Published
//  Description: Constructs a Hermite from the indicated (possibly
//               non-hermite) curve.
////////////////////////////////////////////////////////////////////
88
HermiteCurve::HermiteCurve(void);
HermiteCurve::HermiteCurve(ParametricCurve const &pc);

342 11 get_num_cvs 0 4 518 25 HermiteCurve::get_num_cvs 0 1 87 265
////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::get_num_cvs
//       Access: Published
//  Description: Returns the number of CV's in the curve.
////////////////////////////////////////////////////////////////////
42
int HermiteCurve::get_num_cvs(void) const;

343 9 insert_cv 0 4 518 23 HermiteCurve::insert_cv 0 1 88 908
////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::insert_cv
//       Access: Published
//  Description: Inserts a new CV at the given parametric point along
//               the curve.  If this parametric point is already on
//               the curve, the CV is assigned an index between its
//               two neighbors and the indices of all following CV's
//               are incremented by 1; its in and out tangents are
//               chosen to keep the curve consistent.  If the new
//               parametric point is beyond the end of the existing
//               curve, the curve is extended to meet it and the new
//               CV's position, in tangent, and out tangent are set to
//               zero.
//
//               The index number of the new CV is returned.
////////////////////////////////////////////////////////////////////
37
int HermiteCurve::insert_cv(float t);

344 9 append_cv 0 4 518 23 HermiteCurve::append_cv 0 2 89 90 392
////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::append_cv
//       Access: Published
//  Description: Adds a new CV to the end of the curve.  The new CV is
//               given initial in/out tangents of 0.  The return value
//               is the index of the new CV.
////////////////////////////////////////////////////////////////////
132
int HermiteCurve::append_cv(int type, float x, float y, float z);
inline int HermiteCurve::append_cv(int type, LVecBase3f const &v);

345 9 remove_cv 0 4 518 23 HermiteCurve::remove_cv 0 1 91 326
////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::remove_cv
//       Access: Published
//  Description: Removes the given CV from the curve.  Returns true if
//               the CV existed, false otherwise.
////////////////////////////////////////////////////////////////////
36
bool HermiteCurve::remove_cv(int n);

346 14 remove_all_cvs 0 4 518 28 HermiteCurve::remove_all_cvs 0 1 92 260
////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::remove_all_cvs
//       Access: Published
//  Description: Removes all CV's from the curve.
////////////////////////////////////////////////////////////////////
40
void HermiteCurve::remove_all_cvs(void);

347 11 set_cv_type 0 4 518 25 HermiteCurve::set_cv_type 0 1 93 907
////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::set_cv_type
//       Access: Published
//  Description: Changes the given CV's continuity type.  Legal values
//               are HC_CUT, HC_FREE, HC_G1, or HC_SMOOTH.
//
//               Other than HC_CUT, these have no effect on the actual
//               curve; it remains up to user software to impose the
//               constraints these imply.
//
//               HC_CUT implies a disconnection of the curve; HC_FREE
//               imposes no constraints on the tangents; HC_G1
//               forces the tangents to be collinear, and HC_SMOOTH
//               forces the tangents to be identical.  Setting type
//               type to HC_G1 or HC_SMOOTH may adjust the out
//               tangent to match the in tangent.
////////////////////////////////////////////////////////////////////
48
bool HermiteCurve::set_cv_type(int n, int type);

348 12 set_cv_point 0 4 518 26 HermiteCurve::set_cv_point 0 2 94 95 258
////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::set_cv_point
//       Access: Published
//  Description: Changes the given CV's position.
////////////////////////////////////////////////////////////////////
134
bool HermiteCurve::set_cv_point(int n, float x, float y, float z);
inline bool HermiteCurve::set_cv_point(int n, LVecBase3f const &v);

349 9 set_cv_in 0 4 518 23 HermiteCurve::set_cv_in 0 2 96 97 364
////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::set_cv_in
//       Access: Published
//  Description: Changes the given CV's in tangent.  Depending on the
//               continuity type, this may also adjust the out
//               tangent.
////////////////////////////////////////////////////////////////////
128
bool HermiteCurve::set_cv_in(int n, float x, float y, float z);
inline bool HermiteCurve::set_cv_in(int n, LVecBase3f const &v);

350 10 set_cv_out 0 4 518 24 HermiteCurve::set_cv_out 0 2 98 99 365
////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::set_cv_out
//       Access: Published
//  Description: Changes the given CV's out tangent.  Depending on the
//               continuity type, this may also adjust the in
//               tangent.
////////////////////////////////////////////////////////////////////
130
bool HermiteCurve::set_cv_out(int n, float x, float y, float z);
inline bool HermiteCurve::set_cv_out(int n, LVecBase3f const &v);

351 13 set_cv_tstart 0 4 518 27 HermiteCurve::set_cv_tstart 0 1 100 332
////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::set_cv_tstart
//       Access: Published
//  Description: Changes the given CV's parametric starting time.
//               This may affect the shape of the curve.
////////////////////////////////////////////////////////////////////
54
bool HermiteCurve::set_cv_tstart(int n, float tstart);

352 11 set_cv_name 0 4 518 25 HermiteCurve::set_cv_name 0 1 101 274
////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::set_cv_name
//       Access: Published
//  Description: Changes the name associated with a particular CV.
////////////////////////////////////////////////////////////////////
56
bool HermiteCurve::set_cv_name(int n, char const *name);

353 11 get_cv_type 0 4 518 25 HermiteCurve::get_cv_type 0 1 102 365
////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::get_cv_type
//       Access: Published
//  Description: Returns the given CV's continuity type, HC_CUT,
//               HC_FREE, HC_G1, or HC_SMOOTH, or 0 if there is
//               no such CV.
////////////////////////////////////////////////////////////////////
43
int HermiteCurve::get_cv_type(int n) const;

354 12 get_cv_point 0 4 518 26 HermiteCurve::get_cv_point 0 2 103 104 263
////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::get_cv_point
//       Access: Published
//  Description: Returns the position of the given CV.
////////////////////////////////////////////////////////////////////
119
LVecBase3f const &HermiteCurve::get_cv_point(int n) const;
void HermiteCurve::get_cv_point(int n, LVecBase3f &v) const;

355 9 get_cv_in 0 4 518 23 HermiteCurve::get_cv_in 0 2 105 106 262
////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::get_cv_in
//       Access: Published
//  Description: Returns the in tangent of the given CV.
////////////////////////////////////////////////////////////////////
113
LVecBase3f const &HermiteCurve::get_cv_in(int n) const;
void HermiteCurve::get_cv_in(int n, LVecBase3f &v) const;

356 10 get_cv_out 0 4 518 24 HermiteCurve::get_cv_out 0 2 107 108 264
////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::get_cv_out
//       Access: Published
//  Description: Returns the out tangent of the given CV.
////////////////////////////////////////////////////////////////////
115
LVecBase3f const &HermiteCurve::get_cv_out(int n) const;
void HermiteCurve::get_cv_out(int n, LVecBase3f &v) const;

357 13 get_cv_tstart 0 4 518 27 HermiteCurve::get_cv_tstart 0 1 109 307
////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::get_cv_tstart
//       Access: Published
//  Description: Returns the starting point in parametric space of the
//               given CV.
////////////////////////////////////////////////////////////////////
47
float HermiteCurve::get_cv_tstart(int n) const;

358 11 get_cv_name 0 4 518 25 HermiteCurve::get_cv_name 0 1 110 267
////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::get_cv_name
//       Access: Published
//  Description: Returns the name of the given CV, or NULL.
////////////////////////////////////////////////////////////////////
60
basic_string< char > HermiteCurve::get_cv_name(int n) const;

359 8 write_cv 0 4 518 22 HermiteCurve::write_cv 0 1 111 221
////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::write_cv
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
55
void HermiteCurve::write_cv(ostream &out, int n) const;

360 14 get_class_type 0 4 518 28 HermiteCurve::get_class_type 0 1 112 0
53
static TypeHandle HermiteCurve::get_class_type(void);

361 20 ~NurbsCurveInterface 0 6 519 41 NurbsCurveInterface::~NurbsCurveInterface 0 0 240
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveInterface::Destructor
//       Access: Published, Virtual
//  Description: 
////////////////////////////////////////////////////////////////////
56
virtual NurbsCurveInterface::~NurbsCurveInterface(void);

362 9 set_order 0 6 519 30 NurbsCurveInterface::set_order 0 1 113 0
59
virtual void NurbsCurveInterface::set_order(int order) = 0;

363 9 get_order 0 6 519 30 NurbsCurveInterface::get_order 0 1 114 0
59
virtual int NurbsCurveInterface::get_order(void) const = 0;

364 11 get_num_cvs 0 6 519 32 NurbsCurveInterface::get_num_cvs 0 1 115 0
61
virtual int NurbsCurveInterface::get_num_cvs(void) const = 0;

365 13 get_num_knots 0 6 519 34 NurbsCurveInterface::get_num_knots 0 1 116 0
63
virtual int NurbsCurveInterface::get_num_knots(void) const = 0;

366 9 insert_cv 0 6 519 30 NurbsCurveInterface::insert_cv 0 1 117 0
57
virtual bool NurbsCurveInterface::insert_cv(float t) = 0;

367 9 append_cv 0 4 519 30 NurbsCurveInterface::append_cv 0 3 118 119 120 1186
// Filename: nurbsCurveInterface.I
// Created by:  drose (02Mar01)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveInterface::append_cv
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveInterface::append_cv
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveInterface::append_cv
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
197
inline int NurbsCurveInterface::append_cv(float x, float y, float z);
inline int NurbsCurveInterface::append_cv(LVecBase3f const &v);
inline int NurbsCurveInterface::append_cv(LVecBase4f const &v);

368 9 remove_cv 0 6 519 30 NurbsCurveInterface::remove_cv 0 1 121 0
55
virtual bool NurbsCurveInterface::remove_cv(int n) = 0;

369 14 remove_all_cvs 0 6 519 35 NurbsCurveInterface::remove_all_cvs 0 1 122 0
59
virtual void NurbsCurveInterface::remove_all_cvs(void) = 0;

370 12 set_cv_point 0 4 519 33 NurbsCurveInterface::set_cv_point 0 2 123 124 662
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveInterface::set_cv_point
//       Access: Public, Scheme
//  Description: Repositions the indicated CV.  Returns true if
//               successful, false otherwise.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveInterface::set_cv_point
//       Access: Public, Scheme
//  Description: Repositions the indicated CV.  Returns true if
//               successful, false otherwise.
////////////////////////////////////////////////////////////////////
155
inline bool NurbsCurveInterface::set_cv_point(int n, float x, float y, float z);
inline bool NurbsCurveInterface::set_cv_point(int n, LVecBase3f const &v);

371 12 get_cv_point 0 4 519 33 NurbsCurveInterface::get_cv_point 0 1 125 279
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveInterface::get_cv_point
//       Access: Public, Scheme
//  Description: Returns the position of the indicated CV.
////////////////////////////////////////////////////////////////////
65
inline LVecBase3f NurbsCurveInterface::get_cv_point(int n) const;

372 13 set_cv_weight 0 4 519 34 NurbsCurveInterface::set_cv_weight 0 1 126 331
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveInterface::set_cv_weight
//       Access: Published
//  Description: Sets the weight of the indicated CV without affecting
//               its position in 3-d space.
////////////////////////////////////////////////////////////////////
56
bool NurbsCurveInterface::set_cv_weight(int n, float w);

373 13 get_cv_weight 0 4 519 34 NurbsCurveInterface::get_cv_weight 0 1 127 273
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveInterface::get_cv_weight
//       Access: Published
//  Description: Returns the weight of the indicated CV.
////////////////////////////////////////////////////////////////////
61
inline float NurbsCurveInterface::get_cv_weight(int n) const;

374 6 set_cv 0 6 519 27 NurbsCurveInterface::set_cv 0 1 128 0
73
virtual bool NurbsCurveInterface::set_cv(int n, LVecBase4f const &v) = 0;

375 6 get_cv 0 6 519 27 NurbsCurveInterface::get_cv 0 1 129 0
64
virtual LVecBase4f NurbsCurveInterface::get_cv(int n) const = 0;

376 8 set_knot 0 6 519 29 NurbsCurveInterface::set_knot 0 1 130 0
63
virtual bool NurbsCurveInterface::set_knot(int n, float t) = 0;

377 8 get_knot 0 6 519 29 NurbsCurveInterface::get_knot 0 1 131 0
61
virtual float NurbsCurveInterface::get_knot(int n) const = 0;

378 8 write_cv 0 4 519 29 NurbsCurveInterface::write_cv 0 1 132 228
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveInterface::write_cv
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
62
void NurbsCurveInterface::write_cv(ostream &out, int n) const;

379 14 get_class_type 0 4 519 35 NurbsCurveInterface::get_class_type 0 1 133 0
60
static TypeHandle NurbsCurveInterface::get_class_type(void);

380 24 upcast_to_PiecewiseCurve 0 12 520 36 NurbsCurve::upcast_to_PiecewiseCurve 0 1 137 40
upcast from NurbsCurve to PiecewiseCurve
59
PiecewiseCurve *NurbsCurve::upcast_to_PiecewiseCurve(void);

381 22 downcast_to_NurbsCurve 0 12 517 38 PiecewiseCurve::downcast_to_NurbsCurve 0 1 138 42
downcast from PiecewiseCurve to NurbsCurve
57
NurbsCurve *PiecewiseCurve::downcast_to_NurbsCurve(void);

382 29 upcast_to_NurbsCurveInterface 0 12 520 41 NurbsCurve::upcast_to_NurbsCurveInterface 0 1 139 45
upcast from NurbsCurve to NurbsCurveInterface
69
NurbsCurveInterface *NurbsCurve::upcast_to_NurbsCurveInterface(void);

383 22 downcast_to_NurbsCurve 0 12 519 43 NurbsCurveInterface::downcast_to_NurbsCurve 0 1 140 47
downcast from NurbsCurveInterface to NurbsCurve
62
NurbsCurve *NurbsCurveInterface::downcast_to_NurbsCurve(void);

384 10 NurbsCurve 0 4 520 22 NurbsCurve::NurbsCurve 0 2 134 135 860
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurve::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: NurbsCurve::Copy Constructor
//       Access: Published
//  Description: Constructs a NURBS curve equivalent to the indicated
//               (possibly non-NURBS) curve.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: NurbsCurve::Constructor
//       Access: Published
//  Description: Constructs a NURBS curve according to the indicated
//               NURBS parameters.
////////////////////////////////////////////////////////////////////
80
NurbsCurve::NurbsCurve(void);
NurbsCurve::NurbsCurve(ParametricCurve const &pc);

385 11 ~NurbsCurve 0 6 520 23 NurbsCurve::~NurbsCurve 0 0 230
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurve::Destructor
//       Access: Published, Virtual
//  Description:
////////////////////////////////////////////////////////////////////
38
virtual NurbsCurve::~NurbsCurve(void);

386 14 get_class_type 0 4 520 26 NurbsCurve::get_class_type 0 1 136 0
51
static TypeHandle NurbsCurve::get_class_type(void);

387 11 get_start_t 0 4 521 29 NurbsCurveResult::get_start_t 0 1 141 315
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::get_start_t
//       Access: Published
//  Description: Returns the first legal value of t on the curve.
//               Usually this is 0.0.
////////////////////////////////////////////////////////////////////
55
inline float NurbsCurveResult::get_start_t(void) const;

388 9 get_end_t 0 4 521 27 NurbsCurveResult::get_end_t 0 1 142 274
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::get_end_t
//       Access: Published
//  Description: Returns the last legal value of t on the curve.
////////////////////////////////////////////////////////////////////
53
inline float NurbsCurveResult::get_end_t(void) const;

389 10 eval_point 0 4 521 28 NurbsCurveResult::eval_point 0 1 143 406
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::eval_point
//       Access: Published
//  Description: Computes the point on the curve corresponding to the
//               indicated value in parametric time.  Returns true if
//               the t value is valid, false otherwise.
////////////////////////////////////////////////////////////////////
69
inline bool NurbsCurveResult::eval_point(float t, LVecBase3f &point);

390 12 eval_tangent 0 4 521 30 NurbsCurveResult::eval_tangent 0 1 144 456
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::eval_tangent
//       Access: Published
//  Description: Computes the tangent to the curve at the indicated
//               point in parametric time.  This tangent vector will
//               not necessarily be normalized, and could be zero.
//               See also eval_point().
////////////////////////////////////////////////////////////////////
73
inline bool NurbsCurveResult::eval_tangent(float t, LVecBase3f &tangent);

391 19 eval_extended_point 0 4 521 37 NurbsCurveResult::eval_extended_point 0 1 145 402
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::eval_extended_point
//       Access: Published
//  Description: Evaluates the curve in n-dimensional space according
//               to the extended vertices associated with the curve in
//               the indicated dimension.
////////////////////////////////////////////////////////////////////
67
inline float NurbsCurveResult::eval_extended_point(float t, int d);

392 20 eval_extended_points 0 4 521 38 NurbsCurveResult::eval_extended_points 0 0 534
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::eval_extended_points
//       Access: Published
//  Description: Simultaneously performs eval_extended_point on a
//               contiguous sequence of dimensions.  The dimensions
//               evaluated are d through (d + num_values - 1); the
//               results are filled into the num_values elements in
//               the indicated result array.
////////////////////////////////////////////////////////////////////
118
inline bool NurbsCurveResult::eval_extended_points(float t, int d, void *result[](unsigned int size), int num_values);

393 16 get_num_segments 0 4 521 34 NurbsCurveResult::get_num_segments 0 1 146 438
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::get_num_segments
//       Access: Published
//  Description: Returns the number of piecewise continuous segments
//               within the curve.  This number is usually not
//               important unless you plan to call
//               eval_segment_point().
////////////////////////////////////////////////////////////////////
58
inline int NurbsCurveResult::get_num_segments(void) const;

394 18 eval_segment_point 0 4 521 36 NurbsCurveResult::eval_segment_point 0 1 147 1042
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::eval_segment_point
//       Access: Published
//  Description: Evaluates the point on the curve corresponding to the
//               indicated value in parametric time within the
//               indicated curve segment.  t should be in the range
//               [0, 1].
//
//               The curve is internally represented as a number of
//               connected (or possibly unconnected) piecewise
//               continuous segments.  The exact number of segments
//               for a particular curve depends on the knot vector,
//               and is returned by get_num_segments().  Normally,
//               eval_point() is used to evaluate a point along the
//               continuous curve, but when you care more about local
//               continuity, you can use eval_segment_point() to
//               evaluate the points along each segment.
////////////////////////////////////////////////////////////////////
89
void NurbsCurveResult::eval_segment_point(int segment, float t, LVecBase3f &point) const;

395 20 eval_segment_tangent 0 4 521 38 NurbsCurveResult::eval_segment_tangent 0 1 148 479
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::eval_segment_tangent
//       Access: Published
//  Description: As eval_segment_point, but computes the tangent to
//               the curve at the indicated point.  The tangent vector
//               will not necessarily be normalized, and could be
//               zero, particularly at the endpoints.
////////////////////////////////////////////////////////////////////
93
void NurbsCurveResult::eval_segment_tangent(int segment, float t, LVecBase3f &tangent) const;

396 27 eval_segment_extended_point 0 4 521 45 NurbsCurveResult::eval_segment_extended_point 0 1 149 410
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::eval_segment_extended_point
//       Access: Published
//  Description: Evaluates the curve in n-dimensional space according
//               to the extended vertices associated with the curve in
//               the indicated dimension.
////////////////////////////////////////////////////////////////////
87
float NurbsCurveResult::eval_segment_extended_point(int segment, float t, int d) const;

397 28 eval_segment_extended_points 0 4 521 46 NurbsCurveResult::eval_segment_extended_points 0 0 542
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::eval_segment_extended_points
//       Access: Published
//  Description: Simultaneously performs eval_extended_point on a
//               contiguous sequence of dimensions.  The dimensions
//               evaluated are d through (d + num_values - 1); the
//               results are filled into the num_values elements in
//               the indicated result array.
////////////////////////////////////////////////////////////////////
138
void NurbsCurveResult::eval_segment_extended_points(int segment, float t, int d, void *result[](unsigned int size), int num_values) const;

398 13 get_segment_t 0 4 521 31 NurbsCurveResult::get_segment_t 0 1 150 482
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::get_segment_t
//       Access: Published
//  Description: Accepts a t value in the range [0, 1], and assumed to
//               be relative to the indicated segment (as in
//               eval_segment_point()), and returns the corresponding
//               t value in the entire curve (as in eval_point()).
////////////////////////////////////////////////////////////////////
73
inline float NurbsCurveResult::get_segment_t(int segment, float t) const;

399 15 adaptive_sample 0 4 521 33 NurbsCurveResult::adaptive_sample 0 1 151 642
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::adaptive_sample
//       Access: Published
//  Description: Determines the set of subdivisions necessary to
//               approximate the curve with a set of linear segments,
//               no point of which is farther than tolerance units
//               from the actual curve.
//
//               After this call, you may walk through the resulting
//               set of samples with get_num_samples(),
//               get_sample_t(), and get_sample_point().
////////////////////////////////////////////////////////////////////
56
void NurbsCurveResult::adaptive_sample(float tolerance);

400 15 get_num_samples 0 4 521 33 NurbsCurveResult::get_num_samples 0 1 152 338
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::get_num_samples
//       Access: Published
//  Description: Returns the number of sample points generated by the
//               previous call to adaptive_sample().
////////////////////////////////////////////////////////////////////
57
inline int NurbsCurveResult::get_num_samples(void) const;

401 12 get_sample_t 0 4 521 30 NurbsCurveResult::get_sample_t 0 1 153 343
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::get_sample_t
//       Access: Published
//  Description: Returns the t value of the nth sample point generated
//               by the previous call to adaptive_sample().
////////////////////////////////////////////////////////////////////
57
inline float NurbsCurveResult::get_sample_t(int n) const;

402 16 get_sample_point 0 4 521 34 NurbsCurveResult::get_sample_point 0 1 154 551
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::get_sample_point
//       Access: Published
//  Description: Returns the point on the curve of the nth sample
//               point generated by the previous call to
//               adaptive_sample().
//
//               For tangents, or extended points, you should use
//               get_sample_t() and pass it into eval_tangent() or
//               eval_extended_point().
////////////////////////////////////////////////////////////////////
71
inline LPoint3f const &NurbsCurveResult::get_sample_point(int n) const;

403 19 NurbsCurveEvaluator 0 4 522 40 NurbsCurveEvaluator::NurbsCurveEvaluator 0 1 155 231
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
47
NurbsCurveEvaluator::NurbsCurveEvaluator(void);

404 9 set_order 0 4 522 30 NurbsCurveEvaluator::set_order 0 1 156 997
// Filename: nurbsCurveEvaluator.I
// Created by:  drose (05Dec02)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::set_order
//       Access: Published
//  Description: Sets the order of the curve.  This resets the knot
//               vector to the default knot vector for the number of
//               vertices.
//
//               The order must be 1, 2, 3, or 4, and the value is one
//               more than the degree of the curve.
////////////////////////////////////////////////////////////////////
54
inline void NurbsCurveEvaluator::set_order(int order);

405 9 get_order 0 4 522 30 NurbsCurveEvaluator::get_order 0 1 157 319
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::get_order
//       Access: Published
//  Description: Returns the order of the curve as set by a previous
//               call to set_order().
////////////////////////////////////////////////////////////////////
54
inline int NurbsCurveEvaluator::get_order(void) const;

406 5 reset 0 4 522 26 NurbsCurveEvaluator::reset 0 1 158 508
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::reset
//       Access: Published
//  Description: Resets all the vertices and knots to their default
//               values, and sets the curve up with the indicated
//               number of vertices.  You must then call set_vertex()
//               repeatedly to fill in all of the vertex values
//               appropriately.
////////////////////////////////////////////////////////////////////
50
void NurbsCurveEvaluator::reset(int num_vertices);

407 16 get_num_vertices 0 4 522 37 NurbsCurveEvaluator::get_num_vertices 0 1 159 378
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::get_num_vertices
//       Access: Published
//  Description: Returns the number of control vertices in the curve.
//               This is the number passed to the last call to
//               reset().
////////////////////////////////////////////////////////////////////
61
inline int NurbsCurveEvaluator::get_num_vertices(void) const;

408 10 set_vertex 0 4 522 31 NurbsCurveEvaluator::set_vertex 0 3 160 161 162 985
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::set_vertex
//       Access: Published
//  Description: Sets the nth control vertex of the curve, as a vertex
//               in 4-d homogeneous space.  In this form, the first
//               three components of the vertex should already have
//               been scaled by the fourth component, which is the
//               homogeneous weight.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::set_vertex
//       Access: Published
//  Description: Sets the nth control vertex of the curve.  This
//               flavor sets the vertex as a 3-d coordinate and a
//               weight; the 3-d coordinate values are implicitly
//               scaled up by the weight factor.
////////////////////////////////////////////////////////////////////
175
inline void NurbsCurveEvaluator::set_vertex(int i, LVecBase4f const &vertex);
inline void NurbsCurveEvaluator::set_vertex(int i, LVecBase3f const &vertex, float weight = (1));

409 10 get_vertex 0 4 522 31 NurbsCurveEvaluator::get_vertex 0 2 163 164 670
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::get_vertex
//       Access: Published
//  Description: Returns the nth control vertex of the curve, relative
//               to its indicated coordinate space.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::get_vertex
//       Access: Published
//  Description: Returns the nth control vertex of the curve, relative
//               to the given coordinate space.
////////////////////////////////////////////////////////////////////
158
inline LVecBase4f const &NurbsCurveEvaluator::get_vertex(int i) const;
inline LVecBase4f NurbsCurveEvaluator::get_vertex(int i, NodePath const &rel_to) const;

410 16 set_vertex_space 0 4 522 37 NurbsCurveEvaluator::set_vertex_space 0 2 165 166 1436
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::set_vertex_space
//       Access: Published
//  Description: Sets the coordinate space of the nth control vertex.
//               If this is not specified, or is set to an empty
//               NodePath, the nth control vertex is deemed to be in
//               the coordinate space passed to evaluate().
//
//               This specifies the space as a fixed NodePath, which
//               is always the same NodePath.  Also see setting the
//               space as a path string, which can specify a different
//               NodePath for different instances of the curve.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::set_vertex_space
//       Access: Published
//  Description: Sets the coordinate space of the nth control vertex.
//               If this is not specified, or is set to an empty
//               string, the nth control vertex is deemed to be in
//               the coordinate space passed to evaluate().
//
//               This specifies the space as a string, which describes
//               the path to find the node relative to the rel_to
//               NodePath when the curve is evaluated.
////////////////////////////////////////////////////////////////////
173
inline void NurbsCurveEvaluator::set_vertex_space(int i, NodePath const &space);
inline void NurbsCurveEvaluator::set_vertex_space(int i, basic_string< char > const &space);

411 16 get_vertex_space 0 4 522 37 NurbsCurveEvaluator::get_vertex_space 0 1 167 347
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::get_vertex_space
//       Access: Published
//  Description: Returns the coordinate space of the nth control
//               vertex of the curve, expressed as a NodePath.
////////////////////////////////////////////////////////////////////
84
NodePath NurbsCurveEvaluator::get_vertex_space(int i, NodePath const &rel_to) const;

412 19 set_extended_vertex 0 4 522 40 NurbsCurveEvaluator::set_extended_vertex 0 1 168 1219
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::set_extended_vertex
//       Access: Public
//  Description: Sets an n-dimensional vertex value.  This allows
//               definition of a NURBS surface or curve in a sparse
//               n-dimensional space, typically used for associating
//               additional properties (like color or joint
//               membership) with each vertex of a surface.
//
//               The value d is an arbitrary integer value and
//               specifies the dimension of question for this
//               particular vertex.  Any number of dimensions may be
//               specified, and they need not be consecutive.  If a
//               value for a given dimension is not specified, is it
//               implicitly 0.0.
//
//               The value is implicitly scaled by the homogenous
//               weight value--that is, the fourth component of the
//               value passed to set_vertex().  This means the
//               ordinary vertex must be set first, before the
//               extended vertices can be set.
////////////////////////////////////////////////////////////////////
80
inline void NurbsCurveEvaluator::set_extended_vertex(int i, int d, float value);

413 19 get_extended_vertex 0 4 522 40 NurbsCurveEvaluator::get_extended_vertex 0 1 169 443
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::get_extended_vertex
//       Access: Public
//  Description: Returns an n-dimensional vertex value.  See
//               set_extended_vertex().  This returns the value set
//               for the indicated dimension, or 0.0 if nothing has
//               been set.
////////////////////////////////////////////////////////////////////
74
inline float NurbsCurveEvaluator::get_extended_vertex(int i, int d) const;

414 21 set_extended_vertices 0 4 522 42 NurbsCurveEvaluator::set_extended_vertices 0 0 546
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::set_extended_vertices
//       Access: Public
//  Description: Simultaneously sets several extended values in the
//               slots d through (d + num_values - 1) from the
//               num_values elements of the indicated array.  This is
//               equivalent to calling set_extended_vertex()
//               num_values times.  See set_extended_vertex().
////////////////////////////////////////////////////////////////////
113
void NurbsCurveEvaluator::set_extended_vertices(int i, int d, void *values[](unsigned int size), int num_values);

415 13 get_num_knots 0 4 522 34 NurbsCurveEvaluator::get_num_knots 0 1 170 354
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::get_num_knots
//       Access: Published
//  Description: Returns the number of knot values in the curve.  This
//               is based on the number of vertices and the order.
////////////////////////////////////////////////////////////////////
58
inline int NurbsCurveEvaluator::get_num_knots(void) const;

416 8 set_knot 0 4 522 29 NurbsCurveEvaluator::set_knot 0 1 171 447
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::set_knot
//       Access: Published
//  Description: Sets the value of the nth knot.  Each knot value
//               should be greater than or equal to the preceding
//               value.  If no knot values are set, a default knot
//               vector is supplied.
////////////////////////////////////////////////////////////////////
54
void NurbsCurveEvaluator::set_knot(int i, float knot);

417 8 get_knot 0 4 522 29 NurbsCurveEvaluator::get_knot 0 1 172 263
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::get_knot
//       Access: Published
//  Description: Returns the value of the nth knot.
////////////////////////////////////////////////////////////////////
49
float NurbsCurveEvaluator::get_knot(int i) const;

418 15 normalize_knots 0 4 522 36 NurbsCurveEvaluator::normalize_knots 0 1 173 334
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::normalize_knots
//       Access: Published
//  Description: Normalizes the knot sequence so that the parametric
//               range of the curve is 0 .. 1.
////////////////////////////////////////////////////////////////////
48
void NurbsCurveEvaluator::normalize_knots(void);

419 16 get_num_segments 0 4 522 37 NurbsCurveEvaluator::get_num_segments 0 1 174 354
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::get_num_segments
//       Access: Published
//  Description: Returns the number of piecewise continuous segments
//               in the curve.  This is based on the knot vector.
////////////////////////////////////////////////////////////////////
61
inline int NurbsCurveEvaluator::get_num_segments(void) const;

420 8 evaluate 0 4 522 29 NurbsCurveEvaluator::evaluate 0 3 175 176 177 987
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::evaluate
//       Access: Published
//  Description: Returns a NurbsCurveResult object that represents the
//               result of applying the knots to all of the current
//               values of the vertices, transformed into the
//               indicated coordinate space.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::evaluate
//       Access: Published
//  Description: Returns a NurbsCurveResult object that represents the
//               result of applying the knots to all of the current
//               values of the vertices, transformed into the
//               indicated coordinate space, and then further
//               transformed by the indicated matrix.
////////////////////////////////////////////////////////////////////
212
PointerTo< NurbsCurveResult > NurbsCurveEvaluator::evaluate(NodePath const &rel_to = ((()))) const;
PointerTo< NurbsCurveResult > NurbsCurveEvaluator::evaluate(NodePath const &rel_to, LMatrix4f const &mat) const;

421 6 output 0 4 522 27 NurbsCurveEvaluator::output 0 1 178 227
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::output
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
53
void NurbsCurveEvaluator::output(ostream &out) const;

422 11 get_start_u 0 4 523 31 NurbsSurfaceResult::get_start_u 0 1 179 316
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::get_start_u
//       Access: Public
//  Description: Returns the first legal value of u on the surface.
//               Usually this is 0.0.
////////////////////////////////////////////////////////////////////
57
inline float NurbsSurfaceResult::get_start_u(void) const;

423 9 get_end_u 0 4 523 29 NurbsSurfaceResult::get_end_u 0 1 180 275
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::get_end_u
//       Access: Public
//  Description: Returns the last legal value of u on the surface.
////////////////////////////////////////////////////////////////////
55
inline float NurbsSurfaceResult::get_end_u(void) const;

424 11 get_start_v 0 4 523 31 NurbsSurfaceResult::get_start_v 0 1 181 316
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::get_start_v
//       Access: Public
//  Description: Returns the first legal value of v on the surface.
//               Usually this is 0.0.
////////////////////////////////////////////////////////////////////
57
inline float NurbsSurfaceResult::get_start_v(void) const;

425 9 get_end_v 0 4 523 29 NurbsSurfaceResult::get_end_v 0 1 182 275
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::get_end_v
//       Access: Public
//  Description: Returns the last legal value of v on the surface.
////////////////////////////////////////////////////////////////////
55
inline float NurbsSurfaceResult::get_end_v(void) const;

426 10 eval_point 0 4 523 30 NurbsSurfaceResult::eval_point 0 1 183 415
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::eval_point
//       Access: Published
//  Description: Computes the point on the surface corresponding to the
//               indicated value in parametric time.  Returns true if
//               the u, v values are valid, false otherwise.
////////////////////////////////////////////////////////////////////
80
inline bool NurbsSurfaceResult::eval_point(float u, float v, LVecBase3f &point);

427 11 eval_normal 0 4 523 31 NurbsSurfaceResult::eval_normal 0 1 184 457
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::eval_normal
//       Access: Published
//  Description: Computes the normal to the surface at the indicated
//               point in parametric time.  This normal vector will
//               not necessarily be normalized, and could be zero.
//               See also eval_point().
////////////////////////////////////////////////////////////////////
82
inline bool NurbsSurfaceResult::eval_normal(float u, float v, LVecBase3f &normal);

428 19 eval_extended_point 0 4 523 39 NurbsSurfaceResult::eval_extended_point 0 1 185 408
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::eval_extended_point
//       Access: Published
//  Description: Evaluates the surface in n-dimensional space according
//               to the extended vertices associated with the surface in
//               the indicated dimension.
////////////////////////////////////////////////////////////////////
78
inline float NurbsSurfaceResult::eval_extended_point(float u, float v, int d);

429 20 eval_extended_points 0 4 523 40 NurbsSurfaceResult::eval_extended_points 0 0 536
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::eval_extended_points
//       Access: Published
//  Description: Simultaneously performs eval_extended_point on a
//               contiguous sequence of dimensions.  The dimensions
//               evaluated are d through (d + num_values - 1); the
//               results are filled into the num_values elements in
//               the indicated result array.
////////////////////////////////////////////////////////////////////
129
inline bool NurbsSurfaceResult::eval_extended_points(float u, float v, int d, void *result[](unsigned int size), int num_values);

430 18 get_num_u_segments 0 4 523 38 NurbsSurfaceResult::get_num_u_segments 0 1 186 460
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::get_num_u_segments
//       Access: Public
//  Description: Returns the number of piecewise continuous segments
//               within the surface in the U direction.  This number
//               is usually not important unless you plan to call
//               eval_segment_point().
////////////////////////////////////////////////////////////////////
62
inline int NurbsSurfaceResult::get_num_u_segments(void) const;

431 18 get_num_v_segments 0 4 523 38 NurbsSurfaceResult::get_num_v_segments 0 1 187 460
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::get_num_v_segments
//       Access: Public
//  Description: Returns the number of piecewise continuous segments
//               within the surface in the V direction.  This number
//               is usually not important unless you plan to call
//               eval_segment_point().
////////////////////////////////////////////////////////////////////
62
inline int NurbsSurfaceResult::get_num_v_segments(void) const;

432 18 eval_segment_point 0 4 523 38 NurbsSurfaceResult::eval_segment_point 0 1 188 1060
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::eval_segment_point
//       Access: Published
//  Description: Evaluates the point on the surface corresponding to the
//               indicated value in parametric time within the
//               indicated surface segment.  u and v should be in the
//               range [0, 1].
//
//               The surface is internally represented as a number of
//               connected (or possibly unconnected) piecewise
//               continuous segments.  The exact number of segments
//               for a particular surface depends on the knot vector,
//               and is returned by get_num_segments().  Normally,
//               eval_point() is used to evaluate a point along the
//               continuous surface, but when you care more about local
//               continuity, you can use eval_segment_point() to
//               evaluate the points along each segment.
////////////////////////////////////////////////////////////////////
103
void NurbsSurfaceResult::eval_segment_point(int ui, int vi, float u, float v, LVecBase3f &point) const;

433 19 eval_segment_normal 0 4 523 39 NurbsSurfaceResult::eval_segment_normal 0 1 189 449
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::eval_segment_normal
//       Access: Published
//  Description: As eval_segment_point, but computes the normal to
//               the surface at the indicated point.  The normal vector
//               will not necessarily be normalized, and could be
//               zero.
////////////////////////////////////////////////////////////////////
105
void NurbsSurfaceResult::eval_segment_normal(int ui, int vi, float u, float v, LVecBase3f &normal) const;

434 27 eval_segment_extended_point 0 4 523 47 NurbsSurfaceResult::eval_segment_extended_point 0 1 190 416
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::eval_segment_extended_point
//       Access: Published
//  Description: Evaluates the surface in n-dimensional space according
//               to the extended vertices associated with the surface in
//               the indicated dimension.
////////////////////////////////////////////////////////////////////
101
float NurbsSurfaceResult::eval_segment_extended_point(int ui, int vi, float u, float v, int d) const;

435 28 eval_segment_extended_points 0 4 523 48 NurbsSurfaceResult::eval_segment_extended_points 0 0 544
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::eval_segment_extended_points
//       Access: Published
//  Description: Simultaneously performs eval_extended_point on a
//               contiguous sequence of dimensions.  The dimensions
//               evaluated are d through (d + num_values - 1); the
//               results are filled into the num_values elements in
//               the indicated result array.
////////////////////////////////////////////////////////////////////
152
void NurbsSurfaceResult::eval_segment_extended_points(int ui, int vi, float u, float v, int d, void *result[](unsigned int size), int num_values) const;

436 13 get_segment_u 0 4 523 33 NurbsSurfaceResult::get_segment_u 0 1 191 483
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::get_segment_u
//       Access: Public
//  Description: Accepts a u value in the range [0, 1], and assumed to
//               be relative to the indicated segment (as in
//               eval_segment_point()), and returns the corresponding
//               u value in the entire surface (as in eval_point()).
////////////////////////////////////////////////////////////////////
70
inline float NurbsSurfaceResult::get_segment_u(int ui, float u) const;

437 13 get_segment_v 0 4 523 33 NurbsSurfaceResult::get_segment_v 0 1 192 483
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::get_segment_v
//       Access: Public
//  Description: Accepts a v value in the range [0, 1], and assumed to
//               be relative to the indicated segment (as in
//               eval_segment_point()), and returns the corresponding
//               v value in the entire surface (as in eval_point()).
////////////////////////////////////////////////////////////////////
70
inline float NurbsSurfaceResult::get_segment_v(int vi, float v) const;

438 21 NurbsSurfaceEvaluator 0 4 524 44 NurbsSurfaceEvaluator::NurbsSurfaceEvaluator 0 1 193 233
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
51
NurbsSurfaceEvaluator::NurbsSurfaceEvaluator(void);

439 11 set_u_order 0 4 524 34 NurbsSurfaceEvaluator::set_u_order 0 1 194 1025
// Filename: nurbsSurfaceEvaluator.I
// Created by:  drose (10Oct03)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::set_u_order
//       Access: Published
//  Description: Sets the order of the surface in the U direction.
//               This resets the knot vector to the default knot
//               vector for the number of vertices.
//
//               The order must be 1, 2, 3, or 4, and the value is one
//               more than the degree of the surface.
////////////////////////////////////////////////////////////////////
60
inline void NurbsSurfaceEvaluator::set_u_order(int u_order);

440 11 get_u_order 0 4 524 34 NurbsSurfaceEvaluator::get_u_order 0 1 195 346
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_u_order
//       Access: Published
//  Description: Returns the order of the surface in the U direction
//               as set by a previous call to set_u_order().
////////////////////////////////////////////////////////////////////
58
inline int NurbsSurfaceEvaluator::get_u_order(void) const;

441 11 set_v_order 0 4 524 34 NurbsSurfaceEvaluator::set_v_order 0 1 196 528
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::set_v_order
//       Access: Published
//  Description: Sets the order of the surface in the V direction.
//               This resets the knot vector to the default knot
//               vector for the number of vertices.
//
//               The order must be 1, 2, 3, or 4, and the value is one
//               more than the degree of the surface.
////////////////////////////////////////////////////////////////////
60
inline void NurbsSurfaceEvaluator::set_v_order(int v_order);

442 11 get_v_order 0 4 524 34 NurbsSurfaceEvaluator::get_v_order 0 1 197 346
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_v_order
//       Access: Published
//  Description: Returns the order of the surface in the V direction
//               as set by a previous call to set_v_order().
////////////////////////////////////////////////////////////////////
58
inline int NurbsSurfaceEvaluator::get_v_order(void) const;

443 5 reset 0 4 524 28 NurbsSurfaceEvaluator::reset 0 1 198 512
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::reset
//       Access: Published
//  Description: Resets all the vertices and knots to their default
//               values, and sets the surface up with the indicated
//               number of vertices.  You must then call set_vertex()
//               repeatedly to fill in all of the vertex values
//               appropriately.
////////////////////////////////////////////////////////////////////
74
void NurbsSurfaceEvaluator::reset(int num_u_vertices, int num_v_vertices);

444 18 get_num_u_vertices 0 4 524 41 NurbsSurfaceEvaluator::get_num_u_vertices 0 1 199 404
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_num_u_vertices
//       Access: Published
//  Description: Returns the number of control vertices in the U
//               direction on the surface.  This is the number passed
//               to the last call to reset().
////////////////////////////////////////////////////////////////////
65
inline int NurbsSurfaceEvaluator::get_num_u_vertices(void) const;

445 18 get_num_v_vertices 0 4 524 41 NurbsSurfaceEvaluator::get_num_v_vertices 0 1 200 404
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_num_v_vertices
//       Access: Published
//  Description: Returns the number of control vertices in the V
//               direction on the surface.  This is the number passed
//               to the last call to reset().
////////////////////////////////////////////////////////////////////
65
inline int NurbsSurfaceEvaluator::get_num_v_vertices(void) const;

446 10 set_vertex 0 4 524 33 NurbsSurfaceEvaluator::set_vertex 0 3 201 202 203 993
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::set_vertex
//       Access: Published
//  Description: Sets the nth control vertex of the surface, as a vertex
//               in 4-d homogeneous space.  In this form, the first
//               three components of the vertex should already have
//               been scaled by the fourth component, which is the
//               homogeneous weight.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::set_vertex
//       Access: Published
//  Description: Sets the nth control vertex of the surface.  This
//               flavor sets the vertex as a 3-d coordinate and a
//               weight; the 3-d coordinate values are implicitly
//               scaled up by the weight factor.
////////////////////////////////////////////////////////////////////
197
inline void NurbsSurfaceEvaluator::set_vertex(int ui, int vi, LVecBase4f const &vertex);
inline void NurbsSurfaceEvaluator::set_vertex(int ui, int vi, LVecBase3f const &vertex, float weight = (1));

447 10 get_vertex 0 4 524 33 NurbsSurfaceEvaluator::get_vertex 0 2 204 205 678
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_vertex
//       Access: Published
//  Description: Returns the nth control vertex of the surface, relative
//               to its indicated coordinate space.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_vertex
//       Access: Published
//  Description: Returns the nth control vertex of the surface, relative
//               to the given coordinate space.
////////////////////////////////////////////////////////////////////
180
inline LVecBase4f const &NurbsSurfaceEvaluator::get_vertex(int ui, int vi) const;
inline LVecBase4f NurbsSurfaceEvaluator::get_vertex(int ui, int vi, NodePath const &rel_to) const;

448 16 set_vertex_space 0 4 524 39 NurbsSurfaceEvaluator::set_vertex_space 0 2 206 207 1444
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::set_vertex_space
//       Access: Published
//  Description: Sets the coordinate space of the nth control vertex.
//               If this is not specified, or is set to an empty
//               NodePath, the nth control vertex is deemed to be in
//               the coordinate space passed to evaluate().
//
//               This specifies the space as a fixed NodePath, which
//               is always the same NodePath.  Also see setting the
//               space as a path string, which can specify a different
//               NodePath for different instances of the surface.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::set_vertex_space
//       Access: Published
//  Description: Sets the coordinate space of the nth control vertex.
//               If this is not specified, or is set to an empty
//               string, the nth control vertex is deemed to be in
//               the coordinate space passed to evaluate().
//
//               This specifies the space as a string, which describes
//               the path to find the node relative to the rel_to
//               NodePath when the surface is evaluated.
////////////////////////////////////////////////////////////////////
195
inline void NurbsSurfaceEvaluator::set_vertex_space(int ui, int vi, NodePath const &space);
inline void NurbsSurfaceEvaluator::set_vertex_space(int ui, int vi, basic_string< char > const &space);

449 16 get_vertex_space 0 4 524 39 NurbsSurfaceEvaluator::get_vertex_space 0 1 208 351
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_vertex_space
//       Access: Published
//  Description: Returns the coordinate space of the nth control
//               vertex of the surface, expressed as a NodePath.
////////////////////////////////////////////////////////////////////
95
NodePath NurbsSurfaceEvaluator::get_vertex_space(int ui, int vi, NodePath const &rel_to) const;

450 19 set_extended_vertex 0 4 524 42 NurbsSurfaceEvaluator::set_extended_vertex 0 1 209 1223
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::set_extended_vertex
//       Access: Public
//  Description: Sets an n-dimensional vertex value.  This allows
//               definition of a NURBS surface or surface in a sparse
//               n-dimensional space, typically used for associating
//               additional properties (like color or joint
//               membership) with each vertex of a surface.
//
//               The value d is an arbitrary integer value and
//               specifies the dimension of question for this
//               particular vertex.  Any number of dimensions may be
//               specified, and they need not be consecutive.  If a
//               value for a given dimension is not specified, is it
//               implicitly 0.0.
//
//               The value is implicitly scaled by the homogenous
//               weight value--that is, the fourth component of the
//               value passed to set_vertex().  This means the
//               ordinary vertex must be set first, before the
//               extended vertices can be set.
////////////////////////////////////////////////////////////////////
91
inline void NurbsSurfaceEvaluator::set_extended_vertex(int ui, int vi, int d, float value);

451 19 get_extended_vertex 0 4 524 42 NurbsSurfaceEvaluator::get_extended_vertex 0 1 210 445
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_extended_vertex
//       Access: Public
//  Description: Returns an n-dimensional vertex value.  See
//               set_extended_vertex().  This returns the value set
//               for the indicated dimension, or 0.0 if nothing has
//               been set.
////////////////////////////////////////////////////////////////////
85
inline float NurbsSurfaceEvaluator::get_extended_vertex(int ui, int vi, int d) const;

452 21 set_extended_vertices 0 4 524 44 NurbsSurfaceEvaluator::set_extended_vertices 0 0 548
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::set_extended_vertices
//       Access: Public
//  Description: Simultaneously sets several extended values in the
//               slots d through (d + num_values - 1) from the
//               num_values elements of the indicated array.  This is
//               equivalent to calling set_extended_vertex()
//               num_values times.  See set_extended_vertex().
////////////////////////////////////////////////////////////////////
124
void NurbsSurfaceEvaluator::set_extended_vertices(int ui, int vi, int d, void *values[](unsigned int size), int num_values);

453 15 get_num_u_knots 0 4 524 38 NurbsSurfaceEvaluator::get_num_u_knots 0 1 211 396
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_num_u_knots
//       Access: Published
//  Description: Returns the number of knot values in the surface in
//               the U direction.  This is based on the number of
//               vertices and the order.
////////////////////////////////////////////////////////////////////
62
inline int NurbsSurfaceEvaluator::get_num_u_knots(void) const;

454 10 set_u_knot 0 4 524 33 NurbsSurfaceEvaluator::set_u_knot 0 1 212 451
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::set_u_knot
//       Access: Published
//  Description: Sets the value of the nth knot.  Each knot value
//               should be greater than or equal to the preceding
//               value.  If no knot values are set, a default knot
//               vector is supplied.
////////////////////////////////////////////////////////////////////
58
void NurbsSurfaceEvaluator::set_u_knot(int i, float knot);

455 10 get_u_knot 0 4 524 33 NurbsSurfaceEvaluator::get_u_knot 0 1 213 267
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_u_knot
//       Access: Published
//  Description: Returns the value of the nth knot.
////////////////////////////////////////////////////////////////////
53
float NurbsSurfaceEvaluator::get_u_knot(int i) const;

456 17 normalize_u_knots 0 4 524 40 NurbsSurfaceEvaluator::normalize_u_knots 0 1 214 359
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::normalize_u_knots
//       Access: Published
//  Description: Normalizes the knot sequence so that the parametric
//               range of the surface in the U direction is 0 .. 1.
////////////////////////////////////////////////////////////////////
52
void NurbsSurfaceEvaluator::normalize_u_knots(void);

457 15 get_num_v_knots 0 4 524 38 NurbsSurfaceEvaluator::get_num_v_knots 0 1 215 396
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_num_v_knots
//       Access: Published
//  Description: Returns the number of knot values in the surface in
//               the V direction.  This is based on the number of
//               vertices and the order.
////////////////////////////////////////////////////////////////////
62
inline int NurbsSurfaceEvaluator::get_num_v_knots(void) const;

458 10 set_v_knot 0 4 524 33 NurbsSurfaceEvaluator::set_v_knot 0 1 216 451
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::set_v_knot
//       Access: Published
//  Description: Sets the value of the nth knot.  Each knot value
//               should be greater than or equal to the preceding
//               value.  If no knot values are set, a default knot
//               vector is supplied.
////////////////////////////////////////////////////////////////////
58
void NurbsSurfaceEvaluator::set_v_knot(int i, float knot);

459 10 get_v_knot 0 4 524 33 NurbsSurfaceEvaluator::get_v_knot 0 1 217 267
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_v_knot
//       Access: Published
//  Description: Returns the value of the nth knot.
////////////////////////////////////////////////////////////////////
53
float NurbsSurfaceEvaluator::get_v_knot(int i) const;

460 17 normalize_v_knots 0 4 524 40 NurbsSurfaceEvaluator::normalize_v_knots 0 1 218 359
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::normalize_v_knots
//       Access: Published
//  Description: Normalizes the knot sequence so that the parametric
//               range of the surface in the U direction is 0 .. 1.
////////////////////////////////////////////////////////////////////
52
void NurbsSurfaceEvaluator::normalize_v_knots(void);

461 18 get_num_u_segments 0 4 524 41 NurbsSurfaceEvaluator::get_num_u_segments 0 1 219 396
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_num_u_segments
//       Access: Published
//  Description: Returns the number of piecewise continuous segments
//               in the surface in the U direction.  This is based on
//               the knot vector.
////////////////////////////////////////////////////////////////////
65
inline int NurbsSurfaceEvaluator::get_num_u_segments(void) const;

462 18 get_num_v_segments 0 4 524 41 NurbsSurfaceEvaluator::get_num_v_segments 0 1 220 396
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_num_v_segments
//       Access: Published
//  Description: Returns the number of piecewise continuous segments
//               in the surface in the V direction.  This is based on
//               the knot vector.
////////////////////////////////////////////////////////////////////
65
inline int NurbsSurfaceEvaluator::get_num_v_segments(void) const;

463 8 evaluate 0 4 524 31 NurbsSurfaceEvaluator::evaluate 0 2 221 222 461
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::evaluate
//       Access: Published
//  Description: Returns a NurbsSurfaceResult object that represents the
//               result of applying the knots to all of the current
//               values of the vertices, transformed into the
//               indicated coordinate space.
////////////////////////////////////////////////////////////////////
103
PointerTo< NurbsSurfaceResult > NurbsSurfaceEvaluator::evaluate(NodePath const &rel_to = ((()))) const;

464 6 output 0 4 524 29 NurbsSurfaceEvaluator::output 0 1 223 229
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::output
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
55
void NurbsSurfaceEvaluator::output(ostream &out) const;

465 8 RopeNode 0 4 525 18 RopeNode::RopeNode 0 1 224 444
////////////////////////////////////////////////////////////////////
//     Function: RopeNode::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: RopeNode::Copy Constructor
//       Access: Protected
//  Description:
////////////////////////////////////////////////////////////////////
53
RopeNode::RopeNode(basic_string< char > const &name);

466 9 set_curve 0 4 525 19 RopeNode::set_curve 0 1 225 280
////////////////////////////////////////////////////////////////////
//     Function: set_curve
//       Access: Published
//  Description: Sets the particular curve represented by the
//               RopeNode.
////////////////////////////////////////////////////////////////////
60
inline void RopeNode::set_curve(NurbsCurveEvaluator *curve);

467 9 get_curve 0 4 525 19 RopeNode::get_curve 0 1 226 255
////////////////////////////////////////////////////////////////////
//     Function: get_curve
//       Access: Published
//  Description: Returns the curve represented by the RopeNode.
////////////////////////////////////////////////////////////////////
60
inline NurbsCurveEvaluator *RopeNode::get_curve(void) const;

468 15 set_render_mode 0 4 525 25 RopeNode::set_render_mode 0 1 227 365
////////////////////////////////////////////////////////////////////
//     Function: set_render_mode
//       Access: Published
//  Description: Specifies the method used to render the rope.  The
//               simplest is RM_thread, which just draws a one-pixel
//               line segment.
////////////////////////////////////////////////////////////////////
72
inline void RopeNode::set_render_mode(RopeNode::RenderMode render_mode);

469 15 get_render_mode 0 4 525 25 RopeNode::get_render_mode 0 1 228 299
////////////////////////////////////////////////////////////////////
//     Function: get_render_mode
//       Access: Published
//  Description: Returns the method used to render the rope.  See
//               set_render_mode().
////////////////////////////////////////////////////////////////////
66
inline RopeNode::RenderMode RopeNode::get_render_mode(void) const;

470 11 set_uv_mode 0 4 525 21 RopeNode::set_uv_mode 0 1 229 289
////////////////////////////////////////////////////////////////////
//     Function: set_uv_mode
//       Access: Published
//  Description: Specifies the algorithm to use to generate UV's for
//               the rope.
////////////////////////////////////////////////////////////////////
60
inline void RopeNode::set_uv_mode(RopeNode::UVMode uv_mode);

471 11 get_uv_mode 0 4 525 21 RopeNode::get_uv_mode 0 1 230 287
////////////////////////////////////////////////////////////////////
//     Function: get_uv_mode
//       Access: Published
//  Description: Returns the algorithm to use to generate UV's for the
//               rope.
////////////////////////////////////////////////////////////////////
58
inline RopeNode::UVMode RopeNode::get_uv_mode(void) const;

472 16 set_uv_direction 0 4 525 26 RopeNode::set_uv_direction 0 1 231 334
////////////////////////////////////////////////////////////////////
//     Function: set_uv_direction
//       Access: Published
//  Description: Specify true to vary the U coordinate down the length
//               of the rope, or false to vary the V coordinate.
////////////////////////////////////////////////////////////////////
56
inline void RopeNode::set_uv_direction(bool u_dominant);

473 16 get_uv_direction 0 4 525 26 RopeNode::get_uv_direction 0 1 232 360
////////////////////////////////////////////////////////////////////
//     Function: get_uv_direction
//       Access: Published
//  Description: Returns true if the rope runs down the U coordinate
//               of the texture, or false if it runs down the V
//               coordinate.
////////////////////////////////////////////////////////////////////
51
inline bool RopeNode::get_uv_direction(void) const;

474 12 set_uv_scale 0 4 525 22 RopeNode::set_uv_scale 0 1 233 452
////////////////////////////////////////////////////////////////////
//     Function: set_uv_scale
//       Access: Published
//  Description: Specifies an additional scaling factor to apply to
//               generated UV's along the rope.  This scale factor is
//               applied in whichever direction is along the rope, as
//               specified by set_uv_direction().
////////////////////////////////////////////////////////////////////
48
inline void RopeNode::set_uv_scale(float scale);

475 12 get_uv_scale 0 4 525 22 RopeNode::get_uv_scale 0 1 234 296
////////////////////////////////////////////////////////////////////
//     Function: get_uv_scale
//       Access: Published
//  Description: Returns the scaling factor to apply to generated UV's
//               for the rope.
////////////////////////////////////////////////////////////////////
48
inline float RopeNode::get_uv_scale(void) const;

476 15 set_normal_mode 0 4 525 25 RopeNode::set_normal_mode 0 1 235 441
////////////////////////////////////////////////////////////////////
//     Function: set_normal_mode
//       Access: Published
//  Description: Specifies the kind of normals to generate for the
//               rope.  This is only applicable when the RenderMode is
//               set to RM_tube; in the other render modes, normals
//               are never generated.
////////////////////////////////////////////////////////////////////
72
inline void RopeNode::set_normal_mode(RopeNode::NormalMode normal_mode);

477 15 get_normal_mode 0 4 525 25 RopeNode::get_normal_mode 0 1 236 365
////////////////////////////////////////////////////////////////////
//     Function: get_normal_mode
//       Access: Published
//  Description: Returns the kind of normals to generate for the rope.
//               This is only applicable when the RenderMode is set to
//               RM_tube.
////////////////////////////////////////////////////////////////////
66
inline RopeNode::NormalMode RopeNode::get_normal_mode(void) const;

478 11 set_tube_up 0 4 525 21 RopeNode::set_tube_up 0 1 237 723
////////////////////////////////////////////////////////////////////
//     Function: set_tube_up
//       Access: Published
//  Description: Specifies a normal vector, generally perpendicular to
//               the main axis of the starting point of the curve,
//               that controls the "top" of the curve, when RenderMode
//               is RM_tube.  This is used to orient the vertices that
//               make up the tube.  If this vector is too nearly
//               parallel with the starting direction of the curve,
//               there may be a tendency for the whole tube to
//               gimble-lock around its primary axis.
////////////////////////////////////////////////////////////////////
60
inline void RopeNode::set_tube_up(LVector3f const &tube_up);

479 11 get_tube_up 0 4 525 21 RopeNode::get_tube_up 0 1 238 358
////////////////////////////////////////////////////////////////////
//     Function: get_tube_up
//       Access: Published
//  Description: Returns the normal vector used to control the "top"
//               of the curve, when RenderMode is RM_tube.  See
//               set_tube_up().
////////////////////////////////////////////////////////////////////
58
inline LVector3f const &RopeNode::get_tube_up(void) const;

480 20 set_use_vertex_color 0 4 525 30 RopeNode::set_use_vertex_color 0 1 239 667
////////////////////////////////////////////////////////////////////
//     Function: set_use_vertex_color
//       Access: Published
//  Description: Sets the "use vertex color" flag.  When this is true,
//               the R, G, B, A vertex color is assumed to be stored
//               as the dimensions n + 0, n + 1, n + 2, n + 3,
//               respectively, of the extended vertex values, where n
//               is the value returned by
//               get_vertex_color_dimension().  Use
//               NurbsCurveEvaluator::set_extended_vertex() to set
//               these values.
////////////////////////////////////////////////////////////////////
54
inline void RopeNode::set_use_vertex_color(bool flag);

481 20 get_use_vertex_color 0 4 525 30 RopeNode::get_use_vertex_color 0 1 240 302
////////////////////////////////////////////////////////////////////
//     Function: get_use_vertex_color
//       Access: Published
//  Description: Returns the "use vertex color" flag.  See
//               set_use_vertex_color().
////////////////////////////////////////////////////////////////////
55
inline bool RopeNode::get_use_vertex_color(void) const;

482 26 get_vertex_color_dimension 0 4 525 36 RopeNode::get_vertex_color_dimension 0 1 241 506
////////////////////////////////////////////////////////////////////
//     Function: get_vertex_color_dimension
//       Access: Published, Static
//  Description: Returns the numeric extended dimension in which the
//               color components should be found.  See
//               NurbsCurveEvaluator::set_extended_vertex().
//
//               The color components will be expected at (n, n + 1, n
//               + 2, n + 3).
////////////////////////////////////////////////////////////////////
61
static inline int RopeNode::get_vertex_color_dimension(void);

483 14 set_num_subdiv 0 4 525 24 RopeNode::set_num_subdiv 0 1 242 388
////////////////////////////////////////////////////////////////////
//     Function: set_num_subdiv
//       Access: Published
//  Description: Specifies the number of subdivisions per cubic
//               segment (that is, per unique knot value) to draw in a
//               fixed uniform tesselation of the curve.
////////////////////////////////////////////////////////////////////
53
inline void RopeNode::set_num_subdiv(int num_subdiv);

484 14 get_num_subdiv 0 4 525 24 RopeNode::get_num_subdiv 0 1 243 315
////////////////////////////////////////////////////////////////////
//     Function: get_num_subdiv
//       Access: Published
//  Description: Returns the number of subdivisions per cubic segment
//               to draw.  See set_num_subdiv().
////////////////////////////////////////////////////////////////////
48
inline int RopeNode::get_num_subdiv(void) const;

485 14 set_num_slices 0 4 525 24 RopeNode::set_num_slices 0 1 244 711
////////////////////////////////////////////////////////////////////
//     Function: set_num_slices
//       Access: Published
//  Description: Specifies the number of radial subdivisions to make
//               if RenderMode is RM_tube.  It is ignored in the other
//               render modes.
//
//               Increasing this number increases the roundness of a
//               cross-section of the tube.  The minimum value for a
//               dimensional tube is 3; setting it to 2 will get you a
//               thin piece of tape (which is similar to RM_billboard,
//               except it won't rotate to face the camera).
////////////////////////////////////////////////////////////////////
53
inline void RopeNode::set_num_slices(int num_slices);

486 14 get_num_slices 0 4 525 24 RopeNode::get_num_slices 0 1 245 388
////////////////////////////////////////////////////////////////////
//     Function: get_num_slices
//       Access: Published
//  Description: Returns the number of radial subdivisions to make if
//               RenderMode is RM_tube.  It is ignored in the other
//               render modes.  See set_num_slices().
////////////////////////////////////////////////////////////////////
48
inline int RopeNode::get_num_slices(void) const;

487 24 set_use_vertex_thickness 0 4 525 34 RopeNode::set_use_vertex_thickness 0 1 246 752
////////////////////////////////////////////////////////////////////
//     Function: set_use_vertex_thickness
//       Access: Published
//  Description: Sets the "use vertex thickness" flag.  When this is true,
//               the vertex thickness is assumed to be stored as the
//               dimension get_vertex_thickness_dimension(), of the
//               extended vertex values.  Use
//               NurbsCurveEvaluator::set_extended_vertex() to set
//               these values.
//
//               In this mode, the overall thickness is also applied
//               as a scale to the vertex thickness.  Not all render
//               modes support vertex thickness.
////////////////////////////////////////////////////////////////////
58
inline void RopeNode::set_use_vertex_thickness(bool flag);

488 24 get_use_vertex_thickness 0 4 525 34 RopeNode::get_use_vertex_thickness 0 1 247 314
////////////////////////////////////////////////////////////////////
//     Function: get_use_vertex_thickness
//       Access: Published
//  Description: Returns the "use vertex thickness" flag.  See
//               set_use_vertex_thickness().
////////////////////////////////////////////////////////////////////
59
inline bool RopeNode::get_use_vertex_thickness(void) const;

489 30 get_vertex_thickness_dimension 0 4 525 40 RopeNode::get_vertex_thickness_dimension 0 1 248 409
////////////////////////////////////////////////////////////////////
//     Function: get_vertex_thickness_dimension
//       Access: Published, Static
//  Description: Returns the numeric extended dimension in which the
//               thickness component should be found.  See
//               NurbsCurveEvaluator::set_extended_vertex().
////////////////////////////////////////////////////////////////////
65
static inline int RopeNode::get_vertex_thickness_dimension(void);

490 13 set_thickness 0 4 525 23 RopeNode::set_thickness 0 1 249 497
////////////////////////////////////////////////////////////////////
//     Function: set_thickness
//       Access: Published
//  Description: Specifies the thickness of the rope, in pixels or in
//               spatial units, depending on the render mode.  See
//               set_render_mode().
//
//               The thickness may also be specified on a per-vertex
//               basis.  See set_use_vertex_thickness().
////////////////////////////////////////////////////////////////////
53
inline void RopeNode::set_thickness(float thickness);

491 13 get_thickness 0 4 525 23 RopeNode::get_thickness 0 1 250 286
////////////////////////////////////////////////////////////////////
//     Function: get_thickness
//       Access: Published
//  Description: Returns the thickness of the rope.  See
//               set_thickness().
////////////////////////////////////////////////////////////////////
49
inline float RopeNode::get_thickness(void) const;

492 10 set_matrix 0 4 525 20 RopeNode::set_matrix 0 1 251 451
////////////////////////////////////////////////////////////////////
//     Function: set_matrix
//       Access: Published
//  Description: Specifies an optional matrix which is used to
//               transform each control vertex after it has been
//               transformed into the RopeNode's coordinate space, but
//               before the polygon vertices are generated.
////////////////////////////////////////////////////////////////////
58
inline void RopeNode::set_matrix(LMatrix4f const &matrix);

493 12 clear_matrix 0 4 525 22 RopeNode::clear_matrix 0 1 252 285
////////////////////////////////////////////////////////////////////
//     Function: clear_matrix
//       Access: Published
//  Description: Resets the node's matrix to identity.  See
//               set_matrix().
////////////////////////////////////////////////////////////////////
41
inline void RopeNode::clear_matrix(void);

494 10 has_matrix 0 4 525 20 RopeNode::has_matrix 0 1 253 305
////////////////////////////////////////////////////////////////////
//     Function: has_matrix
//       Access: Published
//  Description: Returns true if the node has a matrix set, false
//               otherwise.  See set_matrix().
////////////////////////////////////////////////////////////////////
45
inline bool RopeNode::has_matrix(void) const;

495 10 get_matrix 0 4 525 20 RopeNode::get_matrix 0 1 254 450
////////////////////////////////////////////////////////////////////
//     Function: get_matrix
//       Access: Published
//  Description: Returns the optional matrix which is used to
//               transform each control vertex after it has been
//               transformed into the RopeNode's coordinate space, but
//               before the polygon vertices are generated.
////////////////////////////////////////////////////////////////////
57
inline LMatrix4f const &RopeNode::get_matrix(void) const;

496 11 reset_bound 0 4 525 21 RopeNode::reset_bound 0 1 255 461
////////////////////////////////////////////////////////////////////
//     Function: RopeNode::reset_bound
//       Access: Published
//  Description: Recomputes the bounding volume.  This is normally
//               called automatically, but it must occasionally be
//               called explicitly when the curve has changed
//               properties outside of this node's knowledge.
////////////////////////////////////////////////////////////////////
51
void RopeNode::reset_bound(NodePath const &rel_to);

497 14 get_class_type 0 4 525 24 RopeNode::get_class_type 0 1 256 0
49
static TypeHandle RopeNode::get_class_type(void);

498 9 ~RopeNode 0 4 525 19 RopeNode::~RopeNode 0 0 0
26
RopeNode::~RopeNode(void);

499 9 SheetNode 0 4 529 20 SheetNode::SheetNode 0 1 257 446
////////////////////////////////////////////////////////////////////
//     Function: SheetNode::Constructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: SheetNode::Copy Constructor
//       Access: Protected
//  Description:
////////////////////////////////////////////////////////////////////
55
SheetNode::SheetNode(basic_string< char > const &name);

500 11 set_surface 0 4 529 22 SheetNode::set_surface 0 1 258 282
////////////////////////////////////////////////////////////////////
//     Function: set_surface
//       Access: Public
//  Description: Sets the particular surface represented by the
//               SheetNode.
////////////////////////////////////////////////////////////////////
67
inline void SheetNode::set_surface(NurbsSurfaceEvaluator *surface);

501 11 get_surface 0 4 529 22 SheetNode::get_surface 0 1 259 257
////////////////////////////////////////////////////////////////////
//     Function: get_surface
//       Access: Public
//  Description: Returns the surface represented by the SheetNode.
////////////////////////////////////////////////////////////////////
65
inline NurbsSurfaceEvaluator *SheetNode::get_surface(void) const;

502 20 set_use_vertex_color 0 4 529 31 SheetNode::set_use_vertex_color 0 1 260 551
////////////////////////////////////////////////////////////////////
//     Function: set_use_vertex_color
//       Access: Public
//  Description: Sets the "use vertex color" flag.  When this is true,
//               the R, G, B, A vertex color is assumed to be stored
//               as the dimensions 0, 1, 2, 3, respectively, of the
//               extended vertex values.  Use
//               NurbsCurveEvaluator::set_extended_vertex() to set
//               these values.
////////////////////////////////////////////////////////////////////
55
inline void SheetNode::set_use_vertex_color(bool flag);

503 20 get_use_vertex_color 0 4 529 31 SheetNode::get_use_vertex_color 0 1 261 299
////////////////////////////////////////////////////////////////////
//     Function: get_use_vertex_color
//       Access: Public
//  Description: Returns the "use vertex color" flag.  See
//               set_use_vertex_color().
////////////////////////////////////////////////////////////////////
56
inline bool SheetNode::get_use_vertex_color(void) const;

504 16 set_num_u_subdiv 0 4 529 27 SheetNode::set_num_u_subdiv 0 1 262 425
////////////////////////////////////////////////////////////////////
//     Function: set_num_u_subdiv
//       Access: Public
//  Description: Specifies the number of subdivisions per cubic
//               segment (that is, per unique knot value) to draw in a
//               fixed uniform tesselation of the surface in the U
//               direction.
////////////////////////////////////////////////////////////////////
58
inline void SheetNode::set_num_u_subdiv(int num_u_subdiv);

505 16 get_num_u_subdiv 0 4 529 27 SheetNode::get_num_u_subdiv 0 1 263 335
////////////////////////////////////////////////////////////////////
//     Function: get_num_u_subdiv
//       Access: Public
//  Description: Returns the number of subdivisions per cubic segment
//               to draw in the U direction.  See set_num_u_subdiv().
////////////////////////////////////////////////////////////////////
51
inline int SheetNode::get_num_u_subdiv(void) const;

506 16 set_num_v_subdiv 0 4 529 27 SheetNode::set_num_v_subdiv 0 1 264 425
////////////////////////////////////////////////////////////////////
//     Function: set_num_v_subdiv
//       Access: Public
//  Description: Specifies the number of subdivisions per cubic
//               segment (that is, per unique knot value) to draw in a
//               fixed uniform tesselation of the surface in the V
//               direction.
////////////////////////////////////////////////////////////////////
58
inline void SheetNode::set_num_v_subdiv(int num_v_subdiv);

507 16 get_num_v_subdiv 0 4 529 27 SheetNode::get_num_v_subdiv 0 1 265 335
////////////////////////////////////////////////////////////////////
//     Function: get_num_v_subdiv
//       Access: Public
//  Description: Returns the number of subdivisions per cubic segment
//               to draw in the V direction.  See set_num_v_subdiv().
////////////////////////////////////////////////////////////////////
51
inline int SheetNode::get_num_v_subdiv(void) const;

508 11 reset_bound 0 4 529 22 SheetNode::reset_bound 0 1 266 464
////////////////////////////////////////////////////////////////////
//     Function: SheetNode::reset_bound
//       Access: Published
//  Description: Recomputes the bounding volume.  This is normally
//               called automatically, but it must occasionally be
//               called explicitly when the surface has changed
//               properties outside of this node's knowledge.
////////////////////////////////////////////////////////////////////
52
void SheetNode::reset_bound(NodePath const &rel_to);

509 14 get_class_type 0 4 529 25 SheetNode::get_class_type 0 1 267 0
50
static TypeHandle SheetNode::get_class_type(void);

510 10 ~SheetNode 0 4 529 21 SheetNode::~SheetNode 0 0 0
28
SheetNode::~SheetNode(void);

267
1 14 Dtool_UKlvgDM7 0 6 3 533 0 14 Dtool_UKlvgDM7 415 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::is_valid
//       Access: Published, Virtual
//  Description: Returns true if the curve is defined.  This base
//               class function always returns true; derived classes
//               might override this to sometimes return false.
//////////////////////////////////////////////////////////////////// 1 4 this 3 531  
2 14 Dtool_UKlvan3O 0 6 4 534 0 14 Dtool_UKlvan3O 522 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::get_max_t
//       Access: Published, Virtual
//  Description: Returns the upper bound of t for the entire curve.
//               The curve is defined in the range 0.0f <= t <=
//               get_max_t().  This base class function always returns
//               1.0f; derived classes might override this to return
//               something else.
//////////////////////////////////////////////////////////////////// 1 4 this 3 531  
3 14 Dtool_UKlvumed 0 4 5 536 0 14 Dtool_UKlvumed 731 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::set_curve_type
//       Access: Published
//  Description: Sets the flag indicating the use to which the curve
//               is intended to be put.  This flag is optional and
//               only serves to provide a hint to the egg reader and
//               writer code; it has no effect on the curve's
//               behavior.
//
//               Setting the curve type also sets the num_dimensions
//               to 3 or 1 according to the type.
//
//               THis flag may have one of the values PCT_XYZ,
//               PCT_HPR, or PCT_T.
//////////////////////////////////////////////////////////////////// 2 4 this 3 535  4 type 1 530  
4 14 Dtool_UKlvuPVX 0 6 6 530 0 14 Dtool_UKlvuPVX 325 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::get_curve_type
//       Access: Published
//  Description: Returns the flag indicating the use to which the curve
//               is intended to be put.
//////////////////////////////////////////////////////////////////// 1 4 this 3 531  
5 14 Dtool_UKlvKuzT 0 4 7 536 0 14 Dtool_UKlvKuzT 622 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::set_num_dimensions
//       Access: Published
//  Description: Specifies the number of significant dimensions in the
//               curve's vertices.  This should be one of 1, 2, or 3.
//               Normally, XYZ and HPR curves have three dimensions;
//               time curves should always have one dimension.  This
//               only serves as a hint to the mopath editor, and also
//               controls how the curve is written out.
//////////////////////////////////////////////////////////////////// 2 4 this 3 535  3 num 1 530  
6 14 Dtool_UKlvlD71 0 6 8 530 0 14 Dtool_UKlvlD71 550 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::get_num_dimensions
//       Access: Published
//  Description: Returns the number of significant dimensions in the
//               curve's vertices, as set by a previous call to
//               set_num_dimensions().  This is only a hint as to how
//               the curve is intended to be used; the actual number
//               of dimensions of any curve is always three.
//////////////////////////////////////////////////////////////////// 1 4 this 3 531  
7 14 Dtool_UKlvbQeF 0 6 9 534 0 14 Dtool_UKlvbQeF 320 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::calc_length
//       Access: Published
//  Description: Approximates the length of the entire curve to within
//               a few decimal places.
//////////////////////////////////////////////////////////////////// 1 4 this 3 531  
8 14 Dtool_UKlvBINZ 0 6 9 534 0 14 Dtool_UKlvBINZ 331 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::calc_length
//       Access: Published
//  Description: Approximates the length of the curve segment from
//               parametric time 'from' to time 'to'.
//////////////////////////////////////////////////////////////////// 3 4 this 3 531  4 from 1 534  2 to 1 534  
9 14 Dtool_UKlvGyLm 0 6 10 534 0 14 Dtool_UKlvGyLm 717 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::find_length
//       Access: Published
//  Description: Returns the parametric value corresponding to the
//               indicated distance along the curve from the starting
//               parametric value.
//
//               This is the inverse of calc_length(): rather than
//               determining the length along the curve between two
//               parametric points, it determines the position in
//               parametric time of a point n units along the curve.
//
//               The search distance must not be negative.
//////////////////////////////////////////////////////////////////// 3 4 this 3 531  7 start_t 1 534  13 length_offset 1 534  
10 14 Dtool_UKlvo5OE 0 6 11 533 0 14 Dtool_UKlvo5OE 0 3 4 this 3 531  1 t 1 534  5 point 1 537  
11 14 Dtool_UKlvGDs0 0 6 12 533 0 14 Dtool_UKlvGDs0 0 3 4 this 3 531  1 t 1 534  7 tangent 1 537  
12 14 Dtool_UKlvPOPy 0 6 13 533 0 14 Dtool_UKlvPOPy 0 4 4 this 3 531  1 t 1 534  5 point 1 537  7 tangent 1 537  
13 14 Dtool_UKlvP1ia 0 6 14 533 0 14 Dtool_UKlvP1ia 0 3 4 this 3 531  1 t 1 534  8 tangent2 1 537  
14 14 Dtool_UKlv6vVs 0 6 15 533 0 14 Dtool_UKlv6vVs 402 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::adjust_point
//       Access: Published, Virtual
//  Description: Recomputes the curve such that it passes through the
//               point (px, py, pz) at time t, but keeps the same
//               tangent value at that point.
//////////////////////////////////////////////////////////////////// 5 4 this 3 535  1 t 1 534  2 px 1 534  2 py 1 534  2 pz 1 534  
15 14 Dtool_UKlvjLxE 0 6 16 533 0 14 Dtool_UKlvjLxE 389 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::adjust_tangent
//       Access: Published, Virtual
//  Description: Recomputes the curve such that it has the tangent
//               (tx, ty, tz) at time t, but keeps the same position
//               at the point.
//////////////////////////////////////////////////////////////////// 5 4 this 3 535  1 t 1 534  2 tx 1 534  2 ty 1 534  2 tz 1 534  
16 14 Dtool_UKlvxacM 0 6 17 533 0 14 Dtool_UKlvxacM 354 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::adjust_pt
//       Access: Published, Virtual
//  Description: Recomputes the curve such that it passes through the
//               point (px, py, pz) with the tangent (tx, ty, tz).
//////////////////////////////////////////////////////////////////// 8 4 this 3 535  1 t 1 534  2 px 1 534  2 py 1 534  2 pz 1 534  2 tx 1 534  2 ty 1 534  2 tz 1 534  
17 14 Dtool_UKlvnG_o 0 6 18 533 0 14 Dtool_UKlvnG_o 370 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::recompute
//       Access: Published, Virtual
//  Description: Recalculates the curve, if necessary.  Returns
//               true if the resulting curve is valid, false
//               otherwise.
//////////////////////////////////////////////////////////////////// 1 4 this 3 535  
18 14 Dtool_UKlvKq7P 0 6 19 533 0 14 Dtool_UKlvKq7P 537 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::stitch
//       Access: Published, Virtual
//  Description: Regenerates this curve as one long curve: the first
//               curve connected end-to-end with the second one.
//               Either a or b may be the same as 'this'.
//
//               Returns true if successful, false on failure or if
//               the curve type does not support stitching.
//////////////////////////////////////////////////////////////////// 3 4 this 3 535  1 a 1 531  1 b 1 531  
19 14 Dtool_UKlv_qGa 0 6 20 533 0 14 Dtool_UKlv_qGa 385 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::write_egg
//       Access: Published
//  Description: Writes an egg description of the nurbs curve to the
//               specified output file.  Returns true if the file is
//               successfully written.
//////////////////////////////////////////////////////////////////// 3 4 this 3 535  8 filename 1 539  2 cs 1 541  
20 14 Dtool_UKlvx_vA 0 6 20 533 0 14 Dtool_UKlvx_vA 385 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::write_egg
//       Access: Published
//  Description: Writes an egg description of the nurbs curve to the
//               specified output file.  Returns true if the file is
//               successfully written.
//////////////////////////////////////////////////////////////////// 2 4 this 3 535  8 filename 1 539  
21 14 Dtool_UKlvvHju 0 6 20 533 0 14 Dtool_UKlvvHju 387 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurve::write_egg
//       Access: Published
//  Description: Writes an egg description of the nurbs curve to the
//               specified output stream.  Returns true if the file is
//               successfully written.
//////////////////////////////////////////////////////////////////// 4 4 this 3 535  3 out 1 542  8 filename 1 544  2 cs 1 541  
22 14 Dtool_UKlvyWO8 0 7 21 547 0 14 Dtool_UKlvyWO8 0 0 
23 14 Dtool_UKlvCmF0 0 7 23 547 0 14 Dtool_UKlvCmF0 0 0 
24 14 Dtool_UKlvxrUC 0 7 26 548 0 14 Dtool_UKlvxrUC 237 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 0 
25 14 Dtool_UKlvXyhA 0 4 27 536 0 14 Dtool_UKlvXyhA 281 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::add_curve
//       Access: Published
//  Description: Adds a new ParametricCurve to the collection.
//////////////////////////////////////////////////////////////////// 2 4 this 3 548  5 curve 1 535  
26 14 Dtool_UKlvsU26 0 4 27 536 0 14 Dtool_UKlvsU26 321 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::add_curve
//       Access: Published
//  Description: Adds a new ParametricCurve to the collection at the
//               indicated index.
//////////////////////////////////////////////////////////////////// 3 4 this 3 548  5 curve 1 535  5 index 1 530  
27 14 Dtool_UKlvN_D0 0 6 28 530 0 14 Dtool_UKlvN_D0 378 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::add_curves
//       Access: Published
//  Description: Adds all the curves found in the scene graph rooted
//               at the given node.  Returns the number of curves
//               found.
//////////////////////////////////////////////////////////////////// 2 4 this 3 548  4 node 1 549  
28 14 Dtool_UKlvrSBL 0 6 29 533 0 14 Dtool_UKlvrSBL 419 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::remove_curve
//       Access: Published
//  Description: Removes the indicated ParametricCurve from the
//               collection.  Returns true if the curve was removed,
//               false if it was not a member of the collection.
//////////////////////////////////////////////////////////////////// 2 4 this 3 548  5 curve 1 535  
29 14 Dtool_UKlvOy0q 0 4 29 536 0 14 Dtool_UKlvOy0q 335 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::remove_curve
//       Access: Published
//  Description: Removes the indicated ParametricCurve from the
//               collection, by its index number.
//////////////////////////////////////////////////////////////////// 2 4 this 3 548  5 index 1 530  
30 14 Dtool_UKlvafPA 0 6 30 533 0 14 Dtool_UKlvafPA 343 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::has_curve
//       Access: Published
//  Description: Returns true if the indicated ParametricCurve appears in
//               this collection, false otherwise.
//////////////////////////////////////////////////////////////////// 2 4 this 3 550  5 curve 1 535  
31 14 Dtool_UKlvJs_a 0 4 31 536 0 14 Dtool_UKlvJs_a 281 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::clear
//       Access: Published
//  Description: Removes all ParametricCurves from the collection.
//////////////////////////////////////////////////////////////////// 1 4 this 3 548  
32 14 Dtool_UKlvU3KR 0 4 32 536 0 14 Dtool_UKlvU3KR 294 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::clear_timewarps
//       Access: Published
//  Description: Removes all the timewarp curves from the collection.
//////////////////////////////////////////////////////////////////// 1 4 this 3 548  
33 14 Dtool_UKlvZbyN 0 6 33 530 0 14 Dtool_UKlvZbyN 298 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::get_num_curves
//       Access: Published
//  Description: Returns the number of ParametricCurves in the collection.
//////////////////////////////////////////////////////////////////// 1 4 this 3 550  
34 14 Dtool_UKlvoks_ 0 7 34 535 0 14 Dtool_UKlvoks_ 286 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::get_curve
//       Access: Published
//  Description: Returns the nth ParametricCurve in the collection.
//////////////////////////////////////////////////////////////////// 2 4 this 3 550  5 index 1 530  
35 14 Dtool_UKlvZo8i 0 7 35 535 0 14 Dtool_UKlvZo8i 338 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::get_xyz_curve
//       Access: Published
//  Description: Returns the first XYZ curve in the collection, if
//               any, or NULL if there are none.
//////////////////////////////////////////////////////////////////// 1 4 this 3 550  
36 14 Dtool_UKlvV_TC 0 7 36 535 0 14 Dtool_UKlvV_TC 338 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::get_hpr_curve
//       Access: Published
//  Description: Returns the first HPR curve in the collection, if
//               any, or NULL if there are none.
//////////////////////////////////////////////////////////////////// 1 4 this 3 550  
37 14 Dtool_UKlv_FGT 0 7 37 535 0 14 Dtool_UKlv_FGT 458 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::get_default_curve
//       Access: Published
//  Description: If there is an XYZ curve in the collection, returns
//               it; otherwise, returns the first curve whose type is
//               unspecified.  Returns NULL if no curve meets the
//               criteria.
//////////////////////////////////////////////////////////////////// 1 4 this 3 550  
38 14 Dtool_UKlvip1P 0 6 38 530 0 14 Dtool_UKlvip1P 317 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::get_num_timewarps
//       Access: Published
//  Description: Returns the number of timewarp curves in the
//               collection.
//////////////////////////////////////////////////////////////////// 1 4 this 3 550  
39 14 Dtool_UKlv6SlK 0 7 39 535 0 14 Dtool_UKlv6SlK 294 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::get_timewarp_curve
//       Access: Published
//  Description: Returns the nth timewarp curve in the collection.
//////////////////////////////////////////////////////////////////// 2 4 this 3 550  1 n 1 530  
40 14 Dtool_UKlvky26 0 6 40 534 0 14 Dtool_UKlvky26 423 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::get_max_t
//       Access: Published
//  Description: Returns the maximum T value associated with the
//               *last* curve in the collection.  Normally, this will
//               be either the XYZ or HPR curve, or a timewarp curve.
//////////////////////////////////////////////////////////////////// 1 4 this 3 550  
41 14 Dtool_UKlvG4bH 0 4 41 536 0 14 Dtool_UKlvG4bH 913 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::make_even
//       Access: Published
//  Description: Discards all existing timewarp curves and recomputes
//               a new timewarp curve that maps distance along the
//               curve to parametric time, so that the distance
//               between any two points in parametric time is
//               proportional to the approximate distance of those
//               same two points along the XYZ curve.
//
//               segments_per_unit represents the number of segments to
//               take per each unit of parametric time of the original
//               XYZ curve.
//
//               The new timewarp curve (and thus, the apparent range
//               of the collection) will range from 0 to max_t.
//////////////////////////////////////////////////////////////////// 3 4 this 3 548  5 max_t 1 534  17 segments_per_unit 1 534  
42 14 Dtool_UKlvmOll 0 4 42 536 0 14 Dtool_UKlvmOll 452 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::face_forward
//       Access: Published
//  Description: Discards the existing HPR curve and generates a new
//               one that looks in the direction of travel along the
//               XYZ curve, based on the XYZ curve's tangent at each
//               point.
//////////////////////////////////////////////////////////////////// 2 4 this 3 548  17 segments_per_unit 1 534  
43 14 Dtool_UKlv72p2 0 4 43 536 0 14 Dtool_UKlv72p2 563 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::reset_max_t
//       Access: Published
//  Description: Adjusts the apparent length of the curve by applying
//               a new timewarp that maps the range [0..max_t] to the
//               range [0..get_max_t()].  After this call, the curve
//               collection will contain one more timewarp curve, and
//               get_max_t() will return the given max_t value.
//////////////////////////////////////////////////////////////////// 2 4 this 3 548  5 max_t 1 534  
44 14 Dtool_UKlvDS8W 0 6 44 533 0 14 Dtool_UKlvDS8W 880 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::evaluate
//       Access: Published
//  Description: Computes the transform matrix representing
//               translation to the position indicated by the first
//               XYZ curve in the collection and the rotation
//               indicated by the first HPR curve in the collection,
//               after t has been modified by all the timewarp curves
//               in the collection applied in sequence, from back to
//               front.
//
//               Returns true if the point is valid (i.e. t is within
//               the bounds indicated by all the timewarp curves and
//               within the bounds of the curves themselves), or false
//               otherwise.
//////////////////////////////////////////////////////////////////// 4 4 this 3 550  1 t 1 534  6 result 1 552  2 cs 1 541  
45 14 Dtool_UKlvf7Zb 0 6 44 533 0 14 Dtool_UKlvf7Zb 880 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::evaluate
//       Access: Published
//  Description: Computes the transform matrix representing
//               translation to the position indicated by the first
//               XYZ curve in the collection and the rotation
//               indicated by the first HPR curve in the collection,
//               after t has been modified by all the timewarp curves
//               in the collection applied in sequence, from back to
//               front.
//
//               Returns true if the point is valid (i.e. t is within
//               the bounds indicated by all the timewarp curves and
//               within the bounds of the curves themselves), or false
//               otherwise.
//////////////////////////////////////////////////////////////////// 3 4 this 3 550  1 t 1 534  6 result 1 552  
46 14 Dtool_UKlvvrTO 0 6 44 533 0 14 Dtool_UKlvvrTO 774 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::evaluate
//       Access: Published
//  Description: Computes the position and rotation represented by the
//               first XYZ and HPR curves in the collection at the
//               given point t, after t has been modified by all the
//               timewarp curves in the collection applied in
//               sequence, from back to front.
//
//               Returns true if the point is valid (i.e. t is within
//               the bounds indicated by all the timewarp curves and
//               within the bounds of the curves themselves), or false
//               otherwise.
//////////////////////////////////////////////////////////////////// 4 4 this 3 550  1 t 1 534  3 xyz 1 537  3 hpr 1 537  
47 14 Dtool_UKlvkozF 0 6 45 534 0 14 Dtool_UKlvkozF 490 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::evaluate_t
//       Access: Published
//  Description: Determines the value of t that should be passed to
//               the XYZ and HPR curves, after applying the given
//               value of t to all the timewarps.  Return -1.0f if the
//               value of t exceeds one of the timewarps' ranges.
//////////////////////////////////////////////////////////////////// 2 4 this 3 550  1 t 1 534  
48 14 Dtool_UKlvKi9F 0 6 46 533 0 14 Dtool_UKlvKi9F 314 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::evaluate_xyz
//       Access: Published
//  Description: Computes only the XYZ part of the curves.  See
//               evaluate().
//////////////////////////////////////////////////////////////////// 3 4 this 3 550  1 t 1 534  3 xyz 1 537  
49 14 Dtool_UKlvRYqE 0 6 47 533 0 14 Dtool_UKlvRYqE 314 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::evaluate_hpr
//       Access: Published
//  Description: Computes only the HPR part of the curves.  See
//               evaluate().
//////////////////////////////////////////////////////////////////// 3 4 this 3 550  1 t 1 534  3 hpr 1 537  
50 14 Dtool_UKlvHVjM 0 6 48 533 0 14 Dtool_UKlvHVjM 478 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::adjust_xyz
//       Access: Published
//  Description: Adjust the XYZ curve at the indicated time to the new
//               value.  The curve shape will change correspondingly.
//               Returns true if successful, false if unable to make
//               the adjustment for some reason.
//////////////////////////////////////////////////////////////////// 3 4 this 3 548  1 t 1 534  3 xyz 1 554  
51 14 Dtool_UKlvn2SI 0 6 48 533 0 14 Dtool_UKlvn2SI 478 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::adjust_xyz
//       Access: Published
//  Description: Adjust the XYZ curve at the indicated time to the new
//               value.  The curve shape will change correspondingly.
//               Returns true if successful, false if unable to make
//               the adjustment for some reason.
//////////////////////////////////////////////////////////////////// 5 4 this 3 548  1 t 1 534  1 x 1 534  1 y 1 534  1 z 1 534  
52 14 Dtool_UKlvNQfE 0 6 49 533 0 14 Dtool_UKlvNQfE 478 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::adjust_hpr
//       Access: Published
//  Description: Adjust the HPR curve at the indicated time to the new
//               value.  The curve shape will change correspondingly.
//               Returns true if successful, false if unable to make
//               the adjustment for some reason.
//////////////////////////////////////////////////////////////////// 3 4 this 3 548  1 t 1 534  3 xyz 1 554  
53 14 Dtool_UKlvxtOA 0 6 49 533 0 14 Dtool_UKlvxtOA 478 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::adjust_hpr
//       Access: Published
//  Description: Adjust the HPR curve at the indicated time to the new
//               value.  The curve shape will change correspondingly.
//               Returns true if successful, false if unable to make
//               the adjustment for some reason.
//////////////////////////////////////////////////////////////////// 5 4 this 3 548  1 t 1 534  1 h 1 534  1 p 1 534  1 r 1 534  
54 14 Dtool_UKlvi2Rj 0 6 50 533 0 14 Dtool_UKlvi2Rj 409 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::recompute
//       Access: Published
//  Description: Ensures all the curves are freshly computed and
//               up-to-date.  Returns true if everything is valid,
//               false if at least one curve is incorrect.
//////////////////////////////////////////////////////////////////// 1 4 this 3 548  
55 14 Dtool_UKlvWz_C 0 6 51 533 0 14 Dtool_UKlvWz_C 541 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::stitch
//       Access: Published
//  Description: Regenerates this curve as one long curve: the first
//               curve connected end-to-end with the second one.
//               Either a or b may be the same as 'this'.  This will
//               lose any timewarps on the input curves.
//
//               Returns true if successful, false on failure.
//////////////////////////////////////////////////////////////////// 3 4 this 3 548  1 a 1 550  1 b 1 550  
56 14 Dtool_UKlvc_Jm 0 4 52 536 0 14 Dtool_UKlvc_Jm 350 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::output
//       Access: Published
//  Description: Writes a brief one-line description of the
//               ParametricCurveCollection to the indicated output stream.
//////////////////////////////////////////////////////////////////// 2 4 this 3 550  3 out 1 542  
57 14 Dtool_UKlv57RA 0 4 53 536 0 14 Dtool_UKlv57RA 354 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::write
//       Access: Published
//  Description: Writes a complete multi-line description of the
//               ParametricCurveCollection to the indicated output stream.
//////////////////////////////////////////////////////////////////// 3 4 this 3 550  3 out 1 542  12 indent_level 1 530  
58 14 Dtool_UKlverdh 0 4 53 536 0 14 Dtool_UKlverdh 354 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::write
//       Access: Published
//  Description: Writes a complete multi-line description of the
//               ParametricCurveCollection to the indicated output stream.
//////////////////////////////////////////////////////////////////// 2 4 this 3 550  3 out 1 542  
59 14 Dtool_UKlvPXGo 0 6 54 533 0 14 Dtool_UKlvPXGo 418 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::write_egg
//       Access: Published
//  Description: Writes an egg description of all the nurbs curves in
//               the collection to the specified output file.  Returns
//               true if the file is successfully written.
//////////////////////////////////////////////////////////////////// 3 4 this 3 548  8 filename 1 539  2 cs 1 541  
60 14 Dtool_UKlvi0bC 0 6 54 533 0 14 Dtool_UKlvi0bC 418 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::write_egg
//       Access: Published
//  Description: Writes an egg description of all the nurbs curves in
//               the collection to the specified output file.  Returns
//               true if the file is successfully written.
//////////////////////////////////////////////////////////////////// 2 4 this 3 548  8 filename 1 539  
61 14 Dtool_UKlvTx15 0 6 54 533 0 14 Dtool_UKlvTx15 420 ////////////////////////////////////////////////////////////////////
//     Function: ParametricCurveCollection::write_egg
//       Access: Published
//  Description: Writes an egg description of all the nurbs curves in
//               the collection to the specified output stream.  Returns
//               true if the file is successfully written.
//////////////////////////////////////////////////////////////////// 4 4 this 3 548  3 out 1 542  8 filename 1 544  2 cs 1 541  
62 14 Dtool_UKlvMvxy 0 7 56 556 318 14 Dtool_UKlvMvxy 220 ////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 0 
63 14 Dtool_UKlvLEBv 0 4 58 536 0 14 Dtool_UKlvLEBv 332 ////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::reset
//       Access: Public
//  Description: Removes all the data points previously added to the
//               CurveFitter, and initializes it for a new curve.
//////////////////////////////////////////////////////////////////// 1 4 this 3 556  
64 14 Dtool_UKlvU_r2 0 4 59 536 0 14 Dtool_UKlvU_r2 242 ////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::add_xyz
//       Access: Public
//  Description: Adds a single sample xyz.
//////////////////////////////////////////////////////////////////// 3 4 this 3 556  1 t 1 534  3 xyz 1 554  
65 14 Dtool_UKlvWyG0 0 4 60 536 0 14 Dtool_UKlvWyG0 242 ////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::add_hpr
//       Access: Public
//  Description: Adds a single sample hpr.
//////////////////////////////////////////////////////////////////// 3 4 this 3 556  1 t 1 534  3 hpr 1 554  
66 14 Dtool_UKlv8TgF 0 4 61 536 0 14 Dtool_UKlv8TgF 267 ////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::add_xyz_hpr
//       Access: Public
//  Description: Adds a single sample xyz & hpr simultaneously.
//////////////////////////////////////////////////////////////////// 4 4 this 3 556  1 t 1 534  3 xyz 1 554  3 hpr 1 554  
67 14 Dtool_UKlvxRbc 0 6 62 530 0 14 Dtool_UKlvxRbc 299 ////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::get_num_samples
//       Access: Public
//  Description: Returns the number of sample points that have been
//               added.
//////////////////////////////////////////////////////////////////// 1 4 this 3 557  
68 14 Dtool_UKlvbZg8 0 6 63 534 0 14 Dtool_UKlvbZg8 275 ////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::get_sample_t
//       Access: Public
//  Description: Returns the parametric value of the nth sample added.
//////////////////////////////////////////////////////////////////// 2 4 this 3 557  1 n 1 530  
69 14 Dtool_UKlveDCE 0 7 64 537 0 14 Dtool_UKlveDCE 275 ////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::get_sample_xyz
//       Access: Public
//  Description: Returns the point in space of the nth sample added.
//////////////////////////////////////////////////////////////////// 2 4 this 3 557  1 n 1 530  
70 14 Dtool_UKlvpADi 0 7 65 537 0 14 Dtool_UKlvpADi 272 ////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::get_sample_hpr
//       Access: Public
//  Description: Returns the orientation of the nth sample added.
//////////////////////////////////////////////////////////////////// 2 4 this 3 557  1 n 1 530  
71 14 Dtool_UKlv6bTo 0 7 66 537 0 14 Dtool_UKlv6bTo 391 ////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::get_sample_tangent
//       Access: Public
//  Description: Returns the tangent associated with the nth sample
//               added.  This is only meaningful if compute_tangents()
//               has already been called.
//////////////////////////////////////////////////////////////////// 2 4 this 3 557  1 n 1 530  
72 14 Dtool_UKlvaErD 0 4 67 536 0 14 Dtool_UKlvaErD 335 ////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::remove_samples
//       Access: Public
//  Description: Eliminates all samples from index begin, up to but not
//               including index end, from the database.
//////////////////////////////////////////////////////////////////// 3 4 this 3 556  5 begin 1 530  3 end 1 530  
73 14 Dtool_UKlvt_E2 0 4 68 536 0 14 Dtool_UKlvt_E2 473 ////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::sample
//       Access: Public
//  Description: Generates a series of data points by sampling the
//               given curve (or xyz/hpr curves) the indicated number
//               of times.  The sampling is made evenly in parametric
//               time, and then the timewarps, if any, are applied.
//////////////////////////////////////////////////////////////////// 3 4 this 3 556  6 curves 1 548  5 count 1 530  
74 14 Dtool_UKlvN25m 0 4 69 536 0 14 Dtool_UKlvN25m 400 ////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::wrap_hpr
//       Access: Public
//  Description: Resets each HPR data point so that the maximum delta
//               between any two consecutive points is 180 degrees,
//               which should prevent incorrect HPR wrapping.
//////////////////////////////////////////////////////////////////// 1 4 this 3 556  
75 14 Dtool_UKlvUxVM 0 4 70 536 0 14 Dtool_UKlvUxVM 339 ////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::sort_points
//       Access: Public
//  Description: Sorts all the data points in order by parametric
//               time, in case they were added in an incorrect order.
//////////////////////////////////////////////////////////////////// 1 4 this 3 556  
76 14 Dtool_UKlve3Ay 0 4 71 536 0 14 Dtool_UKlve3Ay 428 ////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::desample
//       Access: Public
//  Description: Removes sample points in order to reduce the
//               complexity of a sampled curve.  Keeps one out of
//               every factor samples.  Also keeps the first and the
//               last samples.
//////////////////////////////////////////////////////////////////// 2 4 this 3 556  6 factor 1 534  
77 14 Dtool_UKlvsxwM 0 4 72 536 0 14 Dtool_UKlvsxwM 508 ////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::compute_tangents
//       Access: Public
//  Description: Once a set of points has been built, and prior to
//               calling MakeHermite() or MakeNurbs(),
//               ComputeTangents() must be called to set up the
//               tangents correctly (unless the tangents were defined
//               as the points were added).
//////////////////////////////////////////////////////////////////// 2 4 this 3 556  5 scale 1 534  
78 14 Dtool_UKlvTvHh 0 7 73 548 0 14 Dtool_UKlvTvHh 300 ////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::make_hermite
//       Access: Public
//  Description: Converts the current set of data points into a
//               Hermite curve.
//////////////////////////////////////////////////////////////////// 1 4 this 3 557  
79 14 Dtool_UKlvppFN 0 7 74 548 0 14 Dtool_UKlvppFN 374 ////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::make_nurbs
//       Access: Public
//  Description: Converts the current set of data points into a
//               NURBS curve.  This gives a smoother curve than
//               produced by MakeHermite().
//////////////////////////////////////////////////////////////////// 1 4 this 3 557  
80 14 Dtool_UKlvfDRp 0 4 75 536 0 14 Dtool_UKlvfDRp 215 ////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::output
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 557  3 out 1 542  
81 14 Dtool_UKlvX7hW 0 4 76 536 0 14 Dtool_UKlvX7hW 214 ////////////////////////////////////////////////////////////////////
//     Function: CurveFitter::write
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 557  3 out 1 542  
82 14 Dtool_UKlvS9rR 0 7 77 547 0 14 Dtool_UKlvS9rR 0 0 
83 14 Dtool_UKlvZzpr 0 7 79 559 0 14 Dtool_UKlvZzpr 223 ////////////////////////////////////////////////////////////////////
//     Function: PiecewiseCurve::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 0 
84 14 Dtool_UKlvxscQ 0 7 80 547 0 14 Dtool_UKlvxscQ 0 0 
85 14 Dtool_UKlvzsME 0 7 82 560 0 14 Dtool_UKlvzsME 224 ////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 0 
86 14 Dtool_UKlvzviK 0 7 82 560 0 14 Dtool_UKlvzviK 316 ////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::Copy Constructor
//       Access: Published
//  Description: Constructs a Hermite from the indicated (possibly
//               non-hermite) curve.
//////////////////////////////////////////////////////////////////// 1 2 pc 1 531  
87 14 Dtool_UKlv6fOV 0 6 83 530 0 14 Dtool_UKlv6fOV 265 ////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::get_num_cvs
//       Access: Published
//  Description: Returns the number of CV's in the curve.
//////////////////////////////////////////////////////////////////// 1 4 this 3 561  
88 14 Dtool_UKlvLZ8L 0 6 84 530 0 14 Dtool_UKlvLZ8L 908 ////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::insert_cv
//       Access: Published
//  Description: Inserts a new CV at the given parametric point along
//               the curve.  If this parametric point is already on
//               the curve, the CV is assigned an index between its
//               two neighbors and the indices of all following CV's
//               are incremented by 1; its in and out tangents are
//               chosen to keep the curve consistent.  If the new
//               parametric point is beyond the end of the existing
//               curve, the curve is extended to meet it and the new
//               CV's position, in tangent, and out tangent are set to
//               zero.
//
//               The index number of the new CV is returned.
//////////////////////////////////////////////////////////////////// 2 4 this 3 560  1 t 1 534  
89 14 Dtool_UKlvxceQ 0 6 85 530 0 14 Dtool_UKlvxceQ 0 3 4 this 3 560  4 type 1 530  1 v 1 554  
90 14 Dtool_UKlvM_6n 0 6 85 530 0 14 Dtool_UKlvM_6n 392 ////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::append_cv
//       Access: Published
//  Description: Adds a new CV to the end of the curve.  The new CV is
//               given initial in/out tangents of 0.  The return value
//               is the index of the new CV.
//////////////////////////////////////////////////////////////////// 5 4 this 3 560  4 type 1 530  1 x 1 534  1 y 1 534  1 z 1 534  
91 14 Dtool_UKlvcGlz 0 6 86 533 0 14 Dtool_UKlvcGlz 326 ////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::remove_cv
//       Access: Published
//  Description: Removes the given CV from the curve.  Returns true if
//               the CV existed, false otherwise.
//////////////////////////////////////////////////////////////////// 2 4 this 3 560  1 n 1 530  
92 14 Dtool_UKlvYfOG 0 4 87 536 0 14 Dtool_UKlvYfOG 260 ////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::remove_all_cvs
//       Access: Published
//  Description: Removes all CV's from the curve.
//////////////////////////////////////////////////////////////////// 1 4 this 3 560  
93 14 Dtool_UKlvEeDJ 0 6 88 533 0 14 Dtool_UKlvEeDJ 907 ////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::set_cv_type
//       Access: Published
//  Description: Changes the given CV's continuity type.  Legal values
//               are HC_CUT, HC_FREE, HC_G1, or HC_SMOOTH.
//
//               Other than HC_CUT, these have no effect on the actual
//               curve; it remains up to user software to impose the
//               constraints these imply.
//
//               HC_CUT implies a disconnection of the curve; HC_FREE
//               imposes no constraints on the tangents; HC_G1
//               forces the tangents to be collinear, and HC_SMOOTH
//               forces the tangents to be identical.  Setting type
//               type to HC_G1 or HC_SMOOTH may adjust the out
//               tangent to match the in tangent.
//////////////////////////////////////////////////////////////////// 3 4 this 3 560  1 n 1 530  4 type 1 530  
94 14 Dtool_UKlv1ifu 0 6 89 533 0 14 Dtool_UKlv1ifu 0 3 4 this 3 560  1 n 1 530  1 v 1 554  
95 14 Dtool_UKlv2q7R 0 6 89 533 0 14 Dtool_UKlv2q7R 258 ////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::set_cv_point
//       Access: Published
//  Description: Changes the given CV's position.
//////////////////////////////////////////////////////////////////// 5 4 this 3 560  1 n 1 530  1 x 1 534  1 y 1 534  1 z 1 534  
96 14 Dtool_UKlvWhVD 0 6 90 533 0 14 Dtool_UKlvWhVD 0 3 4 this 3 560  1 n 1 530  1 v 1 554  
97 14 Dtool_UKlvFkya 0 6 90 533 0 14 Dtool_UKlvFkya 364 ////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::set_cv_in
//       Access: Published
//  Description: Changes the given CV's in tangent.  Depending on the
//               continuity type, this may also adjust the out
//               tangent.
//////////////////////////////////////////////////////////////////// 5 4 this 3 560  1 n 1 530  1 x 1 534  1 y 1 534  1 z 1 534  
98 14 Dtool_UKlv0v4x 0 6 91 533 0 14 Dtool_UKlv0v4x 0 3 4 this 3 560  1 n 1 530  1 v 1 554  
99 14 Dtool_UKlvkRXh 0 6 91 533 0 14 Dtool_UKlvkRXh 365 ////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::set_cv_out
//       Access: Published
//  Description: Changes the given CV's out tangent.  Depending on the
//               continuity type, this may also adjust the in
//               tangent.
//////////////////////////////////////////////////////////////////// 5 4 this 3 560  1 n 1 530  1 x 1 534  1 y 1 534  1 z 1 534  
100 14 Dtool_UKlvo3DW 0 6 92 533 0 14 Dtool_UKlvo3DW 332 ////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::set_cv_tstart
//       Access: Published
//  Description: Changes the given CV's parametric starting time.
//               This may affect the shape of the curve.
//////////////////////////////////////////////////////////////////// 3 4 this 3 560  1 n 1 530  6 tstart 1 534  
101 14 Dtool_UKlvYy1_ 0 6 93 533 0 14 Dtool_UKlvYy1_ 274 ////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::set_cv_name
//       Access: Published
//  Description: Changes the name associated with a particular CV.
//////////////////////////////////////////////////////////////////// 3 4 this 3 560  1 n 1 530  4 name 1 563  
102 14 Dtool_UKlvoOER 0 6 94 530 0 14 Dtool_UKlvoOER 365 ////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::get_cv_type
//       Access: Published
//  Description: Returns the given CV's continuity type, HC_CUT,
//               HC_FREE, HC_G1, or HC_SMOOTH, or 0 if there is
//               no such CV.
//////////////////////////////////////////////////////////////////// 2 4 this 3 561  1 n 1 530  
103 14 Dtool_UKlvAAkK 0 6 95 554 0 14 Dtool_UKlvAAkK 263 ////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::get_cv_point
//       Access: Published
//  Description: Returns the position of the given CV.
//////////////////////////////////////////////////////////////////// 2 4 this 3 561  1 n 1 530  
104 14 Dtool_UKlvRbj7 0 4 95 536 0 14 Dtool_UKlvRbj7 0 3 4 this 3 561  1 n 1 530  1 v 1 537  
105 14 Dtool_UKlvEkRx 0 6 96 554 0 14 Dtool_UKlvEkRx 262 ////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::get_cv_in
//       Access: Published
//  Description: Returns the in tangent of the given CV.
//////////////////////////////////////////////////////////////////// 2 4 this 3 561  1 n 1 530  
106 14 Dtool_UKlvOXkH 0 4 96 536 0 14 Dtool_UKlvOXkH 0 3 4 this 3 561  1 n 1 530  1 v 1 537  
107 14 Dtool_UKlvCKEx 0 6 97 554 0 14 Dtool_UKlvCKEx 264 ////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::get_cv_out
//       Access: Published
//  Description: Returns the out tangent of the given CV.
//////////////////////////////////////////////////////////////////// 2 4 this 3 561  1 n 1 530  
108 14 Dtool_UKlvOr47 0 4 97 536 0 14 Dtool_UKlvOr47 0 3 4 this 3 561  1 n 1 530  1 v 1 537  
109 14 Dtool_UKlvBbZE 0 6 98 534 0 14 Dtool_UKlvBbZE 307 ////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::get_cv_tstart
//       Access: Published
//  Description: Returns the starting point in parametric space of the
//               given CV.
//////////////////////////////////////////////////////////////////// 2 4 this 3 561  1 n 1 530  
110 14 Dtool_UKlvn1_h 0 6 99 563 0 14 Dtool_UKlvn1_h 267 ////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::get_cv_name
//       Access: Published
//  Description: Returns the name of the given CV, or NULL.
//////////////////////////////////////////////////////////////////// 2 4 this 3 561  1 n 1 530  
111 14 Dtool_UKlveyiA 0 4 100 536 0 14 Dtool_UKlveyiA 221 ////////////////////////////////////////////////////////////////////
//     Function: HermiteCurve::write_cv
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 3 4 this 3 561  3 out 1 542  1 n 1 530  
112 14 Dtool_UKlv3huh 0 7 101 547 0 14 Dtool_UKlv3huh 0 0 
113 14 Dtool_UKlvLhK6 0 4 104 536 0 14 Dtool_UKlvLhK6 0 2 4 this 3 564  5 order 1 530  
114 14 Dtool_UKlviPY_ 0 6 105 530 0 14 Dtool_UKlviPY_ 0 1 4 this 3 565  
115 14 Dtool_UKlvWaqD 0 6 106 530 0 14 Dtool_UKlvWaqD 0 1 4 this 3 565  
116 14 Dtool_UKlvMQ5_ 0 6 107 530 0 14 Dtool_UKlvMQ5_ 0 1 4 this 3 565  
117 14 Dtool_UKlv8ScU 0 6 108 533 0 14 Dtool_UKlv8ScU 0 2 4 this 3 564  1 t 1 534  
118 14 Dtool_UKlvofTi 0 6 109 530 0 14 Dtool_UKlvofTi 229 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveInterface::append_cv
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 564  1 v 1 554  
119 14 Dtool_UKlvgMdi 0 6 109 530 0 14 Dtool_UKlvgMdi 229 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveInterface::append_cv
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 564  1 v 1 567  
120 14 Dtool_UKlvB3ZR 0 6 109 530 0 14 Dtool_UKlvB3ZR 724 // Filename: nurbsCurveInterface.I
// Created by:  drose (02Mar01)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveInterface::append_cv
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 4 4 this 3 564  1 x 1 534  1 y 1 534  1 z 1 534  
121 14 Dtool_UKlvuA5o 0 6 110 533 0 14 Dtool_UKlvuA5o 0 2 4 this 3 564  1 n 1 530  
122 14 Dtool_UKlv1Nej 0 4 111 536 0 14 Dtool_UKlv1Nej 0 1 4 this 3 564  
123 14 Dtool_UKlv03Z_ 0 6 112 533 0 14 Dtool_UKlv03Z_ 330 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveInterface::set_cv_point
//       Access: Public, Scheme
//  Description: Repositions the indicated CV.  Returns true if
//               successful, false otherwise.
//////////////////////////////////////////////////////////////////// 3 4 this 3 564  1 n 1 530  1 v 1 554  
124 14 Dtool_UKlvvbUc 0 6 112 533 0 14 Dtool_UKlvvbUc 330 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveInterface::set_cv_point
//       Access: Public, Scheme
//  Description: Repositions the indicated CV.  Returns true if
//               successful, false otherwise.
//////////////////////////////////////////////////////////////////// 5 4 this 3 564  1 n 1 530  1 x 1 534  1 y 1 534  1 z 1 534  
125 14 Dtool_UKlvKFJB 0 7 113 537 0 14 Dtool_UKlvKFJB 279 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveInterface::get_cv_point
//       Access: Public, Scheme
//  Description: Returns the position of the indicated CV.
//////////////////////////////////////////////////////////////////// 2 4 this 3 565  1 n 1 530  
126 14 Dtool_UKlvkgWd 0 6 114 533 0 14 Dtool_UKlvkgWd 331 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveInterface::set_cv_weight
//       Access: Published
//  Description: Sets the weight of the indicated CV without affecting
//               its position in 3-d space.
//////////////////////////////////////////////////////////////////// 3 4 this 3 564  1 n 1 530  1 w 1 534  
127 14 Dtool_UKlvQgDH 0 6 115 534 0 14 Dtool_UKlvQgDH 273 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveInterface::get_cv_weight
//       Access: Published
//  Description: Returns the weight of the indicated CV.
//////////////////////////////////////////////////////////////////// 2 4 this 3 565  1 n 1 530  
128 14 Dtool_UKlvsLws 0 6 116 533 0 14 Dtool_UKlvsLws 0 3 4 this 3 564  1 n 1 530  1 v 1 567  
129 14 Dtool_UKlv_TRe 0 7 117 570 0 14 Dtool_UKlv_TRe 0 2 4 this 3 565  1 n 1 530  
130 14 Dtool_UKlvDnR8 0 6 118 533 0 14 Dtool_UKlvDnR8 0 3 4 this 3 564  1 n 1 530  1 t 1 534  
131 14 Dtool_UKlv_MjW 0 6 119 534 0 14 Dtool_UKlv_MjW 0 2 4 this 3 565  1 n 1 530  
132 14 Dtool_UKlv6ybU 0 4 120 536 0 14 Dtool_UKlv6ybU 228 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveInterface::write_cv
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 3 4 this 3 565  3 out 1 542  1 n 1 530  
133 14 Dtool_UKlvhfnq 0 7 121 547 0 14 Dtool_UKlvhfnq 0 0 
134 14 Dtool_UKlvoQie 0 7 127 571 385 14 Dtool_UKlvoQie 222 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurve::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 0 
135 14 Dtool_UKlvYpGF 0 7 127 571 385 14 Dtool_UKlvYpGF 325 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurve::Copy Constructor
//       Access: Published
//  Description: Constructs a NURBS curve equivalent to the indicated
//               (possibly non-NURBS) curve.
//////////////////////////////////////////////////////////////////// 1 2 pc 1 531  
136 14 Dtool_UKlvcSO4 0 7 129 547 0 14 Dtool_UKlvcSO4 0 0 
137 14 Dtool_UKlv_oME 0 7 123 559 0 14 Dtool_UKlv_oME 0 1 4 this 3 571  
138 14 Dtool_UKlv66HO 0 7 124 571 385 14 Dtool_UKlv66HO 0 1 4 this 3 559  
139 14 Dtool_UKlvWDPk 0 6 125 564 0 14 Dtool_UKlvWDPk 0 1 4 this 3 571  
140 14 Dtool_UKlvQN7l 0 7 126 571 385 14 Dtool_UKlvQN7l 0 1 4 this 3 564  
141 14 Dtool_UKlvNf1r 0 6 131 534 0 14 Dtool_UKlvNf1r 315 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::get_start_t
//       Access: Published
//  Description: Returns the first legal value of t on the curve.
//               Usually this is 0.0.
//////////////////////////////////////////////////////////////////// 1 4 this 3 572  
142 14 Dtool_UKlvPEFs 0 6 132 534 0 14 Dtool_UKlvPEFs 274 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::get_end_t
//       Access: Published
//  Description: Returns the last legal value of t on the curve.
//////////////////////////////////////////////////////////////////// 1 4 this 3 572  
143 14 Dtool_UKlvkne8 0 6 133 533 0 14 Dtool_UKlvkne8 406 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::eval_point
//       Access: Published
//  Description: Computes the point on the curve corresponding to the
//               indicated value in parametric time.  Returns true if
//               the t value is valid, false otherwise.
//////////////////////////////////////////////////////////////////// 3 4 this 3 574  1 t 1 534  5 point 1 537  
144 14 Dtool_UKlvHZT_ 0 6 134 533 0 14 Dtool_UKlvHZT_ 456 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::eval_tangent
//       Access: Published
//  Description: Computes the tangent to the curve at the indicated
//               point in parametric time.  This tangent vector will
//               not necessarily be normalized, and could be zero.
//               See also eval_point().
//////////////////////////////////////////////////////////////////// 3 4 this 3 574  1 t 1 534  7 tangent 1 537  
145 14 Dtool_UKlvYSlj 0 6 135 534 0 14 Dtool_UKlvYSlj 402 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::eval_extended_point
//       Access: Published
//  Description: Evaluates the curve in n-dimensional space according
//               to the extended vertices associated with the curve in
//               the indicated dimension.
//////////////////////////////////////////////////////////////////// 3 4 this 3 574  1 t 1 534  1 d 1 530  
146 14 Dtool_UKlvw2Tl 0 6 137 530 0 14 Dtool_UKlvw2Tl 438 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::get_num_segments
//       Access: Published
//  Description: Returns the number of piecewise continuous segments
//               within the curve.  This number is usually not
//               important unless you plan to call
//               eval_segment_point().
//////////////////////////////////////////////////////////////////// 1 4 this 3 572  
147 14 Dtool_UKlviDoh 0 4 138 536 0 14 Dtool_UKlviDoh 1042 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::eval_segment_point
//       Access: Published
//  Description: Evaluates the point on the curve corresponding to the
//               indicated value in parametric time within the
//               indicated curve segment.  t should be in the range
//               [0, 1].
//
//               The curve is internally represented as a number of
//               connected (or possibly unconnected) piecewise
//               continuous segments.  The exact number of segments
//               for a particular curve depends on the knot vector,
//               and is returned by get_num_segments().  Normally,
//               eval_point() is used to evaluate a point along the
//               continuous curve, but when you care more about local
//               continuity, you can use eval_segment_point() to
//               evaluate the points along each segment.
//////////////////////////////////////////////////////////////////// 4 4 this 3 572  7 segment 1 530  1 t 1 534  5 point 1 537  
148 14 Dtool_UKlvNjKk 0 4 139 536 0 14 Dtool_UKlvNjKk 479 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::eval_segment_tangent
//       Access: Published
//  Description: As eval_segment_point, but computes the tangent to
//               the curve at the indicated point.  The tangent vector
//               will not necessarily be normalized, and could be
//               zero, particularly at the endpoints.
//////////////////////////////////////////////////////////////////// 4 4 this 3 572  7 segment 1 530  1 t 1 534  7 tangent 1 537  
149 14 Dtool_UKlvtc44 0 6 140 534 0 14 Dtool_UKlvtc44 410 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::eval_segment_extended_point
//       Access: Published
//  Description: Evaluates the curve in n-dimensional space according
//               to the extended vertices associated with the curve in
//               the indicated dimension.
//////////////////////////////////////////////////////////////////// 4 4 this 3 572  7 segment 1 530  1 t 1 534  1 d 1 530  
150 14 Dtool_UKlv6YrI 0 6 142 534 0 14 Dtool_UKlv6YrI 482 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::get_segment_t
//       Access: Published
//  Description: Accepts a t value in the range [0, 1], and assumed to
//               be relative to the indicated segment (as in
//               eval_segment_point()), and returns the corresponding
//               t value in the entire curve (as in eval_point()).
//////////////////////////////////////////////////////////////////// 3 4 this 3 572  7 segment 1 530  1 t 1 534  
151 14 Dtool_UKlv_xKr 0 4 143 536 0 14 Dtool_UKlv_xKr 642 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::adaptive_sample
//       Access: Published
//  Description: Determines the set of subdivisions necessary to
//               approximate the curve with a set of linear segments,
//               no point of which is farther than tolerance units
//               from the actual curve.
//
//               After this call, you may walk through the resulting
//               set of samples with get_num_samples(),
//               get_sample_t(), and get_sample_point().
//////////////////////////////////////////////////////////////////// 2 4 this 3 574  9 tolerance 1 534  
152 14 Dtool_UKlvKVw6 0 6 144 530 0 14 Dtool_UKlvKVw6 338 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::get_num_samples
//       Access: Published
//  Description: Returns the number of sample points generated by the
//               previous call to adaptive_sample().
//////////////////////////////////////////////////////////////////// 1 4 this 3 572  
153 14 Dtool_UKlv5E66 0 6 145 534 0 14 Dtool_UKlv5E66 343 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::get_sample_t
//       Access: Published
//  Description: Returns the t value of the nth sample point generated
//               by the previous call to adaptive_sample().
//////////////////////////////////////////////////////////////////// 2 4 this 3 572  1 n 1 530  
154 14 Dtool_UKlvb_Bj 0 6 146 575 0 14 Dtool_UKlvb_Bj 551 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveResult::get_sample_point
//       Access: Published
//  Description: Returns the point on the curve of the nth sample
//               point generated by the previous call to
//               adaptive_sample().
//
//               For tangents, or extended points, you should use
//               get_sample_t() and pass it into eval_tangent() or
//               eval_extended_point().
//////////////////////////////////////////////////////////////////// 2 4 this 3 572  1 n 1 530  
155 14 Dtool_UKlvoL16 0 7 148 578 0 14 Dtool_UKlvoL16 231 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 0 
156 14 Dtool_UKlv59cz 0 4 149 536 0 14 Dtool_UKlv59cz 997 // Filename: nurbsCurveEvaluator.I
// Created by:  drose (05Dec02)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::set_order
//       Access: Published
//  Description: Sets the order of the curve.  This resets the knot
//               vector to the default knot vector for the number of
//               vertices.
//
//               The order must be 1, 2, 3, or 4, and the value is one
//               more than the degree of the curve.
//////////////////////////////////////////////////////////////////// 2 4 this 3 578  5 order 1 530  
157 14 Dtool_UKlvyKq4 0 6 150 530 0 14 Dtool_UKlvyKq4 319 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::get_order
//       Access: Published
//  Description: Returns the order of the curve as set by a previous
//               call to set_order().
//////////////////////////////////////////////////////////////////// 1 4 this 3 579  
158 14 Dtool_UKlvc62C 0 4 151 536 0 14 Dtool_UKlvc62C 508 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::reset
//       Access: Published
//  Description: Resets all the vertices and knots to their default
//               values, and sets the curve up with the indicated
//               number of vertices.  You must then call set_vertex()
//               repeatedly to fill in all of the vertex values
//               appropriately.
//////////////////////////////////////////////////////////////////// 2 4 this 3 578  12 num_vertices 1 530  
159 14 Dtool_UKlvWeXN 0 6 152 530 0 14 Dtool_UKlvWeXN 378 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::get_num_vertices
//       Access: Published
//  Description: Returns the number of control vertices in the curve.
//               This is the number passed to the last call to
//               reset().
//////////////////////////////////////////////////////////////////// 1 4 this 3 579  
160 14 Dtool_UKlvJSId 0 4 153 536 0 14 Dtool_UKlvJSId 459 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::set_vertex
//       Access: Published
//  Description: Sets the nth control vertex of the curve.  This
//               flavor sets the vertex as a 3-d coordinate and a
//               weight; the 3-d coordinate values are implicitly
//               scaled up by the weight factor.
//////////////////////////////////////////////////////////////////// 4 4 this 3 578  1 i 1 530  6 vertex 1 554  6 weight 1 534  
161 14 Dtool_UKlvTeoz 0 4 153 536 0 14 Dtool_UKlvTeoz 459 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::set_vertex
//       Access: Published
//  Description: Sets the nth control vertex of the curve.  This
//               flavor sets the vertex as a 3-d coordinate and a
//               weight; the 3-d coordinate values are implicitly
//               scaled up by the weight factor.
//////////////////////////////////////////////////////////////////// 3 4 this 3 578  1 i 1 530  6 vertex 1 554  
162 14 Dtool_UKlvTmY9 0 4 153 536 0 14 Dtool_UKlvTmY9 524 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::set_vertex
//       Access: Published
//  Description: Sets the nth control vertex of the curve, as a vertex
//               in 4-d homogeneous space.  In this form, the first
//               three components of the vertex should already have
//               been scaled by the fourth component, which is the
//               homogeneous weight.
//////////////////////////////////////////////////////////////////// 3 4 this 3 578  1 i 1 530  6 vertex 1 567  
163 14 Dtool_UKlvPRq2 0 6 154 567 0 14 Dtool_UKlvPRq2 336 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::get_vertex
//       Access: Published
//  Description: Returns the nth control vertex of the curve, relative
//               to its indicated coordinate space.
//////////////////////////////////////////////////////////////////// 2 4 this 3 579  1 i 1 530  
164 14 Dtool_UKlvcIW3 0 7 154 570 0 14 Dtool_UKlvcIW3 332 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::get_vertex
//       Access: Published
//  Description: Returns the nth control vertex of the curve, relative
//               to the given coordinate space.
//////////////////////////////////////////////////////////////////// 3 4 this 3 579  1 i 1 530  6 rel_to 1 581  
165 14 Dtool_UKlvweNU 0 4 155 536 0 14 Dtool_UKlvweNU 758 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::set_vertex_space
//       Access: Published
//  Description: Sets the coordinate space of the nth control vertex.
//               If this is not specified, or is set to an empty
//               NodePath, the nth control vertex is deemed to be in
//               the coordinate space passed to evaluate().
//
//               This specifies the space as a fixed NodePath, which
//               is always the same NodePath.  Also see setting the
//               space as a path string, which can specify a different
//               NodePath for different instances of the curve.
//////////////////////////////////////////////////////////////////// 3 4 this 3 578  1 i 1 530  5 space 1 581  
166 14 Dtool_UKlvyxIB 0 4 155 536 0 14 Dtool_UKlvyxIB 676 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::set_vertex_space
//       Access: Published
//  Description: Sets the coordinate space of the nth control vertex.
//               If this is not specified, or is set to an empty
//               string, the nth control vertex is deemed to be in
//               the coordinate space passed to evaluate().
//
//               This specifies the space as a string, which describes
//               the path to find the node relative to the rel_to
//               NodePath when the curve is evaluated.
//////////////////////////////////////////////////////////////////// 3 4 this 3 578  1 i 1 530  5 space 1 563  
167 14 Dtool_UKlvNK37 0 7 156 584 0 14 Dtool_UKlvNK37 347 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::get_vertex_space
//       Access: Published
//  Description: Returns the coordinate space of the nth control
//               vertex of the curve, expressed as a NodePath.
//////////////////////////////////////////////////////////////////// 3 4 this 3 579  1 i 1 530  6 rel_to 1 581  
168 14 Dtool_UKlvnasG 0 4 157 536 0 14 Dtool_UKlvnasG 1219 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::set_extended_vertex
//       Access: Public
//  Description: Sets an n-dimensional vertex value.  This allows
//               definition of a NURBS surface or curve in a sparse
//               n-dimensional space, typically used for associating
//               additional properties (like color or joint
//               membership) with each vertex of a surface.
//
//               The value d is an arbitrary integer value and
//               specifies the dimension of question for this
//               particular vertex.  Any number of dimensions may be
//               specified, and they need not be consecutive.  If a
//               value for a given dimension is not specified, is it
//               implicitly 0.0.
//
//               The value is implicitly scaled by the homogenous
//               weight value--that is, the fourth component of the
//               value passed to set_vertex().  This means the
//               ordinary vertex must be set first, before the
//               extended vertices can be set.
//////////////////////////////////////////////////////////////////// 4 4 this 3 578  1 i 1 530  1 d 1 530  5 value 1 534  
169 14 Dtool_UKlvKQQ_ 0 6 158 534 0 14 Dtool_UKlvKQQ_ 443 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::get_extended_vertex
//       Access: Public
//  Description: Returns an n-dimensional vertex value.  See
//               set_extended_vertex().  This returns the value set
//               for the indicated dimension, or 0.0 if nothing has
//               been set.
//////////////////////////////////////////////////////////////////// 3 4 this 3 579  1 i 1 530  1 d 1 530  
170 14 Dtool_UKlv8dL4 0 6 160 530 0 14 Dtool_UKlv8dL4 354 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::get_num_knots
//       Access: Published
//  Description: Returns the number of knot values in the curve.  This
//               is based on the number of vertices and the order.
//////////////////////////////////////////////////////////////////// 1 4 this 3 579  
171 14 Dtool_UKlvxjj1 0 4 161 536 0 14 Dtool_UKlvxjj1 447 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::set_knot
//       Access: Published
//  Description: Sets the value of the nth knot.  Each knot value
//               should be greater than or equal to the preceding
//               value.  If no knot values are set, a default knot
//               vector is supplied.
//////////////////////////////////////////////////////////////////// 3 4 this 3 578  1 i 1 530  4 knot 1 534  
172 14 Dtool_UKlvuP1P 0 6 162 534 0 14 Dtool_UKlvuP1P 263 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::get_knot
//       Access: Published
//  Description: Returns the value of the nth knot.
//////////////////////////////////////////////////////////////////// 2 4 this 3 579  1 i 1 530  
173 14 Dtool_UKlvmh_4 0 4 163 536 0 14 Dtool_UKlvmh_4 334 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::normalize_knots
//       Access: Published
//  Description: Normalizes the knot sequence so that the parametric
//               range of the curve is 0 .. 1.
//////////////////////////////////////////////////////////////////// 1 4 this 3 578  
174 14 Dtool_UKlvEL14 0 6 164 530 0 14 Dtool_UKlvEL14 354 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::get_num_segments
//       Access: Published
//  Description: Returns the number of piecewise continuous segments
//               in the curve.  This is based on the knot vector.
//////////////////////////////////////////////////////////////////// 1 4 this 3 579  
175 14 Dtool_UKlvApE_ 0 7 165 574 0 14 Dtool_UKlvApE_ 457 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::evaluate
//       Access: Published
//  Description: Returns a NurbsCurveResult object that represents the
//               result of applying the knots to all of the current
//               values of the vertices, transformed into the
//               indicated coordinate space.
//////////////////////////////////////////////////////////////////// 2 4 this 3 579  6 rel_to 1 581  
176 14 Dtool_UKlv2r74 0 7 165 574 0 14 Dtool_UKlv2r74 457 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::evaluate
//       Access: Published
//  Description: Returns a NurbsCurveResult object that represents the
//               result of applying the knots to all of the current
//               values of the vertices, transformed into the
//               indicated coordinate space.
//////////////////////////////////////////////////////////////////// 1 4 this 3 579  
177 14 Dtool_UKlvWA8J 0 7 165 574 0 14 Dtool_UKlvWA8J 528 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::evaluate
//       Access: Published
//  Description: Returns a NurbsCurveResult object that represents the
//               result of applying the knots to all of the current
//               values of the vertices, transformed into the
//               indicated coordinate space, and then further
//               transformed by the indicated matrix.
//////////////////////////////////////////////////////////////////// 3 4 this 3 579  6 rel_to 1 581  3 mat 1 585  
178 14 Dtool_UKlvh3t0 0 4 166 536 0 14 Dtool_UKlvh3t0 227 ////////////////////////////////////////////////////////////////////
//     Function: NurbsCurveEvaluator::output
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 579  3 out 1 542  
179 14 Dtool_UKlvlxRL 0 6 168 534 0 14 Dtool_UKlvlxRL 316 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::get_start_u
//       Access: Public
//  Description: Returns the first legal value of u on the surface.
//               Usually this is 0.0.
//////////////////////////////////////////////////////////////////// 1 4 this 3 587  
180 14 Dtool_UKlvxP5f 0 6 169 534 0 14 Dtool_UKlvxP5f 275 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::get_end_u
//       Access: Public
//  Description: Returns the last legal value of u on the surface.
//////////////////////////////////////////////////////////////////// 1 4 this 3 587  
181 14 Dtool_UKlvlIgM 0 6 170 534 0 14 Dtool_UKlvlIgM 316 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::get_start_v
//       Access: Public
//  Description: Returns the first legal value of v on the surface.
//               Usually this is 0.0.
//////////////////////////////////////////////////////////////////// 1 4 this 3 587  
182 14 Dtool_UKlvJL57 0 6 171 534 0 14 Dtool_UKlvJL57 275 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::get_end_v
//       Access: Public
//  Description: Returns the last legal value of v on the surface.
//////////////////////////////////////////////////////////////////// 1 4 this 3 587  
183 14 Dtool_UKlvtQQk 0 6 172 533 0 14 Dtool_UKlvtQQk 415 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::eval_point
//       Access: Published
//  Description: Computes the point on the surface corresponding to the
//               indicated value in parametric time.  Returns true if
//               the u, v values are valid, false otherwise.
//////////////////////////////////////////////////////////////////// 4 4 this 3 589  1 u 1 534  1 v 1 534  5 point 1 537  
184 14 Dtool_UKlv_6lV 0 6 173 533 0 14 Dtool_UKlv_6lV 457 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::eval_normal
//       Access: Published
//  Description: Computes the normal to the surface at the indicated
//               point in parametric time.  This normal vector will
//               not necessarily be normalized, and could be zero.
//               See also eval_point().
//////////////////////////////////////////////////////////////////// 4 4 this 3 589  1 u 1 534  1 v 1 534  6 normal 1 537  
185 14 Dtool_UKlv9yzI 0 6 174 534 0 14 Dtool_UKlv9yzI 408 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::eval_extended_point
//       Access: Published
//  Description: Evaluates the surface in n-dimensional space according
//               to the extended vertices associated with the surface in
//               the indicated dimension.
//////////////////////////////////////////////////////////////////// 4 4 this 3 589  1 u 1 534  1 v 1 534  1 d 1 530  
186 14 Dtool_UKlvQs85 0 6 176 530 0 14 Dtool_UKlvQs85 460 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::get_num_u_segments
//       Access: Public
//  Description: Returns the number of piecewise continuous segments
//               within the surface in the U direction.  This number
//               is usually not important unless you plan to call
//               eval_segment_point().
//////////////////////////////////////////////////////////////////// 1 4 this 3 587  
187 14 Dtool_UKlvZT9V 0 6 177 530 0 14 Dtool_UKlvZT9V 460 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::get_num_v_segments
//       Access: Public
//  Description: Returns the number of piecewise continuous segments
//               within the surface in the V direction.  This number
//               is usually not important unless you plan to call
//               eval_segment_point().
//////////////////////////////////////////////////////////////////// 1 4 this 3 587  
188 14 Dtool_UKlvqiBr 0 4 178 536 0 14 Dtool_UKlvqiBr 1060 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::eval_segment_point
//       Access: Published
//  Description: Evaluates the point on the surface corresponding to the
//               indicated value in parametric time within the
//               indicated surface segment.  u and v should be in the
//               range [0, 1].
//
//               The surface is internally represented as a number of
//               connected (or possibly unconnected) piecewise
//               continuous segments.  The exact number of segments
//               for a particular surface depends on the knot vector,
//               and is returned by get_num_segments().  Normally,
//               eval_point() is used to evaluate a point along the
//               continuous surface, but when you care more about local
//               continuity, you can use eval_segment_point() to
//               evaluate the points along each segment.
//////////////////////////////////////////////////////////////////// 6 4 this 3 587  2 ui 1 530  2 vi 1 530  1 u 1 534  1 v 1 534  5 point 1 537  
189 14 Dtool_UKlvmDzQ 0 4 179 536 0 14 Dtool_UKlvmDzQ 449 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::eval_segment_normal
//       Access: Published
//  Description: As eval_segment_point, but computes the normal to
//               the surface at the indicated point.  The normal vector
//               will not necessarily be normalized, and could be
//               zero.
//////////////////////////////////////////////////////////////////// 6 4 this 3 587  2 ui 1 530  2 vi 1 530  1 u 1 534  1 v 1 534  6 normal 1 537  
190 14 Dtool_UKlvZ0qy 0 6 180 534 0 14 Dtool_UKlvZ0qy 416 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::eval_segment_extended_point
//       Access: Published
//  Description: Evaluates the surface in n-dimensional space according
//               to the extended vertices associated with the surface in
//               the indicated dimension.
//////////////////////////////////////////////////////////////////// 6 4 this 3 587  2 ui 1 530  2 vi 1 530  1 u 1 534  1 v 1 534  1 d 1 530  
191 14 Dtool_UKlvPEBw 0 6 182 534 0 14 Dtool_UKlvPEBw 483 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::get_segment_u
//       Access: Public
//  Description: Accepts a u value in the range [0, 1], and assumed to
//               be relative to the indicated segment (as in
//               eval_segment_point()), and returns the corresponding
//               u value in the entire surface (as in eval_point()).
//////////////////////////////////////////////////////////////////// 3 4 this 3 587  2 ui 1 530  1 u 1 534  
192 14 Dtool_UKlvTExR 0 6 183 534 0 14 Dtool_UKlvTExR 483 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceResult::get_segment_v
//       Access: Public
//  Description: Accepts a v value in the range [0, 1], and assumed to
//               be relative to the indicated segment (as in
//               eval_segment_point()), and returns the corresponding
//               v value in the entire surface (as in eval_point()).
//////////////////////////////////////////////////////////////////// 3 4 this 3 587  2 vi 1 530  1 v 1 534  
193 14 Dtool_UKlvPTGr 0 7 185 590 0 14 Dtool_UKlvPTGr 233 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 0 
194 14 Dtool_UKlvU5Cj 0 4 186 536 0 14 Dtool_UKlvU5Cj 1025 // Filename: nurbsSurfaceEvaluator.I
// Created by:  drose (10Oct03)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::set_u_order
//       Access: Published
//  Description: Sets the order of the surface in the U direction.
//               This resets the knot vector to the default knot
//               vector for the number of vertices.
//
//               The order must be 1, 2, 3, or 4, and the value is one
//               more than the degree of the surface.
//////////////////////////////////////////////////////////////////// 2 4 this 3 590  7 u_order 1 530  
195 14 Dtool_UKlvr6rC 0 6 187 530 0 14 Dtool_UKlvr6rC 346 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_u_order
//       Access: Published
//  Description: Returns the order of the surface in the U direction
//               as set by a previous call to set_u_order().
//////////////////////////////////////////////////////////////////// 1 4 this 3 591  
196 14 Dtool_UKlvi46T 0 4 188 536 0 14 Dtool_UKlvi46T 528 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::set_v_order
//       Access: Published
//  Description: Sets the order of the surface in the V direction.
//               This resets the knot vector to the default knot
//               vector for the number of vertices.
//
//               The order must be 1, 2, 3, or 4, and the value is one
//               more than the degree of the surface.
//////////////////////////////////////////////////////////////////// 2 4 this 3 590  7 v_order 1 530  
197 14 Dtool_UKlvS6jz 0 6 189 530 0 14 Dtool_UKlvS6jz 346 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_v_order
//       Access: Published
//  Description: Returns the order of the surface in the V direction
//               as set by a previous call to set_v_order().
//////////////////////////////////////////////////////////////////// 1 4 this 3 591  
198 14 Dtool_UKlvR8n7 0 4 190 536 0 14 Dtool_UKlvR8n7 512 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::reset
//       Access: Published
//  Description: Resets all the vertices and knots to their default
//               values, and sets the surface up with the indicated
//               number of vertices.  You must then call set_vertex()
//               repeatedly to fill in all of the vertex values
//               appropriately.
//////////////////////////////////////////////////////////////////// 3 4 this 3 590  14 num_u_vertices 1 530  14 num_v_vertices 1 530  
199 14 Dtool_UKlvSVa7 0 6 191 530 0 14 Dtool_UKlvSVa7 404 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_num_u_vertices
//       Access: Published
//  Description: Returns the number of control vertices in the U
//               direction on the surface.  This is the number passed
//               to the last call to reset().
//////////////////////////////////////////////////////////////////// 1 4 this 3 591  
200 14 Dtool_UKlvR1di 0 6 192 530 0 14 Dtool_UKlvR1di 404 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_num_v_vertices
//       Access: Published
//  Description: Returns the number of control vertices in the V
//               direction on the surface.  This is the number passed
//               to the last call to reset().
//////////////////////////////////////////////////////////////////// 1 4 this 3 591  
201 14 Dtool_UKlv_QQa 0 4 193 536 0 14 Dtool_UKlv_QQa 463 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::set_vertex
//       Access: Published
//  Description: Sets the nth control vertex of the surface.  This
//               flavor sets the vertex as a 3-d coordinate and a
//               weight; the 3-d coordinate values are implicitly
//               scaled up by the weight factor.
//////////////////////////////////////////////////////////////////// 5 4 this 3 590  2 ui 1 530  2 vi 1 530  6 vertex 1 554  6 weight 1 534  
202 14 Dtool_UKlvgFq4 0 4 193 536 0 14 Dtool_UKlvgFq4 463 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::set_vertex
//       Access: Published
//  Description: Sets the nth control vertex of the surface.  This
//               flavor sets the vertex as a 3-d coordinate and a
//               weight; the 3-d coordinate values are implicitly
//               scaled up by the weight factor.
//////////////////////////////////////////////////////////////////// 4 4 this 3 590  2 ui 1 530  2 vi 1 530  6 vertex 1 554  
203 14 Dtool_UKlvpOqU 0 4 193 536 0 14 Dtool_UKlvpOqU 528 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::set_vertex
//       Access: Published
//  Description: Sets the nth control vertex of the surface, as a vertex
//               in 4-d homogeneous space.  In this form, the first
//               three components of the vertex should already have
//               been scaled by the fourth component, which is the
//               homogeneous weight.
//////////////////////////////////////////////////////////////////// 4 4 this 3 590  2 ui 1 530  2 vi 1 530  6 vertex 1 567  
204 14 Dtool_UKlvO2eA 0 6 194 567 0 14 Dtool_UKlvO2eA 340 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_vertex
//       Access: Published
//  Description: Returns the nth control vertex of the surface, relative
//               to its indicated coordinate space.
//////////////////////////////////////////////////////////////////// 3 4 this 3 591  2 ui 1 530  2 vi 1 530  
205 14 Dtool_UKlvf6Jc 0 7 194 570 0 14 Dtool_UKlvf6Jc 336 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_vertex
//       Access: Published
//  Description: Returns the nth control vertex of the surface, relative
//               to the given coordinate space.
//////////////////////////////////////////////////////////////////// 4 4 this 3 591  2 ui 1 530  2 vi 1 530  6 rel_to 1 581  
206 14 Dtool_UKlv2rJC 0 4 195 536 0 14 Dtool_UKlv2rJC 762 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::set_vertex_space
//       Access: Published
//  Description: Sets the coordinate space of the nth control vertex.
//               If this is not specified, or is set to an empty
//               NodePath, the nth control vertex is deemed to be in
//               the coordinate space passed to evaluate().
//
//               This specifies the space as a fixed NodePath, which
//               is always the same NodePath.  Also see setting the
//               space as a path string, which can specify a different
//               NodePath for different instances of the surface.
//////////////////////////////////////////////////////////////////// 4 4 this 3 590  2 ui 1 530  2 vi 1 530  5 space 1 581  
207 14 Dtool_UKlvklv_ 0 4 195 536 0 14 Dtool_UKlvklv_ 680 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::set_vertex_space
//       Access: Published
//  Description: Sets the coordinate space of the nth control vertex.
//               If this is not specified, or is set to an empty
//               string, the nth control vertex is deemed to be in
//               the coordinate space passed to evaluate().
//
//               This specifies the space as a string, which describes
//               the path to find the node relative to the rel_to
//               NodePath when the surface is evaluated.
//////////////////////////////////////////////////////////////////// 4 4 this 3 590  2 ui 1 530  2 vi 1 530  5 space 1 563  
208 14 Dtool_UKlvHN7J 0 7 196 584 0 14 Dtool_UKlvHN7J 351 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_vertex_space
//       Access: Published
//  Description: Returns the coordinate space of the nth control
//               vertex of the surface, expressed as a NodePath.
//////////////////////////////////////////////////////////////////// 4 4 this 3 591  2 ui 1 530  2 vi 1 530  6 rel_to 1 581  
209 14 Dtool_UKlvow1w 0 4 197 536 0 14 Dtool_UKlvow1w 1223 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::set_extended_vertex
//       Access: Public
//  Description: Sets an n-dimensional vertex value.  This allows
//               definition of a NURBS surface or surface in a sparse
//               n-dimensional space, typically used for associating
//               additional properties (like color or joint
//               membership) with each vertex of a surface.
//
//               The value d is an arbitrary integer value and
//               specifies the dimension of question for this
//               particular vertex.  Any number of dimensions may be
//               specified, and they need not be consecutive.  If a
//               value for a given dimension is not specified, is it
//               implicitly 0.0.
//
//               The value is implicitly scaled by the homogenous
//               weight value--that is, the fourth component of the
//               value passed to set_vertex().  This means the
//               ordinary vertex must be set first, before the
//               extended vertices can be set.
//////////////////////////////////////////////////////////////////// 5 4 this 3 590  2 ui 1 530  2 vi 1 530  1 d 1 530  5 value 1 534  
210 14 Dtool_UKlvrTUV 0 6 198 534 0 14 Dtool_UKlvrTUV 445 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_extended_vertex
//       Access: Public
//  Description: Returns an n-dimensional vertex value.  See
//               set_extended_vertex().  This returns the value set
//               for the indicated dimension, or 0.0 if nothing has
//               been set.
//////////////////////////////////////////////////////////////////// 4 4 this 3 591  2 ui 1 530  2 vi 1 530  1 d 1 530  
211 14 Dtool_UKlvRhHW 0 6 200 530 0 14 Dtool_UKlvRhHW 396 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_num_u_knots
//       Access: Published
//  Description: Returns the number of knot values in the surface in
//               the U direction.  This is based on the number of
//               vertices and the order.
//////////////////////////////////////////////////////////////////// 1 4 this 3 591  
212 14 Dtool_UKlv8ALf 0 4 201 536 0 14 Dtool_UKlv8ALf 451 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::set_u_knot
//       Access: Published
//  Description: Sets the value of the nth knot.  Each knot value
//               should be greater than or equal to the preceding
//               value.  If no knot values are set, a default knot
//               vector is supplied.
//////////////////////////////////////////////////////////////////// 3 4 this 3 590  1 i 1 530  4 knot 1 534  
213 14 Dtool_UKlvQ_JQ 0 6 202 534 0 14 Dtool_UKlvQ_JQ 267 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_u_knot
//       Access: Published
//  Description: Returns the value of the nth knot.
//////////////////////////////////////////////////////////////////// 2 4 this 3 591  1 i 1 530  
214 14 Dtool_UKlvkyv3 0 4 203 536 0 14 Dtool_UKlvkyv3 359 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::normalize_u_knots
//       Access: Published
//  Description: Normalizes the knot sequence so that the parametric
//               range of the surface in the U direction is 0 .. 1.
//////////////////////////////////////////////////////////////////// 1 4 this 3 590  
215 14 Dtool_UKlvRBK9 0 6 204 530 0 14 Dtool_UKlvRBK9 396 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_num_v_knots
//       Access: Published
//  Description: Returns the number of knot values in the surface in
//               the V direction.  This is based on the number of
//               vertices and the order.
//////////////////////////////////////////////////////////////////// 1 4 this 3 591  
216 14 Dtool_UKlvyADQ 0 4 205 536 0 14 Dtool_UKlvyADQ 451 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::set_v_knot
//       Access: Published
//  Description: Sets the value of the nth knot.  Each knot value
//               should be greater than or equal to the preceding
//               value.  If no knot values are set, a default knot
//               vector is supplied.
//////////////////////////////////////////////////////////////////// 3 4 this 3 590  1 i 1 530  4 knot 1 534  
217 14 Dtool_UKlvm_BB 0 6 206 534 0 14 Dtool_UKlvm_BB 267 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_v_knot
//       Access: Published
//  Description: Returns the value of the nth knot.
//////////////////////////////////////////////////////////////////// 2 4 this 3 591  1 i 1 530  
218 14 Dtool_UKlv14vv 0 4 207 536 0 14 Dtool_UKlv14vv 359 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::normalize_v_knots
//       Access: Published
//  Description: Normalizes the knot sequence so that the parametric
//               range of the surface in the U direction is 0 .. 1.
//////////////////////////////////////////////////////////////////// 1 4 this 3 590  
219 14 Dtool_UKlvfAIa 0 6 208 530 0 14 Dtool_UKlvfAIa 396 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_num_u_segments
//       Access: Published
//  Description: Returns the number of piecewise continuous segments
//               in the surface in the U direction.  This is based on
//               the knot vector.
//////////////////////////////////////////////////////////////////// 1 4 this 3 591  
220 14 Dtool_UKlvghMB 0 6 209 530 0 14 Dtool_UKlvghMB 396 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::get_num_v_segments
//       Access: Published
//  Description: Returns the number of piecewise continuous segments
//               in the surface in the V direction.  This is based on
//               the knot vector.
//////////////////////////////////////////////////////////////////// 1 4 this 3 591  
221 14 Dtool_UKlvKtCQ 0 7 210 589 0 14 Dtool_UKlvKtCQ 461 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::evaluate
//       Access: Published
//  Description: Returns a NurbsSurfaceResult object that represents the
//               result of applying the knots to all of the current
//               values of the vertices, transformed into the
//               indicated coordinate space.
//////////////////////////////////////////////////////////////////// 2 4 this 3 591  6 rel_to 1 581  
222 14 Dtool_UKlvNggZ 0 7 210 589 0 14 Dtool_UKlvNggZ 461 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::evaluate
//       Access: Published
//  Description: Returns a NurbsSurfaceResult object that represents the
//               result of applying the knots to all of the current
//               values of the vertices, transformed into the
//               indicated coordinate space.
//////////////////////////////////////////////////////////////////// 1 4 this 3 591  
223 14 Dtool_UKlvz87T 0 4 211 536 0 14 Dtool_UKlvz87T 229 ////////////////////////////////////////////////////////////////////
//     Function: NurbsSurfaceEvaluator::output
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 591  3 out 1 542  
224 14 Dtool_UKlvzBQj 0 7 213 593 498 14 Dtool_UKlvzBQj 217 ////////////////////////////////////////////////////////////////////
//     Function: RopeNode::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 name 1 563  
225 14 Dtool_UKlvFaXK 0 4 217 536 0 14 Dtool_UKlvFaXK 280 ////////////////////////////////////////////////////////////////////
//     Function: set_curve
//       Access: Published
//  Description: Sets the particular curve represented by the
//               RopeNode.
//////////////////////////////////////////////////////////////////// 2 4 this 3 593  5 curve 1 578  
226 14 Dtool_UKlvaios 0 7 218 578 0 14 Dtool_UKlvaios 255 ////////////////////////////////////////////////////////////////////
//     Function: get_curve
//       Access: Published
//  Description: Returns the curve represented by the RopeNode.
//////////////////////////////////////////////////////////////////// 1 4 this 3 594  
227 14 Dtool_UKlvuWlh 0 4 219 536 0 14 Dtool_UKlvuWlh 365 ////////////////////////////////////////////////////////////////////
//     Function: set_render_mode
//       Access: Published
//  Description: Specifies the method used to render the rope.  The
//               simplest is RM_thread, which just draws a one-pixel
//               line segment.
//////////////////////////////////////////////////////////////////// 2 4 this 3 593  11 render_mode 1 526  
228 14 Dtool_UKlvYvch 0 6 220 526 0 14 Dtool_UKlvYvch 299 ////////////////////////////////////////////////////////////////////
//     Function: get_render_mode
//       Access: Published
//  Description: Returns the method used to render the rope.  See
//               set_render_mode().
//////////////////////////////////////////////////////////////////// 1 4 this 3 594  
229 14 Dtool_UKlv6nhf 0 4 221 536 0 14 Dtool_UKlv6nhf 289 ////////////////////////////////////////////////////////////////////
//     Function: set_uv_mode
//       Access: Published
//  Description: Specifies the algorithm to use to generate UV's for
//               the rope.
//////////////////////////////////////////////////////////////////// 2 4 this 3 593  7 uv_mode 1 527  
230 14 Dtool_UKlvigqq 0 6 222 527 0 14 Dtool_UKlvigqq 287 ////////////////////////////////////////////////////////////////////
//     Function: get_uv_mode
//       Access: Published
//  Description: Returns the algorithm to use to generate UV's for the
//               rope.
//////////////////////////////////////////////////////////////////// 1 4 this 3 594  
231 14 Dtool_UKlvgEwx 0 4 223 536 0 14 Dtool_UKlvgEwx 334 ////////////////////////////////////////////////////////////////////
//     Function: set_uv_direction
//       Access: Published
//  Description: Specify true to vary the U coordinate down the length
//               of the rope, or false to vary the V coordinate.
//////////////////////////////////////////////////////////////////// 2 4 this 3 593  10 u_dominant 1 533  
232 14 Dtool_UKlv_9Z_ 0 6 224 533 0 14 Dtool_UKlv_9Z_ 360 ////////////////////////////////////////////////////////////////////
//     Function: get_uv_direction
//       Access: Published
//  Description: Returns true if the rope runs down the U coordinate
//               of the texture, or false if it runs down the V
//               coordinate.
//////////////////////////////////////////////////////////////////// 1 4 this 3 594  
233 14 Dtool_UKlv2gSR 0 4 225 536 0 14 Dtool_UKlv2gSR 452 ////////////////////////////////////////////////////////////////////
//     Function: set_uv_scale
//       Access: Published
//  Description: Specifies an additional scaling factor to apply to
//               generated UV's along the rope.  This scale factor is
//               applied in whichever direction is along the rope, as
//               specified by set_uv_direction().
//////////////////////////////////////////////////////////////////// 2 4 this 3 593  5 scale 1 534  
234 14 Dtool_UKlvUMN6 0 6 226 534 0 14 Dtool_UKlvUMN6 296 ////////////////////////////////////////////////////////////////////
//     Function: get_uv_scale
//       Access: Published
//  Description: Returns the scaling factor to apply to generated UV's
//               for the rope.
//////////////////////////////////////////////////////////////////// 1 4 this 3 594  
235 14 Dtool_UKlvoMpH 0 4 227 536 0 14 Dtool_UKlvoMpH 441 ////////////////////////////////////////////////////////////////////
//     Function: set_normal_mode
//       Access: Published
//  Description: Specifies the kind of normals to generate for the
//               rope.  This is only applicable when the RenderMode is
//               set to RM_tube; in the other render modes, normals
//               are never generated.
//////////////////////////////////////////////////////////////////// 2 4 this 3 593  11 normal_mode 1 528  
236 14 Dtool_UKlvGyYY 0 6 228 528 0 14 Dtool_UKlvGyYY 365 ////////////////////////////////////////////////////////////////////
//     Function: get_normal_mode
//       Access: Published
//  Description: Returns the kind of normals to generate for the rope.
//               This is only applicable when the RenderMode is set to
//               RM_tube.
//////////////////////////////////////////////////////////////////// 1 4 this 3 594  
237 14 Dtool_UKlvjaO5 0 4 229 536 0 14 Dtool_UKlvjaO5 723 ////////////////////////////////////////////////////////////////////
//     Function: set_tube_up
//       Access: Published
//  Description: Specifies a normal vector, generally perpendicular to
//               the main axis of the starting point of the curve,
//               that controls the "top" of the curve, when RenderMode
//               is RM_tube.  This is used to orient the vertices that
//               make up the tube.  If this vector is too nearly
//               parallel with the starting direction of the curve,
//               there may be a tendency for the whole tube to
//               gimble-lock around its primary axis.
//////////////////////////////////////////////////////////////////// 2 4 this 3 593  7 tube_up 1 596  
238 14 Dtool_UKlvHo6a 0 6 230 596 0 14 Dtool_UKlvHo6a 358 ////////////////////////////////////////////////////////////////////
//     Function: get_tube_up
//       Access: Published
//  Description: Returns the normal vector used to control the "top"
//               of the curve, when RenderMode is RM_tube.  See
//               set_tube_up().
//////////////////////////////////////////////////////////////////// 1 4 this 3 594  
239 14 Dtool_UKlvnZ_r 0 4 231 536 0 14 Dtool_UKlvnZ_r 667 ////////////////////////////////////////////////////////////////////
//     Function: set_use_vertex_color
//       Access: Published
//  Description: Sets the "use vertex color" flag.  When this is true,
//               the R, G, B, A vertex color is assumed to be stored
//               as the dimensions n + 0, n + 1, n + 2, n + 3,
//               respectively, of the extended vertex values, where n
//               is the value returned by
//               get_vertex_color_dimension().  Use
//               NurbsCurveEvaluator::set_extended_vertex() to set
//               these values.
//////////////////////////////////////////////////////////////////// 2 4 this 3 593  4 flag 1 533  
240 14 Dtool_UKlvB86D 0 6 232 533 0 14 Dtool_UKlvB86D 302 ////////////////////////////////////////////////////////////////////
//     Function: get_use_vertex_color
//       Access: Published
//  Description: Returns the "use vertex color" flag.  See
//               set_use_vertex_color().
//////////////////////////////////////////////////////////////////// 1 4 this 3 594  
241 14 Dtool_UKlvAhPX 0 6 233 530 0 14 Dtool_UKlvAhPX 506 ////////////////////////////////////////////////////////////////////
//     Function: get_vertex_color_dimension
//       Access: Published, Static
//  Description: Returns the numeric extended dimension in which the
//               color components should be found.  See
//               NurbsCurveEvaluator::set_extended_vertex().
//
//               The color components will be expected at (n, n + 1, n
//               + 2, n + 3).
//////////////////////////////////////////////////////////////////// 0 
242 14 Dtool_UKlvjOxh 0 4 234 536 0 14 Dtool_UKlvjOxh 388 ////////////////////////////////////////////////////////////////////
//     Function: set_num_subdiv
//       Access: Published
//  Description: Specifies the number of subdivisions per cubic
//               segment (that is, per unique knot value) to draw in a
//               fixed uniform tesselation of the curve.
//////////////////////////////////////////////////////////////////// 2 4 this 3 593  10 num_subdiv 1 530  
243 14 Dtool_UKlv9Cxy 0 6 235 530 0 14 Dtool_UKlv9Cxy 315 ////////////////////////////////////////////////////////////////////
//     Function: get_num_subdiv
//       Access: Published
//  Description: Returns the number of subdivisions per cubic segment
//               to draw.  See set_num_subdiv().
//////////////////////////////////////////////////////////////////// 1 4 this 3 594  
244 14 Dtool_UKlvDjUu 0 4 236 536 0 14 Dtool_UKlvDjUu 711 ////////////////////////////////////////////////////////////////////
//     Function: set_num_slices
//       Access: Published
//  Description: Specifies the number of radial subdivisions to make
//               if RenderMode is RM_tube.  It is ignored in the other
//               render modes.
//
//               Increasing this number increases the roundness of a
//               cross-section of the tube.  The minimum value for a
//               dimensional tube is 3; setting it to 2 will get you a
//               thin piece of tape (which is similar to RM_billboard,
//               except it won't rotate to face the camera).
//////////////////////////////////////////////////////////////////// 2 4 this 3 593  10 num_slices 1 530  
245 14 Dtool_UKlvMuU_ 0 6 237 530 0 14 Dtool_UKlvMuU_ 388 ////////////////////////////////////////////////////////////////////
//     Function: get_num_slices
//       Access: Published
//  Description: Returns the number of radial subdivisions to make if
//               RenderMode is RM_tube.  It is ignored in the other
//               render modes.  See set_num_slices().
//////////////////////////////////////////////////////////////////// 1 4 this 3 594  
246 14 Dtool_UKlvq7ur 0 4 238 536 0 14 Dtool_UKlvq7ur 752 ////////////////////////////////////////////////////////////////////
//     Function: set_use_vertex_thickness
//       Access: Published
//  Description: Sets the "use vertex thickness" flag.  When this is true,
//               the vertex thickness is assumed to be stored as the
//               dimension get_vertex_thickness_dimension(), of the
//               extended vertex values.  Use
//               NurbsCurveEvaluator::set_extended_vertex() to set
//               these values.
//
//               In this mode, the overall thickness is also applied
//               as a scale to the vertex thickness.  Not all render
//               modes support vertex thickness.
//////////////////////////////////////////////////////////////////// 2 4 this 3 593  4 flag 1 533  
247 14 Dtool_UKlvZeXw 0 6 239 533 0 14 Dtool_UKlvZeXw 314 ////////////////////////////////////////////////////////////////////
//     Function: get_use_vertex_thickness
//       Access: Published
//  Description: Returns the "use vertex thickness" flag.  See
//               set_use_vertex_thickness().
//////////////////////////////////////////////////////////////////// 1 4 this 3 594  
248 14 Dtool_UKlv6HSd 0 6 240 530 0 14 Dtool_UKlv6HSd 409 ////////////////////////////////////////////////////////////////////
//     Function: get_vertex_thickness_dimension
//       Access: Published, Static
//  Description: Returns the numeric extended dimension in which the
//               thickness component should be found.  See
//               NurbsCurveEvaluator::set_extended_vertex().
//////////////////////////////////////////////////////////////////// 0 
249 14 Dtool_UKlvF_Y0 0 4 241 536 0 14 Dtool_UKlvF_Y0 497 ////////////////////////////////////////////////////////////////////
//     Function: set_thickness
//       Access: Published
//  Description: Specifies the thickness of the rope, in pixels or in
//               spatial units, depending on the render mode.  See
//               set_render_mode().
//
//               The thickness may also be specified on a per-vertex
//               basis.  See set_use_vertex_thickness().
//////////////////////////////////////////////////////////////////// 2 4 this 3 593  9 thickness 1 534  
250 14 Dtool_UKlvbcPu 0 6 242 534 0 14 Dtool_UKlvbcPu 286 ////////////////////////////////////////////////////////////////////
//     Function: get_thickness
//       Access: Published
//  Description: Returns the thickness of the rope.  See
//               set_thickness().
//////////////////////////////////////////////////////////////////// 1 4 this 3 594  
251 14 Dtool_UKlvMilH 0 4 243 536 0 14 Dtool_UKlvMilH 451 ////////////////////////////////////////////////////////////////////
//     Function: set_matrix
//       Access: Published
//  Description: Specifies an optional matrix which is used to
//               transform each control vertex after it has been
//               transformed into the RopeNode's coordinate space, but
//               before the polygon vertices are generated.
//////////////////////////////////////////////////////////////////// 2 4 this 3 593  6 matrix 1 585  
252 14 Dtool_UKlvRoo1 0 4 244 536 0 14 Dtool_UKlvRoo1 285 ////////////////////////////////////////////////////////////////////
//     Function: clear_matrix
//       Access: Published
//  Description: Resets the node's matrix to identity.  See
//               set_matrix().
//////////////////////////////////////////////////////////////////// 1 4 this 3 593  
253 14 Dtool_UKlv9ssg 0 6 245 533 0 14 Dtool_UKlv9ssg 305 ////////////////////////////////////////////////////////////////////
//     Function: has_matrix
//       Access: Published
//  Description: Returns true if the node has a matrix set, false
//               otherwise.  See set_matrix().
//////////////////////////////////////////////////////////////////// 1 4 this 3 594  
254 14 Dtool_UKlvYvf4 0 6 246 585 0 14 Dtool_UKlvYvf4 450 ////////////////////////////////////////////////////////////////////
//     Function: get_matrix
//       Access: Published
//  Description: Returns the optional matrix which is used to
//               transform each control vertex after it has been
//               transformed into the RopeNode's coordinate space, but
//               before the polygon vertices are generated.
//////////////////////////////////////////////////////////////////// 1 4 this 3 594  
255 14 Dtool_UKlv4xWg 0 4 247 536 0 14 Dtool_UKlv4xWg 461 ////////////////////////////////////////////////////////////////////
//     Function: RopeNode::reset_bound
//       Access: Published
//  Description: Recomputes the bounding volume.  This is normally
//               called automatically, but it must occasionally be
//               called explicitly when the curve has changed
//               properties outside of this node's knowledge.
//////////////////////////////////////////////////////////////////// 2 4 this 3 593  6 rel_to 1 581  
256 14 Dtool_UKlvXsAM 0 7 248 547 0 14 Dtool_UKlvXsAM 0 0 
257 14 Dtool_UKlvHNcz 0 7 251 599 510 14 Dtool_UKlvHNcz 218 ////////////////////////////////////////////////////////////////////
//     Function: SheetNode::Constructor
//       Access: Public
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 name 1 563  
258 14 Dtool_UKlv0cvy 0 4 252 536 0 14 Dtool_UKlv0cvy 282 ////////////////////////////////////////////////////////////////////
//     Function: set_surface
//       Access: Public
//  Description: Sets the particular surface represented by the
//               SheetNode.
//////////////////////////////////////////////////////////////////// 2 4 this 3 599  7 surface 1 590  
259 14 Dtool_UKlv18wP 0 7 253 590 0 14 Dtool_UKlv18wP 257 ////////////////////////////////////////////////////////////////////
//     Function: get_surface
//       Access: Public
//  Description: Returns the surface represented by the SheetNode.
//////////////////////////////////////////////////////////////////// 1 4 this 3 600  
260 14 Dtool_UKlvYR_Z 0 4 254 536 0 14 Dtool_UKlvYR_Z 551 ////////////////////////////////////////////////////////////////////
//     Function: set_use_vertex_color
//       Access: Public
//  Description: Sets the "use vertex color" flag.  When this is true,
//               the R, G, B, A vertex color is assumed to be stored
//               as the dimensions 0, 1, 2, 3, respectively, of the
//               extended vertex values.  Use
//               NurbsCurveEvaluator::set_extended_vertex() to set
//               these values.
//////////////////////////////////////////////////////////////////// 2 4 this 3 599  4 flag 1 533  
261 14 Dtool_UKlvE_yX 0 6 255 533 0 14 Dtool_UKlvE_yX 299 ////////////////////////////////////////////////////////////////////
//     Function: get_use_vertex_color
//       Access: Public
//  Description: Returns the "use vertex color" flag.  See
//               set_use_vertex_color().
//////////////////////////////////////////////////////////////////// 1 4 this 3 600  
262 14 Dtool_UKlvATi0 0 4 256 536 0 14 Dtool_UKlvATi0 425 ////////////////////////////////////////////////////////////////////
//     Function: set_num_u_subdiv
//       Access: Public
//  Description: Specifies the number of subdivisions per cubic
//               segment (that is, per unique knot value) to draw in a
//               fixed uniform tesselation of the surface in the U
//               direction.
//////////////////////////////////////////////////////////////////// 2 4 this 3 599  12 num_u_subdiv 1 530  
263 14 Dtool_UKlvor5e 0 6 257 530 0 14 Dtool_UKlvor5e 335 ////////////////////////////////////////////////////////////////////
//     Function: get_num_u_subdiv
//       Access: Public
//  Description: Returns the number of subdivisions per cubic segment
//               to draw in the U direction.  See set_num_u_subdiv().
//////////////////////////////////////////////////////////////////// 1 4 this 3 600  
264 14 Dtool_UKlv65jU 0 4 258 536 0 14 Dtool_UKlv65jU 425 ////////////////////////////////////////////////////////////////////
//     Function: set_num_v_subdiv
//       Access: Public
//  Description: Specifies the number of subdivisions per cubic
//               segment (that is, per unique knot value) to draw in a
//               fixed uniform tesselation of the surface in the V
//               direction.
//////////////////////////////////////////////////////////////////// 2 4 this 3 599  12 num_v_subdiv 1 530  
265 14 Dtool_UKlvkQ7_ 0 6 259 530 0 14 Dtool_UKlvkQ7_ 335 ////////////////////////////////////////////////////////////////////
//     Function: get_num_v_subdiv
//       Access: Public
//  Description: Returns the number of subdivisions per cubic segment
//               to draw in the V direction.  See set_num_v_subdiv().
//////////////////////////////////////////////////////////////////// 1 4 this 3 600  
266 14 Dtool_UKlvZQ8j 0 4 260 536 0 14 Dtool_UKlvZQ8j 464 ////////////////////////////////////////////////////////////////////
//     Function: SheetNode::reset_bound
//       Access: Published
//  Description: Recomputes the bounding volume.  This is normally
//               called automatically, but it must occasionally be
//               called explicitly when the surface has changed
//               properties outside of this node's knowledge.
//////////////////////////////////////////////////////////////////// 2 4 this 3 599  6 rel_to 1 581  
267 14 Dtool_UKlvv2IZ 0 7 261 547 0 14 Dtool_UKlvv2IZ 0 0 
92
511 15 ParametricCurve 0 75777 15 ParametricCurve 15 ParametricCurve 0 0 0 0 0 0 19 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 0 0 1 0 512 0 0 0 0 370
////////////////////////////////////////////////////////////////////
//       Class : ParametricCurve
// Description : A virtual base class for parametric curves.
//               This encapsulates all curves in 3-d space defined
//               for a single parameter t in the range [0,get_max_t()].
////////////////////////////////////////////////////////////////////

512 9 PandaNode 0 2049 9 PandaNode 9 PandaNode 0 0 0 0 0 0 0 0 0 0 0 0 374
////////////////////////////////////////////////////////////////////
//       Class : PandaNode
// Description : A basic node of the scene graph or data graph.  This
//               is the base class of all specialized nodes, and also
//               serves as a generic node with no special properties.
////////////////////////////////////////////////////////////////////

513 13 CubicCurveseg 0 75777 13 CubicCurveseg 13 CubicCurveseg 0 0 0 0 0 0 1 287 0 0 1 0 511 0 0 0 0 1386
////////////////////////////////////////////////////////////////////
//       Class : CubicCurveseg
// Description : A CubicCurveseg is any curve that can be completely
//               described by four 4-valued basis vectors, one for
//               each dimension in three-space, and one for the
//               homogeneous coordinate.  This includes Beziers,
//               Hermites, and NURBS.
//
//               This class encapsulates a single curve segment of the
//               cubic curve.  Normally, when we think of Bezier and
//               Hermite curves, we think of a piecewise collection of
//               such segments.
//
//               Although this class includes methods such as
//               hermite_basis() and nurbs_basis(), to generate a
//               Hermite and NURBS curve segment, respectively, only
//               the final basis vectors are stored: the product of
//               the basis matrix of the corresponding curve type, and
//               its geometry vectors.  This is the minimum
//               information needed to evaluate the curve.  However,
//               the individual CV's that were used to compute these
//               basis vectors are not retained; this might be handled
//               in a subclass (for instance, HermiteCurve).
////////////////////////////////////////////////////////////////////

514 25 ParametricCurveCollection 0 75777 25 ParametricCurveCollection 25 ParametricCurveCollection 0 0 0 1 288 0 0 28 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 2 611 612 0 1 0 515 0 0 0 0 620
////////////////////////////////////////////////////////////////////
//       Class : ParametricCurveCollection
// Description : This is a set of zero or more ParametricCurves, which
//               may or may not be related.  If they are related, the
//               set should contain no more than one XYZ curve, no
//               more than one HPR curve, and zero or more Timewarp
//               curves, which can then be evaluated as a unit to
//               return a single transformation matrix for a given
//               unit of time.
////////////////////////////////////////////////////////////////////

515 14 ReferenceCount 0 2049 14 ReferenceCount 14 ReferenceCount 0 0 0 0 0 0 0 0 0 0 0 0 425
////////////////////////////////////////////////////////////////////
//       Class : ReferenceCount
// Description : A base class for all things that want to be
//               reference-counted.  ReferenceCount works in
//               conjunction with PointerTo to automatically delete
//               objects when the last pointer to them goes away.
////////////////////////////////////////////////////////////////////

516 11 CurveFitter 0 26625 11 CurveFitter 11 CurveFitter 0 0 0 1 317 318 0 20 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 0 0 0 0 0 183
////////////////////////////////////////////////////////////////////
//       Class : CurveFitter
// Description :
////////////////////////////////////////////////////////////////////

517 14 PiecewiseCurve 0 75777 14 PiecewiseCurve 14 PiecewiseCurve 0 0 0 1 339 0 0 1 340 0 0 1 0 511 0 0 0 0 405
////////////////////////////////////////////////////////////////////
//       Class : PiecewiseCurve
// Description : A PiecewiseCurve is a curve made up of several curve
//               segments, connected in a head-to-tail fashion.  The
//               length of each curve segment in parametric space is
//               definable.
////////////////////////////////////////////////////////////////////

518 12 HermiteCurve 0 75777 12 HermiteCurve 12 HermiteCurve 0 0 0 1 341 0 0 19 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 0 0 1 0 517 0 0 0 0 700
////////////////////////////////////////////////////////////////////
//       Class : HermiteCurve
// Description : A parametric curve defined by a sequence of control
//               vertices, each with an in and out tangent.
//
//               This class is actually implemented as a
//               PiecewiseCurve made up of several CubicCurvesegs,
//               each of which is created using the hermite_basis()
//               method.  The HermiteCurve class itself keeps its own
//               list of the CV's that are used to define the curve
//               (since the CubicCurveseg class doesn't retain these).
////////////////////////////////////////////////////////////////////

519 19 NurbsCurveInterface 0 26625 19 NurbsCurveInterface 19 NurbsCurveInterface 0 0 0 0 361 0 18 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 2 613 614 0 0 0 0 454
////////////////////////////////////////////////////////////////////
//       Class : NurbsCurveInterface
// Description : This abstract class defines the interface only for a
//               Nurbs-style curve, with knots and coordinates in
//               homogeneous space.
//
//               The NurbsCurve class inherits both from this and from
//               ParametricCurve.
////////////////////////////////////////////////////////////////////

520 10 NurbsCurve 0 26625 10 NurbsCurve 10 NurbsCurve 0 0 0 1 384 385 0 1 386 0 0 2 3 517 380 381 3 519 382 383 0 0 1243
////////////////////////////////////////////////////////////////////
//       Class : NurbsCurve
// Description : A Nonuniform Rational B-Spline.
//
//               This class is actually implemented as a
//               PiecewiseCurve made up of several CubicCurvesegs,
//               each of which is created using the nurbs_basis()
//               method.  The list of CV's and knots is kept here,
//               within the NurbsCurve class.
//
//               This class is the original Panda-native
//               implementation of a NURBS curve.  It is typedeffed as
//               "NurbsCurve" and performs all NURBS curve functions
//               if we do not have the NURBS++ library available.
//
//               However, if we *do* have the NURBS++ library, another
//               class exists, the NurbsPPCurve, which is a wrapper
//               around that library and provides some additional
//               functionality.  In that case, the other class is
//               typedeffed to "NurbsCurve" instead of this one, and
//               performs most of the NURBS curve functions.  This
//               class then becomes vestigial.
////////////////////////////////////////////////////////////////////

521 16 NurbsCurveResult 0 75777 16 NurbsCurveResult 16 NurbsCurveResult 0 0 0 0 0 0 16 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 2 615 616 0 1 0 515 0 0 0 0 748
////////////////////////////////////////////////////////////////////
//       Class : NurbsCurveResult
// Description : The result of a NurbsCurveEvaluator.  This object
//               represents a curve in a particular coordinate space.
//               It can return the point and/or tangent to the curve
//               at any point.
//
//               This is not related to NurbsCurve, CubicCurveseg or
//               any of the ParametricCurve-derived objects in this
//               module.  It is a completely parallel implementation
//               of NURBS curves, and will probably eventually replace
//               the whole ParametricCurve class hierarchy.
////////////////////////////////////////////////////////////////////

522 19 NurbsCurveEvaluator 0 75777 19 NurbsCurveEvaluator 19 NurbsCurveEvaluator 0 0 0 1 403 0 0 18 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 2 617 618 0 1 0 515 0 0 0 0 808
////////////////////////////////////////////////////////////////////
//       Class : NurbsCurveEvaluator
// Description : This class is an abstraction for evaluating NURBS
//               curves.  It accepts an array of vertices, each of
//               which may be in a different coordinate space (as
//               defined by a NodePath), as well as an optional knot
//               vector.
//
//               This is not related to NurbsCurve, CubicCurveseg or
//               any of the ParametricCurve-derived objects in this
//               module.  It is a completely parallel implementation
//               of NURBS curves, and will probably eventually replace
//               the whole ParametricCurve class hierarchy.
////////////////////////////////////////////////////////////////////

523 18 NurbsSurfaceResult 0 75777 18 NurbsSurfaceResult 18 NurbsSurfaceResult 0 0 0 0 0 0 16 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 0 0 1 0 515 0 0 0 0 415
////////////////////////////////////////////////////////////////////
//       Class : NurbsSurfaceResult
// Description : The result of a NurbsSurfaceEvaluator.  This object
//               represents a surface in a particular coordinate space.
//               It can return the point and/or normal to the surface
//               at any point.
////////////////////////////////////////////////////////////////////

524 21 NurbsSurfaceEvaluator 0 75777 21 NurbsSurfaceEvaluator 21 NurbsSurfaceEvaluator 0 0 0 1 438 0 0 26 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 2 619 620 0 1 0 515 0 0 0 0 472
////////////////////////////////////////////////////////////////////
//       Class : NurbsSurfaceEvaluator
// Description : This class is an abstraction for evaluating NURBS
//               surfaces.  It accepts an array of vertices, each of
//               which may be in a different coordinate space (as
//               defined by a NodePath), as well as an optional knot
//               vector.
////////////////////////////////////////////////////////////////////

525 8 RopeNode 0 141313 8 RopeNode 8 RopeNode 0 0 0 1 465 498 0 32 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 0 0 1 0 512 0 0 0 3 526 527 528 702
////////////////////////////////////////////////////////////////////
//       Class : RopeNode
// Description : This class draws a visible representation of the
//               NURBS curve stored in its NurbsCurveEvaluator.  It
//               automatically recomputes the curve every frame.
//
//               This is not related to NurbsCurve, CubicCurveseg or
//               any of the ParametricCurve-derived objects in this
//               module.  It is a completely parallel implementation
//               of NURBS curves, and will probably eventually replace
//               the whole ParametricCurve class hierarchy.
////////////////////////////////////////////////////////////////////

526 10 RenderMode 0 794624 20 RopeNode::RenderMode 20 RopeNode::RenderMode 525 0 0 0 0 0 0 0 0 0 4 9 RM_thread 19 RopeNode::RM_thread 0 7 RM_tape 17 RopeNode::RM_tape 1 12 RM_billboard 22 RopeNode::RM_billboard 2 7 RM_tube 17 RopeNode::RM_tube 3 0 0

527 6 UVMode 0 794624 16 RopeNode::UVMode 16 RopeNode::UVMode 525 0 0 0 0 0 0 0 0 0 4 7 UV_none 17 RopeNode::UV_none 0 13 UV_parametric 23 RopeNode::UV_parametric 1 11 UV_distance 21 RopeNode::UV_distance 2 12 UV_distance2 22 RopeNode::UV_distance2 3 0 0

528 10 NormalMode 0 794624 20 RopeNode::NormalMode 20 RopeNode::NormalMode 525 0 0 0 0 0 0 0 0 0 2 7 NM_none 17 RopeNode::NM_none 0 9 NM_vertex 19 RopeNode::NM_vertex 1 0 0

529 9 SheetNode 0 141313 9 SheetNode 9 SheetNode 0 0 0 1 499 510 0 10 500 501 502 503 504 505 506 507 508 509 0 0 1 0 512 0 0 0 0 736
////////////////////////////////////////////////////////////////////
//       Class : SheetNode
// Description : This class draws a visible representation of the
//               NURBS surface stored in its NurbsSurfaceEvaluator.  It
//               automatically recomputes the surface every frame.
//
//               This is not related to NurbsSurface, CubicSurfaceseg
//               or any of the ParametricSurface-derived objects in
//               this module.  It is a completely parallel
//               implementation of NURBS surfaces, and will probably
//               eventually replace the whole ParametricSurface class
//               hierarchy.
////////////////////////////////////////////////////////////////////

530 3 int 0 8194 3 int 3 int 0 1 0 0 0 0 0 0 0 0 0 0 0

531 23 ParametricCurve const * 0 8576 23 ParametricCurve const * 23 ParametricCurve const * 0 0 532 0 0 0 0 0 0 0 0 0 0

532 21 ParametricCurve const 0 8832 21 ParametricCurve const 21 ParametricCurve const 0 0 511 0 0 0 0 0 0 0 0 0 0

533 4 bool 0 8194 4 bool 4 bool 0 4 0 0 0 0 0 0 0 0 0 0 0

534 5 float 0 8194 5 float 5 float 0 2 0 0 0 0 0 0 0 0 0 0 0

535 17 ParametricCurve * 0 8576 17 ParametricCurve * 17 ParametricCurve * 0 0 511 0 0 0 0 0 0 0 0 0 0

536 4 void 0 8194 4 void 4 void 0 6 0 0 0 0 0 0 0 0 0 0 0

537 12 LVecBase3f * 0 8576 12 LVecBase3f * 12 LVecBase3f * 0 0 538 0 0 0 0 0 0 0 0 0 0

538 10 LVecBase3f 0 2048 10 LVecBase3f 10 LVecBase3f 0 0 0 0 0 0 0 0 0 0 0 0 754
// Filename: lvecBase3_src.h
// Created by:  drose (08Mar00)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//       Class : LVecBase3
// Description : This is the base class for all three-component
//               vectors and points.
////////////////////////////////////////////////////////////////////

539 10 Filename * 0 8576 10 Filename * 10 Filename * 0 0 540 0 0 0 0 0 0 0 0 0 0

540 8 Filename 0 2048 8 Filename 8 Filename 0 0 0 0 0 0 0 0 0 0 0 0 869
////////////////////////////////////////////////////////////////////
//       Class : Filename
// Description : The name of a file, such as a texture file or an Egg
//               file.  Stores the full pathname, and includes
//               functions for extracting out the directory prefix
//               part and the file extension and stuff.
//
//               A Filename is also aware of the mapping between the
//               Unix-like filename convention we use internally, and
//               the local OS's specific filename convention, and it
//               knows how to perform basic OS-specific I/O, like
//               testing for file existence and searching a
//               searchpath, as well as the best way to open an
//               fstream for reading or writing.
////////////////////////////////////////////////////////////////////

541 16 CoordinateSystem 0 532480 16 CoordinateSystem 16 CoordinateSystem 0 0 0 0 0 0 0 0 0 0 6 10 CS_default 10 CS_default 0 12 CS_zup_right 12 CS_zup_right 1 12 CS_yup_right 12 CS_yup_right 2 11 CS_zup_left 11 CS_zup_left 3 11 CS_yup_left 11 CS_yup_left 4 10 CS_invalid 10 CS_invalid 5 0 0

542 9 ostream * 0 8576 9 ostream * 9 ostream * 0 0 543 0 0 0 0 0 0 0 0 0 0

543 7 ostream 0 2048 7 ostream 7 ostream 0 0 0 0 0 0 0 0 0 0 0 0 0

544 16 Filename const * 0 8576 16 Filename const * 16 Filename const * 0 0 545 0 0 0 0 0 0 0 0 0 0

545 14 Filename const 0 8832 14 Filename const 14 Filename const 0 0 540 0 0 0 0 0 0 0 0 0 0

546 10 TypeHandle 0 2048 10 TypeHandle 10 TypeHandle 0 0 0 0 0 0 0 0 0 0 0 0 1098
////////////////////////////////////////////////////////////////////
//       Class : TypeHandle
// Description : TypeHandle is the identifier used to differentiate
//               C++ class types.  Any C++ classes that inherit from
//               some base class, and must be differentiated at run
//               time, should store a static TypeHandle object that
//               can be queried through a static member function
//               named get_class_type().  Most of the time, it is also
//               desirable to inherit from TypedObject, which provides
//               some virtual functions to return the TypeHandle for a
//               particular instance.
//
//               At its essence, a TypeHandle is simply a unique
//               identifier that is assigned by the TypeRegistry.  The
//               TypeRegistry stores a tree of TypeHandles, so that
//               ancestry of a particular type may be queried, and the
//               type name may be retrieved for run-time display.
////////////////////////////////////////////////////////////////////

547 12 TypeHandle * 0 8576 12 TypeHandle * 12 TypeHandle * 0 0 546 0 0 0 0 0 0 0 0 0 0

548 27 ParametricCurveCollection * 0 8576 27 ParametricCurveCollection * 27 ParametricCurveCollection * 0 0 514 0 0 0 0 0 0 0 0 0 0

549 11 PandaNode * 0 8576 11 PandaNode * 11 PandaNode * 0 0 512 0 0 0 0 0 0 0 0 0 0

550 33 ParametricCurveCollection const * 0 8576 33 ParametricCurveCollection const * 33 ParametricCurveCollection const * 0 0 551 0 0 0 0 0 0 0 0 0 0

551 31 ParametricCurveCollection const 0 8832 31 ParametricCurveCollection const 31 ParametricCurveCollection const 0 0 514 0 0 0 0 0 0 0 0 0 0

552 11 LMatrix4f * 0 8576 11 LMatrix4f * 11 LMatrix4f * 0 0 553 0 0 0 0 0 0 0 0 0 0

553 9 LMatrix4f 0 2048 9 LMatrix4f 9 LMatrix4f 0 0 0 0 0 0 0 3 621 622 623 0 0 0 0 215
////////////////////////////////////////////////////////////////////
//       Class : LMatrix4
// Description : This is a 4-by-4 transform matrix.
////////////////////////////////////////////////////////////////////

554 18 LVecBase3f const * 0 8576 18 LVecBase3f const * 18 LVecBase3f const * 0 0 555 0 0 0 0 0 0 0 0 0 0

555 16 LVecBase3f const 0 8832 16 LVecBase3f const 16 LVecBase3f const 0 0 538 0 0 0 0 0 0 0 0 0 0

556 13 CurveFitter * 0 8576 13 CurveFitter * 13 CurveFitter * 0 0 516 0 0 0 0 0 0 0 0 0 0

557 19 CurveFitter const * 0 8576 19 CurveFitter const * 19 CurveFitter const * 0 0 558 0 0 0 0 0 0 0 0 0 0

558 17 CurveFitter const 0 8832 17 CurveFitter const 17 CurveFitter const 0 0 516 0 0 0 0 0 0 0 0 0 0

559 16 PiecewiseCurve * 0 8576 16 PiecewiseCurve * 16 PiecewiseCurve * 0 0 517 0 0 0 0 0 0 0 0 0 0

560 14 HermiteCurve * 0 8576 14 HermiteCurve * 14 HermiteCurve * 0 0 518 0 0 0 0 0 0 0 0 0 0

561 20 HermiteCurve const * 0 8576 20 HermiteCurve const * 20 HermiteCurve const * 0 0 562 0 0 0 0 0 0 0 0 0 0

562 18 HermiteCurve const 0 8832 18 HermiteCurve const 18 HermiteCurve const 0 0 518 0 0 0 0 0 0 0 0 0 0

563 13 atomic string 0 2 13 atomic string 13 atomic string 0 7 0 0 0 0 0 0 0 0 0 0 0

564 21 NurbsCurveInterface * 0 8576 21 NurbsCurveInterface * 21 NurbsCurveInterface * 0 0 519 0 0 0 0 0 0 0 0 0 0

565 27 NurbsCurveInterface const * 0 8576 27 NurbsCurveInterface const * 27 NurbsCurveInterface const * 0 0 566 0 0 0 0 0 0 0 0 0 0

566 25 NurbsCurveInterface const 0 8832 25 NurbsCurveInterface const 25 NurbsCurveInterface const 0 0 519 0 0 0 0 0 0 0 0 0 0

567 18 LVecBase4f const * 0 8576 18 LVecBase4f const * 18 LVecBase4f const * 0 0 568 0 0 0 0 0 0 0 0 0 0

568 16 LVecBase4f const 0 8832 16 LVecBase4f const 16 LVecBase4f const 0 0 569 0 0 0 0 0 0 0 0 0 0

569 10 LVecBase4f 0 2048 10 LVecBase4f 10 LVecBase4f 0 0 0 0 0 0 0 0 0 0 0 0 265
////////////////////////////////////////////////////////////////////
//       Class : LVecBase4
// Description : This is the base class for all three-component
//               vectors and points.
////////////////////////////////////////////////////////////////////

570 12 LVecBase4f * 0 8576 12 LVecBase4f * 12 LVecBase4f * 0 0 569 0 0 0 0 0 0 0 0 0 0

571 12 NurbsCurve * 0 8576 12 NurbsCurve * 12 NurbsCurve * 0 0 520 0 0 0 0 0 0 0 0 0 0

572 24 NurbsCurveResult const * 0 8576 24 NurbsCurveResult const * 24 NurbsCurveResult const * 0 0 573 0 0 0 0 0 0 0 0 0 0

573 22 NurbsCurveResult const 0 8832 22 NurbsCurveResult const 22 NurbsCurveResult const 0 0 521 0 0 0 0 0 0 0 0 0 0

574 18 NurbsCurveResult * 0 8576 18 NurbsCurveResult * 18 NurbsCurveResult * 0 0 521 0 0 0 0 0 0 0 0 0 0

575 16 LPoint3f const * 0 8576 16 LPoint3f const * 16 LPoint3f const * 0 0 576 0 0 0 0 0 0 0 0 0 0

576 14 LPoint3f const 0 8832 14 LPoint3f const 14 LPoint3f const 0 0 577 0 0 0 0 0 0 0 0 0 0

577 8 LPoint3f 0 2048 8 LPoint3f 8 LPoint3f 0 0 0 0 0 0 0 0 0 0 0 0 1083
// Filename: lpoint3_src.h
// Created by:  drose (25Sep99)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//       Class : LPoint3
// Description : This is a three-component point in space (as opposed
//               to a three-component vector, which represents a
//               direction and a distance).  Some of the methods are
//               slightly different between LPoint3 and LVector3; in
//               particular, subtraction of two points yields a
//               vector, while addition of a vector and a point yields
//               a point.
////////////////////////////////////////////////////////////////////

578 21 NurbsCurveEvaluator * 0 8576 21 NurbsCurveEvaluator * 21 NurbsCurveEvaluator * 0 0 522 0 0 0 0 0 0 0 0 0 0

579 27 NurbsCurveEvaluator const * 0 8576 27 NurbsCurveEvaluator const * 27 NurbsCurveEvaluator const * 0 0 580 0 0 0 0 0 0 0 0 0 0

580 25 NurbsCurveEvaluator const 0 8832 25 NurbsCurveEvaluator const 25 NurbsCurveEvaluator const 0 0 522 0 0 0 0 0 0 0 0 0 0

581 16 NodePath const * 0 8576 16 NodePath const * 16 NodePath const * 0 0 582 0 0 0 0 0 0 0 0 0 0

582 14 NodePath const 0 8832 14 NodePath const 14 NodePath const 0 0 583 0 0 0 0 0 0 0 0 0 0

583 8 NodePath 0 2048 8 NodePath 8 NodePath 0 0 0 0 0 0 0 2 624 625 0 0 0 0 4938
//
// A NodePath is the fundamental unit of high-level interaction with
// the scene graph.  It encapsulates the complete path down to a node
// from some other node, usually the root of the scene graph.  This is
// used to resolve ambiguities associated with instancing.
//
// NodePath also contains a number of handy high-level methods for
// common scene-graph manipulations, such as reparenting, and common
// state changes, such as repositioning.
//
// There are also a number of NodePath methods for finding nodes deep
// within the tree by name or by type.  These take a path string,
// which at its simplest consists of a series of node names separated
// by slashes, like a directory pathname.
//
// Each component of the path string may optionally consist of one of
// the following special names, instead of a node name:
//
//   *          -- matches exactly one node, with any name.
//   **         -- matches any sequence of zero or more nodes.
//   +typename  -- matches any node that is or derives from the given type.
//   -typename  -- matches any node that is the given type exactly.
//   =tag       -- matches any node that has the indicated tag.
//   =tag=value -- matches any node whose tag matches the indicated value.
//
// Furthermore, a node name may itself contain standard filename
// globbing characters, like *, ?, and [a-z], that will be accepted as
// a partial match.  (In fact, the '*' special name may be seen as
// just a special case of this.)  The globbing characters may not be
// used with the typename matches or with tag matches, but they may
// be used to match a tag's value in the =tag=value syntax.
//
// The special characters "@@", appearing at the beginning of a node
// name, indicate a stashed node.  Normally, stashed nodes are not
// returned by a find (but see the special flags, below), but a
// stashed node may be found if it is explicitly named with its
// leading @@ characters.  By extension, "@@*" may be used to identify
// any stashed node.
//
// Examples:
//
// "room//graph" will look for a node named "graph", which is a child
// of an unnamed node, which is a child of a node named "room", which
// is a child of the starting path.
//
// "**/red*" will look for any node anywhere in the tree (below the
// starting path) with a name that begins with "red".
//
// "**/+PartBundleNode/**/head" will look for a node named "head",
// somewhere below a PartBundleNode anywhere in the tree.
//
//
// The search is always potentially ambiguous, even if the special
// wildcard operators are not used, because there may be multiple
// nodes in the tree with the same name.  In general, in the case of
// an ambiguity, the shortest path is preferred; when a method (such
// as extend_by) must choose only only one of several possible paths,
// it will choose the shortest available; on the other hand, when a
// method (such as find_all_matches) is to return all of the matching
// paths, it will sort them so that the shortest paths appear first in
// the output.
//
//
// Special flags.  The entire string may optionally be followed by the
// ";" character, followed by one or more of the following special
// control flags, with no intervening spaces or punctuation:
//
//    -h    Do not return hidden nodes.
//    +h    Do return hidden nodes.
//    -s    Do not return stashed nodes unless explicitly referenced with @@.
//    +s    Return stashed nodes even without any explicit @@ characters.
//    -i    Node name comparisons are not case insensitive: case must match
//          exactly.
//    +i    Node name comparisons are case insensitive: case is not important.
//          This affects matches against the node name only; node type
//          and tag strings are always case sensitive.
//
// The default flags are +h-s-i.
//
////////////////////////////////////////////////////////////////////
//       Class : NodePath
// Description : NodePath is the fundamental system for disambiguating
//               instances, and also provides a higher-level interface
//               for manipulating the scene graph.
//
//               A NodePath is a list of connected nodes from the root
//               of the graph to any sub-node.  Each NodePath
//               therefore uniquely describes one instance of a node.
//
//               NodePaths themselves are lightweight objects that may
//               easily be copied and passed by value.  Their data is
//               stored as a series of NodePathComponents that are
//               stored on the nodes.  Holding a NodePath will keep a
//               reference count to all the nodes in the path.
//               However, if any node in the path is removed or
//               reparented (perhaps through a different NodePath),
//               the NodePath will automatically be updated to reflect
//               the changes.
////////////////////////////////////////////////////////////////////

584 10 NodePath * 0 8576 10 NodePath * 10 NodePath * 0 0 583 0 0 0 0 0 0 0 0 0 0

585 17 LMatrix4f const * 0 8576 17 LMatrix4f const * 17 LMatrix4f const * 0 0 586 0 0 0 0 0 0 0 0 0 0

586 15 LMatrix4f const 0 8832 15 LMatrix4f const 15 LMatrix4f const 0 0 553 0 0 0 0 0 0 0 0 0 0

587 26 NurbsSurfaceResult const * 0 8576 26 NurbsSurfaceResult const * 26 NurbsSurfaceResult const * 0 0 588 0 0 0 0 0 0 0 0 0 0

588 24 NurbsSurfaceResult const 0 8832 24 NurbsSurfaceResult const 24 NurbsSurfaceResult const 0 0 523 0 0 0 0 0 0 0 0 0 0

589 20 NurbsSurfaceResult * 0 8576 20 NurbsSurfaceResult * 20 NurbsSurfaceResult * 0 0 523 0 0 0 0 0 0 0 0 0 0

590 23 NurbsSurfaceEvaluator * 0 8576 23 NurbsSurfaceEvaluator * 23 NurbsSurfaceEvaluator * 0 0 524 0 0 0 0 0 0 0 0 0 0

591 29 NurbsSurfaceEvaluator const * 0 8576 29 NurbsSurfaceEvaluator const * 29 NurbsSurfaceEvaluator const * 0 0 592 0 0 0 0 0 0 0 0 0 0

592 27 NurbsSurfaceEvaluator const 0 8832 27 NurbsSurfaceEvaluator const 27 NurbsSurfaceEvaluator const 0 0 524 0 0 0 0 0 0 0 0 0 0

593 10 RopeNode * 0 8576 10 RopeNode * 10 RopeNode * 0 0 525 0 0 0 0 0 0 0 0 0 0

594 16 RopeNode const * 0 8576 16 RopeNode const * 16 RopeNode const * 0 0 595 0 0 0 0 0 0 0 0 0 0

595 14 RopeNode const 0 8832 14 RopeNode const 14 RopeNode const 0 0 525 0 0 0 0 0 0 0 0 0 0

596 17 LVector3f const * 0 8576 17 LVector3f const * 17 LVector3f const * 0 0 597 0 0 0 0 0 0 0 0 0 0

597 15 LVector3f const 0 8832 15 LVector3f const 15 LVector3f const 0 0 598 0 0 0 0 0 0 0 0 0 0

598 9 LVector3f 0 2048 9 LVector3f 9 LVector3f 0 0 0 0 0 0 0 0 0 0 0 0 1086
// Filename: lvector3_src.h
// Created by:  drose (24Sep99)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//       Class : LVector3
// Description : This is a three-component vector distance (as opposed
//               to a three-component point, which represents a
//               particular point in space).  Some of the methods are
//               slightly different between LPoint3 and LVector3; in
//               particular, subtraction of two points yields a
//               vector, while addition of a vector and a point yields
//               a point.
////////////////////////////////////////////////////////////////////

599 11 SheetNode * 0 8576 11 SheetNode * 11 SheetNode * 0 0 529 0 0 0 0 0 0 0 0 0 0

600 17 SheetNode const * 0 8576 17 SheetNode const * 17 SheetNode const * 0 0 601 0 0 0 0 0 0 0 0 0 0

601 15 SheetNode const 0 8832 15 SheetNode const 15 SheetNode const 0 0 529 0 0 0 0 0 0 0 0 0 0

602 6 string 0 2048 20 basic_string< char > 20 basic_string< char > 0 0 0 0 0 0 0 0 0 0 0 0 0

8
603 6 HC_CUT 0 5 1 530 0 1 1 
604 7 HC_FREE 0 5 2 530 0 1 2 
605 5 HC_G1 0 5 3 530 0 1 3 
606 9 HC_SMOOTH 0 5 4 530 0 1 4 
607 7 PCT_HPR 0 5 2 530 0 1 2 
608 8 PCT_NONE 0 5 0 530 0 1 0 
609 5 PCT_T 0 5 3 530 0 1 3 
610 7 PCT_XYZ 0 5 1 530 0 1 1 
0
15
611 0 0 24 10 get_curves 14 get_num_curves 9 get_curve 
612 0 0 24 19 get_timewarp_curves 17 get_num_timewarps 18 get_timewarp_curve 
613 0 0 102 7 get_cvs 11 get_num_cvs 6 get_cv 
614 0 0 102 9 get_knots 13 get_num_knots 8 get_knot 
615 0 0 130 13 get_sample_ts 15 get_num_samples 12 get_sample_t 
616 0 0 130 17 get_sample_points 15 get_num_samples 17 get_sample_points 
617 0 0 147 12 get_vertices 16 get_num_vertices 10 get_vertex 
618 0 0 147 9 get_knots 13 get_num_knots 8 get_knot 
619 0 0 184 11 get_u_knots 15 get_num_u_knots 10 get_u_knot 
620 0 0 184 11 get_v_knots 15 get_num_v_knots 10 get_v_knot 
621 0 0 338 8 get_rows 4 size 7 get_row 
622 0 0 338 8 get_cols 4 size 7 get_col 
623 0 0 338 9 get_row3s 4 size 8 get_row3 
624 0 0 494 9 get_nodes 13 get_num_nodes 8 get_node 
625 0 0 494 13 get_ancestors 13 get_num_nodes 12 get_ancestor 
