?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
changed: gcc8 base update
[opensg.git] / Source / System / Dynamics / Skeleton / OSGSkeletonBase.cpp
blobdf2aebab0c919ef10d44c100ca379246b6062cb2
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 Skeleton!
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 "OSGNode.h" // Roots Class
66 #include "OSGBaseSkeletonJoint.h" // Joints Class
67
68 #include "OSGSkeletonBase.h"
69 #include "OSGSkeleton.h"
70
71 #include <boost/bind.hpp>
72
73 OSG_BEGIN_NAMESPACE
74
75 /***************************************************************************\
76 * Description *
77 \***************************************************************************/
78
79 /*! \class OSG::Skeleton
80 A Skeleton is simply one (or multiple) node hierarchies that contain some
81 SkeletonJoint cores.
82 Traversal will jump to the roots (MFRoots) of these hierarchies and traverse
83 them, updating the matrix for each joint (MFJointMatrices) in the process.
84 A Skeleton assumes exclusive ownership of its joints, but the Skeleton itself
85 may be shared.
86 */
87
88 /***************************************************************************\
89 * Field Documentation *
90 \***************************************************************************/
91
92 /*! \var Node * SkeletonBase::_mfRoots
93 The roots of the joint (or bone) hierarchies for the skeleton.
94 There should be Nodes with SkeletonJoint cores in the pointed-to
95 hierarchies.
96 */
97
98 /*! \var BaseSkeletonJoint * SkeletonBase::_mfJoints
99 The joints (or bones) of the skeleton. Sorted by their jointId.
100 READ ONLY: You should never write to this field, Skeleton scans
101 for joints whenever the set of roots is modified.
102 */
103
104 /*! \var BaseSkeletonJoint * SkeletonBase::_mfParentJoints
105 Stores the parent of each joint at the position of the childs jointId.
106 In other words parentJoints[i] is the parent of the joint with
107 jointId i (which is stored in joints[i]). If the joint has no parent
108 NULL is stored instead.
109 READ ONLY: You should never write to this field, Skeleton scans
110 for joints whenever the set of roots is modified.
111 */
112
113 /*! \var Matrix SkeletonBase::_mfJointMatrices
114 Matrices for all joints of the skeleton. Elements correspond to
115 joints at the same index in _mfJoints.
116 These matrices are absolute, not relative to the parent joint.
117 READ ONLY: You should never write to this field, Skeleton updates
118 it during the RenderActions traversal.
119 */
120
121 /*! \var Matrix SkeletonBase::_mfJointNormalMatrices
122 Normal matrices for all joints of the skeleton (these are the inverse
123 transpose of the jointMatrices). Elements correspond to
124 joints at the same index in _mfJoints.
125 These matrices are absolute, not relative to the parent joint.
126 READ ONLY: You should never write to this field, Skeleton updates
127 it during the RenderActions traversal.
128 */
129
130 /*! \var bool SkeletonBase::_sfUseInvBindMatrix
131 Whether joints should use their SFInvBindMatrix when computing
132 the jointMatrices/jointNormalMatrices.
133 This is normally set automatically by a SkinnedGeometry as for
134 debug rendering of the bones this must be false.
135 */
136
137 /*! \var bool SkeletonBase::_sfCalcNormalMatrices
138 Whether jointNormalMatrices should be calculated when computing the
139 jointMatrices.
140 */
141
142 /*! \var OSGAny SkeletonBase::_sfJointsChanged
143 Used by the joints to efficiently notify the Skeleton that they have been
144 modified and matrices need to be recalculated.
145 If the trees starting at 'roots' contain for example Transform cores and
146 you modify those without making changes to any SkeletonJoint cores you will
147 have to call editJointsChanged() manually once per frame to force a
148 recomputation of the joint matrices.
149 */
150
151
152 /***************************************************************************\
153 * FieldType/FieldTrait Instantiation *
154 \***************************************************************************/
155
156 #if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)
157 PointerType FieldTraits<Skeleton *, nsOSG>::_type(
158 "SkeletonPtr",
159 "AttachmentContainerPtr",
160 Skeleton::getClassType(),
161 nsOSG);
162 #endif
163
164 OSG_FIELDTRAITS_GETTYPE_NS(Skeleton *, nsOSG)
165
166 OSG_EXPORT_PTR_SFIELD_FULL(PointerSField,
167 Skeleton *,
168 nsOSG)
169
170 OSG_EXPORT_PTR_MFIELD_FULL(PointerMField,
171 Skeleton *,
172 nsOSG)
173
174 DataType &FieldTraits< Skeleton *, nsOSG + 1 >::getType(void)
175 {
176 return FieldTraits<Skeleton *, nsOSG>::getType();
177 }
178
179
180 OSG_EXPORT_PTR_SFIELD(ChildPointerSField,
181 Skeleton *,
182 UnrecordedRefCountPolicy,
183 nsOSG + 1)
184
185
186 OSG_EXPORT_PTR_MFIELD(ChildPointerMField,
187 Skeleton *,
188 UnrecordedRefCountPolicy,
189 nsOSG + 1)
190
191
192 DataType &FieldTraits<Skeleton *, nsOSG + 2 >::getType(void)
193 {
194 return FieldTraits<Skeleton *, nsOSG>::getType();
195 }
196
197
198 OSG_SFIELDTYPE_INST(ParentPointerSField,
199 Skeleton *,
200 NoRefCountPolicy,
201 nsOSG + 2);
202
203 OSG_FIELD_DLLEXPORT_DEF3(ParentPointerSField,
204 Skeleton *,
205 NoRefCountPolicy,
206 nsOSG + 2)
207
208
209 OSG_MFIELDTYPE_INST(ParentPointerMField,
210 Skeleton *,
211 NoRefCountPolicy,
212 2);
213
214 OSG_FIELD_DLLEXPORT_DEF3(ParentPointerMField,
215 Skeleton *,
216 NoRefCountPolicy,
217 2)
218
219
220 /***************************************************************************\
221 * Field Description *
222 \***************************************************************************/
223
224 void SkeletonBase::classDescInserter(TypeObject &oType)
225 {
226 Inherited::classDescInserter(oType);
227
228 FieldDescriptionBase *pDesc = NULL;
229
230
231 pDesc = new MFUnrecNodePtr::Description(
232 MFUnrecNodePtr::getClassType(),
233 "roots",
234 "The roots of the joint (or bone) hierarchies for the skeleton.\n"
235 "There should be Nodes with SkeletonJoint cores in the pointed-to\n"
236 "hierarchies.\n",
237 RootsFieldId, RootsFieldMask,
238 false,
239 (Field::MFDefaultFlags | Field::FStdAccess),
240 static_cast<FieldEditMethodSig>(&Skeleton::editHandleRoots),
241 static_cast<FieldGetMethodSig >(&Skeleton::getHandleRoots));
242
243 oType.addInitialDesc(pDesc);
244
245 pDesc = new MFUnrecChildBaseSkeletonJointPtr::Description(
246 MFUnrecChildBaseSkeletonJointPtr::getClassType(),
247 "joints",
248 "The joints (or bones) of the skeleton. Sorted by their jointId.\n"
249 "READ ONLY: You should never write to this field, Skeleton scans\n"
250 "for joints whenever the set of roots is modified.\n",
251 JointsFieldId, JointsFieldMask,
252 false,
253 (Field::MFDefaultFlags | Field::FStdAccess),
254 static_cast<FieldEditMethodSig>(&Skeleton::editHandleJoints),
255 static_cast<FieldGetMethodSig >(&Skeleton::getHandleJoints));
256
257 oType.addInitialDesc(pDesc);
258
259 pDesc = new MFUnrecBaseSkeletonJointPtr::Description(
260 MFUnrecBaseSkeletonJointPtr::getClassType(),
261 "parentJoints",
262 "Stores the parent of each joint at the position of the childs jointId.\n"
263 "In other words parentJoints[i] is the parent of the joint with\n"
264 "jointId i (which is stored in joints[i]). If the joint has no parent\n"
265 "NULL is stored instead.\n"
266 "READ ONLY: You should never write to this field, Skeleton scans\n"
267 "for joints whenever the set of roots is modified.\n",
268 ParentJointsFieldId, ParentJointsFieldMask,
269 true,
270 (Field::MFDefaultFlags | Field::FStdAccess),
271 static_cast<FieldEditMethodSig>(&Skeleton::editHandleParentJoints),
272 static_cast<FieldGetMethodSig >(&Skeleton::getHandleParentJoints));
273
274 oType.addInitialDesc(pDesc);
275
276 pDesc = new MFMatrix::Description(
277 MFMatrix::getClassType(),
278 "jointMatrices",
279 "Matrices for all joints of the skeleton. Elements correspond to\n"
280 "joints at the same index in _mfJoints.\n"
281 "These matrices are absolute, not relative to the parent joint.\n"
282 "READ ONLY: You should never write to this field, Skeleton updates\n"
283 "it during the RenderActions traversal.\n",
284 JointMatricesFieldId, JointMatricesFieldMask,
285 true,
286 (Field::MFDefaultFlags | Field::FStdAccess),
287 static_cast<FieldEditMethodSig>(&Skeleton::editHandleJointMatrices),
288 static_cast<FieldGetMethodSig >(&Skeleton::getHandleJointMatrices));
289
290 oType.addInitialDesc(pDesc);
291
292 pDesc = new MFMatrix::Description(
293 MFMatrix::getClassType(),
294 "jointNormalMatrices",
295 "Normal matrices for all joints of the skeleton (these are the inverse\n"
296 "transpose of the jointMatrices). Elements correspond to\n"
297 "joints at the same index in _mfJoints.\n"
298 "These matrices are absolute, not relative to the parent joint.\n"
299 "READ ONLY: You should never write to this field, Skeleton updates\n"
300 "it during the RenderActions traversal.\n",
301 JointNormalMatricesFieldId, JointNormalMatricesFieldMask,
302 true,
303 (Field::MFDefaultFlags | Field::FStdAccess),
304 static_cast<FieldEditMethodSig>(&Skeleton::editHandleJointNormalMatrices),
305 static_cast<FieldGetMethodSig >(&Skeleton::getHandleJointNormalMatrices));
306
307 oType.addInitialDesc(pDesc);
308
309 pDesc = new SFBool::Description(
310 SFBool::getClassType(),
311 "useInvBindMatrix",
312 "Whether joints should use their SFInvBindMatrix when computing\n"
313 "the jointMatrices/jointNormalMatrices.\n"
314 "This is normally set automatically by a SkinnedGeometry as for\n"
315 "debug rendering of the bones this must be false.\n",
316 UseInvBindMatrixFieldId, UseInvBindMatrixFieldMask,
317 false,
318 (Field::SFDefaultFlags | Field::FStdAccess),
319 static_cast<FieldEditMethodSig>(&Skeleton::editHandleUseInvBindMatrix),
320 static_cast<FieldGetMethodSig >(&Skeleton::getHandleUseInvBindMatrix));
321
322 oType.addInitialDesc(pDesc);
323
324 pDesc = new SFBool::Description(
325 SFBool::getClassType(),
326 "calcNormalMatrices",
327 "Whether jointNormalMatrices should be calculated when computing the\n"
328 "jointMatrices.\n",
329 CalcNormalMatricesFieldId, CalcNormalMatricesFieldMask,
330 false,
331 (Field::SFDefaultFlags | Field::FStdAccess),
332 static_cast<FieldEditMethodSig>(&Skeleton::editHandleCalcNormalMatrices),
333 static_cast<FieldGetMethodSig >(&Skeleton::getHandleCalcNormalMatrices));
334
335 oType.addInitialDesc(pDesc);
336
337 pDesc = new SFOSGAny::Description(
338 SFOSGAny::getClassType(),
339 "jointsChanged",
340 "Used by the joints to efficiently notify the Skeleton that they have been\n"
341 "modified and matrices need to be recalculated.\n"
342 "If the trees starting at 'roots' contain for example Transform cores and\n"
343 "you modify those without making changes to any SkeletonJoint cores you will\n"
344 "have to call editJointsChanged() manually once per frame to force a\n"
345 "recomputation of the joint matrices.\n",
346 JointsChangedFieldId, JointsChangedFieldMask,
347 true,
348 (Field::SFDefaultFlags | Field::FStdAccess),
349 static_cast<FieldEditMethodSig>(&Skeleton::editHandleJointsChanged),
350 static_cast<FieldGetMethodSig >(&Skeleton::getHandleJointsChanged));
351
352 oType.addInitialDesc(pDesc);
353 }
354
355
356 SkeletonBase::TypeObject SkeletonBase::_type(
357 SkeletonBase::getClassname(),
358 Inherited::getClassname(),
359 "NULL",
360 nsOSG, //Namespace
361 reinterpret_cast<PrototypeCreateF>(&SkeletonBase::createEmptyLocal),
362 reinterpret_cast<InitContainerF>(&Skeleton::initMethod),
363 reinterpret_cast<ExitContainerF>(&Skeleton::exitMethod),
364 reinterpret_cast<InitalInsertDescFunc>(
365 reinterpret_cast<void *>(&Skeleton::classDescInserter)),
366 false,
367 0,
368 "<?xml version=\"1.0\"?>\n"
369 "\n"
370 "<FieldContainer\n"
371 " name=\"Skeleton\"\n"
372 " parent=\"AttachmentContainer\"\n"
373 " mixinparent=\"SkeletonParent\"\n"
374 " library=\"Dynamics\"\n"
375 " pointerfieldtypes=\"both\"\n"
376 " structure=\"concrete\"\n"
377 " systemcomponent=\"true\"\n"
378 " parentsystemcomponent=\"true\"\n"
379 " decoratable=\"false\"\n"
380 " childFields=\"both\"\n"
381 " parentFields=\"both\"\n"
382 ">\n"
383 " A Skeleton is simply one (or multiple) node hierarchies that contain some\n"
384 " SkeletonJoint cores.\n"
385 " Traversal will jump to the roots (MFRoots) of these hierarchies and traverse\n"
386 " them, updating the matrix for each joint (MFJointMatrices) in the process.\n"
387 " A Skeleton assumes exclusive ownership of its joints, but the Skeleton itself\n"
388 " may be shared.\n"
389 "\n"
390 " <Field\n"
391 " name=\"roots\"\n"
392 " type=\"Node\"\n"
393 " category=\"pointer\"\n"
394 " cardinality=\"multi\"\n"
395 " visibility=\"external\"\n"
396 " access=\"public\"\n"
397 " >\n"
398 " The roots of the joint (or bone) hierarchies for the skeleton.\n"
399 " There should be Nodes with SkeletonJoint cores in the pointed-to\n"
400 " hierarchies.\n"
401 " </Field>\n"
402 "\n"
403 " <Field\n"
404 " name=\"joints\"\n"
405 " type=\"BaseSkeletonJoint\"\n"
406 " category=\"childpointer\"\n"
407 " linkParentField=\"Skeleton\"\n"
408 " cardinality=\"multi\"\n"
409 " visibility=\"external\"\n"
410 " access=\"public\"\n"
411 " >\n"
412 " The joints (or bones) of the skeleton. Sorted by their jointId.\n"
413 " READ ONLY: You should never write to this field, Skeleton scans\n"
414 " for joints whenever the set of roots is modified.\n"
415 " </Field>\n"
416 "\n"
417 " <Field\n"
418 " name=\"parentJoints\"\n"
419 " type=\"BaseSkeletonJoint\"\n"
420 " category=\"pointer\"\n"
421 " cardinality=\"multi\"\n"
422 " visibility=\"internal\"\n"
423 " access=\"public\"\n"
424 " >\n"
425 " Stores the parent of each joint at the position of the childs jointId.\n"
426 " In other words parentJoints[i] is the parent of the joint with\n"
427 " jointId i (which is stored in joints[i]). If the joint has no parent\n"
428 " NULL is stored instead.\n"
429 " READ ONLY: You should never write to this field, Skeleton scans\n"
430 " for joints whenever the set of roots is modified.\n"
431 " </Field>\n"
432 "\n"
433 " <Field\n"
434 " name=\"jointMatrices\"\n"
435 " type=\"Matrix\"\n"
436 " category=\"data\"\n"
437 " cardinality=\"multi\"\n"
438 " visibility=\"internal\"\n"
439 " access=\"public\"\n"
440 " >\n"
441 " Matrices for all joints of the skeleton. Elements correspond to\n"
442 " joints at the same index in _mfJoints.\n"
443 " These matrices are absolute, not relative to the parent joint.\n"
444 " READ ONLY: You should never write to this field, Skeleton updates\n"
445 " it during the RenderActions traversal.\n"
446 " </Field>\n"
447 "\n"
448 " <Field\n"
449 " name=\"jointNormalMatrices\"\n"
450 " type=\"Matrix\"\n"
451 " category=\"data\"\n"
452 " cardinality=\"multi\"\n"
453 " visibility=\"internal\"\n"
454 " access=\"public\"\n"
455 " >\n"
456 " Normal matrices for all joints of the skeleton (these are the inverse\n"
457 " transpose of the jointMatrices). Elements correspond to\n"
458 " joints at the same index in _mfJoints.\n"
459 " These matrices are absolute, not relative to the parent joint.\n"
460 " READ ONLY: You should never write to this field, Skeleton updates\n"
461 " it during the RenderActions traversal.\n"
462 " </Field>\n"
463 "\n"
464 " <Field\n"
465 " name=\"useInvBindMatrix\"\n"
466 " type=\"bool\"\n"
467 " category=\"data\"\n"
468 " cardinality=\"single\"\n"
469 " visibility=\"external\"\n"
470 " access=\"public\"\n"
471 " defaultValue=\"true\"\n"
472 " >\n"
473 " Whether joints should use their SFInvBindMatrix when computing\n"
474 " the jointMatrices/jointNormalMatrices.\n"
475 " This is normally set automatically by a SkinnedGeometry as for\n"
476 " debug rendering of the bones this must be false.\n"
477 " </Field>\n"
478 "\n"
479 " <Field\n"
480 " name=\"calcNormalMatrices\"\n"
481 " type=\"bool\"\n"
482 " category=\"data\"\n"
483 " cardinality=\"single\"\n"
484 " visibility=\"external\"\n"
485 " access=\"public\"\n"
486 " defaultValue=\"false\"\n"
487 " >\n"
488 " Whether jointNormalMatrices should be calculated when computing the\n"
489 " jointMatrices.\n"
490 " </Field>\n"
491 "\n"
492 " <Field\n"
493 " name=\"jointsChanged\"\n"
494 " type=\"OSGAny\"\n"
495 " category=\"data\"\n"
496 " cardinality=\"single\"\n"
497 " visibility=\"internal\"\n"
498 " access=\"public\"\n"
499 " >\n"
500 " Used by the joints to efficiently notify the Skeleton that they have been\n"
501 " modified and matrices need to be recalculated.\n"
502 " If the trees starting at 'roots' contain for example Transform cores and\n"
503 " you modify those without making changes to any SkeletonJoint cores you will\n"
504 " have to call editJointsChanged() manually once per frame to force a\n"
505 " recomputation of the joint matrices.\n"
506 " </Field>\n"
507 "\n"
508 "</FieldContainer>\n",
509 "A Skeleton is simply one (or multiple) node hierarchies that contain some\n"
510 "SkeletonJoint cores.\n"
511 "Traversal will jump to the roots (MFRoots) of these hierarchies and traverse\n"
512 "them, updating the matrix for each joint (MFJointMatrices) in the process.\n"
513 "A Skeleton assumes exclusive ownership of its joints, but the Skeleton itself\n"
514 "may be shared.\n"
515 );
516
517 /*------------------------------ get -----------------------------------*/
518
519 FieldContainerType &SkeletonBase::getType(void)
520 {
521 return _type;
522 }
523
524 const FieldContainerType &SkeletonBase::getType(void) const
525 {
526 return _type;
527 }
528
529 UInt32 SkeletonBase::getContainerSize(void) const
530 {
531 return sizeof(Skeleton);
532 }
533
534 /*------------------------- decorator get ------------------------------*/
535
536
537 //! Get the Skeleton::_mfRoots field.
538 const MFUnrecNodePtr *SkeletonBase::getMFRoots(void) const
539 {
540 return &_mfRoots;
541 }
542
543 MFUnrecNodePtr *SkeletonBase::editMFRoots (void)
544 {
545 editMField(RootsFieldMask, _mfRoots);
546
547 return &_mfRoots;
548 }
549 Node * SkeletonBase::getRoots(const UInt32 index) const
550 {
551 return _mfRoots[index];
552 }
553
554 //! Get the Skeleton::_mfJoints field.
555 const MFUnrecChildBaseSkeletonJointPtr *SkeletonBase::getMFJoints(void) const
556 {
557 return &_mfJoints;
558 }
559
560 MFUnrecChildBaseSkeletonJointPtr *SkeletonBase::editMFJoints (void)
561 {
562 editMField(JointsFieldMask, _mfJoints);
563
564 return &_mfJoints;
565 }
566 BaseSkeletonJoint * SkeletonBase::getJoints(const UInt32 index) const
567 {
568 return _mfJoints[index];
569 }
570
571 //! Get the Skeleton::_mfParentJoints field.
572 const MFUnrecBaseSkeletonJointPtr *SkeletonBase::getMFParentJoints(void) const
573 {
574 return &_mfParentJoints;
575 }
576
577 MFUnrecBaseSkeletonJointPtr *SkeletonBase::editMFParentJoints (void)
578 {
579 editMField(ParentJointsFieldMask, _mfParentJoints);
580
581 return &_mfParentJoints;
582 }
583 BaseSkeletonJoint * SkeletonBase::getParentJoints(const UInt32 index) const
584 {
585 return _mfParentJoints[index];
586 }
587
588 MFMatrix *SkeletonBase::editMFJointMatrices(void)
589 {
590 editMField(JointMatricesFieldMask, _mfJointMatrices);
591
592 return &_mfJointMatrices;
593 }
594
595 const MFMatrix *SkeletonBase::getMFJointMatrices(void) const
596 {
597 return &_mfJointMatrices;
598 }
599
600
601 MFMatrix *SkeletonBase::editMFJointNormalMatrices(void)
602 {
603 editMField(JointNormalMatricesFieldMask, _mfJointNormalMatrices);
604
605 return &_mfJointNormalMatrices;
606 }
607
608 const MFMatrix *SkeletonBase::getMFJointNormalMatrices(void) const
609 {
610 return &_mfJointNormalMatrices;
611 }
612
613
614 SFBool *SkeletonBase::editSFUseInvBindMatrix(void)
615 {
616 editSField(UseInvBindMatrixFieldMask);
617
618 return &_sfUseInvBindMatrix;
619 }
620
621 const SFBool *SkeletonBase::getSFUseInvBindMatrix(void) const
622 {
623 return &_sfUseInvBindMatrix;
624 }
625
626
627 SFBool *SkeletonBase::editSFCalcNormalMatrices(void)
628 {
629 editSField(CalcNormalMatricesFieldMask);
630
631 return &_sfCalcNormalMatrices;
632 }
633
634 const SFBool *SkeletonBase::getSFCalcNormalMatrices(void) const
635 {
636 return &_sfCalcNormalMatrices;
637 }
638
639
640 SFOSGAny *SkeletonBase::editSFJointsChanged(void)
641 {
642 editSField(JointsChangedFieldMask);
643
644 return &_sfJointsChanged;
645 }
646
647 const SFOSGAny *SkeletonBase::getSFJointsChanged(void) const
648 {
649 return &_sfJointsChanged;
650 }
651
652
653
654
655 void SkeletonBase::pushToRoots(Node * const value)
656 {
657 editMField(RootsFieldMask, _mfRoots);
658
659 _mfRoots.push_back(value);
660 }
661
662 void SkeletonBase::assignRoots (const MFUnrecNodePtr &value)
663 {
664 MFUnrecNodePtr ::const_iterator elemIt =
665 value.begin();
666 MFUnrecNodePtr ::const_iterator elemEnd =
667 value.end ();
668
669 static_cast<Skeleton *>(this)->clearRoots();
670
671 while(elemIt != elemEnd)
672 {
673 this->pushToRoots(*elemIt);
674
675 ++elemIt;
676 }
677 }
678
679 void SkeletonBase::removeFromRoots(UInt32 uiIndex)
680 {
681 if(uiIndex < _mfRoots.size())
682 {
683 editMField(RootsFieldMask, _mfRoots);
684
685 _mfRoots.erase(uiIndex);
686 }
687 }
688
689 void SkeletonBase::removeObjFromRoots(Node * const value)
690 {
691 Int32 iElemIdx = _mfRoots.findIndex(value);
692
693 if(iElemIdx != -1)
694 {
695 editMField(RootsFieldMask, _mfRoots);
696
697 _mfRoots.erase(iElemIdx);
698 }
699 }
700 void SkeletonBase::clearRoots(void)
701 {
702 editMField(RootsFieldMask, _mfRoots);
703
704
705 _mfRoots.clear();
706 }
707
708 void SkeletonBase::pushToJoints(BaseSkeletonJoint * const value)
709 {
710 editMField(JointsFieldMask, _mfJoints);
711
712 _mfJoints.push_back(value);
713 }
714
715 void SkeletonBase::assignJoints (const MFUnrecChildBaseSkeletonJointPtr &value)
716 {
717 MFUnrecChildBaseSkeletonJointPtr::const_iterator elemIt =
718 value.begin();
719 MFUnrecChildBaseSkeletonJointPtr::const_iterator elemEnd =
720 value.end ();
721
722 static_cast<Skeleton *>(this)->clearJoints();
723
724 while(elemIt != elemEnd)
725 {
726 this->pushToJoints(*elemIt);
727
728 ++elemIt;
729 }
730 }
731
732 void SkeletonBase::removeFromJoints(UInt32 uiIndex)
733 {
734 if(uiIndex < _mfJoints.size())
735 {
736 editMField(JointsFieldMask, _mfJoints);
737
738 _mfJoints.erase(uiIndex);
739 }
740 }
741
742 void SkeletonBase::removeObjFromJoints(BaseSkeletonJoint * const value)
743 {
744 Int32 iElemIdx = _mfJoints.findIndex(value);
745
746 if(iElemIdx != -1)
747 {
748 editMField(JointsFieldMask, _mfJoints);
749
750 _mfJoints.erase(iElemIdx);
751 }
752 }
753 void SkeletonBase::clearJoints(void)
754 {
755 editMField(JointsFieldMask, _mfJoints);
756
757
758 _mfJoints.clear();
759 }
760
761 void SkeletonBase::pushToParentJoints(BaseSkeletonJoint * const value)
762 {
763 editMField(ParentJointsFieldMask, _mfParentJoints);
764
765 _mfParentJoints.push_back(value);
766 }
767
768 void SkeletonBase::assignParentJoints(const MFUnrecBaseSkeletonJointPtr &value)
769 {
770 MFUnrecBaseSkeletonJointPtr::const_iterator elemIt =
771 value.begin();
772 MFUnrecBaseSkeletonJointPtr::const_iterator elemEnd =
773 value.end ();
774
775 static_cast<Skeleton *>(this)->clearParentJoints();
776
777 while(elemIt != elemEnd)
778 {
779 this->pushToParentJoints(*elemIt);
780
781 ++elemIt;
782 }
783 }
784
785 void SkeletonBase::removeFromParentJoints(UInt32 uiIndex)
786 {
787 if(uiIndex < _mfParentJoints.size())
788 {
789 editMField(ParentJointsFieldMask, _mfParentJoints);
790
791 _mfParentJoints.erase(uiIndex);
792 }
793 }
794
795 void SkeletonBase::removeObjFromParentJoints(BaseSkeletonJoint * const value)
796 {
797 Int32 iElemIdx = _mfParentJoints.findIndex(value);
798
799 if(iElemIdx != -1)
800 {
801 editMField(ParentJointsFieldMask, _mfParentJoints);
802
803 _mfParentJoints.erase(iElemIdx);
804 }
805 }
806 void SkeletonBase::clearParentJoints(void)
807 {
808 editMField(ParentJointsFieldMask, _mfParentJoints);
809
810
811 _mfParentJoints.clear();
812 }
813
814
815
816 /*------------------------------ access -----------------------------------*/
817
818 SizeT SkeletonBase::getBinSize(ConstFieldMaskArg whichField)
819 {
820 SizeT returnValue = Inherited::getBinSize(whichField);
821
822 if(FieldBits::NoField != (RootsFieldMask & whichField))
823 {
824 returnValue += _mfRoots.getBinSize();
825 }
826 if(FieldBits::NoField != (JointsFieldMask & whichField))
827 {
828 returnValue += _mfJoints.getBinSize();
829 }
830 if(FieldBits::NoField != (ParentJointsFieldMask & whichField))
831 {
832 returnValue += _mfParentJoints.getBinSize();
833 }
834 if(FieldBits::NoField != (JointMatricesFieldMask & whichField))
835 {
836 returnValue += _mfJointMatrices.getBinSize();
837 }
838 if(FieldBits::NoField != (JointNormalMatricesFieldMask & whichField))
839 {
840 returnValue += _mfJointNormalMatrices.getBinSize();
841 }
842 if(FieldBits::NoField != (UseInvBindMatrixFieldMask & whichField))
843 {
844 returnValue += _sfUseInvBindMatrix.getBinSize();
845 }
846 if(FieldBits::NoField != (CalcNormalMatricesFieldMask & whichField))
847 {
848 returnValue += _sfCalcNormalMatrices.getBinSize();
849 }
850 if(FieldBits::NoField != (JointsChangedFieldMask & whichField))
851 {
852 returnValue += _sfJointsChanged.getBinSize();
853 }
854
855 return returnValue;
856 }
857
858 void SkeletonBase::copyToBin(BinaryDataHandler &pMem,
859 ConstFieldMaskArg whichField)
860 {
861 Inherited::copyToBin(pMem, whichField);
862
863 if(FieldBits::NoField != (RootsFieldMask & whichField))
864 {
865 _mfRoots.copyToBin(pMem);
866 }
867 if(FieldBits::NoField != (JointsFieldMask & whichField))
868 {
869 _mfJoints.copyToBin(pMem);
870 }
871 if(FieldBits::NoField != (ParentJointsFieldMask & whichField))
872 {
873 _mfParentJoints.copyToBin(pMem);
874 }
875 if(FieldBits::NoField != (JointMatricesFieldMask & whichField))
876 {
877 _mfJointMatrices.copyToBin(pMem);
878 }
879 if(FieldBits::NoField != (JointNormalMatricesFieldMask & whichField))
880 {
881 _mfJointNormalMatrices.copyToBin(pMem);
882 }
883 if(FieldBits::NoField != (UseInvBindMatrixFieldMask & whichField))
884 {
885 _sfUseInvBindMatrix.copyToBin(pMem);
886 }
887 if(FieldBits::NoField != (CalcNormalMatricesFieldMask & whichField))
888 {
889 _sfCalcNormalMatrices.copyToBin(pMem);
890 }
891 if(FieldBits::NoField != (JointsChangedFieldMask & whichField))
892 {
893 _sfJointsChanged.copyToBin(pMem);
894 }
895 }
896
897 void SkeletonBase::copyFromBin(BinaryDataHandler &pMem,
898 ConstFieldMaskArg whichField)
899 {
900 Inherited::copyFromBin(pMem, whichField);
901
902 if(FieldBits::NoField != (RootsFieldMask & whichField))
903 {
904 editMField(RootsFieldMask, _mfRoots);
905 _mfRoots.copyFromBin(pMem);
906 }
907 if(FieldBits::NoField != (JointsFieldMask & whichField))
908 {
909 editMField(JointsFieldMask, _mfJoints);
910 _mfJoints.copyFromBin(pMem);
911 }
912 if(FieldBits::NoField != (ParentJointsFieldMask & whichField))
913 {
914 editMField(ParentJointsFieldMask, _mfParentJoints);
915 _mfParentJoints.copyFromBin(pMem);
916 }
917 if(FieldBits::NoField != (JointMatricesFieldMask & whichField))
918 {
919 editMField(JointMatricesFieldMask, _mfJointMatrices);
920 _mfJointMatrices.copyFromBin(pMem);
921 }
922 if(FieldBits::NoField != (JointNormalMatricesFieldMask & whichField))
923 {
924 editMField(JointNormalMatricesFieldMask, _mfJointNormalMatrices);
925 _mfJointNormalMatrices.copyFromBin(pMem);
926 }
927 if(FieldBits::NoField != (UseInvBindMatrixFieldMask & whichField))
928 {
929 editSField(UseInvBindMatrixFieldMask);
930 _sfUseInvBindMatrix.copyFromBin(pMem);
931 }
932 if(FieldBits::NoField != (CalcNormalMatricesFieldMask & whichField))
933 {
934 editSField(CalcNormalMatricesFieldMask);
935 _sfCalcNormalMatrices.copyFromBin(pMem);
936 }
937 if(FieldBits::NoField != (JointsChangedFieldMask & whichField))
938 {
939 editSField(JointsChangedFieldMask);
940 _sfJointsChanged.copyFromBin(pMem);
941 }
942 }
943
944 //! create a new instance of the class
945 SkeletonTransitPtr SkeletonBase::createLocal(BitVector bFlags)
946 {
947 SkeletonTransitPtr fc;
948
949 if(getClassType().getPrototype() != NULL)
950 {
951 FieldContainerTransitPtr tmpPtr =
952 getClassType().getPrototype()-> shallowCopyLocal(bFlags);
953
954 fc = dynamic_pointer_cast<Skeleton>(tmpPtr);
955 }
956
957 return fc;
958 }
959
960 //! create a new instance of the class, copy the container flags
961 SkeletonTransitPtr SkeletonBase::createDependent(BitVector bFlags)
962 {
963 SkeletonTransitPtr fc;
964
965 if(getClassType().getPrototype() != NULL)
966 {
967 FieldContainerTransitPtr tmpPtr =
968 getClassType().getPrototype()-> shallowCopyDependent(bFlags);
969
970 fc = dynamic_pointer_cast<Skeleton>(tmpPtr);
971 }
972
973 return fc;
974 }
975
976 //! create a new instance of the class
977 SkeletonTransitPtr SkeletonBase::create(void)
978 {
979 SkeletonTransitPtr fc;
980
981 if(getClassType().getPrototype() != NULL)
982 {
983 FieldContainerTransitPtr tmpPtr =
984 getClassType().getPrototype()-> shallowCopy();
985
986 fc = dynamic_pointer_cast<Skeleton>(tmpPtr);
987 }
988
989 return fc;
990 }
991
992 Skeleton *SkeletonBase::createEmptyLocal(BitVector bFlags)
993 {
994 Skeleton *returnValue;
995
996 newPtr<Skeleton>(returnValue, bFlags);
997
998 returnValue->_pFieldFlags->_bNamespaceMask &= ~bFlags;
999
1000 return returnValue;
1001 }
1002
1003 //! create an empty new instance of the class, do not copy the prototype
1004 Skeleton *SkeletonBase::createEmpty(void)
1005 {
1006 Skeleton *returnValue;
1007
1008 newPtr<Skeleton>(returnValue, Thread::getCurrentLocalFlags());
1009
1010 returnValue->_pFieldFlags->_bNamespaceMask &=
1011 ~Thread::getCurrentLocalFlags();
1012
1013 return returnValue;
1014 }
1015
1016
1017 FieldContainerTransitPtr SkeletonBase::shallowCopyLocal(
1018 BitVector bFlags) const
1019 {
1020 Skeleton *tmpPtr;
1021
1022 newPtr(tmpPtr, dynamic_cast<const Skeleton *>(this), bFlags);
1023
1024 FieldContainerTransitPtr returnValue(tmpPtr);
1025
1026 tmpPtr->_pFieldFlags->_bNamespaceMask &= ~bFlags;
1027
1028 return returnValue;
1029 }
1030
1031 FieldContainerTransitPtr SkeletonBase::shallowCopyDependent(
1032 BitVector bFlags) const
1033 {
1034 Skeleton *tmpPtr;
1035
1036 newPtr(tmpPtr, dynamic_cast<const Skeleton *>(this), ~bFlags);
1037
1038 FieldContainerTransitPtr returnValue(tmpPtr);
1039
1040 tmpPtr->_pFieldFlags->_bNamespaceMask = bFlags;
1041
1042 return returnValue;
1043 }
1044
1045 FieldContainerTransitPtr SkeletonBase::shallowCopy(void) const
1046 {
1047 Skeleton *tmpPtr;
1048
1049 newPtr(tmpPtr,
1050 dynamic_cast<const Skeleton *>(this),
1051 Thread::getCurrentLocalFlags());
1052
1053 tmpPtr->_pFieldFlags->_bNamespaceMask &= ~Thread::getCurrentLocalFlags();
1054
1055 FieldContainerTransitPtr returnValue(tmpPtr);
1056
1057 return returnValue;
1058 }
1059
1060
1061
1062
1063 /*------------------------- constructors ----------------------------------*/
1064
1065 SkeletonBase::SkeletonBase(void) :
1066 Inherited(),
1067 _mfRoots (),
1068 _mfJoints (this,
1069 JointsFieldId,
1070 BaseSkeletonJoint::SkeletonFieldId),
1071 _mfParentJoints (),
1072 _mfJointMatrices (),
1073 _mfJointNormalMatrices (),
1074 _sfUseInvBindMatrix (bool(true)),
1075 _sfCalcNormalMatrices (bool(false)),
1076 _sfJointsChanged ()
1077 {
1078 }
1079
1080 SkeletonBase::SkeletonBase(const SkeletonBase &source) :
1081 Inherited(source),
1082 _mfRoots (),
1083 _mfJoints (this,
1084 JointsFieldId,
1085 BaseSkeletonJoint::SkeletonFieldId),
1086 _mfParentJoints (),
1087 _mfJointMatrices (source._mfJointMatrices ),
1088 _mfJointNormalMatrices (source._mfJointNormalMatrices ),
1089 _sfUseInvBindMatrix (source._sfUseInvBindMatrix ),
1090 _sfCalcNormalMatrices (source._sfCalcNormalMatrices ),
1091 _sfJointsChanged (source._sfJointsChanged )
1092 {
1093 }
1094
1095
1096 /*-------------------------- destructors ----------------------------------*/
1097
1098 SkeletonBase::~SkeletonBase(void)
1099 {
1100 }
1101
1102 /*-------------------------------------------------------------------------*/
1103 /* Child linking */
1104
1105 bool SkeletonBase::unlinkChild(
1106 FieldContainer * const pChild,
1107 UInt16 const childFieldId)
1108 {
1109 if(childFieldId == JointsFieldId)
1110 {
1111 BaseSkeletonJoint * pTypedChild =
1112 dynamic_cast<BaseSkeletonJoint *>(pChild);
1113
1114 if(pTypedChild != NULL)
1115 {
1116 Int32 iChildIdx = _mfJoints.findIndex(pTypedChild);
1117
1118 if(iChildIdx != -1)
1119 {
1120 editMField(JointsFieldMask, _mfJoints);
1121
1122 _mfJoints.erase(iChildIdx);
1123
1124 return true;
1125 }
1126
1127 SWARNING << "Parent ([" << this
1128 << "] id [" << this->getId()
1129 << "] type [" << this->getType().getCName()
1130 << "] childFieldId [" << childFieldId
1131 << "]) - Child ([" << pChild
1132 << "] id [" << pChild->getId()
1133 << "] type [" << pChild->getType().getCName()
1134 << "]): link inconsistent!"
1135 << std::endl;
1136
1137 return false;
1138 }
1139
1140 return false;
1141 }
1142
1143
1144 return Inherited::unlinkChild(pChild, childFieldId);
1145 }
1146
1147 void SkeletonBase::onCreate(const Skeleton *source)
1148 {
1149 Inherited::onCreate(source);
1150
1151 if(source != NULL)
1152 {
1153 Skeleton *pThis = static_cast<Skeleton *>(this);
1154
1155 MFUnrecNodePtr::const_iterator RootsIt =
1156 source->_mfRoots.begin();
1157 MFUnrecNodePtr::const_iterator RootsEnd =
1158 source->_mfRoots.end ();
1159
1160 while(RootsIt != RootsEnd)
1161 {
1162 pThis->pushToRoots(*RootsIt);
1163
1164 ++RootsIt;
1165 }
1166
1167 MFUnrecChildBaseSkeletonJointPtr::const_iterator JointsIt =
1168 source->_mfJoints.begin();
1169 MFUnrecChildBaseSkeletonJointPtr::const_iterator JointsEnd =
1170 source->_mfJoints.end ();
1171
1172 while(JointsIt != JointsEnd)
1173 {
1174 pThis->pushToJoints(*JointsIt);
1175
1176 ++JointsIt;
1177 }
1178
1179 MFUnrecBaseSkeletonJointPtr::const_iterator ParentJointsIt =
1180 source->_mfParentJoints.begin();
1181 MFUnrecBaseSkeletonJointPtr::const_iterator ParentJointsEnd =
1182 source->_mfParentJoints.end ();
1183
1184 while(ParentJointsIt != ParentJointsEnd)
1185 {
1186 pThis->pushToParentJoints(*ParentJointsIt);
1187
1188 ++ParentJointsIt;
1189 }
1190 }
1191 }
1192
1193 GetFieldHandlePtr SkeletonBase::getHandleRoots (void) const
1194 {
1195 MFUnrecNodePtr::GetHandlePtr returnValue(
1196 new MFUnrecNodePtr::GetHandle(
1197 &_mfRoots,
1198 this->getType().getFieldDesc(RootsFieldId),
1199 const_cast<SkeletonBase *>(this)));
1200
1201 return returnValue;
1202 }
1203
1204 EditFieldHandlePtr SkeletonBase::editHandleRoots (void)
1205 {
1206 MFUnrecNodePtr::EditHandlePtr returnValue(
1207 new MFUnrecNodePtr::EditHandle(
1208 &_mfRoots,
1209 this->getType().getFieldDesc(RootsFieldId),
1210 this));
1211
1212 returnValue->setAddMethod(
1213 boost::bind(&Skeleton::pushToRoots,
1214 static_cast<Skeleton *>(this), _1));
1215 returnValue->setRemoveMethod(
1216 boost::bind(&Skeleton::removeFromRoots,
1217 static_cast<Skeleton *>(this), _1));
1218 returnValue->setRemoveObjMethod(
1219 boost::bind(&Skeleton::removeObjFromRoots,
1220 static_cast<Skeleton *>(this), _1));
1221 returnValue->setClearMethod(
1222 boost::bind(&Skeleton::clearRoots,
1223 static_cast<Skeleton *>(this)));
1224
1225 editMField(RootsFieldMask, _mfRoots);
1226
1227 return returnValue;
1228 }
1229
1230 GetFieldHandlePtr SkeletonBase::getHandleJoints (void) const
1231 {
1232 MFUnrecChildBaseSkeletonJointPtr::GetHandlePtr returnValue(
1233 new MFUnrecChildBaseSkeletonJointPtr::GetHandle(
1234 &_mfJoints,
1235 this->getType().getFieldDesc(JointsFieldId),
1236 const_cast<SkeletonBase *>(this)));
1237
1238 return returnValue;
1239 }
1240
1241 EditFieldHandlePtr SkeletonBase::editHandleJoints (void)
1242 {
1243 MFUnrecChildBaseSkeletonJointPtr::EditHandlePtr returnValue(
1244 new MFUnrecChildBaseSkeletonJointPtr::EditHandle(
1245 &_mfJoints,
1246 this->getType().getFieldDesc(JointsFieldId),
1247 this));
1248
1249 returnValue->setAddMethod(
1250 boost::bind(&Skeleton::pushToJoints,
1251 static_cast<Skeleton *>(this), _1));
1252 returnValue->setRemoveMethod(
1253 boost::bind(&Skeleton::removeFromJoints,
1254 static_cast<Skeleton *>(this), _1));
1255 returnValue->setRemoveObjMethod(
1256 boost::bind(&Skeleton::removeObjFromJoints,
1257 static_cast<Skeleton *>(this), _1));
1258 returnValue->setClearMethod(
1259 boost::bind(&Skeleton::clearJoints,
1260 static_cast<Skeleton *>(this)));
1261
1262 editMField(JointsFieldMask, _mfJoints);
1263
1264 return returnValue;
1265 }
1266
1267 GetFieldHandlePtr SkeletonBase::getHandleParentJoints (void) const
1268 {
1269 MFUnrecBaseSkeletonJointPtr::GetHandlePtr returnValue(
1270 new MFUnrecBaseSkeletonJointPtr::GetHandle(
1271 &_mfParentJoints,
1272 this->getType().getFieldDesc(ParentJointsFieldId),
1273 const_cast<SkeletonBase *>(this)));
1274
1275 return returnValue;
1276 }
1277
1278 EditFieldHandlePtr SkeletonBase::editHandleParentJoints (void)
1279 {
1280 MFUnrecBaseSkeletonJointPtr::EditHandlePtr returnValue(
1281 new MFUnrecBaseSkeletonJointPtr::EditHandle(
1282 &_mfParentJoints,
1283 this->getType().getFieldDesc(ParentJointsFieldId),
1284 this));
1285
1286 returnValue->setAddMethod(
1287 boost::bind(&Skeleton::pushToParentJoints,
1288 static_cast<Skeleton *>(this), _1));
1289 returnValue->setRemoveMethod(
1290 boost::bind(&Skeleton::removeFromParentJoints,
1291 static_cast<Skeleton *>(this), _1));
1292 returnValue->setRemoveObjMethod(
1293 boost::bind(&Skeleton::removeObjFromParentJoints,
1294 static_cast<Skeleton *>(this), _1));
1295 returnValue->setClearMethod(
1296 boost::bind(&Skeleton::clearParentJoints,
1297 static_cast<Skeleton *>(this)));
1298
1299 editMField(ParentJointsFieldMask, _mfParentJoints);
1300
1301 return returnValue;
1302 }
1303
1304 GetFieldHandlePtr SkeletonBase::getHandleJointMatrices (void) const
1305 {
1306 MFMatrix::GetHandlePtr returnValue(
1307 new MFMatrix::GetHandle(
1308 &_mfJointMatrices,
1309 this->getType().getFieldDesc(JointMatricesFieldId),
1310 const_cast<SkeletonBase *>(this)));
1311
1312 return returnValue;
1313 }
1314
1315 EditFieldHandlePtr SkeletonBase::editHandleJointMatrices (void)
1316 {
1317 MFMatrix::EditHandlePtr returnValue(
1318 new MFMatrix::EditHandle(
1319 &_mfJointMatrices,
1320 this->getType().getFieldDesc(JointMatricesFieldId),
1321 this));
1322
1323
1324 editMField(JointMatricesFieldMask, _mfJointMatrices);
1325
1326 return returnValue;
1327 }
1328
1329 GetFieldHandlePtr SkeletonBase::getHandleJointNormalMatrices (void) const
1330 {
1331 MFMatrix::GetHandlePtr returnValue(
1332 new MFMatrix::GetHandle(
1333 &_mfJointNormalMatrices,
1334 this->getType().getFieldDesc(JointNormalMatricesFieldId),
1335 const_cast<SkeletonBase *>(this)));
1336
1337 return returnValue;
1338 }
1339
1340 EditFieldHandlePtr SkeletonBase::editHandleJointNormalMatrices(void)
1341 {
1342 MFMatrix::EditHandlePtr returnValue(
1343 new MFMatrix::EditHandle(
1344 &_mfJointNormalMatrices,
1345 this->getType().getFieldDesc(JointNormalMatricesFieldId),
1346 this));
1347
1348
1349 editMField(JointNormalMatricesFieldMask, _mfJointNormalMatrices);
1350
1351 return returnValue;
1352 }
1353
1354 GetFieldHandlePtr SkeletonBase::getHandleUseInvBindMatrix (void) const
1355 {
1356 SFBool::GetHandlePtr returnValue(
1357 new SFBool::GetHandle(
1358 &_sfUseInvBindMatrix,
1359 this->getType().getFieldDesc(UseInvBindMatrixFieldId),
1360 const_cast<SkeletonBase *>(this)));
1361
1362 return returnValue;
1363 }
1364
1365 EditFieldHandlePtr SkeletonBase::editHandleUseInvBindMatrix(void)
1366 {
1367 SFBool::EditHandlePtr returnValue(
1368 new SFBool::EditHandle(
1369 &_sfUseInvBindMatrix,
1370 this->getType().getFieldDesc(UseInvBindMatrixFieldId),
1371 this));
1372
1373
1374 editSField(UseInvBindMatrixFieldMask);
1375
1376 return returnValue;
1377 }
1378
1379 GetFieldHandlePtr SkeletonBase::getHandleCalcNormalMatrices (void) const
1380 {
1381 SFBool::GetHandlePtr returnValue(
1382 new SFBool::GetHandle(
1383 &_sfCalcNormalMatrices,
1384 this->getType().getFieldDesc(CalcNormalMatricesFieldId),
1385 const_cast<SkeletonBase *>(this)));
1386
1387 return returnValue;
1388 }
1389
1390 EditFieldHandlePtr SkeletonBase::editHandleCalcNormalMatrices(void)
1391 {
1392 SFBool::EditHandlePtr returnValue(
1393 new SFBool::EditHandle(
1394 &_sfCalcNormalMatrices,
1395 this->getType().getFieldDesc(CalcNormalMatricesFieldId),
1396 this));
1397
1398
1399 editSField(CalcNormalMatricesFieldMask);
1400
1401 return returnValue;
1402 }
1403
1404 GetFieldHandlePtr SkeletonBase::getHandleJointsChanged (void) const
1405 {
1406 SFOSGAny::GetHandlePtr returnValue(
1407 new SFOSGAny::GetHandle(
1408 &_sfJointsChanged,
1409 this->getType().getFieldDesc(JointsChangedFieldId),
1410 const_cast<SkeletonBase *>(this)));
1411
1412 return returnValue;
1413 }
1414
1415 EditFieldHandlePtr SkeletonBase::editHandleJointsChanged (void)
1416 {
1417 SFOSGAny::EditHandlePtr returnValue(
1418 new SFOSGAny::EditHandle(
1419 &_sfJointsChanged,
1420 this->getType().getFieldDesc(JointsChangedFieldId),
1421 this));
1422
1423
1424 editSField(JointsChangedFieldMask);
1425
1426 return returnValue;
1427 }
1428
1429
1430 #ifdef OSG_MT_CPTR_ASPECT
1431 void SkeletonBase::execSyncV( FieldContainer &oFrom,
1432 ConstFieldMaskArg whichField,
1433 AspectOffsetStore &oOffsets,
1434 ConstFieldMaskArg syncMode,
1435 const UInt32 uiSyncInfo)
1436 {
1437 Skeleton *pThis = static_cast<Skeleton *>(this);
1438
1439 pThis->execSync(static_cast<Skeleton *>(&oFrom),
1440 whichField,
1441 oOffsets,
1442 syncMode,
1443 uiSyncInfo);
1444 }
1445 #endif
1446
1447
1448 #ifdef OSG_MT_CPTR_ASPECT
1449 FieldContainer *SkeletonBase::createAspectCopy(
1450 const FieldContainer *pRefAspect) const
1451 {
1452 Skeleton *returnValue;
1453
1454 newAspectCopy(returnValue,
1455 dynamic_cast<const Skeleton *>(pRefAspect),
1456 dynamic_cast<const Skeleton *>(this));
1457
1458 return returnValue;
1459 }
1460 #endif
1461
1462 void SkeletonBase::resolveLinks(void)
1463 {
1464 Inherited::resolveLinks();
1465
1466 static_cast<Skeleton *>(this)->clearRoots();
1467
1468 static_cast<Skeleton *>(this)->clearJoints();
1469
1470 static_cast<Skeleton *>(this)->clearParentJoints();
1471
1472 #ifdef OSG_MT_CPTR_ASPECT
1473 AspectOffsetStore oOffsets;
1474
1475 _pAspectStore->fillOffsetArray(oOffsets, this);
1476 #endif
1477
1478 #ifdef OSG_MT_CPTR_ASPECT
1479 _mfJointMatrices.terminateShare(Thread::getCurrentAspect(),
1480 oOffsets);
1481 #endif
1482 #ifdef OSG_MT_CPTR_ASPECT
1483 _mfJointNormalMatrices.terminateShare(Thread::getCurrentAspect(),
1484 oOffsets);
1485 #endif
1486 }
1487
1488
1489 OSG_END_NAMESPACE