?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
changed: gcc8 base update
[opensg.git] / Source / System / NodeCores / Drawables / Nurbs / OSGSurfaceBase.cpp
blob270b3704125c82b606e059af944c37e0e66ec04c
1 /*---------------------------------------------------------------------------*\
2 * OpenSG *
3 * *
4 * *
5 * Copyright (C) 2000-2013 by the OpenSG Forum *
6 * *
7 * www.opensg.org *
8 * *
9 * contact: dirk@opensg.org, gerrit.voss@vossg.org, carsten_neumann@gmx.net *
10 * *
11 \*---------------------------------------------------------------------------*/
12 /*---------------------------------------------------------------------------*\
13 * License *
14 * *
15 * This library is free software; you can redistribute it and/or modify it *
16 * under the terms of the GNU Library General Public License as published *
17 * by the Free Software Foundation, version 2. *
18 * *
19 * This library is distributed in the hope that it will be useful, but *
20 * WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
22 * Library General Public License for more details. *
23 * *
24 * You should have received a copy of the GNU Library General Public *
25 * License along with this library; if not, write to the Free Software *
26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
27 * *
28 \*---------------------------------------------------------------------------*/
29 /*---------------------------------------------------------------------------*\
30 * Changes *
31 * *
32 * *
33 * *
34 * *
35 * *
36 * *
37 \*---------------------------------------------------------------------------*/
38
39 /*****************************************************************************\
40 *****************************************************************************
41 ** **
42 ** This file is automatically generated. **
43 ** **
44 ** Any changes made to this file WILL be lost when it is **
45 ** regenerated, which can become necessary at any time. **
46 ** **
47 ** Do not change this file, changes should be done in the derived **
48 ** class Surface!
49 ** **
50 *****************************************************************************
51 \*****************************************************************************/
52
53 #include <cstdlib>
54 #include <cstdio>
55
56 #ifdef WIN32
57 #pragma warning(disable: 4355) // turn off 'this' : used in base member initializer list warning
58 #pragma warning(disable: 4290) // disable exception specification warning
59 #endif
60
61 #include "OSGConfig.h"
62
63
64
65 #include "OSGGeoVectorProperty.h" // ControlPoints Class
66
67 #include "OSGSurfaceBase.h"
68 #include "OSGSurface.h"
69
70 #include <boost/bind.hpp>
71
72 OSG_BEGIN_NAMESPACE
73
74 /***************************************************************************\
75 * Description *
76 \***************************************************************************/
77
78 /*! \class OSG::Surface
79 This is the OpenSG NURBS surface node. It supports an arbitrary number of
80 trimming curves. The interface lets you define both rational and nonrational
81 surfaces, and you can also vary rational and nonrational trimming curves.
82 */
83
84 /***************************************************************************\
85 * Field Documentation *
86 \***************************************************************************/
87
88 /*! \var UInt32 SurfaceBase::_sfDimU
89 The surface dimension in U
90 */
91
92 /*! \var UInt32 SurfaceBase::_sfDimV
93 The surface dimension in V
94 */
95
96 /*! \var Real32 SurfaceBase::_mfKnotsU
97 The surface knots in U direction
98 */
99
100 /*! \var Real32 SurfaceBase::_mfKnotsV
101 The surface knots in V direction
102 */
103
104 /*! \var GeoVectorProperty * SurfaceBase::_sfControlPoints
105 The control points for the surface
106 */
107
108 /*! \var Real32 SurfaceBase::_sfError
109 The approximation error for the tessellation
110 */
111
112 /*! \var UInt32 SurfaceBase::_sfNumCurves
113 The number of trimming curves
114 */
115
116 /*! \var UInt32 SurfaceBase::_mfKnotLengths
117 The knotlengths for the trimming curves
118 */
119
120 /*! \var UInt32 SurfaceBase::_mfDimensions
121 The dimensions for the trimming curves
122 */
123
124 /*! \var Pnt3f SurfaceBase::_mfCurveControlPoints
125 The control points for the trimming curves
126 */
127
128 /*! \var Real32 SurfaceBase::_mfKnots
129 The knotvectors for the trimming curves
130 */
131
132 /*! \var UInt32 SurfaceBase::_mfCurvesPerLoop
133 Specifies the number of trimming curves in each trimming curve loop
134 */
135
136 /*! \var bool SurfaceBase::_sfIsDelaunay
137 Whether to use Delaunay triangulation. Default is no, because it's faster
138 and slightly more robust numerically, but produces a somewhat less "nice"
139 triangulation. Set to true, if you want Delaunay triangulation. The number
140 of triangles generated is the same in both modes.
141 */
142
143 /*! \var GeoVectorProperty * SurfaceBase::_sfTextureControlPoints
144 The control points for textures (always 2D)
145 */
146
147 /*! \var UInt32 SurfaceBase::_sfDirtyMask
148
149 */
150
151 /*! \var Int32 SurfaceBase::_sfSurfaceGLId
152 Surface GL Id, internal use.
153 */
154
155
156 /***************************************************************************\
157 * FieldType/FieldTrait Instantiation *
158 \***************************************************************************/
159
160 #if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)
161 PointerType FieldTraits<Surface *, nsOSG>::_type(
162 "SurfacePtr",
163 "GeometryPtr",
164 Surface::getClassType(),
165 nsOSG);
166 #endif
167
168 OSG_FIELDTRAITS_GETTYPE_NS(Surface *, nsOSG)
169
170 OSG_EXPORT_PTR_SFIELD_FULL(PointerSField,
171 Surface *,
172 nsOSG)
173
174 OSG_EXPORT_PTR_MFIELD_FULL(PointerMField,
175 Surface *,
176 nsOSG)
177
178 /***************************************************************************\
179 * Field Description *
180 \***************************************************************************/
181
182 void SurfaceBase::classDescInserter(TypeObject &oType)
183 {
184 FieldDescriptionBase *pDesc = NULL;
185
186
187 pDesc = new SFUInt32::Description(
188 SFUInt32::getClassType(),
189 "dimU",
190 "The surface dimension in U\n",
191 DimUFieldId, DimUFieldMask,
192 false,
193 (Field::SFDefaultFlags | Field::FStdAccess),
194 static_cast<FieldEditMethodSig>(&Surface::editHandleDimU),
195 static_cast<FieldGetMethodSig >(&Surface::getHandleDimU));
196
197 oType.addInitialDesc(pDesc);
198
199 pDesc = new SFUInt32::Description(
200 SFUInt32::getClassType(),
201 "dimV",
202 "The surface dimension in V\n",
203 DimVFieldId, DimVFieldMask,
204 false,
205 (Field::SFDefaultFlags | Field::FStdAccess),
206 static_cast<FieldEditMethodSig>(&Surface::editHandleDimV),
207 static_cast<FieldGetMethodSig >(&Surface::getHandleDimV));
208
209 oType.addInitialDesc(pDesc);
210
211 pDesc = new MFReal32::Description(
212 MFReal32::getClassType(),
213 "knotsU",
214 "The surface knots in U direction\n",
215 KnotsUFieldId, KnotsUFieldMask,
216 false,
217 (Field::MFDefaultFlags | Field::FStdAccess),
218 static_cast<FieldEditMethodSig>(&Surface::editHandleKnotsU),
219 static_cast<FieldGetMethodSig >(&Surface::getHandleKnotsU));
220
221 oType.addInitialDesc(pDesc);
222
223 pDesc = new MFReal32::Description(
224 MFReal32::getClassType(),
225 "knotsV",
226 "The surface knots in V direction\n",
227 KnotsVFieldId, KnotsVFieldMask,
228 false,
229 (Field::MFDefaultFlags | Field::FStdAccess),
230 static_cast<FieldEditMethodSig>(&Surface::editHandleKnotsV),
231 static_cast<FieldGetMethodSig >(&Surface::getHandleKnotsV));
232
233 oType.addInitialDesc(pDesc);
234
235 pDesc = new SFUnrecChildGeoVectorPropertyPtr::Description(
236 SFUnrecChildGeoVectorPropertyPtr::getClassType(),
237 "controlPoints",
238 "The control points for the surface\n",
239 ControlPointsFieldId, ControlPointsFieldMask,
240 false,
241 (Field::SFDefaultFlags | Field::FStdAccess),
242 static_cast<FieldEditMethodSig>(&Surface::editHandleControlPoints),
243 static_cast<FieldGetMethodSig >(&Surface::getHandleControlPoints));
244
245 oType.addInitialDesc(pDesc);
246
247 pDesc = new SFReal32::Description(
248 SFReal32::getClassType(),
249 "error",
250 "The approximation error for the tessellation\n",
251 ErrorFieldId, ErrorFieldMask,
252 false,
253 (Field::SFDefaultFlags | Field::FStdAccess),
254 static_cast<FieldEditMethodSig>(&Surface::editHandleError),
255 static_cast<FieldGetMethodSig >(&Surface::getHandleError));
256
257 oType.addInitialDesc(pDesc);
258
259 pDesc = new SFUInt32::Description(
260 SFUInt32::getClassType(),
261 "numCurves",
262 "The number of trimming curves\n",
263 NumCurvesFieldId, NumCurvesFieldMask,
264 false,
265 (Field::SFDefaultFlags | Field::FStdAccess),
266 static_cast<FieldEditMethodSig>(&Surface::editHandleNumCurves),
267 static_cast<FieldGetMethodSig >(&Surface::getHandleNumCurves));
268
269 oType.addInitialDesc(pDesc);
270
271 pDesc = new MFUInt32::Description(
272 MFUInt32::getClassType(),
273 "knotLengths",
274 "The knotlengths for the trimming curves\n",
275 KnotLengthsFieldId, KnotLengthsFieldMask,
276 false,
277 (Field::MFDefaultFlags | Field::FStdAccess),
278 static_cast<FieldEditMethodSig>(&Surface::editHandleKnotLengths),
279 static_cast<FieldGetMethodSig >(&Surface::getHandleKnotLengths));
280
281 oType.addInitialDesc(pDesc);
282
283 pDesc = new MFUInt32::Description(
284 MFUInt32::getClassType(),
285 "dimensions",
286 "The dimensions for the trimming curves\n",
287 DimensionsFieldId, DimensionsFieldMask,
288 false,
289 (Field::MFDefaultFlags | Field::FStdAccess),
290 static_cast<FieldEditMethodSig>(&Surface::editHandleDimensions),
291 static_cast<FieldGetMethodSig >(&Surface::getHandleDimensions));
292
293 oType.addInitialDesc(pDesc);
294
295 pDesc = new MFPnt3f::Description(
296 MFPnt3f::getClassType(),
297 "curveControlPoints",
298 "The control points for the trimming curves\n",
299 CurveControlPointsFieldId, CurveControlPointsFieldMask,
300 false,
301 (Field::MFDefaultFlags | Field::FStdAccess),
302 static_cast<FieldEditMethodSig>(&Surface::editHandleCurveControlPoints),
303 static_cast<FieldGetMethodSig >(&Surface::getHandleCurveControlPoints));
304
305 oType.addInitialDesc(pDesc);
306
307 pDesc = new MFReal32::Description(
308 MFReal32::getClassType(),
309 "knots",
310 "The knotvectors for the trimming curves\n",
311 KnotsFieldId, KnotsFieldMask,
312 false,
313 (Field::MFDefaultFlags | Field::FStdAccess),
314 static_cast<FieldEditMethodSig>(&Surface::editHandleKnots),
315 static_cast<FieldGetMethodSig >(&Surface::getHandleKnots));
316
317 oType.addInitialDesc(pDesc);
318
319 pDesc = new MFUInt32::Description(
320 MFUInt32::getClassType(),
321 "curvesPerLoop",
322 "Specifies the number of trimming curves in each trimming curve loop\n",
323 CurvesPerLoopFieldId, CurvesPerLoopFieldMask,
324 false,
325 (Field::MFDefaultFlags | Field::FStdAccess),
326 static_cast<FieldEditMethodSig>(&Surface::editHandleCurvesPerLoop),
327 static_cast<FieldGetMethodSig >(&Surface::getHandleCurvesPerLoop));
328
329 oType.addInitialDesc(pDesc);
330
331 pDesc = new SFBool::Description(
332 SFBool::getClassType(),
333 "isDelaunay",
334 "Whether to use Delaunay triangulation. Default is no, because it's faster\n"
335 "and slightly more robust numerically, but produces a somewhat less \"nice\"\n"
336 "triangulation. Set to true, if you want Delaunay triangulation. The number\n"
337 "of triangles generated is the same in both modes.\n",
338 IsDelaunayFieldId, IsDelaunayFieldMask,
339 false,
340 (Field::SFDefaultFlags | Field::FStdAccess),
341 static_cast<FieldEditMethodSig>(&Surface::editHandleIsDelaunay),
342 static_cast<FieldGetMethodSig >(&Surface::getHandleIsDelaunay));
343
344 oType.addInitialDesc(pDesc);
345
346 pDesc = new SFUnrecChildGeoVectorPropertyPtr::Description(
347 SFUnrecChildGeoVectorPropertyPtr::getClassType(),
348 "textureControlPoints",
349 "The control points for textures (always 2D)\n",
350 TextureControlPointsFieldId, TextureControlPointsFieldMask,
351 false,
352 (Field::SFDefaultFlags | Field::FStdAccess),
353 static_cast<FieldEditMethodSig>(&Surface::editHandleTextureControlPoints),
354 static_cast<FieldGetMethodSig >(&Surface::getHandleTextureControlPoints));
355
356 oType.addInitialDesc(pDesc);
357
358 pDesc = new SFUInt32::Description(
359 SFUInt32::getClassType(),
360 "dirtyMask",
361 "",
362 DirtyMaskFieldId, DirtyMaskFieldMask,
363 false,
364 (Field::SFDefaultFlags | Field::FStdAccess),
365 static_cast<FieldEditMethodSig>(&Surface::editHandleDirtyMask),
366 static_cast<FieldGetMethodSig >(&Surface::getHandleDirtyMask));
367
368 oType.addInitialDesc(pDesc);
369
370 pDesc = new SFInt32::Description(
371 SFInt32::getClassType(),
372 "surfaceGLId",
373 "Surface GL Id, internal use.\n",
374 SurfaceGLIdFieldId, SurfaceGLIdFieldMask,
375 true,
376 (Field::FClusterLocal),
377 static_cast<FieldEditMethodSig>(&Surface::editHandleSurfaceGLId),
378 static_cast<FieldGetMethodSig >(&Surface::getHandleSurfaceGLId));
379
380 oType.addInitialDesc(pDesc);
381 }
382
383
384 SurfaceBase::TypeObject SurfaceBase::_type(
385 SurfaceBase::getClassname(),
386 Inherited::getClassname(),
387 "NULL",
388 nsOSG, //Namespace
389 reinterpret_cast<PrototypeCreateF>(&SurfaceBase::createEmptyLocal),
390 reinterpret_cast<InitContainerF>(&Surface::initMethod),
391 reinterpret_cast<ExitContainerF>(&Surface::exitMethod),
392 reinterpret_cast<InitalInsertDescFunc>(
393 reinterpret_cast<void *>(&Surface::classDescInserter)),
394 false,
395 0,
396 "<?xml version=\"1.0\"?>\n"
397 "\n"
398 "<FieldContainer\n"
399 " name=\"Surface\"\n"
400 " parent=\"Geometry\"\n"
401 " library=\"Drawable\"\n"
402 " pointerfieldtypes=\"both\"\n"
403 " structure=\"concrete\"\n"
404 " systemcomponent=\"true\"\n"
405 " parentsystemcomponent=\"true\"\n"
406 " decoratable=\"false\"\n"
407 " isNodeCore=\"true\"\n"
408 " docGroupBase=\"GrpDrawablesNurbs\"\n"
409 " >\n"
410 " This is the OpenSG NURBS surface node. It supports an arbitrary number of\n"
411 " trimming curves. The interface lets you define both rational and nonrational\n"
412 " surfaces, and you can also vary rational and nonrational trimming curves.\n"
413 " <Field\n"
414 " name=\"dimU\"\n"
415 " type=\"UInt32\"\n"
416 " cardinality=\"single\"\n"
417 " visibility=\"external\"\n"
418 " defaultValue=\"0\"\n"
419 " access=\"public\"\n"
420 " >\n"
421 " The surface dimension in U\n"
422 " </Field>\n"
423 " <Field\n"
424 " name=\"dimV\"\n"
425 " type=\"UInt32\"\n"
426 " cardinality=\"single\"\n"
427 " visibility=\"external\"\n"
428 " defaultValue=\"0\"\n"
429 " access=\"public\"\n"
430 " >\n"
431 " The surface dimension in V\n"
432 " </Field>\n"
433 " <Field\n"
434 " name=\"knotsU\"\n"
435 " type=\"Real32\"\n"
436 " cardinality=\"multi\"\n"
437 " visibility=\"external\"\n"
438 " access=\"public\"\n"
439 " >\n"
440 " The surface knots in U direction\n"
441 " </Field>\n"
442 " <Field\n"
443 " name=\"knotsV\"\n"
444 " type=\"Real32\"\n"
445 " cardinality=\"multi\"\n"
446 " visibility=\"external\"\n"
447 " access=\"public\"\n"
448 " >\n"
449 " The surface knots in V direction\n"
450 " </Field>\n"
451 " <Field\n"
452 " name=\"controlPoints\"\n"
453 " type=\"GeoVectorProperty\"\n"
454 " cardinality=\"single\"\n"
455 " visibility=\"external\"\n"
456 " access=\"public\"\n"
457 " category=\"childpointer\"\n"
458 " childParentType=\"FieldContainer\"\n"
459 " linkParentField=\"Parents\"\n"
460 " >\n"
461 " The control points for the surface\n"
462 " </Field>\n"
463 " <Field\n"
464 " name=\"error\"\n"
465 " type=\"Real32\"\n"
466 " cardinality=\"single\"\n"
467 " visibility=\"external\"\n"
468 " defaultValue=\"0.5\"\n"
469 " access=\"public\"\n"
470 " >\n"
471 " The approximation error for the tessellation\n"
472 " </Field>\n"
473 " <Field\n"
474 " name=\"numCurves\"\n"
475 " type=\"UInt32\"\n"
476 " cardinality=\"single\"\n"
477 " visibility=\"external\"\n"
478 " defaultValue=\"0\"\n"
479 " access=\"protected\"\n"
480 " >\n"
481 " The number of trimming curves\n"
482 " </Field>\n"
483 " <Field\n"
484 " name=\"knotLengths\"\n"
485 " type=\"UInt32\"\n"
486 " cardinality=\"multi\"\n"
487 " visibility=\"external\"\n"
488 " access=\"protected\"\n"
489 " >\n"
490 " The knotlengths for the trimming curves\n"
491 " </Field>\n"
492 " <Field\n"
493 " name=\"dimensions\"\n"
494 " type=\"UInt32\"\n"
495 " cardinality=\"multi\"\n"
496 " visibility=\"external\"\n"
497 " access=\"protected\"\n"
498 " >\n"
499 " The dimensions for the trimming curves\n"
500 " </Field>\n"
501 " <Field\n"
502 " name=\"curveControlPoints\"\n"
503 " type=\"Pnt3f\"\n"
504 " cardinality=\"multi\"\n"
505 " visibility=\"external\"\n"
506 " access=\"protected\"\n"
507 " >\n"
508 " The control points for the trimming curves\n"
509 " </Field>\n"
510 " <Field\n"
511 " name=\"knots\"\n"
512 " type=\"Real32\"\n"
513 " cardinality=\"multi\"\n"
514 " visibility=\"external\"\n"
515 " access=\"protected\"\n"
516 " >\n"
517 " The knotvectors for the trimming curves\n"
518 " </Field>\n"
519 " <Field\n"
520 " name=\"curvesPerLoop\"\n"
521 " type=\"UInt32\"\n"
522 " cardinality=\"multi\"\n"
523 " visibility=\"external\"\n"
524 " access=\"protected\"\n"
525 " >\n"
526 " Specifies the number of trimming curves in each trimming curve loop\n"
527 " </Field>\n"
528 " <Field\n"
529 " name=\"isDelaunay\"\n"
530 " type=\"bool\"\n"
531 " cardinality=\"single\"\n"
532 " visibility=\"external\"\n"
533 " defaultValue=\"false\"\n"
534 " access=\"public\"\n"
535 " >\n"
536 " Whether to use Delaunay triangulation. Default is no, because it's faster\n"
537 " and slightly more robust numerically, but produces a somewhat less \"nice\"\n"
538 " triangulation. Set to true, if you want Delaunay triangulation. The number\n"
539 " of triangles generated is the same in both modes.\n"
540 " </Field>\n"
541 " <Field\n"
542 " name=\"textureControlPoints\"\n"
543 " type=\"GeoVectorProperty\"\n"
544 " cardinality=\"single\"\n"
545 " visibility=\"external\"\n"
546 " access=\"public\"\n"
547 " category=\"childpointer\"\n"
548 " childParentType=\"FieldContainer\"\n"
549 " linkParentField=\"Parents\"\n"
550 " >\n"
551 " The control points for textures (always 2D)\n"
552 " </Field>\n"
553 " <Field\n"
554 " name=\"dirtyMask\"\n"
555 " type=\"UInt32\"\n"
556 " cardinality=\"single\"\n"
557 " visibility=\"external\"\n"
558 " defaultValue=\"0\"\n"
559 " access=\"protected\"\n"
560 " >\n"
561 " </Field>\n"
562 " <Field\n"
563 " name=\"surfaceGLId\"\n"
564 " type=\"Int32\"\n"
565 " cardinality=\"single\"\n"
566 " visibility=\"internal\"\n"
567 " defaultValue=\"0\"\n"
568 " access=\"protected\"\n"
569 " fieldFlags=\"FClusterLocal\"\n"
570 " >\n"
571 " Surface GL Id, internal use.\n"
572 " </Field>\n"
573 "</FieldContainer>\n",
574 "This is the OpenSG NURBS surface node. It supports an arbitrary number of\n"
575 "trimming curves. The interface lets you define both rational and nonrational\n"
576 "surfaces, and you can also vary rational and nonrational trimming curves.\n"
577 );
578
579 /*------------------------------ get -----------------------------------*/
580
581 FieldContainerType &SurfaceBase::getType(void)
582 {
583 return _type;
584 }
585
586 const FieldContainerType &SurfaceBase::getType(void) const
587 {
588 return _type;
589 }
590
591 UInt32 SurfaceBase::getContainerSize(void) const
592 {
593 return sizeof(Surface);
594 }
595
596 /*------------------------- decorator get ------------------------------*/
597
598
599 SFUInt32 *SurfaceBase::editSFDimU(void)
600 {
601 editSField(DimUFieldMask);
602
603 return &_sfDimU;
604 }
605
606 const SFUInt32 *SurfaceBase::getSFDimU(void) const
607 {
608 return &_sfDimU;
609 }
610
611
612 SFUInt32 *SurfaceBase::editSFDimV(void)
613 {
614 editSField(DimVFieldMask);
615
616 return &_sfDimV;
617 }
618
619 const SFUInt32 *SurfaceBase::getSFDimV(void) const
620 {
621 return &_sfDimV;
622 }
623
624
625 MFReal32 *SurfaceBase::editMFKnotsU(void)
626 {
627 editMField(KnotsUFieldMask, _mfKnotsU);
628
629 return &_mfKnotsU;
630 }
631
632 const MFReal32 *SurfaceBase::getMFKnotsU(void) const
633 {
634 return &_mfKnotsU;
635 }
636
637
638 MFReal32 *SurfaceBase::editMFKnotsV(void)
639 {
640 editMField(KnotsVFieldMask, _mfKnotsV);
641
642 return &_mfKnotsV;
643 }
644
645 const MFReal32 *SurfaceBase::getMFKnotsV(void) const
646 {
647 return &_mfKnotsV;
648 }
649
650
651 //! Get the Surface::_sfControlPoints field.
652 const SFUnrecChildGeoVectorPropertyPtr *SurfaceBase::getSFControlPoints(void) const
653 {
654 return &_sfControlPoints;
655 }
656
657 SFUnrecChildGeoVectorPropertyPtr *SurfaceBase::editSFControlPoints (void)
658 {
659 editSField(ControlPointsFieldMask);
660
661 return &_sfControlPoints;
662 }
663
664 //! Get the value of the Surface::_sfControlPoints field.
665 GeoVectorProperty * SurfaceBase::getControlPoints(void) const
666 {
667 return _sfControlPoints.getValue();
668 }
669
670 //! Set the value of the Surface::_sfControlPoints field.
671 void SurfaceBase::setControlPoints(GeoVectorProperty * const value)
672 {
673 editSField(ControlPointsFieldMask);
674
675 _sfControlPoints.setValue(value);
676 }
677
678
679 SFReal32 *SurfaceBase::editSFError(void)
680 {
681 editSField(ErrorFieldMask);
682
683 return &_sfError;
684 }
685
686 const SFReal32 *SurfaceBase::getSFError(void) const
687 {
688 return &_sfError;
689 }
690
691
692 SFUInt32 *SurfaceBase::editSFNumCurves(void)
693 {
694 editSField(NumCurvesFieldMask);
695
696 return &_sfNumCurves;
697 }
698
699 const SFUInt32 *SurfaceBase::getSFNumCurves(void) const
700 {
701 return &_sfNumCurves;
702 }
703
704
705 MFUInt32 *SurfaceBase::editMFKnotLengths(void)
706 {
707 editMField(KnotLengthsFieldMask, _mfKnotLengths);
708
709 return &_mfKnotLengths;
710 }
711
712 const MFUInt32 *SurfaceBase::getMFKnotLengths(void) const
713 {
714 return &_mfKnotLengths;
715 }
716
717
718 MFUInt32 *SurfaceBase::editMFDimensions(void)
719 {
720 editMField(DimensionsFieldMask, _mfDimensions);
721
722 return &_mfDimensions;
723 }
724
725 const MFUInt32 *SurfaceBase::getMFDimensions(void) const
726 {
727 return &_mfDimensions;
728 }
729
730
731 MFPnt3f *SurfaceBase::editMFCurveControlPoints(void)
732 {
733 editMField(CurveControlPointsFieldMask, _mfCurveControlPoints);
734
735 return &_mfCurveControlPoints;
736 }
737
738 const MFPnt3f *SurfaceBase::getMFCurveControlPoints(void) const
739 {
740 return &_mfCurveControlPoints;
741 }
742
743
744 MFReal32 *SurfaceBase::editMFKnots(void)
745 {
746 editMField(KnotsFieldMask, _mfKnots);
747
748 return &_mfKnots;
749 }
750
751 const MFReal32 *SurfaceBase::getMFKnots(void) const
752 {
753 return &_mfKnots;
754 }
755
756
757 MFUInt32 *SurfaceBase::editMFCurvesPerLoop(void)
758 {
759 editMField(CurvesPerLoopFieldMask, _mfCurvesPerLoop);
760
761 return &_mfCurvesPerLoop;
762 }
763
764 const MFUInt32 *SurfaceBase::getMFCurvesPerLoop(void) const
765 {
766 return &_mfCurvesPerLoop;
767 }
768
769
770 SFBool *SurfaceBase::editSFIsDelaunay(void)
771 {
772 editSField(IsDelaunayFieldMask);
773
774 return &_sfIsDelaunay;
775 }
776
777 const SFBool *SurfaceBase::getSFIsDelaunay(void) const
778 {
779 return &_sfIsDelaunay;
780 }
781
782
783 //! Get the Surface::_sfTextureControlPoints field.
784 const SFUnrecChildGeoVectorPropertyPtr *SurfaceBase::getSFTextureControlPoints(void) const
785 {
786 return &_sfTextureControlPoints;
787 }
788
789 SFUnrecChildGeoVectorPropertyPtr *SurfaceBase::editSFTextureControlPoints(void)
790 {
791 editSField(TextureControlPointsFieldMask);
792
793 return &_sfTextureControlPoints;
794 }
795
796 //! Get the value of the Surface::_sfTextureControlPoints field.
797 GeoVectorProperty * SurfaceBase::getTextureControlPoints(void) const
798 {
799 return _sfTextureControlPoints.getValue();
800 }
801
802 //! Set the value of the Surface::_sfTextureControlPoints field.
803 void SurfaceBase::setTextureControlPoints(GeoVectorProperty * const value)
804 {
805 editSField(TextureControlPointsFieldMask);
806
807 _sfTextureControlPoints.setValue(value);
808 }
809
810
811 SFUInt32 *SurfaceBase::editSFDirtyMask(void)
812 {
813 editSField(DirtyMaskFieldMask);
814
815 return &_sfDirtyMask;
816 }
817
818 const SFUInt32 *SurfaceBase::getSFDirtyMask(void) const
819 {
820 return &_sfDirtyMask;
821 }
822
823
824 SFInt32 *SurfaceBase::editSFSurfaceGLId(void)
825 {
826 editSField(SurfaceGLIdFieldMask);
827
828 return &_sfSurfaceGLId;
829 }
830
831 const SFInt32 *SurfaceBase::getSFSurfaceGLId(void) const
832 {
833 return &_sfSurfaceGLId;
834 }
835
836
837
838
839
840
841 /*------------------------------ access -----------------------------------*/
842
843 SizeT SurfaceBase::getBinSize(ConstFieldMaskArg whichField)
844 {
845 SizeT returnValue = Inherited::getBinSize(whichField);
846
847 if(FieldBits::NoField != (DimUFieldMask & whichField))
848 {
849 returnValue += _sfDimU.getBinSize();
850 }
851 if(FieldBits::NoField != (DimVFieldMask & whichField))
852 {
853 returnValue += _sfDimV.getBinSize();
854 }
855 if(FieldBits::NoField != (KnotsUFieldMask & whichField))
856 {
857 returnValue += _mfKnotsU.getBinSize();
858 }
859 if(FieldBits::NoField != (KnotsVFieldMask & whichField))
860 {
861 returnValue += _mfKnotsV.getBinSize();
862 }
863 if(FieldBits::NoField != (ControlPointsFieldMask & whichField))
864 {
865 returnValue += _sfControlPoints.getBinSize();
866 }
867 if(FieldBits::NoField != (ErrorFieldMask & whichField))
868 {
869 returnValue += _sfError.getBinSize();
870 }
871 if(FieldBits::NoField != (NumCurvesFieldMask & whichField))
872 {
873 returnValue += _sfNumCurves.getBinSize();
874 }
875 if(FieldBits::NoField != (KnotLengthsFieldMask & whichField))
876 {
877 returnValue += _mfKnotLengths.getBinSize();
878 }
879 if(FieldBits::NoField != (DimensionsFieldMask & whichField))
880 {
881 returnValue += _mfDimensions.getBinSize();
882 }
883 if(FieldBits::NoField != (CurveControlPointsFieldMask & whichField))
884 {
885 returnValue += _mfCurveControlPoints.getBinSize();
886 }
887 if(FieldBits::NoField != (KnotsFieldMask & whichField))
888 {
889 returnValue += _mfKnots.getBinSize();
890 }
891 if(FieldBits::NoField != (CurvesPerLoopFieldMask & whichField))
892 {
893 returnValue += _mfCurvesPerLoop.getBinSize();
894 }
895 if(FieldBits::NoField != (IsDelaunayFieldMask & whichField))
896 {
897 returnValue += _sfIsDelaunay.getBinSize();
898 }
899 if(FieldBits::NoField != (TextureControlPointsFieldMask & whichField))
900 {
901 returnValue += _sfTextureControlPoints.getBinSize();
902 }
903 if(FieldBits::NoField != (DirtyMaskFieldMask & whichField))
904 {
905 returnValue += _sfDirtyMask.getBinSize();
906 }
907 if(FieldBits::NoField != (SurfaceGLIdFieldMask & whichField))
908 {
909 returnValue += _sfSurfaceGLId.getBinSize();
910 }
911
912 return returnValue;
913 }
914
915 void SurfaceBase::copyToBin(BinaryDataHandler &pMem,
916 ConstFieldMaskArg whichField)
917 {
918 Inherited::copyToBin(pMem, whichField);
919
920 if(FieldBits::NoField != (DimUFieldMask & whichField))
921 {
922 _sfDimU.copyToBin(pMem);
923 }
924 if(FieldBits::NoField != (DimVFieldMask & whichField))
925 {
926 _sfDimV.copyToBin(pMem);
927 }
928 if(FieldBits::NoField != (KnotsUFieldMask & whichField))
929 {
930 _mfKnotsU.copyToBin(pMem);
931 }
932 if(FieldBits::NoField != (KnotsVFieldMask & whichField))
933 {
934 _mfKnotsV.copyToBin(pMem);
935 }
936 if(FieldBits::NoField != (ControlPointsFieldMask & whichField))
937 {
938 _sfControlPoints.copyToBin(pMem);
939 }
940 if(FieldBits::NoField != (ErrorFieldMask & whichField))
941 {
942 _sfError.copyToBin(pMem);
943 }
944 if(FieldBits::NoField != (NumCurvesFieldMask & whichField))
945 {
946 _sfNumCurves.copyToBin(pMem);
947 }
948 if(FieldBits::NoField != (KnotLengthsFieldMask & whichField))
949 {
950 _mfKnotLengths.copyToBin(pMem);
951 }
952 if(FieldBits::NoField != (DimensionsFieldMask & whichField))
953 {
954 _mfDimensions.copyToBin(pMem);
955 }
956 if(FieldBits::NoField != (CurveControlPointsFieldMask & whichField))
957 {
958 _mfCurveControlPoints.copyToBin(pMem);
959 }
960 if(FieldBits::NoField != (KnotsFieldMask & whichField))
961 {
962 _mfKnots.copyToBin(pMem);
963 }
964 if(FieldBits::NoField != (CurvesPerLoopFieldMask & whichField))
965 {
966 _mfCurvesPerLoop.copyToBin(pMem);
967 }
968 if(FieldBits::NoField != (IsDelaunayFieldMask & whichField))
969 {
970 _sfIsDelaunay.copyToBin(pMem);
971 }
972 if(FieldBits::NoField != (TextureControlPointsFieldMask & whichField))
973 {
974 _sfTextureControlPoints.copyToBin(pMem);
975 }
976 if(FieldBits::NoField != (DirtyMaskFieldMask & whichField))
977 {
978 _sfDirtyMask.copyToBin(pMem);
979 }
980 if(FieldBits::NoField != (SurfaceGLIdFieldMask & whichField))
981 {
982 _sfSurfaceGLId.copyToBin(pMem);
983 }
984 }
985
986 void SurfaceBase::copyFromBin(BinaryDataHandler &pMem,
987 ConstFieldMaskArg whichField)
988 {
989 Inherited::copyFromBin(pMem, whichField);
990
991 if(FieldBits::NoField != (DimUFieldMask & whichField))
992 {
993 editSField(DimUFieldMask);
994 _sfDimU.copyFromBin(pMem);
995 }
996 if(FieldBits::NoField != (DimVFieldMask & whichField))
997 {
998 editSField(DimVFieldMask);
999 _sfDimV.copyFromBin(pMem);
1000 }
1001 if(FieldBits::NoField != (KnotsUFieldMask & whichField))
1002 {
1003 editMField(KnotsUFieldMask, _mfKnotsU);
1004 _mfKnotsU.copyFromBin(pMem);
1005 }
1006 if(FieldBits::NoField != (KnotsVFieldMask & whichField))
1007 {
1008 editMField(KnotsVFieldMask, _mfKnotsV);
1009 _mfKnotsV.copyFromBin(pMem);
1010 }
1011 if(FieldBits::NoField != (ControlPointsFieldMask & whichField))
1012 {
1013 editSField(ControlPointsFieldMask);
1014 _sfControlPoints.copyFromBin(pMem);
1015 }
1016 if(FieldBits::NoField != (ErrorFieldMask & whichField))
1017 {
1018 editSField(ErrorFieldMask);
1019 _sfError.copyFromBin(pMem);
1020 }
1021 if(FieldBits::NoField != (NumCurvesFieldMask & whichField))
1022 {
1023 editSField(NumCurvesFieldMask);
1024 _sfNumCurves.copyFromBin(pMem);
1025 }
1026 if(FieldBits::NoField != (KnotLengthsFieldMask & whichField))
1027 {
1028 editMField(KnotLengthsFieldMask, _mfKnotLengths);
1029 _mfKnotLengths.copyFromBin(pMem);
1030 }
1031 if(FieldBits::NoField != (DimensionsFieldMask & whichField))
1032 {
1033 editMField(DimensionsFieldMask, _mfDimensions);
1034 _mfDimensions.copyFromBin(pMem);
1035 }
1036 if(FieldBits::NoField != (CurveControlPointsFieldMask & whichField))
1037 {
1038 editMField(CurveControlPointsFieldMask, _mfCurveControlPoints);
1039 _mfCurveControlPoints.copyFromBin(pMem);
1040 }
1041 if(FieldBits::NoField != (KnotsFieldMask & whichField))
1042 {
1043 editMField(KnotsFieldMask, _mfKnots);
1044 _mfKnots.copyFromBin(pMem);
1045 }
1046 if(FieldBits::NoField != (CurvesPerLoopFieldMask & whichField))
1047 {
1048 editMField(CurvesPerLoopFieldMask, _mfCurvesPerLoop);
1049 _mfCurvesPerLoop.copyFromBin(pMem);
1050 }
1051 if(FieldBits::NoField != (IsDelaunayFieldMask & whichField))
1052 {
1053 editSField(IsDelaunayFieldMask);
1054 _sfIsDelaunay.copyFromBin(pMem);
1055 }
1056 if(FieldBits::NoField != (TextureControlPointsFieldMask & whichField))
1057 {
1058 editSField(TextureControlPointsFieldMask);
1059 _sfTextureControlPoints.copyFromBin(pMem);
1060 }
1061 if(FieldBits::NoField != (DirtyMaskFieldMask & whichField))
1062 {
1063 editSField(DirtyMaskFieldMask);
1064 _sfDirtyMask.copyFromBin(pMem);
1065 }
1066 if(FieldBits::NoField != (SurfaceGLIdFieldMask & whichField))
1067 {
1068 editSField(SurfaceGLIdFieldMask);
1069 _sfSurfaceGLId.copyFromBin(pMem);
1070 }
1071 }
1072
1073 //! create a new instance of the class
1074 SurfaceTransitPtr SurfaceBase::createLocal(BitVector bFlags)
1075 {
1076 SurfaceTransitPtr fc;
1077
1078 if(getClassType().getPrototype() != NULL)
1079 {
1080 FieldContainerTransitPtr tmpPtr =
1081 getClassType().getPrototype()-> shallowCopyLocal(bFlags);
1082
1083 fc = dynamic_pointer_cast<Surface>(tmpPtr);
1084 }
1085
1086 return fc;
1087 }
1088
1089 //! create a new instance of the class, copy the container flags
1090 SurfaceTransitPtr SurfaceBase::createDependent(BitVector bFlags)
1091 {
1092 SurfaceTransitPtr fc;
1093
1094 if(getClassType().getPrototype() != NULL)
1095 {
1096 FieldContainerTransitPtr tmpPtr =
1097 getClassType().getPrototype()-> shallowCopyDependent(bFlags);
1098
1099 fc = dynamic_pointer_cast<Surface>(tmpPtr);
1100 }
1101
1102 return fc;
1103 }
1104
1105 //! create a new instance of the class
1106 SurfaceTransitPtr SurfaceBase::create(void)
1107 {
1108 SurfaceTransitPtr fc;
1109
1110 if(getClassType().getPrototype() != NULL)
1111 {
1112 FieldContainerTransitPtr tmpPtr =
1113 getClassType().getPrototype()-> shallowCopy();
1114
1115 fc = dynamic_pointer_cast<Surface>(tmpPtr);
1116 }
1117
1118 return fc;
1119 }
1120
1121 Surface *SurfaceBase::createEmptyLocal(BitVector bFlags)
1122 {
1123 Surface *returnValue;
1124
1125 newPtr<Surface>(returnValue, bFlags);
1126
1127 returnValue->_pFieldFlags->_bNamespaceMask &= ~bFlags;
1128
1129 return returnValue;
1130 }
1131
1132 //! create an empty new instance of the class, do not copy the prototype
1133 Surface *SurfaceBase::createEmpty(void)
1134 {
1135 Surface *returnValue;
1136
1137 newPtr<Surface>(returnValue, Thread::getCurrentLocalFlags());
1138
1139 returnValue->_pFieldFlags->_bNamespaceMask &=
1140 ~Thread::getCurrentLocalFlags();
1141
1142 return returnValue;
1143 }
1144
1145
1146 FieldContainerTransitPtr SurfaceBase::shallowCopyLocal(
1147 BitVector bFlags) const
1148 {
1149 Surface *tmpPtr;
1150
1151 newPtr(tmpPtr, dynamic_cast<const Surface *>(this), bFlags);
1152
1153 FieldContainerTransitPtr returnValue(tmpPtr);
1154
1155 tmpPtr->_pFieldFlags->_bNamespaceMask &= ~bFlags;
1156
1157 return returnValue;
1158 }
1159
1160 FieldContainerTransitPtr SurfaceBase::shallowCopyDependent(
1161 BitVector bFlags) const
1162 {
1163 Surface *tmpPtr;
1164
1165 newPtr(tmpPtr, dynamic_cast<const Surface *>(this), ~bFlags);
1166
1167 FieldContainerTransitPtr returnValue(tmpPtr);
1168
1169 tmpPtr->_pFieldFlags->_bNamespaceMask = bFlags;
1170
1171 return returnValue;
1172 }
1173
1174 FieldContainerTransitPtr SurfaceBase::shallowCopy(void) const
1175 {
1176 Surface *tmpPtr;
1177
1178 newPtr(tmpPtr,
1179 dynamic_cast<const Surface *>(this),
1180 Thread::getCurrentLocalFlags());
1181
1182 tmpPtr->_pFieldFlags->_bNamespaceMask &= ~Thread::getCurrentLocalFlags();
1183
1184 FieldContainerTransitPtr returnValue(tmpPtr);
1185
1186 return returnValue;
1187 }
1188
1189
1190
1191
1192 /*------------------------- constructors ----------------------------------*/
1193
1194 SurfaceBase::SurfaceBase(void) :
1195 Inherited(),
1196 _sfDimU (UInt32(0)),
1197 _sfDimV (UInt32(0)),
1198 _mfKnotsU (),
1199 _mfKnotsV (),
1200 _sfControlPoints (this,
1201 ControlPointsFieldId,
1202 GeoVectorProperty::ParentsFieldId),
1203 _sfError (Real32(0.5)),
1204 _sfNumCurves (UInt32(0)),
1205 _mfKnotLengths (),
1206 _mfDimensions (),
1207 _mfCurveControlPoints (),
1208 _mfKnots (),
1209 _mfCurvesPerLoop (),
1210 _sfIsDelaunay (bool(false)),
1211 _sfTextureControlPoints (this,
1212 TextureControlPointsFieldId,
1213 GeoVectorProperty::ParentsFieldId),
1214 _sfDirtyMask (UInt32(0)),
1215 _sfSurfaceGLId (Int32(0))
1216 {
1217 }
1218
1219 SurfaceBase::SurfaceBase(const SurfaceBase &source) :
1220 Inherited(source),
1221 _sfDimU (source._sfDimU ),
1222 _sfDimV (source._sfDimV ),
1223 _mfKnotsU (source._mfKnotsU ),
1224 _mfKnotsV (source._mfKnotsV ),
1225 _sfControlPoints (this,
1226 ControlPointsFieldId,
1227 GeoVectorProperty::ParentsFieldId),
1228 _sfError (source._sfError ),
1229 _sfNumCurves (source._sfNumCurves ),
1230 _mfKnotLengths (source._mfKnotLengths ),
1231 _mfDimensions (source._mfDimensions ),
1232 _mfCurveControlPoints (source._mfCurveControlPoints ),
1233 _mfKnots (source._mfKnots ),
1234 _mfCurvesPerLoop (source._mfCurvesPerLoop ),
1235 _sfIsDelaunay (source._sfIsDelaunay ),
1236 _sfTextureControlPoints (this,
1237 TextureControlPointsFieldId,
1238 GeoVectorProperty::ParentsFieldId),
1239 _sfDirtyMask (source._sfDirtyMask ),
1240 _sfSurfaceGLId (source._sfSurfaceGLId )
1241 {
1242 }
1243
1244
1245 /*-------------------------- destructors ----------------------------------*/
1246
1247 SurfaceBase::~SurfaceBase(void)
1248 {
1249 }
1250
1251 /*-------------------------------------------------------------------------*/
1252 /* Child linking */
1253
1254 bool SurfaceBase::unlinkChild(
1255 FieldContainer * const pChild,
1256 UInt16 const childFieldId)
1257 {
1258 if(childFieldId == ControlPointsFieldId)
1259 {
1260 GeoVectorProperty * pTypedChild =
1261 dynamic_cast<GeoVectorProperty *>(pChild);
1262
1263 if(pTypedChild != NULL)
1264 {
1265 if(_sfControlPoints.getValue() == pTypedChild)
1266 {
1267 editSField(ControlPointsFieldMask);
1268
1269 _sfControlPoints.setValue(NULL);
1270
1271 return true;
1272 }
1273
1274 SWARNING << "Parent ([" << this
1275 << "] id [" << this->getId()
1276 << "] type [" << this->getType().getCName()
1277 << "] childFieldId [" << childFieldId
1278 << "]) - Child ([" << pChild
1279 << "] id [" << pChild->getId()
1280 << "] type [" << pChild->getType().getCName()
1281 << "]): link inconsistent!"
1282 << std::endl;
1283
1284 return false;
1285 }
1286
1287 return false;
1288 }
1289
1290 if(childFieldId == TextureControlPointsFieldId)
1291 {
1292 GeoVectorProperty * pTypedChild =
1293 dynamic_cast<GeoVectorProperty *>(pChild);
1294
1295 if(pTypedChild != NULL)
1296 {
1297 if(_sfTextureControlPoints.getValue() == pTypedChild)
1298 {
1299 editSField(TextureControlPointsFieldMask);
1300
1301 _sfTextureControlPoints.setValue(NULL);
1302
1303 return true;
1304 }
1305
1306 SWARNING << "Parent ([" << this
1307 << "] id [" << this->getId()
1308 << "] type [" << this->getType().getCName()
1309 << "] childFieldId [" << childFieldId
1310 << "]) - Child ([" << pChild
1311 << "] id [" << pChild->getId()
1312 << "] type [" << pChild->getType().getCName()
1313 << "]): link inconsistent!"
1314 << std::endl;
1315
1316 return false;
1317 }
1318
1319 return false;
1320 }
1321
1322
1323 return Inherited::unlinkChild(pChild, childFieldId);
1324 }
1325
1326 void SurfaceBase::onCreate(const Surface *source)
1327 {
1328 Inherited::onCreate(source);
1329
1330 if(source != NULL)
1331 {
1332 Surface *pThis = static_cast<Surface *>(this);
1333
1334 pThis->setControlPoints(source->getControlPoints());
1335
1336 pThis->setTextureControlPoints(source->getTextureControlPoints());
1337 }
1338 }
1339
1340 GetFieldHandlePtr SurfaceBase::getHandleDimU (void) const
1341 {
1342 SFUInt32::GetHandlePtr returnValue(
1343 new SFUInt32::GetHandle(
1344 &_sfDimU,
1345 this->getType().getFieldDesc(DimUFieldId),
1346 const_cast<SurfaceBase *>(this)));
1347
1348 return returnValue;
1349 }
1350
1351 EditFieldHandlePtr SurfaceBase::editHandleDimU (void)
1352 {
1353 SFUInt32::EditHandlePtr returnValue(
1354 new SFUInt32::EditHandle(
1355 &_sfDimU,
1356 this->getType().getFieldDesc(DimUFieldId),
1357 this));
1358
1359
1360 editSField(DimUFieldMask);
1361
1362 return returnValue;
1363 }
1364
1365 GetFieldHandlePtr SurfaceBase::getHandleDimV (void) const
1366 {
1367 SFUInt32::GetHandlePtr returnValue(
1368 new SFUInt32::GetHandle(
1369 &_sfDimV,
1370 this->getType().getFieldDesc(DimVFieldId),
1371 const_cast<SurfaceBase *>(this)));
1372
1373 return returnValue;
1374 }
1375
1376 EditFieldHandlePtr SurfaceBase::editHandleDimV (void)
1377 {
1378 SFUInt32::EditHandlePtr returnValue(
1379 new SFUInt32::EditHandle(
1380 &_sfDimV,
1381 this->getType().getFieldDesc(DimVFieldId),
1382 this));
1383
1384
1385 editSField(DimVFieldMask);
1386
1387 return returnValue;
1388 }
1389
1390 GetFieldHandlePtr SurfaceBase::getHandleKnotsU (void) const
1391 {
1392 MFReal32::GetHandlePtr returnValue(
1393 new MFReal32::GetHandle(
1394 &_mfKnotsU,
1395 this->getType().getFieldDesc(KnotsUFieldId),
1396 const_cast<SurfaceBase *>(this)));
1397
1398 return returnValue;
1399 }
1400
1401 EditFieldHandlePtr SurfaceBase::editHandleKnotsU (void)
1402 {
1403 MFReal32::EditHandlePtr returnValue(
1404 new MFReal32::EditHandle(
1405 &_mfKnotsU,
1406 this->getType().getFieldDesc(KnotsUFieldId),
1407 this));
1408
1409
1410 editMField(KnotsUFieldMask, _mfKnotsU);
1411
1412 return returnValue;
1413 }
1414
1415 GetFieldHandlePtr SurfaceBase::getHandleKnotsV (void) const
1416 {
1417 MFReal32::GetHandlePtr returnValue(
1418 new MFReal32::GetHandle(
1419 &_mfKnotsV,
1420 this->getType().getFieldDesc(KnotsVFieldId),
1421 const_cast<SurfaceBase *>(this)));
1422
1423 return returnValue;
1424 }
1425
1426 EditFieldHandlePtr SurfaceBase::editHandleKnotsV (void)
1427 {
1428 MFReal32::EditHandlePtr returnValue(
1429 new MFReal32::EditHandle(
1430 &_mfKnotsV,
1431 this->getType().getFieldDesc(KnotsVFieldId),
1432 this));
1433
1434
1435 editMField(KnotsVFieldMask, _mfKnotsV);
1436
1437 return returnValue;
1438 }
1439
1440 GetFieldHandlePtr SurfaceBase::getHandleControlPoints (void) const
1441 {
1442 SFUnrecChildGeoVectorPropertyPtr::GetHandlePtr returnValue(
1443 new SFUnrecChildGeoVectorPropertyPtr::GetHandle(
1444 &_sfControlPoints,
1445 this->getType().getFieldDesc(ControlPointsFieldId),
1446 const_cast<SurfaceBase *>(this)));
1447
1448 return returnValue;
1449 }
1450
1451 EditFieldHandlePtr SurfaceBase::editHandleControlPoints (void)
1452 {
1453 SFUnrecChildGeoVectorPropertyPtr::EditHandlePtr returnValue(
1454 new SFUnrecChildGeoVectorPropertyPtr::EditHandle(
1455 &_sfControlPoints,
1456 this->getType().getFieldDesc(ControlPointsFieldId),
1457 this));
1458
1459 returnValue->setSetMethod(
1460 boost::bind(&Surface::setControlPoints,
1461 static_cast<Surface *>(this), _1));
1462
1463 editSField(ControlPointsFieldMask);
1464
1465 return returnValue;
1466 }
1467
1468 GetFieldHandlePtr SurfaceBase::getHandleError (void) const
1469 {
1470 SFReal32::GetHandlePtr returnValue(
1471 new SFReal32::GetHandle(
1472 &_sfError,
1473 this->getType().getFieldDesc(ErrorFieldId),
1474 const_cast<SurfaceBase *>(this)));
1475
1476 return returnValue;
1477 }
1478
1479 EditFieldHandlePtr SurfaceBase::editHandleError (void)
1480 {
1481 SFReal32::EditHandlePtr returnValue(
1482 new SFReal32::EditHandle(
1483 &_sfError,
1484 this->getType().getFieldDesc(ErrorFieldId),
1485 this));
1486
1487
1488 editSField(ErrorFieldMask);
1489
1490 return returnValue;
1491 }
1492
1493 GetFieldHandlePtr SurfaceBase::getHandleNumCurves (void) const
1494 {
1495 SFUInt32::GetHandlePtr returnValue(
1496 new SFUInt32::GetHandle(
1497 &_sfNumCurves,
1498 this->getType().getFieldDesc(NumCurvesFieldId),
1499 const_cast<SurfaceBase *>(this)));
1500
1501 return returnValue;
1502 }
1503
1504 EditFieldHandlePtr SurfaceBase::editHandleNumCurves (void)
1505 {
1506 SFUInt32::EditHandlePtr returnValue(
1507 new SFUInt32::EditHandle(
1508 &_sfNumCurves,
1509 this->getType().getFieldDesc(NumCurvesFieldId),
1510 this));
1511
1512
1513 editSField(NumCurvesFieldMask);
1514
1515 return returnValue;
1516 }
1517
1518 GetFieldHandlePtr SurfaceBase::getHandleKnotLengths (void) const
1519 {
1520 MFUInt32::GetHandlePtr returnValue(
1521 new MFUInt32::GetHandle(
1522 &_mfKnotLengths,
1523 this->getType().getFieldDesc(KnotLengthsFieldId),
1524 const_cast<SurfaceBase *>(this)));
1525
1526 return returnValue;
1527 }
1528
1529 EditFieldHandlePtr SurfaceBase::editHandleKnotLengths (void)
1530 {
1531 MFUInt32::EditHandlePtr returnValue(
1532 new MFUInt32::EditHandle(
1533 &_mfKnotLengths,
1534 this->getType().getFieldDesc(KnotLengthsFieldId),
1535 this));
1536
1537
1538 editMField(KnotLengthsFieldMask, _mfKnotLengths);
1539
1540 return returnValue;
1541 }
1542
1543 GetFieldHandlePtr SurfaceBase::getHandleDimensions (void) const
1544 {
1545 MFUInt32::GetHandlePtr returnValue(
1546 new MFUInt32::GetHandle(
1547 &_mfDimensions,
1548 this->getType().getFieldDesc(DimensionsFieldId),
1549 const_cast<SurfaceBase *>(this)));
1550
1551 return returnValue;
1552 }
1553
1554 EditFieldHandlePtr SurfaceBase::editHandleDimensions (void)
1555 {
1556 MFUInt32::EditHandlePtr returnValue(
1557 new MFUInt32::EditHandle(
1558 &_mfDimensions,
1559 this->getType().getFieldDesc(DimensionsFieldId),
1560 this));
1561
1562
1563 editMField(DimensionsFieldMask, _mfDimensions);
1564
1565 return returnValue;
1566 }
1567
1568 GetFieldHandlePtr SurfaceBase::getHandleCurveControlPoints (void) const
1569 {
1570 MFPnt3f::GetHandlePtr returnValue(
1571 new MFPnt3f::GetHandle(
1572 &_mfCurveControlPoints,
1573 this->getType().getFieldDesc(CurveControlPointsFieldId),
1574 const_cast<SurfaceBase *>(this)));
1575
1576 return returnValue;
1577 }
1578
1579 EditFieldHandlePtr SurfaceBase::editHandleCurveControlPoints(void)
1580 {
1581 MFPnt3f::EditHandlePtr returnValue(
1582 new MFPnt3f::EditHandle(
1583 &_mfCurveControlPoints,
1584 this->getType().getFieldDesc(CurveControlPointsFieldId),
1585 this));
1586
1587
1588 editMField(CurveControlPointsFieldMask, _mfCurveControlPoints);
1589
1590 return returnValue;
1591 }
1592
1593 GetFieldHandlePtr SurfaceBase::getHandleKnots (void) const
1594 {
1595 MFReal32::GetHandlePtr returnValue(
1596 new MFReal32::GetHandle(
1597 &_mfKnots,
1598 this->getType().getFieldDesc(KnotsFieldId),
1599 const_cast<SurfaceBase *>(this)));
1600
1601 return returnValue;
1602 }
1603
1604 EditFieldHandlePtr SurfaceBase::editHandleKnots (void)
1605 {
1606 MFReal32::EditHandlePtr returnValue(
1607 new MFReal32::EditHandle(
1608 &_mfKnots,
1609 this->getType().getFieldDesc(KnotsFieldId),
1610 this));
1611
1612
1613 editMField(KnotsFieldMask, _mfKnots);
1614
1615 return returnValue;
1616 }
1617
1618 GetFieldHandlePtr SurfaceBase::getHandleCurvesPerLoop (void) const
1619 {
1620 MFUInt32::GetHandlePtr returnValue(
1621 new MFUInt32::GetHandle(
1622 &_mfCurvesPerLoop,
1623 this->getType().getFieldDesc(CurvesPerLoopFieldId),
1624 const_cast<SurfaceBase *>(this)));
1625
1626 return returnValue;
1627 }
1628
1629 EditFieldHandlePtr SurfaceBase::editHandleCurvesPerLoop (void)
1630 {
1631 MFUInt32::EditHandlePtr returnValue(
1632 new MFUInt32::EditHandle(
1633 &_mfCurvesPerLoop,
1634 this->getType().getFieldDesc(CurvesPerLoopFieldId),
1635 this));
1636
1637
1638 editMField(CurvesPerLoopFieldMask, _mfCurvesPerLoop);
1639
1640 return returnValue;
1641 }
1642
1643 GetFieldHandlePtr SurfaceBase::getHandleIsDelaunay (void) const
1644 {
1645 SFBool::GetHandlePtr returnValue(
1646 new SFBool::GetHandle(
1647 &_sfIsDelaunay,
1648 this->getType().getFieldDesc(IsDelaunayFieldId),
1649 const_cast<SurfaceBase *>(this)));
1650
1651 return returnValue;
1652 }
1653
1654 EditFieldHandlePtr SurfaceBase::editHandleIsDelaunay (void)
1655 {
1656 SFBool::EditHandlePtr returnValue(
1657 new SFBool::EditHandle(
1658 &_sfIsDelaunay,
1659 this->getType().getFieldDesc(IsDelaunayFieldId),
1660 this));
1661
1662
1663 editSField(IsDelaunayFieldMask);
1664
1665 return returnValue;
1666 }
1667
1668 GetFieldHandlePtr SurfaceBase::getHandleTextureControlPoints (void) const
1669 {
1670 SFUnrecChildGeoVectorPropertyPtr::GetHandlePtr returnValue(
1671 new SFUnrecChildGeoVectorPropertyPtr::GetHandle(
1672 &_sfTextureControlPoints,
1673 this->getType().getFieldDesc(TextureControlPointsFieldId),
1674 const_cast<SurfaceBase *>(this)));
1675
1676 return returnValue;
1677 }
1678
1679 EditFieldHandlePtr SurfaceBase::editHandleTextureControlPoints(void)
1680 {
1681 SFUnrecChildGeoVectorPropertyPtr::EditHandlePtr returnValue(
1682 new SFUnrecChildGeoVectorPropertyPtr::EditHandle(
1683 &_sfTextureControlPoints,
1684 this->getType().getFieldDesc(TextureControlPointsFieldId),
1685 this));
1686
1687 returnValue->setSetMethod(
1688 boost::bind(&Surface::setTextureControlPoints,
1689 static_cast<Surface *>(this), _1));
1690
1691 editSField(TextureControlPointsFieldMask);
1692
1693 return returnValue;
1694 }
1695
1696 GetFieldHandlePtr SurfaceBase::getHandleDirtyMask (void) const
1697 {
1698 SFUInt32::GetHandlePtr returnValue(
1699 new SFUInt32::GetHandle(
1700 &_sfDirtyMask,
1701 this->getType().getFieldDesc(DirtyMaskFieldId),
1702 const_cast<SurfaceBase *>(this)));
1703
1704 return returnValue;
1705 }
1706
1707 EditFieldHandlePtr SurfaceBase::editHandleDirtyMask (void)
1708 {
1709 SFUInt32::EditHandlePtr returnValue(
1710 new SFUInt32::EditHandle(
1711 &_sfDirtyMask,
1712 this->getType().getFieldDesc(DirtyMaskFieldId),
1713 this));
1714
1715
1716 editSField(DirtyMaskFieldMask);
1717
1718 return returnValue;
1719 }
1720
1721 GetFieldHandlePtr SurfaceBase::getHandleSurfaceGLId (void) const
1722 {
1723 SFInt32::GetHandlePtr returnValue(
1724 new SFInt32::GetHandle(
1725 &_sfSurfaceGLId,
1726 this->getType().getFieldDesc(SurfaceGLIdFieldId),
1727 const_cast<SurfaceBase *>(this)));
1728
1729 return returnValue;
1730 }
1731
1732 EditFieldHandlePtr SurfaceBase::editHandleSurfaceGLId (void)
1733 {
1734 SFInt32::EditHandlePtr returnValue(
1735 new SFInt32::EditHandle(
1736 &_sfSurfaceGLId,
1737 this->getType().getFieldDesc(SurfaceGLIdFieldId),
1738 this));
1739
1740
1741 editSField(SurfaceGLIdFieldMask);
1742
1743 return returnValue;
1744 }
1745
1746
1747 #ifdef OSG_MT_CPTR_ASPECT
1748 void SurfaceBase::execSyncV( FieldContainer &oFrom,
1749 ConstFieldMaskArg whichField,
1750 AspectOffsetStore &oOffsets,
1751 ConstFieldMaskArg syncMode,
1752 const UInt32 uiSyncInfo)
1753 {
1754 Surface *pThis = static_cast<Surface *>(this);
1755
1756 pThis->execSync(static_cast<Surface *>(&oFrom),
1757 whichField,
1758 oOffsets,
1759 syncMode,
1760 uiSyncInfo);
1761 }
1762 #endif
1763
1764
1765 #ifdef OSG_MT_CPTR_ASPECT
1766 FieldContainer *SurfaceBase::createAspectCopy(
1767 const FieldContainer *pRefAspect) const
1768 {
1769 Surface *returnValue;
1770
1771 newAspectCopy(returnValue,
1772 dynamic_cast<const Surface *>(pRefAspect),
1773 dynamic_cast<const Surface *>(this));
1774
1775 return returnValue;
1776 }
1777 #endif
1778
1779 void SurfaceBase::resolveLinks(void)
1780 {
1781 Inherited::resolveLinks();
1782
1783 static_cast<Surface *>(this)->setControlPoints(NULL);
1784
1785 static_cast<Surface *>(this)->setTextureControlPoints(NULL);
1786
1787 #ifdef OSG_MT_CPTR_ASPECT
1788 AspectOffsetStore oOffsets;
1789
1790 _pAspectStore->fillOffsetArray(oOffsets, this);
1791 #endif
1792
1793 #ifdef OSG_MT_CPTR_ASPECT
1794 _mfKnotsU.terminateShare(Thread::getCurrentAspect(),
1795 oOffsets);
1796 #endif
1797 #ifdef OSG_MT_CPTR_ASPECT
1798 _mfKnotsV.terminateShare(Thread::getCurrentAspect(),
1799 oOffsets);
1800 #endif
1801 #ifdef OSG_MT_CPTR_ASPECT
1802 _mfKnotLengths.terminateShare(Thread::getCurrentAspect(),
1803 oOffsets);
1804 #endif
1805 #ifdef OSG_MT_CPTR_ASPECT
1806 _mfDimensions.terminateShare(Thread::getCurrentAspect(),
1807 oOffsets);
1808 #endif
1809 #ifdef OSG_MT_CPTR_ASPECT
1810 _mfCurveControlPoints.terminateShare(Thread::getCurrentAspect(),
1811 oOffsets);
1812 #endif
1813 #ifdef OSG_MT_CPTR_ASPECT
1814 _mfKnots.terminateShare(Thread::getCurrentAspect(),
1815 oOffsets);
1816 #endif
1817 #ifdef OSG_MT_CPTR_ASPECT
1818 _mfCurvesPerLoop.terminateShare(Thread::getCurrentAspect(),
1819 oOffsets);
1820 #endif
1821 }
1822
1823
1824 OSG_END_NAMESPACE