OpenSG: osg::StateBase Class Reference

00093     {
00094         ChunksFieldId = Inherited::NextFieldId,
00095         NextFieldId   = ChunksFieldId + 1
00096     };

00165                          :
00166     _mfChunks                 (), 
00167     Inherited() 
00168 {
00169 }

00175                                             :
00176     _mfChunks                 (source._mfChunks                 ), 
00177     Inherited                 (source)
00178 {
00179 }

00059 {
00060     return _type; 
00061 }

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

00107 {
00108     return _type; 
00109 }

00112 {
00113     return _type;
00114 }

00127 { 
00128     return sizeof(State); 
00129 }

00102 {
00103     return &_mfChunks;
00104 }

00111 {
00112     return _mfChunks[index];
00113 }

00118 {
00119     return _mfChunks;
00120 }

00125 {
00126     return _mfChunks;
00127 }

00190 {
00191     UInt32 returnValue = Inherited::getBinSize(whichField);
00192 
00193     if(FieldBits::NoField != (ChunksFieldMask & whichField))
00194     {
00195         returnValue += _mfChunks.getBinSize();
00196     }
00197 
00198 
00199     return returnValue;
00200 }

00204 {
00205     Inherited::copyToBin(pMem, whichField);
00206 
00207     if(FieldBits::NoField != (ChunksFieldMask & whichField))
00208     {
00209         _mfChunks.copyToBin(pMem);
00210     }
00211 
00212 
00213 }

00217 {
00218     Inherited::copyFromBin(pMem, whichField);
00219 
00220     if(FieldBits::NoField != (ChunksFieldMask & whichField))
00221     {
00222         _mfChunks.copyFromBin(pMem);
00223     }
00224 
00225 
00226 }

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

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

00118 { 
00119     StatePtr returnValue; 
00120 
00121     newPtr(returnValue, dynamic_cast<const State *>(this)); 
00122 
00123     return returnValue; 
00124 }

00231 {
00232 
00233     Inherited::executeSyncImpl(pOther, whichField);
00234 
00235     if(FieldBits::NoField != (ChunksFieldMask & whichField))
00236         _mfChunks.syncWith(pOther->_mfChunks);
00237 
00238 
00239 }

00135 {
00136     this->executeSyncImpl((StateBase *) &other, whichField);
00137 }

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 StatePtr	Ptr
enum	{ ChunksFieldId = Inherited::NextFieldId, NextFieldId = ChunksFieldId + 1 }
Public Member Functions
FieldContainer Get
*virtual FieldContainerType &	getType (void)
virtual const FieldContainerType &	getType (void) const
virtual UInt32	getContainerSize (void) const
Field Get
MFStateChunkPtr	getMFChunks (void)
	Get the State::_mfChunks field.
StateChunkPtr &	getChunks (const UInt32 index)
	Get the value of the index element the State::_mfChunks field.
MFStateChunkPtr &	getChunks (void)
	Get the State::_mfChunks field.
const MFStateChunkPtr &	getChunks (void) const
	Get the State::_mfChunks 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 StatePtr	create (void)
	create a new instance of the class
static StatePtr	createEmpty (void)
	create an empty new instance of the class, do not copy the prototype
Static Public Attributes
static const osg::BitVector	ChunksFieldMask
static const osg::BitVector	MTInfluenceMask
static const BitVector	NextFieldMask
Protected Member Functions
Constructors
*	StateBase (void)
	StateBase (const StateBase &source)
Destructors
*virtual	~StateBase (void)
Sync
*void	executeSyncImpl (StateBase *pOther, const BitVector &whichField)
virtual void	executeSync (FieldContainer &other, const BitVector &whichField)
Protected Attributes
Fields
*MFStateChunkPtr	_mfChunks
Private Types
typedef FieldContainer	Inherited
Private Member Functions
void	operator= (const StateBase &source)
Static Private Attributes
static FieldDescription *	_desc []
	State description.
static FieldContainerType	_type
Friends
class	FieldContainer

osg::StateBase 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