OpenSG: osg::DVRClipGeometryBase Class Reference

00094     {
00095         GeometryNodeFieldId = Inherited::NextFieldId,
00096         BeaconFieldId       = GeometryNodeFieldId + 1,
00097         NextFieldId         = BeaconFieldId       + 1
00098     };

00175                                              :
00176     _sfGeometryNode           (NodePtr(NullFC)), 
00177     _sfBeacon                 (NodePtr(NullFC)), 
00178     Inherited() 
00179 {
00180 }

00186                                                                           :
00187     _sfGeometryNode           (source._sfGeometryNode           ), 
00188     _sfBeacon                 (source._sfBeacon                 ), 
00189     Inherited                 (source)
00190 {
00191 }

00059 {
00060     return _type; 
00061 }

00066 {
00067     return _type.getId(); 
00068 }

00118 {
00119     return _type; 
00120 }

00123 {
00124     return _type;
00125 }

00138 { 
00139     return sizeof(DVRClipGeometry); 
00140 }

00102 {
00103     return &_sfGeometryNode;
00104 }

00109 {
00110     return &_sfBeacon;
00111 }

00117 {
00118     return _sfGeometryNode.getValue();
00119 }

00124 {
00125     return _sfGeometryNode.getValue();
00126 }

00138 {
00139     return _sfBeacon.getValue();
00140 }

00145 {
00146     return _sfBeacon.getValue();
00147 }

00131 {
00132     _sfGeometryNode.setValue(value);
00133 }

00152 {
00153     _sfBeacon.setValue(value);
00154 }

00202 {
00203     UInt32 returnValue = Inherited::getBinSize(whichField);
00204 
00205     if(FieldBits::NoField != (GeometryNodeFieldMask & whichField))
00206     {
00207         returnValue += _sfGeometryNode.getBinSize();
00208     }
00209 
00210     if(FieldBits::NoField != (BeaconFieldMask & whichField))
00211     {
00212         returnValue += _sfBeacon.getBinSize();
00213     }
00214 
00215 
00216     return returnValue;
00217 }

00221 {
00222     Inherited::copyToBin(pMem, whichField);
00223 
00224     if(FieldBits::NoField != (GeometryNodeFieldMask & whichField))
00225     {
00226         _sfGeometryNode.copyToBin(pMem);
00227     }
00228 
00229     if(FieldBits::NoField != (BeaconFieldMask & whichField))
00230     {
00231         _sfBeacon.copyToBin(pMem);
00232     }
00233 
00234 
00235 }

00239 {
00240     Inherited::copyFromBin(pMem, whichField);
00241 
00242     if(FieldBits::NoField != (GeometryNodeFieldMask & whichField))
00243     {
00244         _sfGeometryNode.copyFromBin(pMem);
00245     }
00246 
00247     if(FieldBits::NoField != (BeaconFieldMask & whichField))
00248     {
00249         _sfBeacon.copyFromBin(pMem);
00250     }
00251 
00252 
00253 }

00073 {
00074     DVRClipGeometryPtr fc; 
00075 
00076     if(getClassType().getPrototype() != OSG::NullFC) 
00077     {
00078         fc = DVRClipGeometryPtr::dcast(
00079             getClassType().getPrototype()-> shallowCopy()); 
00080     }
00081     
00082     return fc; 
00083 }

00088 { 
00089     DVRClipGeometryPtr returnValue; 
00090     
00091     newPtr(returnValue); 
00092 
00093     return returnValue; 
00094 }

00129 { 
00130     DVRClipGeometryPtr returnValue; 
00131 
00132     newPtr(returnValue, dynamic_cast<const DVRClipGeometry *>(this)); 
00133 
00134     return returnValue; 
00135 }

00258 {
00259 
00260     Inherited::executeSyncImpl(pOther, whichField);
00261 
00262     if(FieldBits::NoField != (GeometryNodeFieldMask & whichField))
00263         _sfGeometryNode.syncWith(pOther->_sfGeometryNode);
00264 
00265     if(FieldBits::NoField != (BeaconFieldMask & whichField))
00266         _sfBeacon.syncWith(pOther->_sfBeacon);
00267 
00268 
00269 }

00146 {
00147     this->executeSyncImpl((DVRClipGeometryBase *) &other, whichField);
00148 }

00072 {
00073     return _type.getGroupId();
00074 }

00078 {
00079     return getType().getId();
00080 }

00084 {
00085     return getType().getGroupId();
00086 }

00090 {
00091     return getType().getCName();
00092 }

00096 {
00097     const FieldDescription *desc = getType().getFieldDescription(fieldId);
00098 
00099     return desc ? desc->getField(*this) : NULL;
00100 }

00104 {
00105     const FieldDescription *desc =getType().findFieldDescription(fieldName);
00106 
00107     return desc ? desc->getField(*this) : NULL;
00108 }

00091 {
00092     // fprintf(stderr, "FC Changed %d %d\n", whichField, fromSync);
00093 }


Public Types
typedef DVRClipGeometryPtr	Ptr
enum	{ GeometryNodeFieldId = Inherited::NextFieldId, BeaconFieldId = GeometryNodeFieldId + 1, NextFieldId = BeaconFieldId + 1 }
Public Member Functions
FieldContainer Get
*virtual FieldContainerType &	getType (void)
virtual const FieldContainerType &	getType (void) const
virtual UInt32	getContainerSize (void) const
Field Get
SFNodePtr	getSFGeometryNode (void)
	Get the DVRClipGeometry::_sfGeometryNode field.
SFNodePtr *	getSFBeacon (void)
	Get the DVRClipGeometry::_sfBeacon field.
NodePtr &	getGeometryNode (void)
	Get the value of the DVRClipGeometry::_sfGeometryNode field.
const NodePtr &	getGeometryNode (void) const
	Get the value of the DVRClipGeometry::_sfGeometryNode field.
NodePtr &	getBeacon (void)
	Get the value of the DVRClipGeometry::_sfBeacon field.
const NodePtr &	getBeacon (void) const
	Get the value of the DVRClipGeometry::_sfBeacon field.
Field Set
*void	setGeometryNode (const NodePtr &value)
	Set the value of the DVRClipGeometry::_sfGeometryNode field.
void	setBeacon (const NodePtr &value)
	Set the value of the DVRClipGeometry::_sfBeacon field.
Binary Access
*virtual UInt32	getBinSize (const BitVector &whichField)
virtual void	copyToBin (BinaryDataHandler &pMem, const BitVector &whichField)
virtual void	copyFromBin (BinaryDataHandler &pMem, const BitVector &whichField)
Copy
*virtual FieldContainerPtr	shallowCopy (void) const
Changed
*virtual void	changed (BitVector whichField, UInt32 origin)
Dump
*virtual void	dump (UInt32 uiIndent=0, const BitVector bvFlags=0) const =0
Static Public Member Functions
Class Get
*static FieldContainerType &	getClassType (void)
	access the type of the class
static UInt32	getClassTypeId (void)
	access the numerical type of the class
Construction
*static DVRClipGeometryPtr	create (void)
	create a new instance of the class
static DVRClipGeometryPtr	createEmpty (void)
	create an empty new instance of the class, do not copy the prototype
Static Public Attributes
static const osg::BitVector	GeometryNodeFieldMask
static const osg::BitVector	BeaconFieldMask
static const osg::BitVector	MTInfluenceMask
static const BitVector	NextFieldMask
Protected Member Functions
Constructors
*	DVRClipGeometryBase (void)
	DVRClipGeometryBase (const DVRClipGeometryBase &source)
Destructors
*virtual	~DVRClipGeometryBase (void)
Sync
*void	executeSyncImpl (DVRClipGeometryBase *pOther, const BitVector &whichField)
virtual void	executeSync (FieldContainer &other, const BitVector &whichField)
Protected Attributes
Fields
*SFNodePtr	_sfGeometryNode
SFNodePtr	_sfBeacon
Private Types
typedef FieldContainer	Inherited
Private Member Functions
void	operator= (const DVRClipGeometryBase &source)
Static Private Attributes
static FieldDescription *	_desc []
	DVRClipGeometry description.
static FieldContainerType	_type
Friends
class	FieldContainer

osg::DVRClipGeometryBase Class Reference

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Static Private Attributes

Friends

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation