Panda3D

hermiteCurve.cxx
Go to the documentation of this file.
1 /**
2 * PANDA 3D SOFTWARE
3 * Copyright (c) Carnegie Mellon University. All rights reserved.
4 *
5 * All use of this software is subject to the terms of the revised BSD
6 * license. You should have received a copy of this license along
7 * with this source code in a file named "LICENSE."
8 *
9 * @file hermiteCurve.cxx
10 * @author drose
11 * @date 1998-02-27
12 */
13
14 #include "pandabase.h"
15 #include "hermiteCurve.h"
16 #include "config_parametrics.h"
17 #include "luse.h"
18
19 #include "indent.h"
20 #include "datagram.h"
21 #include "datagramIterator.h"
22 #include "bamWriter.h"
23 #include "bamReader.h"
24
25 #include <math.h>
26
27 using std::ostream;
28 using std::string;
29
30 TypeHandle HermiteCurve::_type_handle;
31
32 static const LVecBase3 zerovec_3 = LVecBase3(0.0f, 0.0f, 0.0f);
33 // This is returned occasionally from some of the functions, and is used from
34 // time to time as an initializer.
35
36
37 /**
38 * This function writes a LVecBase3, with a specified number of significant
39 * dimensions.
40 */
41 static ostream &
42 show_vec3(ostream &out, int indent_level, const LVecBase3 &v,
43 int num_dimensions) {
44 indent(out, indent_level) << v[0];
45 for (int i = 1; i<num_dimensions; i++) {
46 out << " " << v[i];
47 }
48 return out;
49 }
50
51 /**
52 *
53 */
54 HermiteCurveCV::
55 HermiteCurveCV() {
56 }
57
58
59 /**
60 *
61 */
62 HermiteCurveCV::
63 HermiteCurveCV(const HermiteCurveCV &c) :
64 _p(c._p), _in(c._in), _out(c._out),
65 _type(c._type), _name(c._name)
66 {
67 }
68
69
70 /**
71 *
72 */
73 HermiteCurveCV::
74 ~HermiteCurveCV() {
75 }
76
77
78
79 /**
80 * Sets the CV's in tangent.
81 */
82 void HermiteCurveCV::
83 set_in(const LVecBase3 &in) {
84 _in = in;
85 /*
86 PN_stdfloat l;
87 switch (_type) {
88 case HC_G1:
89 l = _in.length();
90 if (l!=0.0f) {
91 _out = _in * _out.length() / l;
92 }
93 break;
94
95 case HC_SMOOTH:
96 _out = _in;
97 break;
98 }
99 */
100 }
101
102
103 /**
104 * Sets the CV's out tangent.
105 */
106 void HermiteCurveCV::
107 set_out(const LVecBase3 &out) {
108 _out = out;
109 /*
110 PN_stdfloat l;
111 switch (_type) {
112 case HC_G1:
113 l = _out.length();
114 if (l!=0.0f) {
115 _in = _out * _in.length() / l;
116 }
117 break;
118
119 case HC_SMOOTH:
120 _in = _out;
121 break;
122 }
123 */
124 }
125
126
127 /**
128 * Sets the continuity type of the CV. Values may be HC_CUT, indicating a
129 * discontinous break in the curve, HC_FREE, for unconstrained in and out
130 * tangents, HC_G1, for in and out tangents constrained to be collinear, and
131 * HC_SMOOTH, for in and out tangents constrained to be equal. Other than
132 * HC_CUT, these are for documentation only; setting this has no direct effect
133 * on the tangents.
134 */
135 void HermiteCurveCV::
136 set_type(int type) {
137 _type = type;
138 /*
139 switch (_type) {
140 case HC_G1:
141 _out = _out.length() * _in;
142 break;
143
144 case HC_SMOOTH:
145 _out = _in;
146 break;
147 }
148 */
149 }
150
151
152
153 /**
154 * Sets the name associated with the CV.
155 */
156 void HermiteCurveCV::
157 set_name(const string &name) {
158 _name = name;
159 }
160
161
162 /**
163 * Formats the CV for output to an egg file.
164 */
165 void HermiteCurveCV::
166 format_egg(ostream &out, int indent_level, int num_dimensions,
167 bool show_in, bool show_out,
168 PN_stdfloat scale_in, PN_stdfloat scale_out) const {
169 if (show_in) {
170 indent(out, indent_level) << "<Vertex> {\n";
171 show_vec3(out, indent_level + 2, _p - scale_in * _in / 3.0,
172 num_dimensions) << "\n";
173 indent(out, indent_level) << "}\n";
174 }
175
176 indent(out, indent_level) << "<Vertex> {\n";
177 show_vec3(out, indent_level + 2, _p, num_dimensions) << "\n";
178
179 indent(out, indent_level+2) << "<Scalar> continuity-type { ";
180 switch (_type) {
181 case HC_CUT:
182 out << "Cut";
183 break;
184
185 case HC_FREE:
186 out << "Free";
187 break;
188
189 case HC_G1:
190 out << "G1";
191 break;
192
193 case HC_SMOOTH:
194 out << "Smooth";
195 break;
196 };
197 out << " }\n";
198
199 indent(out, indent_level) << "}\n";
200
201 if (show_out) {
202 indent(out, indent_level) << "<Vertex> {\n";
203 show_vec3(out, indent_level + 2, _p + scale_out * _out / 3.0,
204 num_dimensions) << "\n";
205 indent(out, indent_level) << "}\n";
206 }
207 }
208
209 /**
210 * Function to write the important information in the particular object to a
211 * Datagram
212 */
213 void HermiteCurveCV::
214 write_datagram(BamWriter *, Datagram &me) const {
215 _p.write_datagram(me);
216 _in.write_datagram(me);
217 _out.write_datagram(me);
218 me.add_int8(_type);
219 me.add_string(_name);
220 }
221
222 /**
223 * Function that reads out of the datagram (or asks manager to read) all of
224 * the data that is needed to re-create this object and stores it in the
225 * appropiate place
226 */
227 void HermiteCurveCV::
228 fillin(DatagramIterator &scan, BamReader *) {
229 _p.read_datagram(scan);
230 _in.read_datagram(scan);
231 _out.read_datagram(scan);
232
233 _type = scan.get_int8();
234 _name = scan.get_string();
235 }
236
237 /**
238 *
239 */
240 HermiteCurve::
241 HermiteCurve() {
242 }
243
244 /**
245 * Constructs a Hermite from the indicated (possibly non-hermite) curve.
246 */
247 HermiteCurve::
248 HermiteCurve(const ParametricCurve &nc) {
249 if (!nc.convert_to_hermite(this)) {
250 parametrics_cat->warning()
251 << "Cannot make a Hermite from the indicated curve."
252 << std::endl;
253 }
254 }
255
256
257 /**
258 *
259 */
260 HermiteCurve::
261 ~HermiteCurve() {
262 }
263
264
265
266
267
268
269 /**
270 * Returns the number of CV's in the curve.
271 */
272 int HermiteCurve::
273 get_num_cvs() const {
274 return _points.size();
275 }
276
277
278 /**
279 * Inserts a new CV at the given parametric point along the curve. If this
280 * parametric point is already on the curve, the CV is assigned an index
281 * between its two neighbors and the indices of all following CV's are
282 * incremented by 1; its in and out tangents are chosen to keep the curve
283 * consistent. If the new parametric point is beyond the end of the existing
284 * curve, the curve is extended to meet it and the new CV's position, in
285 * tangent, and out tangent are set to zero.
286 *
287 * The index number of the new CV is returned.
288 */
289 int HermiteCurve::
290 insert_cv(PN_stdfloat t) {
291 if (!is_valid() || t >= get_max_t()) {
292 int n = append_cv(HC_SMOOTH, 0.0f, 0.0f, 0.0f);
293 set_cv_tstart(n, t);
294 return n;
295 }
296
297 t = std::min(std::max(t, (PN_stdfloat)0.0), get_max_t());
298
299 int n = find_cv(t);
300 nassertr(n+1<get_num_cvs(), 0);
301
302 HermiteCurveCV cv;
303 LVecBase3 tan;
304 cv._type = HC_SMOOTH;
305 get_pt(t, cv._p, tan);
306 cv._out = cv._in = tan * 0.5f;
307
308 _points.insert(_points.begin() + n + 1, cv);
309 bool result =
310 insert_curveseg(n, new CubicCurveseg, t - get_cv_tstart(n));
311 nassertr(result, 0);
312
313 recompute_basis();
314 invalidate_all();
315
316 return n + 1;
317 }
318
319
320 /**
321 * Adds a new CV to the end of the curve. The new CV is given initial in/out
322 * tangents of 0. The return value is the index of the new CV.
323 */
324 int HermiteCurve::
325 append_cv(int type, PN_stdfloat x, PN_stdfloat y, PN_stdfloat z) {
326 HermiteCurveCV cv;
327 cv.set_type(type);
328 cv.set_point(LVecBase3(x, y, z));
329 cv.set_in(zerovec_3);
330 cv.set_out(zerovec_3);
331 _points.push_back(cv);
332 if (_points.size()>1) {
333 bool result =
334 insert_curveseg(_segs.size(), new CubicCurveseg, 1.0f);
335 nassertr(result, 0);
336 }
337
338 recompute_basis();
339 invalidate_all();
340
341 return _points.size()-1;
342 }
343
344
345 /**
346 * Removes the given CV from the curve. Returns true if the CV existed, false
347 * otherwise.
348 */
349 bool HermiteCurve::
350 remove_cv(int n) {
351 if (n < 0 || n >= (int)_points.size()) {
352 return false;
353 }
354
355 _points.erase(_points.begin() + n);
356 if (_segs.size()>0) {
357 remove_curveseg(_segs.size()-1);
358 }
359
360 recompute_basis();
361 invalidate_all();
362 return true;
363 }
364
365
366 /**
367 * Removes all CV's from the curve.
368 */
369 void HermiteCurve::
370 remove_all_cvs() {
371 _points.erase(_points.begin(), _points.end());
372 remove_all_curvesegs();
373
374 invalidate_all();
375 }
376
377
378
379
380 /**
381 * Changes the given CV's continuity type. Legal values are HC_CUT, HC_FREE,
382 * HC_G1, or HC_SMOOTH.
383 *
384 * Other than HC_CUT, these have no effect on the actual curve; it remains up
385 * to user software to impose the constraints these imply.
386 *
387 * HC_CUT implies a disconnection of the curve; HC_FREE imposes no constraints
388 * on the tangents; HC_G1 forces the tangents to be collinear, and HC_SMOOTH
389 * forces the tangents to be identical. Setting type type to HC_G1 or
390 * HC_SMOOTH may adjust the out tangent to match the in tangent.
391 */
392 bool HermiteCurve::
393 set_cv_type(int n, int type) {
394 if (n < 0 || n >= (int)_points.size()) {
395 return false;
396 }
397
398 bool changed_cut = false;
399
400 if (type!=_points[n]._type) {
401 changed_cut = (type==HC_CUT || _points[n]._type==HC_CUT);
402 _points[n].set_type(type);
403 }
404
405 invalidate_cv(n, changed_cut);
406 return true;
407 }
408
409
410 /**
411 * Changes the given CV's position.
412 */
413 bool HermiteCurve::
414 set_cv_point(int n, PN_stdfloat x, PN_stdfloat y, PN_stdfloat z) {
415 if (n < 0 || n >= (int)_points.size()) {
416 return false;
417 }
418 _points[n].set_point(LVecBase3(x, y, z));
419 invalidate_cv(n, false);
420 return true;
421 }
422
423 /**
424 * Changes the given CV's in tangent. Depending on the continuity type, this
425 * may also adjust the out tangent.
426 */
427 bool HermiteCurve::
428 set_cv_in(int n, PN_stdfloat x, PN_stdfloat y, PN_stdfloat z) {
429 if (n < 0 || n >= (int)_points.size()) {
430 return false;
431 }
432 _points[n].set_in(LVecBase3(x, y, z));
433 invalidate_cv(n, false);
434 return true;
435 }
436
437 /**
438 * Changes the given CV's out tangent. Depending on the continuity type, this
439 * may also adjust the in tangent.
440 */
441 bool HermiteCurve::
442 set_cv_out(int n, PN_stdfloat x, PN_stdfloat y, PN_stdfloat z) {
443 if (n < 0 || n >= (int)_points.size()) {
444 return false;
445 }
446 _points[n].set_out(LVecBase3(x, y, z));
447 invalidate_cv(n, false);
448 return true;
449 }
450
451 /**
452 * Changes the given CV's parametric starting time. This may affect the shape
453 * of the curve.
454 */
455 bool HermiteCurve::
456 set_cv_tstart(int n, PN_stdfloat tstart) {
457 if (n <= 0 || n >= (int)_points.size()) {
458 return false;
459 }
460 if (fabs(tstart - get_cv_tstart(n)) > 0.0001f) {
461 set_tlength(n-1, tstart - get_tstart(n-1));
462 recompute_basis();
463 invalidate_all();
464 }
465 return true;
466 }
467
468
469 /**
470 * Changes the name associated with a particular CV.
471 */
472 bool HermiteCurve::
473 set_cv_name(int n, const char *name) {
474 if (n < 0 || n >= (int)_points.size()) {
475 return false;
476 }
477 _points[n].set_name(name);
478 return true;
479 }
480
481
482
483 /**
484 * Returns the given CV's continuity type, HC_CUT, HC_FREE, HC_G1, or
485 * HC_SMOOTH, or 0 if there is no such CV.
486 */
487 int HermiteCurve::
488 get_cv_type(int n) const {
489 if (n < 0 || n >= (int)_points.size()) {
490 return 0;
491 }
492
493 return _points[n]._type;
494 }
495
496
497 /**
498 * Returns the position of the given CV.
499 */
500 const LVecBase3 &HermiteCurve::
501 get_cv_point(int n) const {
502 if (n < 0 || n >= (int)_points.size()) {
503 return zerovec_3;
504 }
505
506 return _points[n]._p;
507 }
508 void HermiteCurve::
509 get_cv_point(int n, LVecBase3 &v) const {
510 v = get_cv_point(n);
511 }
512
513
514 /**
515 * Returns the in tangent of the given CV.
516 */
517 const LVecBase3 &HermiteCurve::
518 get_cv_in(int n) const {
519 if (n < 0 || n >= (int)_points.size() || _points[n-1]._type==HC_CUT) {
520 return zerovec_3;
521 }
522
523 return _points[n]._in;
524 }
525 void HermiteCurve::
526 get_cv_in(int n, LVecBase3 &v) const {
527 v = get_cv_in(n);
528 }
529
530
531 /**
532 * Returns the out tangent of the given CV.
533 */
534 const LVecBase3 &HermiteCurve::
535 get_cv_out(int n) const {
536 if (n < 0 || n >= (int)_points.size() || _points[n]._type==HC_CUT) {
537 return zerovec_3;
538 }
539
540 return _points[n]._out;
541 }
542 void HermiteCurve::
543 get_cv_out(int n, LVecBase3 &v) const {
544 v = get_cv_out(n);
545 }
546
547
548 /**
549 * Returns the starting point in parametric space of the given CV.
550 */
551 PN_stdfloat HermiteCurve::
552 get_cv_tstart(int n) const {
553 if (n<0) {
554 return 0.0f;
555 } else if (n >= (int)_points.size()) {
556 return get_max_t();
557 }
558
559 return get_tstart(n);
560 }
561
562 /**
563 * Returns the name of the given CV, or NULL.
564 */
565 string HermiteCurve::
566 get_cv_name(int n) const {
567 if (n < 0 || n >= (int)_points.size()) {
568 return string();
569 }
570
571 return _points[n]._name;
572 }
573
574
575 /**
576 *
577 */
578 void HermiteCurve::
579 output(ostream &out) const {
580 PiecewiseCurve::output(out);
581
582 out << " (";
583 switch (get_curve_type()) {
584 case PCT_T:
585 out << "in T, ";
586 break;
587
588 case PCT_XYZ:
589 out << "in XYZ, ";
590 break;
591
592 case PCT_HPR:
593 out << "in HPR, ";
594 break;
595
596 default:
597 break;
598 }
599
600 out << get_num_cvs() << " CV's)";
601 }
602
603 /**
604 *
605 */
606 void HermiteCurve::
607 write_cv(ostream &out, int n) const {
608 out << "CV";
609 if (!get_cv_name(n).empty()) {
610 out << " " << get_cv_name(n);
611 }
612
613 out << " at t = " << get_cv_tstart(n)
614 << "\npoint = " << get_cv_point(n)
615 << "\nin = " << get_cv_in(n) << " out = " << get_cv_out(n)
616 << "\ncontinuity type = ";
617
618 switch (get_cv_type(n)) {
619 case HC_CUT:
620 out << "Cut";
621 break;
622
623 case HC_FREE:
624 out << "Free";
625 break;
626
627 case HC_G1:
628 out << "G1";
629 break;
630
631 case HC_SMOOTH:
632 out << "Smooth";
633 break;
634
635 default:
636 break;
637 }
638
639 out << "\n";
640 }
641
642
643 /**
644 * Rebuilds the current curve segment (as selected by the most recent call to
645 * find_curve()) according to the specified properties (see
646 * CubicCurveseg::compute_seg). Returns true if possible, false if something
647 * goes horribly wrong.
648 */
649 bool HermiteCurve::
650 rebuild_curveseg(int, PN_stdfloat, const LVecBase4 &,
651 int, PN_stdfloat, const LVecBase4 &,
652 int, PN_stdfloat, const LVecBase4 &,
653 int, PN_stdfloat, const LVecBase4 &) {
654 std::cerr << "rebuild_curveseg not implemented for this curve type.\n";
655 return false;
656 }
657
658 /**
659 * Formats the Hermite curve for output to an Egg file.
660 */
661 bool HermiteCurve::
662 format_egg(ostream &out, const string &name, const string &curve_type,
663 int indent_level) const {
664 indent(out, indent_level)
665 << "<VertexPool> " << name << ".pool {\n";
666
667 int i;
668 for (i = 0; i < (int)_points.size(); i++) {
669 bool show_in = (i != 0);
670 bool show_out = (i != (int)_points.size()-1);
671 _points[i].format_egg(out, indent_level + 2, _num_dimensions,
672 show_in, show_out,
673 show_in ? get_tlength(i-1) : 0.0f,
674 show_out ? get_tlength(i) : 0.0f);
675 }
676 indent(out, indent_level) << "}\n";
677
678 indent(out, indent_level) << "<BezierCurve> " << name << " {\n";
679
680 if (!curve_type.empty()) {
681 indent(out, indent_level+2)
682 << "<Scalar> type { " << curve_type << " }\n";
683 }
684
685 indent(out, indent_level+2) << "<TLengths> {";
686 if (_points.size() > 1) {
687 for (i = 0; i < (int)_segs.size(); i++) {
688 if (i%10 == 1) {
689 out << "\n";
690 indent(out, indent_level+3);
691 }
692 out << " " << get_tlength(i);
693 }
694 }
695 out << "\n";
696 indent(out, indent_level+2) << "}\n";
697
698 indent(out, indent_level+2) << "<VertexRef> {";
699 for (i = 1; i <= (int)_points.size() * 3 - 2; i++) {
700 if (i%10 == 1) {
701 out << "\n";
702 indent(out, indent_level+3);
703 }
704 out << " " << i;
705 }
706 out << "\n";
707 indent(out, indent_level+4) << "<Ref> { " << name << ".pool }\n";
708 indent(out, indent_level+2) << "}\n";
709
710 indent(out, indent_level) << "}\n";
711
712 return true;
713 }
714
715
716 static void
717 wrap_hpr(const LVecBase3 &hpr1, LVecBase3 &hpr2) {
718 for (int i = 0; i < 3; i++) {
719 while ((hpr2[i] - hpr1[i]) > 180.0) {
720 hpr2[i] -= 360.0;
721 }
722
723 while ((hpr2[i] - hpr1[i]) < -180.0) {
724 hpr2[i] += 360.0;
725 }
726 }
727 }
728
729 /**
730 * Recomputes the CV and its neighbors appropriately after a change.
731 */
732 void HermiteCurve::
733 invalidate_cv(int n, bool redo_all) {
734 PN_stdfloat t1 = 0.0f, t2 = get_max_t();
735 if (n>0 && _points[n-1]._type!=HC_CUT) {
736 const HermiteCurveCV &p1 = _points[n-1];
737 HermiteCurveCV p2(_points[n]);
738 if (_curve_type == PCT_HPR) {
739 wrap_hpr(p1._p, p2._p);
740 }
741 get_curveseg(n-1)->hermite_basis(p1, p2, get_tlength(n-1));
742 t1 = get_cv_tstart(n-1);
743 }
744
745 if (n+1 < (int)_points.size()) {
746 if (_points[n]._type==HC_CUT) {
747 BezierSeg seg;
748 seg._v[0] = seg._v[1] = seg._v[2] = seg._v[3] = _points[n]._p;
749 get_curveseg(n)->bezier_basis(seg);
750 } else {
751 const HermiteCurveCV &p1 = _points[n];
752 HermiteCurveCV p2(_points[n+1]);
753 if (_curve_type == PCT_HPR) {
754 wrap_hpr(p1._p, p2._p);
755 }
756 get_curveseg(n)->hermite_basis(p1, p2, get_tlength(n));
757 t2 = get_cv_tstart(n+2);
758 }
759 }
760
761 if (is_valid()) {
762 if (redo_all) {
763 invalidate_all();
764 } else {
765 invalidate(t1, t2);
766 }
767 }
768 }
769
770
771
772 /**
773 * Finds the CV immediately preceding the given value of t.
774 */
775 int HermiteCurve::
776 find_cv(PN_stdfloat t) {
777 nassertr(is_valid(), 0);
778
779 int n;
780 for (n = 0; n < (int)_segs.size(); n++) {
781 if (_segs[n]._tend+0.00001 > t) {
782 break;
783 }
784 }
785
786 return n;
787 }
788
789
790 /**
791 * Recomputes the coefficients for all the CV's in the curve. This is
792 * intended to be called whenever the CV's have been changed in some drastic
793 * way, and it's safest just to recompute everything.
794 */
795 void HermiteCurve::
796 recompute_basis() {
797 int n;
798 for (n = 0; n < (int)_segs.size(); n++) {
799 if (_points[n]._type==HC_CUT) {
800 BezierSeg seg;
801 seg._v[0] = seg._v[1] = seg._v[2] = seg._v[3] = _points[n]._p;
802 get_curveseg(n)->bezier_basis(seg);
803 } else {
804 const HermiteCurveCV &p1 = _points[n];
805 HermiteCurveCV p2(_points[n+1]);
806 if (_curve_type == PCT_HPR) {
807 wrap_hpr(p1._p, p2._p);
808 }
809 get_curveseg(n)->hermite_basis(p1, p2, get_tlength(n));
810 }
811 }
812 }
813
814
815 /**
816 * Initializes the factory for reading these things from Bam files.
817 */
818 void HermiteCurve::
819 register_with_read_factory() {
820 BamReader::get_factory()->register_factory(get_class_type(), make_HermiteCurve);
821 }
822
823 /**
824 * Factory method to generate an object of this type.
825 */
826 TypedWritable *HermiteCurve::
827 make_HermiteCurve(const FactoryParams &params) {
828 HermiteCurve *me = new HermiteCurve;
829 DatagramIterator scan;
830 BamReader *manager;
831
832 parse_params(params, scan, manager);
833 me->fillin(scan, manager);
834 return me;
835 }
836
837 /**
838 * Function to write the important information in the particular object to a
839 * Datagram
840 */
841 void HermiteCurve::
842 write_datagram(BamWriter *manager, Datagram &me) {
843 PiecewiseCurve::write_datagram(manager, me);
844
845 me.add_uint32(_points.size());
846 size_t i;
847 for (i = 0; i < _points.size(); i++) {
848 _points[i].write_datagram(manager, me);
849 }
850 }
851
852 /**
853 * Function that reads out of the datagram (or asks manager to read) all of
854 * the data that is needed to re-create this object and stores it in the
855 * appropiate place
856 */
857 void HermiteCurve::
858 fillin(DatagramIterator &scan, BamReader *manager) {
859 PiecewiseCurve::fillin(scan, manager);
860
861 size_t num_points = scan.get_uint32();
862 _points.reserve(num_points);
863 size_t i;
864 for (i = 0; i < num_points; i++) {
865 HermiteCurveCV cv;
866 cv.fillin(scan, manager);
867 _points.push_back(cv);
868 }
869 }
bamReader.h
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
parse_params
void parse_params(const FactoryParams &params, DatagramIterator &scan, BamReader *&manager)
Takes in a FactoryParams, passed from a WritableFactory into any TypedWritable's make function,...
Definition: bamReader.I:275
bamWriter.h
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
BamReader
This is the fundamental interface for extracting binary objects from a Bam file, as generated by a Ba...
Definition: bamReader.h:110
BamReader::get_factory
static WritableFactory * get_factory()
Returns the global WritableFactory for generating TypedWritable objects.
Definition: bamReader.I:177
BamWriter
This is the fundamental interface for writing binary objects to a Bam file, to be extracted later by ...
Definition: bamWriter.h:63
CubicCurveseg
A CubicCurveseg is any curve that can be completely described by four 4-valued basis vectors,...
Definition: cubicCurveseg.h:50
CubicCurveseg::bezier_basis
void bezier_basis(const BezierSeg &seg)
Defines the curve segment as a Bezier.
Definition: cubicCurveseg.cxx:149
CubicCurveseg::hermite_basis
void hermite_basis(const HermiteCurveCV &cv0, const HermiteCurveCV &cv1, PN_stdfloat tlength=1.0f)
Defines the curve segment as a Hermite.
Definition: cubicCurveseg.cxx:121
DatagramIterator
A class to retrieve the individual data elements previously stored in a Datagram.
Definition: datagramIterator.h:27
DatagramIterator::get_uint32
uint32_t get_uint32()
Extracts an unsigned 32-bit integer.
Definition: datagramIterator.I:164
DatagramIterator::get_int8
int8_t get_int8()
Extracts a signed 8-bit integer.
Definition: datagramIterator.I:56
DatagramIterator::get_string
std::string get_string()
Extracts a variable-length string.
Definition: datagramIterator.cxx:26
Datagram
An ordered list of data elements, formatted in memory for transmission over a socket or writing to a ...
Definition: datagram.h:38
Datagram::add_uint32
void add_uint32(uint32_t value)
Adds an unsigned 32-bit integer to the datagram.
Definition: datagram.I:94
Datagram::add_string
void add_string(const std::string &str)
Adds a variable-length string to the datagram.
Definition: datagram.I:219
Datagram::add_int8
void add_int8(int8_t value)
Adds a signed 8-bit integer to the datagram.
Definition: datagram.I:42
FactoryParams
An instance of this class is passed to the Factory when requesting it to do its business and construc...
Definition: factoryParams.h:36
Factory::register_factory
void register_factory(TypeHandle handle, CreateFunc *func, void *user_data=nullptr)
Registers a new kind of thing the Factory will be able to create.
Definition: factory.I:73
HermiteCurveCV
A single CV of a Hermite curve.
Definition: hermiteCurve.h:50
HermiteCurveCV::write_datagram
void write_datagram(BamWriter *manager, Datagram &me) const
Function to write the important information in the particular object to a Datagram.
Definition: hermiteCurve.cxx:214
HermiteCurveCV::set_in
void set_in(const LVecBase3 &in)
Sets the CV's in tangent.
Definition: hermiteCurve.cxx:83
HermiteCurveCV::set_type
void set_type(int type)
Sets the continuity type of the CV.
Definition: hermiteCurve.cxx:136
HermiteCurveCV::format_egg
void format_egg(std::ostream &out, int indent, int num_dimensions, bool show_in, bool show_out, PN_stdfloat scale_in, PN_stdfloat scale_out) const
Formats the CV for output to an egg file.
Definition: hermiteCurve.cxx:166
HermiteCurveCV::fillin
void fillin(DatagramIterator &scan, BamReader *manager)
Function that reads out of the datagram (or asks manager to read) all of the data that is needed to r...
Definition: hermiteCurve.cxx:228
HermiteCurveCV::set_out
void set_out(const LVecBase3 &out)
Sets the CV's out tangent.
Definition: hermiteCurve.cxx:107
HermiteCurveCV::set_name
void set_name(const std::string &name)
Sets the name associated with the CV.
Definition: hermiteCurve.cxx:157
HermiteCurve
A parametric curve defined by a sequence of control vertices, each with an in and out tangent.
Definition: hermiteCurve.h:83
HermiteCurve::append_cv
int append_cv(int type, PN_stdfloat x, PN_stdfloat y, PN_stdfloat z)
Adds a new CV to the end of the curve.
Definition: hermiteCurve.cxx:325
HermiteCurve::get_cv_tstart
PN_stdfloat get_cv_tstart(int n) const
Returns the starting point in parametric space of the given CV.
Definition: hermiteCurve.cxx:552
HermiteCurve::set_cv_out
bool set_cv_out(int n, PN_stdfloat x, PN_stdfloat y, PN_stdfloat z)
Changes the given CV's out tangent.
Definition: hermiteCurve.cxx:442
HermiteCurve::set_cv_tstart
bool set_cv_tstart(int n, PN_stdfloat tstart)
Changes the given CV's parametric starting time.
Definition: hermiteCurve.cxx:456
HermiteCurve::get_cv_point
const LVecBase3 & get_cv_point(int n) const
Returns the position of the given CV.
Definition: hermiteCurve.cxx:501
HermiteCurve::set_cv_name
bool set_cv_name(int n, const char *name)
Changes the name associated with a particular CV.
Definition: hermiteCurve.cxx:473
HermiteCurve::insert_cv
int insert_cv(PN_stdfloat t)
Inserts a new CV at the given parametric point along the curve.
Definition: hermiteCurve.cxx:290
HermiteCurve::get_cv_out
const LVecBase3 & get_cv_out(int n) const
Returns the out tangent of the given CV.
Definition: hermiteCurve.cxx:535
HermiteCurve::set_cv_point
bool set_cv_point(int n, PN_stdfloat x, PN_stdfloat y, PN_stdfloat z)
Changes the given CV's position.
Definition: hermiteCurve.cxx:414
HermiteCurve::get_num_cvs
int get_num_cvs() const
Returns the number of CV's in the curve.
Definition: hermiteCurve.cxx:273
HermiteCurve::get_cv_name
std::string get_cv_name(int n) const
Returns the name of the given CV, or NULL.
Definition: hermiteCurve.cxx:566
HermiteCurve::set_cv_in
bool set_cv_in(int n, PN_stdfloat x, PN_stdfloat y, PN_stdfloat z)
Changes the given CV's in tangent.
Definition: hermiteCurve.cxx:428
HermiteCurve::get_cv_type
int get_cv_type(int n) const
Returns the given CV's continuity type, HC_CUT, HC_FREE, HC_G1, or HC_SMOOTH, or 0 if there is no suc...
Definition: hermiteCurve.cxx:488
HermiteCurve::remove_all_cvs
void remove_all_cvs()
Removes all CV's from the curve.
Definition: hermiteCurve.cxx:370
HermiteCurve::remove_cv
bool remove_cv(int n)
Removes the given CV from the curve.
Definition: hermiteCurve.cxx:350
HermiteCurve::register_with_read_factory
static void register_with_read_factory()
Initializes the factory for reading these things from Bam files.
Definition: hermiteCurve.cxx:819
HermiteCurve::set_cv_type
bool set_cv_type(int n, int type)
Changes the given CV's continuity type.
Definition: hermiteCurve.cxx:393
HermiteCurve::rebuild_curveseg
virtual bool rebuild_curveseg(int rtype0, PN_stdfloat t0, const LVecBase4 &v0, int rtype1, PN_stdfloat t1, const LVecBase4 &v1, int rtype2, PN_stdfloat t2, const LVecBase4 &v2, int rtype3, PN_stdfloat t3, const LVecBase4 &v3)
Rebuilds the current curve segment (as selected by the most recent call to find_curve()) according to...
Definition: hermiteCurve.cxx:650
HermiteCurve::get_cv_in
const LVecBase3 & get_cv_in(int n) const
Returns the in tangent of the given CV.
Definition: hermiteCurve.cxx:518
ParametricCurve
A virtual base class for parametric curves.
Definition: parametricCurve.h:56
ParametricCurve::get_curve_type
int get_curve_type() const
Returns the flag indicating the use to which the curve is intended to be put.
Definition: parametricCurve.cxx:128
ParametricCurve::convert_to_hermite
virtual bool convert_to_hermite(HermiteCurve *hc) const
Stores an equivalent curve representation in the indicated Hermite curve, if possible.
Definition: parametricCurve.cxx:429
PiecewiseCurve::remove_all_curvesegs
void remove_all_curvesegs()
Removes all curve segments from the curve.
Definition: piecewiseCurve.cxx:270
PiecewiseCurve::insert_curveseg
bool insert_curveseg(int ti, ParametricCurve *seg, PN_stdfloat tlength)
Inserts a new curve segment at the indicated index.
Definition: piecewiseCurve.cxx:222
PiecewiseCurve::is_valid
virtual bool is_valid() const
Returns true if the curve is defined.
Definition: piecewiseCurve.cxx:49
PiecewiseCurve::get_tlength
PN_stdfloat get_tlength(int ti) const
Returns the parametric length of the given segment of the curve.
Definition: piecewiseCurve.cxx:279
PiecewiseCurve::set_tlength
bool set_tlength(int ti, PN_stdfloat tlength)
Sets the parametric length of the given segment of the curve.
Definition: piecewiseCurve.cxx:309
PiecewiseCurve::get_max_t
virtual PN_stdfloat get_max_t() const
Returns the upper bound of t for the entire curve.
Definition: piecewiseCurve.cxx:58
PiecewiseCurve::remove_curveseg
bool remove_curveseg(int ti)
Removes the given curve segment from the curve and frees it.
Definition: piecewiseCurve.cxx:248
PiecewiseCurve::get_tstart
PN_stdfloat get_tstart(int ti) const
Returns the parametric start of the given segment of the curve.
Definition: piecewiseCurve.cxx:288
PiecewiseCurve::get_pt
virtual bool get_pt(PN_stdfloat t, LVecBase3 &point, LVecBase3 &tangent) const
Simultaneously returns the point and tangent of the curve at a given parametric point t.
Definition: piecewiseCurve.cxx:185
TypeHandle
TypeHandle is the identifier used to differentiate C++ class types.
Definition: typeHandle.h:81
TypedWritable
Base class for objects that can be written to and read from Bam files.
Definition: typedWritable.h:35
config_parametrics.h
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
datagramIterator.h
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
datagram.h
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
hermiteCurve.h
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
indent
std::ostream & indent(std::ostream &out, int indent_level)
A handy function for doing text formatting.
Definition: indent.cxx:20
indent.h
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
luse.h
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
pandabase.h
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.