osg::PassiveWindow Class Reference

Enumeration values for the status of the GL objects. This is primarily used to signal the object's callback functions what to do. See OpenGL Objects & Extension Handling for a description.

Enumerator:

notused	Object is not used at all right now.
initialize	The object is being initialized for the first time.
reinitialize	The object is being re-initialized, i.e. it has changed significantly.
initialized	The object is initialized and valid.
needrefresh	The object is initialized but needs a refresh.
destroy	The object is to be destroyed, i.e. removed from the current OpenGL context.
finaldestroy	The object has been removed from all OpenGL contexts and used ressources but be freed now.

Definition at line 78 of file OSGWindow.h.

00079     {
00080         notused      = 1, 
00081         initialize, 
00082         reinitialize, 
00083         initialized,
00084         needrefresh, 
00085         destroy, 
00086         finaldestroy 
00087     };

anonymous enum [inherited]

Enumerator:

invalidExtensionID
invalidFunctionID

Definition at line 89 of file OSGWindow.h.

00089 { invalidExtensionID = 0x7fffffff, invalidFunctionID = 0x7fffffff };

anonymous enum [inherited]

Enumerator:

statusShift
statusMask

Definition at line 92 of file OSGWindow.h.

00092 { statusShift = 3, statusMask = 7 };

anonymous enum [inherited]

Enumerator:

WidthFieldId
HeightFieldId
PortFieldId
ResizePendingFieldId
GlObjectEventCounterFieldId
GlObjectLastRefreshFieldId
GlObjectLastReinitializeFieldId
NextFieldId

Definition at line 98 of file OSGWindowBase.h.

00099     {
00100         WidthFieldId                    = Inherited::NextFieldId,
00101         HeightFieldId                   = WidthFieldId                    + 1,
00102         PortFieldId                     = HeightFieldId                   + 1,
00103         ResizePendingFieldId            = PortFieldId                     + 1,
00104         GlObjectEventCounterFieldId     = ResizePendingFieldId            + 1,
00105         GlObjectLastRefreshFieldId      = GlObjectEventCounterFieldId     + 1,
00106         GlObjectLastReinitializeFieldId = GlObjectLastRefreshFieldId      + 1,
00107         NextFieldId                     = GlObjectLastReinitializeFieldId + 1
00108     };

anonymous enum [inherited]

Enumerator:

AttachmentsFieldId
NextFieldId

Definition at line 78 of file OSGAttachmentContainerImpl.h.

00079     { 
00080         AttachmentsFieldId = Inherited::NextFieldId, 
00081         NextFieldId        = AttachmentsFieldId + 1
00082     };

anonymous enum [inherited]

Enumerator:

NextFieldId

Definition at line 73 of file OSGFieldContainerImpl.h.

00073 { NextFieldId = 1 };

Constructor & Destructor Documentation

PassiveWindow::PassiveWindow ( void ) [protected]

Definition at line 66 of file OSGPassiveWindow.cpp.

00066                                  :
00067     Inherited()
00068 {
00069 }

PassiveWindow::PassiveWindow ( const PassiveWindow & source ) [protected]

Definition at line 71 of file OSGPassiveWindow.cpp.

00071                                                         :
00072     Inherited(source)
00073 {
00074 }

PassiveWindow::~PassiveWindow ( void ) [protected, virtual]

Definition at line 76 of file OSGPassiveWindow.cpp.

00077 {
00078 }

Member Function Documentation

void PassiveWindow::changed	(	BitVector	whichField,
		UInt32	origin
	)			`[virtual]`

Reimplemented from osg::Window.

Definition at line 86 of file OSGPassiveWindow.cpp.

References osg::Window::changed().

00087 {
00088     Inherited::changed(whichField, origin);
00089 }

void PassiveWindow::dump	(	UInt32	uiIndent = `0`,
		const BitVector	bvFlags = `0`
	)			const `[virtual]`

Reimplemented from osg::Window.

Definition at line 91 of file OSGPassiveWindow.cpp.

References SLOG.

00093 {
00094     SLOG << "Dump PassiveWindow NI" << std::endl;
00095 }

void PassiveWindow::init ( void ) [virtual]

Just call the standard OpenGL setup.

Implements osg::Window.

Definition at line 99 of file OSGPassiveWindow.cpp.

References osg::Window::setupGL().

00100 {
00101     setupGL();
00102 }

void PassiveWindow::activate ( void ) [virtual]

Just call the standard OpenGL setup.

Implements osg::Window.

Definition at line 106 of file OSGPassiveWindow.cpp.

00107 {
00108 }

virtual void osg::PassiveWindow::deactivate ( void ) [inline, virtual]

Just call the standard OpenGL setup.

Implements osg::Window.

Definition at line 88 of file OSGPassiveWindow.h.

00088 {}

void PassiveWindow::swap ( void ) [virtual]

Just call the standard OpenGL setup.

Implements osg::Window.

Definition at line 112 of file OSGPassiveWindow.cpp.

00113 {
00114 }

void PassiveWindow::initMethod ( void ) [static, private]

initialize the static features of the class, e.g. action callbacks

Reimplemented from osg::Window.

Definition at line 82 of file OSGPassiveWindow.cpp.

00083 {
00084 }

void osg::PassiveWindow::operator= ( const PassiveWindow & source ) [private]

osg::FieldContainerType & osg::PassiveWindowBase::getClassType ( void ) [inline, static, inherited]

Reimplemented from osg::WindowBase.

Definition at line 58 of file OSGPassiveWindowBase.inl.

References osg::PassiveWindowBase::_type.

Referenced by osg::PassiveWindowBase::create().

00059 {
00060     return _type; 
00061 }

osg::UInt32 osg::PassiveWindowBase::getClassTypeId ( void ) [inline, static, inherited]

Reimplemented from osg::WindowBase.

Definition at line 65 of file OSGPassiveWindowBase.inl.

References osg::PassiveWindowBase::_type, and osg::TypeBase::getId().

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

FieldContainerType & PassiveWindowBase::getType ( void ) [virtual, inherited]

Reimplemented from osg::WindowBase.

Definition at line 86 of file OSGPassiveWindowBase.cpp.

References osg::PassiveWindowBase::_type.

00087 {
00088     return _type; 
00089 }

const FieldContainerType & PassiveWindowBase::getType ( void ) const [virtual, inherited]

Reimplemented from osg::WindowBase.

Definition at line 91 of file OSGPassiveWindowBase.cpp.

References osg::PassiveWindowBase::_type.

00092 {
00093     return _type;
00094 }

UInt32 PassiveWindowBase::getContainerSize ( void ) const [virtual, inherited]

Reimplemented from osg::WindowBase.

Definition at line 106 of file OSGPassiveWindowBase.cpp.

00107 { 
00108     return sizeof(PassiveWindow); 
00109 }

UInt32 PassiveWindowBase::getBinSize ( const BitVector & whichField ) [virtual, inherited]

Reimplemented from osg::WindowBase.

Definition at line 166 of file OSGPassiveWindowBase.cpp.

References osg::WindowBase::getBinSize().

00167 {
00168     UInt32 returnValue = Inherited::getBinSize(whichField);
00169 
00170 
00171     return returnValue;
00172 }

void PassiveWindowBase::copyToBin	(	BinaryDataHandler &	pMem,
		const BitVector &	whichField
	)			`[virtual, inherited]`

Reimplemented from osg::WindowBase.

Definition at line 174 of file OSGPassiveWindowBase.cpp.

References osg::WindowBase::copyToBin().

00176 {
00177     Inherited::copyToBin(pMem, whichField);
00178 
00179 
00180 }

void PassiveWindowBase::copyFromBin	(	BinaryDataHandler &	pMem,
		const BitVector &	whichField
	)			`[virtual, inherited]`

Reimplemented from osg::WindowBase.

Definition at line 182 of file OSGPassiveWindowBase.cpp.

References osg::WindowBase::copyFromBin().

00184 {
00185     Inherited::copyFromBin(pMem, whichField);
00186 
00187 
00188 }

PassiveWindowPtr osg::PassiveWindowBase::create ( void ) [inline, static, inherited]

Definition at line 72 of file OSGPassiveWindowBase.inl.

References osg::AttachmentContainerPtr::dcast(), osg::PassiveWindowBase::getClassType(), osg::NullFC, and osg::PassiveWindowBase::shallowCopy().

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

PassiveWindowPtr osg::PassiveWindowBase::createEmpty ( void ) [inline, static, inherited]

Definition at line 87 of file OSGPassiveWindowBase.inl.

References osg::FieldContainer::newPtr().

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

FieldContainerPtr PassiveWindowBase::shallowCopy ( void ) const [virtual, inherited]

Implements osg::FieldContainer.

Definition at line 97 of file OSGPassiveWindowBase.cpp.

References osg::FieldContainer::newPtr().

Referenced by osg::PassiveWindowBase::create().

00098 { 
00099     PassiveWindowPtr returnValue; 
00100 
00101     newPtr(returnValue, dynamic_cast<const PassiveWindow *>(this)); 
00102 
00103     return returnValue; 
00104 }

void PassiveWindowBase::executeSyncImpl	(	PassiveWindowBase *	pOther,
		const BitVector &	whichField
	)			`[protected, inherited]`

Definition at line 191 of file OSGPassiveWindowBase.cpp.

References osg::WindowBase::executeSyncImpl().

Referenced by osg::PassiveWindowBase::executeSync().

00193 {
00194 
00195     Inherited::executeSyncImpl(pOther, whichField);
00196 
00197 
00198 }

void WindowBase::executeSyncImpl	(	WindowBase *	pOther,
		const BitVector &	whichField
	)			`[protected, inherited]`

Definition at line 390 of file OSGWindowBase.cpp.

References osg::WindowBase::_mfGlObjectLastRefresh, osg::WindowBase::_mfGlObjectLastReinitialize, osg::WindowBase::_mfPort, osg::WindowBase::_sfGlObjectEventCounter, osg::WindowBase::_sfHeight, osg::WindowBase::_sfResizePending, osg::WindowBase::_sfWidth, osg::AttachmentContainer::executeSyncImpl(), osg::WindowBase::GlObjectEventCounterFieldMask, osg::WindowBase::GlObjectLastRefreshFieldMask, osg::WindowBase::GlObjectLastReinitializeFieldMask, osg::WindowBase::HeightFieldMask, osg::FieldBits::NoField, osg::WindowBase::PortFieldMask, osg::WindowBase::ResizePendingFieldMask, osg::MField< FieldTypeT, fieldNameSpace >::syncWith(), osg::SField< FieldTypeT, fieldNameSpace >::syncWith(), and osg::WindowBase::WidthFieldMask.

Referenced by osg::WindowBase::executeSync(), osg::XWindowBase::executeSyncImpl(), osg::WIN32WindowBase::executeSyncImpl(), osg::PassiveWindowBase::executeSyncImpl(), osg::GLUTWindowBase::executeSyncImpl(), and osg::ClusterWindowBase::executeSyncImpl().

00392 {
00393 
00394     Inherited::executeSyncImpl(pOther, whichField);
00395 
00396     if(FieldBits::NoField != (WidthFieldMask & whichField))
00397         _sfWidth.syncWith(pOther->_sfWidth);
00398 
00399     if(FieldBits::NoField != (HeightFieldMask & whichField))
00400         _sfHeight.syncWith(pOther->_sfHeight);
00401 
00402     if(FieldBits::NoField != (PortFieldMask & whichField))
00403         _mfPort.syncWith(pOther->_mfPort);
00404 
00405     if(FieldBits::NoField != (ResizePendingFieldMask & whichField))
00406         _sfResizePending.syncWith(pOther->_sfResizePending);
00407 
00408     if(FieldBits::NoField != (GlObjectEventCounterFieldMask & whichField))
00409         _sfGlObjectEventCounter.syncWith(pOther->_sfGlObjectEventCounter);
00410 
00411     if(FieldBits::NoField != (GlObjectLastRefreshFieldMask & whichField))
00412         _mfGlObjectLastRefresh.syncWith(pOther->_mfGlObjectLastRefresh);
00413 
00414     if(FieldBits::NoField != (GlObjectLastReinitializeFieldMask & whichField))
00415         _mfGlObjectLastReinitialize.syncWith(pOther->_mfGlObjectLastReinitialize);
00416 
00417 
00418 }

void AttachmentContainer::executeSyncImpl	(	AttachmentContainer *	pOther,
		const BitVector &	whichField
	)			`[protected, inherited]`

Definition at line 316 of file OSGAttachmentContainer.cpp.

References osg::AttachmentContainer::_attachmentMap, osg::AttachmentContainer::AttachmentsFieldMask, osg::FieldContainer::executeSyncImpl(), osg::FieldBits::NoField, and osg::SField< FieldTypeT, fieldNameSpace >::syncWith().

00319 {
00320     Inherited::executeSyncImpl(pOther, whichField);
00321 
00322     if (FieldBits::NoField != (AttachmentsFieldMask & whichField))
00323     {
00324         _attachmentMap.syncWith(pOther->_attachmentMap);
00325     }
00326 }

void osg::FieldContainer::executeSyncImpl	(	FieldContainer *	pOther,
		const BitVector &	whichField
	)			`[inline, protected, inherited]`

Definition at line 333 of file OSGFieldContainerImpl.inl.

Referenced by osg::StateBase::executeSyncImpl(), osg::DVRShaderBase::executeSyncImpl(), osg::DVRClipGeometryBase::executeSyncImpl(), osg::AttachmentContainer::executeSyncImpl(), and osg::Attachment::executeSyncImpl().

00335 {
00336 }

void PassiveWindowBase::executeSync	(	FieldContainer &	other,
		const BitVector &	whichField
	)			`[protected, virtual, inherited]`

Reimplemented from osg::WindowBase.

Definition at line 113 of file OSGPassiveWindowBase.cpp.

References osg::PassiveWindowBase::executeSyncImpl().

00115 {
00116     this->executeSyncImpl((PassiveWindowBase *) &other, whichField);
00117 }

static const char* osg::Window::getClassname ( void ) [inline, static, inherited]

Definition at line 107 of file OSGWindow.h.

00107 { return "Window"; };

void osg::Window::addPort ( const ViewportPtr & portP ) [inherited]

Definition at line 407 of file OSGWindow.cpp.

References osg::WindowBase::_mfPort, osg::MField< FieldTypeT, fieldNameSpace >::back(), osg::beginEditCP(), osg::endEditCP(), osg::NullFC, osg::ViewportBase::ParentFieldMask, and osg::MField< FieldTypeT, fieldNameSpace >::push_back().

00408 {
00409     if(portP != NullFC)
00410     {
00411         _mfPort.push_back(portP);
00412 // CHECK CHECK
00413 //        _mfPort.back()->setParent(FieldContainer::getPtr<WindowPtr>(*this));
00414 
00415         beginEditCP(portP, Viewport::ParentFieldMask);
00416         {
00417             _mfPort.back()->setParent(WindowPtr(*this));
00418         }
00419         endEditCP  (portP, Viewport::ParentFieldMask);
00420     }
00421 }

void osg::Window::insertPort	(	UInt32	portIndex,
		const ViewportPtr &	portP
	)			`[inherited]`

Definition at line 423 of file OSGWindow.cpp.

References osg::WindowBase::_mfPort, osg::MField< FieldTypeT, fieldNameSpace >::begin(), osg::beginEditCP(), osg::endEditCP(), osg::MField< FieldTypeT, fieldNameSpace >::insert(), osg::NullFC, and osg::ViewportBase::ParentFieldMask.

00424 {    
00425     MFViewportPtr::iterator portIt = _mfPort.begin();
00426 
00427     if(portP != NullFC)
00428     {
00429         portIt += portIndex;
00430   
00431 // CHECK CHECK      
00432 //        (*(_mfPort.insert(portIt, portP)))->setParent(
00433 //            FieldContainer::getPtr<WindowPtr>(*this));
00434 
00435         beginEditCP(portP, Viewport::ParentFieldMask);
00436         {
00437             (*(_mfPort.insert(portIt, portP)))->setParent(
00438                 WindowPtr(*this));
00439         }
00440         endEditCP  (portP, Viewport::ParentFieldMask);
00441 
00442     }
00443 }

void osg::Window::replacePort	(	UInt32	portIndex,
		const ViewportPtr &	portP
	)			`[inherited]`

Definition at line 446 of file OSGWindow.cpp.

References osg::WindowBase::_mfPort, and osg::NullFC.

00447 {
00448     if(portP != NullFC)
00449     {
00450         _mfPort[portIndex]->setParent(NullFC);
00451         _mfPort[portIndex] = portP;
00452 // CHECK CHECK
00453 //        _mfPort.getValue(portIndex)->setParent(
00454 //            FieldContainer::getPtr<WindowPtr>(*this));
00455         _mfPort[portIndex]->setParent(
00456             WindowPtr(*this));
00457     }
00458 }

void osg::Window::replacePortBy	(	const ViewportPtr &	portP,
		const ViewportPtr &	newPortP
	)			`[inherited]`

Definition at line 460 of file OSGWindow.cpp.

References osg::WindowBase::_mfPort, osg::MField< FieldTypeT, fieldNameSpace >::end(), osg::MField< FieldTypeT, fieldNameSpace >::find(), and osg::NullFC.

00462 {
00463     MFViewportPtr::iterator portIt = _mfPort.find(portP);
00464 
00465     if(newportP != NullFC)
00466     {
00467         if(portIt != _mfPort.end())
00468         {
00469             (*portIt)->setParent(NullFC);
00470             (*portIt) = newportP;
00471 // CHECK CHECK
00472 //            (*portIt)->setParent(
00473 //                FieldContainer::getPtr<WindowPtr>(*this));
00474             (*portIt)->setParent(
00475                 WindowPtr(*this));
00476         }
00477     }
00478 }

void osg::Window::subPort ( const ViewportPtr & portP ) [inherited]

Definition at line 480 of file OSGWindow.cpp.

References osg::WindowBase::_mfPort, osg::MField< FieldTypeT, fieldNameSpace >::end(), osg::MField< FieldTypeT, fieldNameSpace >::erase(), osg::MField< FieldTypeT, fieldNameSpace >::find(), and osg::NullFC.

00481 {
00482     MFViewportPtr::iterator portIt = _mfPort.find(portP);
00483 
00484     if(portIt != _mfPort.end())
00485     {
00486         (*portIt)->setParent(NullFC);
00487 
00488         _mfPort.erase(portIt);
00489     }
00490 
00491 }

void osg::Window::subPort ( UInt32 portIndex ) [inherited]

Definition at line 493 of file OSGWindow.cpp.

References osg::WindowBase::_mfPort, osg::MField< FieldTypeT, fieldNameSpace >::begin(), osg::MField< FieldTypeT, fieldNameSpace >::end(), osg::MField< FieldTypeT, fieldNameSpace >::erase(), and osg::NullFC.

00494 {
00495     MFViewportPtr::iterator portIt = _mfPort.begin();
00496 
00497     portIt += portIndex;
00498 
00499     if(portIt != _mfPort.end())
00500     {
00501         (*portIt)->setParent(NullFC);
00502 
00503         _mfPort.erase(portIt);
00504     }
00505 }

void osg::Window::clearPorts ( void ) [inherited]

Definition at line 507 of file OSGWindow.cpp.

References osg::WindowBase::_mfPort, osg::MField< FieldTypeT, fieldNameSpace >::begin(), osg::MField< FieldTypeT, fieldNameSpace >::clear(), osg::MField< FieldTypeT, fieldNameSpace >::end(), osg::NullFC, and osg::subRefCP().

00508 {
00509     MFViewportPtr::iterator portIt = _mfPort.begin();
00510 
00511     while(portIt != _mfPort.end())
00512     {
00513         (*portIt)->setParent(NullFC);
00514 
00515         subRefCP(*portIt);
00516     }
00517  
00518     _mfPort.clear();
00519 }

UInt32 osg::Window::registerExtension ( const Char8 * s ) [static, inherited]

Register a new OpenGL extension. See OpenGL Extensions for details. Ignores NULL strings.

Definition at line 920 of file OSGWindow.cpp.

References osg::Window::_registeredExtensions, FDEBUG, FPDEBUG, osg::Window::staticAcquire(), and osg::Window::staticRelease().

Referenced by osg::BlendChunk::BlendChunk(), osg::PhongMaterial::createChunkMaterial(), osg::DisplayCalibration::createCMViewports(), osg::DVRIsoShader::DVRIsoShader(), osg::DVRMtexLUTShader::DVRMtexLUTShader(), osg::DVRSimpleLUTShader::DVRSimpleLUTShader(), osg::FBOViewport::FBOViewport(), osg::FragmentProgramChunk::FragmentProgramChunk(), osg::GeoPumpFactory::glextInitFunction(), osg::Particles::Particles(), osg::PhongMaterial::PhongMaterial(), osg::PointChunk::PointChunk(), osg::ProgramChunk::ProgramChunk(), osg::RegisterCombinersChunk::RegisterCombinersChunk(), osg::RenderAction::RenderAction(), osg::SHLChunk::SHLChunk(), osg::SHLParameterChunk::SHLParameterChunk(), osg::Slices::Slices(), osg::TextureChunk::TextureChunk(), and osg::VertexProgramChunk::VertexProgramChunk().

00921 {
00922     FDEBUG(("Window::registerExtension: register '%s': ", s));
00923     staticAcquire();
00924    
00925     if(s == NULL)
00926     {
00927         staticRelease();
00928         return TypeTraits<UInt32>::getMax();
00929     }
00930     
00931     std::vector<std::string>::iterator i;
00932     
00933     i = std::find(_registeredExtensions.begin(), _registeredExtensions.end(), 
00934                   s);
00935     
00936     if(i < _registeredExtensions.end())
00937     {
00938         staticRelease();
00939         FPDEBUG(("reusing id %d\n", i - _registeredExtensions.begin()));
00940         return i - _registeredExtensions.begin();
00941     }
00942         
00943     UInt32 r = _registeredExtensions.size();
00944     _registeredExtensions.push_back(s);
00945     
00946     FPDEBUG(("new id %d\n", r));
00947     
00948     staticRelease();
00949     return r;
00950 }

void osg::Window::ignoreExtensions ( const Char8 * s ) [static, inherited]

Register new OpenGL extensions to ignore. See OpenGL Extensions for details.

Definition at line 977 of file OSGWindow.cpp.

References osg::Window::_allWindows, osg::Window::_ignoredExtensions, osg::Window::_registeredExtensions, FDEBUG, FPDEBUG, osg::Window::staticAcquire(), and osg::Window::staticRelease().

Referenced by osg::Window::frameInit().

00978 {    
00979     FDEBUG(("Window:: Ignoring extensions '%s'\n", s));
00980 
00981     staticAcquire();
00982     
00983     std::back_insert_iterator< std::vector<std::string> > 
00984             extension_back_inserter(_ignoredExtensions);
00985 
00986     std::string toex(s);
00987     
00988     for(string_token_iterator ignit = string_token_iterator(toex, ",. ");
00989         ignit != string_token_iterator(); ++ignit)
00990     {          
00991         std::string ignore = *ignit;
00992 
00993         FDEBUG(("Ignoring '%s':", ignore.c_str()));
00994         
00995         if(std::find(_ignoredExtensions.begin(),
00996                      _ignoredExtensions.end(),
00997                      ignore.c_str())            != _ignoredExtensions.end())
00998         {
00999             FPDEBUG((" already ignored.\n"));
01000             continue;
01001         }
01002         
01003         _ignoredExtensions.push_back(ignore);
01004         
01005         std::vector<std::string>::iterator regit;
01006         
01007         // if extension is registered, disable it on all existing Windows
01008         
01009         regit = std::find(_registeredExtensions.begin(),
01010                           _registeredExtensions.end(),
01011                           ignore.c_str());                                 
01012         
01013         Int32 ind = -1;
01014         
01015         if(regit != _registeredExtensions.end())
01016         {
01017             ind = regit - _registeredExtensions.begin();
01018             FPDEBUG(("(reg as %d)", ind));
01019         }
01020 
01021         // Walk all existing windows and remove the ignored extension 
01022         // from the _extensions vector. Disable it if it was a registered one.
01023         
01024         std::vector<WindowPtr>::iterator winit;
01025 
01026         for(winit = _allWindows.begin(); winit != _allWindows.end(); ++winit)
01027         {
01028             FPDEBUG((" %p:", (*winit).getCPtr()));
01029             
01030             std::vector<std::string>::iterator extit;
01031             
01032             extit = std::find((*winit)->_extensions.begin(),
01033                               (*winit)->_extensions.end(),
01034                               ignore.c_str()); 
01035                                                                      
01036             if(extit != (*winit)->_extensions.end())
01037             {
01038                 FPDEBUG((" removed"));
01039                 (*winit)->_extensions.erase(extit);
01040             }
01041             else
01042             {
01043                 FPDEBUG((" nonsupp"));            
01044             }
01045                         
01046             if(ind >= 0)
01047             {
01048                 if((*winit)->_availExtensions.size() > UInt32(ind))
01049                 {
01050                     (*winit)->_availExtensions[ind] = false;
01051                     FPDEBUG((" disabled"));            
01052                 }
01053                 if((*winit)->_commonExtensions.size() > UInt32(ind))
01054                 {
01055                     (*winit)->_commonExtensions[ind] = false;
01056                     FPDEBUG((" uncommoned"));            
01057                 }
01058             }
01059         }
01060         FPDEBUG(("\n"));    
01061     }
01062 
01063     std::sort(_ignoredExtensions.begin(), _ignoredExtensions.end());
01064     
01065     staticRelease();
01066 }

UInt32 osg::Window::registerFunction	(	const Char8 *	s,
		Int32	ext = `-1`,
		UInt32	version = `0xffff`
	)			`[static, inherited]`

Register a new OpenGL extension function. See OpenGL Extensions for details. Ignores NULL strings.

Definition at line 1071 of file OSGWindow.cpp.

References osg::Window::_registeredFunctionExts, osg::Window::_registeredFunctions, osg::Window::_registeredFunctionVersions, FDEBUG, FPDEBUG, osg::Window::staticAcquire(), and osg::Window::staticRelease().

Referenced by osg::BlendChunk::BlendChunk(), osg::DVRIsoShader::DVRIsoShader(), osg::DVRMtexLUTShader::DVRMtexLUTShader(), osg::DVRSimpleLUTShader::DVRSimpleLUTShader(), osg::FBOViewport::FBOViewport(), osg::GeoPumpFactory::glextInitFunction(), glextFuncInit::init(), osg::Particles::Particles(), osg::PointChunk::PointChunk(), osg::ProgramChunk::ProgramChunk(), osg::RegisterCombinersChunk::RegisterCombinersChunk(), osg::RenderAction::RenderAction(), osg::SHLChunk::SHLChunk(), osg::Slices::Slices(), and osg::TextureChunk::TextureChunk().

01073 {
01074     if(s == NULL)
01075         return TypeTraits<UInt32>::getMax();
01076 
01077     FDEBUG(("Window::registerFunction: register '%s': ", s));
01078 
01079     staticAcquire();
01080     
01081     std::vector<std::string>::iterator i;
01082     
01083     i = std::find(_registeredFunctions.begin(), _registeredFunctions.end(), 
01084                   s);
01085     
01086     if(i < _registeredFunctions.end())
01087     {
01088         staticRelease();
01089         FPDEBUG(("reusing id %d\n", i - _registeredFunctions.begin()));
01090         return i - _registeredFunctions.begin();
01091     }
01092             
01093     UInt32 r=_registeredFunctions.size();
01094     _registeredFunctions.push_back(s);
01095     _registeredFunctionExts.push_back(ext);
01096     _registeredFunctionVersions.push_back(version);
01097 
01098     FPDEBUG(("new id %d\n", r));
01099     
01100     staticRelease();
01101     return r;
01102 }

void osg::Window::registerConstant ( GLenum val ) [static, inherited]

Register a new OpenGL constant. See OpenGL Extensions for details.

Definition at line 1107 of file OSGWindow.cpp.

References osg::Window::_registeredConstants, osg::Window::staticAcquire(), and osg::Window::staticRelease().

Referenced by osg::TextureChunk::TextureChunk().

01108 {
01109     staticAcquire();
01110    
01111     if(std::find(_registeredConstants.begin(), 
01112             _registeredConstants.end(),
01113             val) ==  _registeredConstants.end())
01114     {
01115         _registeredConstants.push_back(val);
01116     }
01117     
01118     staticRelease();
01119 }

void osg::Window::setGLLibraryName ( const Char8 * s ) [inline, static, inherited]

Set the library name where to find OpenGL extension functions. This has to be called before the first extension function is accessed, and it's safe to call it before osgInit().

Definition at line 121 of file OSGWindow.inl.

References osg::Window::_glLibraryName.

00122 {
00123     _glLibraryName = s;
00124 }

UInt32 osg::Window::getGLVersion ( void ) [inline, inherited]

Return the version of OpenGL running in the Window in the form 0x<major><major><minor><minor>, e.g. 0x0201 for version 2.1.

Definition at line 129 of file OSGWindow.inl.

References osg::Window::_glVersion.

Referenced by osg::TextureChunk::activate(), osg::TextureChunk::changeFrom(), osg::TextureChunk::deactivate(), osg::TextureChunk::handleGL(), and osg::TextureChunk::handleTexture().

00130 {
00131     return _glVersion;
00132 }

Int32 osg::Window::getExtensionId ( const Char8 * s ) [inline, static, inherited]

Find the id of a registered extension. Return -1 if extension not registered.

Definition at line 137 of file OSGWindow.inl.

References osg::Window::_registeredExtensions.

00138 {
00139     std::vector<std::string>::iterator it;
00140 
00141     it = std::find(_registeredExtensions.begin(),
00142               _registeredExtensions.end(),
00143               s);
00144 
00145     if(it == _registeredExtensions.end())
00146         return -1;
00147 
00148     return Int32(it -_registeredExtensions.begin());
00149 }

bool osg::Window::hasExtension ( UInt32 id ) [inline, inherited]

Check if the window has the indicated extension.

Warning:: No error checks are done on the passed index!

Definition at line 64 of file OSGWindow.inl.

References osg::Window::_availExtensions.

Referenced by osg::TextureChunk::activate(), osg::SHLParameterChunk::activate(), osg::RegisterCombinersChunk::activate(), osg::ProgramChunk::activate(), osg::PointChunk::activate(), osg::DVRSimpleLUTShader::activate(), osg::CubeTextureChunk::activate(), osg::BlendChunk::activate(), osg::DVRIsoShader::activate_NVRegisterCombinerShading(), osg::TextureChunk::changeFrom(), osg::SHLParameterChunk::changeFrom(), osg::ProgramChunk::changeFrom(), osg::PointChunk::changeFrom(), osg::CubeTextureChunk::changeFrom(), osg::BlendChunk::changeFrom(), osg::TextureChunk::deactivate(), osg::ProgramChunk::deactivate(), osg::PointChunk::deactivate(), osg::CubeTextureChunk::deactivate(), osg::BlendChunk::deactivate(), osg::GeoVBO::draw(), osg::Slices::drawSlices(), GeoPump128(), GeoPump129(), osg::DVRVolume::getTextureMode(), osg::TextureChunk::handleGL(), osg::SHLChunk::handleGL(), osg::ProgramChunk::handleGL(), osg::Geometry::handleGL(), osg::CubeTextureChunk::handleGL(), osg::TextureChunk::handleTexture(), osg::TextureChunk::handleTextureShader(), osg::TextureChunk::hasMultiTexture(), osg::DVRMtexLUTShader::initCombiners(), osg::DVRMtexLUTShader::initialize(), osg::DVRVolume::initializeClipObjects(), osg::DVRSimpleLUTShader::isModeSupported(), osg::DVRIsoShader::isModeSupported(), osg::FBOViewport::render(), osg::DVRMtexLUTShader::renderSlice(), osg::DVRSimpleLUTShader::setupAlphaCorrectionRegisterCombiners(), osg::RenderAction::start(), osg::SHLChunk::updateProgram(), and osg::SHLChunk::updateProgramParameters().

00065 {
00066     return _availExtensions[id];
00067 }

bool osg::Window::hasExtension ( const Char8 * s ) [inherited]

Check if the Window supports the given extension. Should be used for initialisation checks only, for checks done often it's recommended to register the extensions and use hasExtension(UInt32) instead.

Definition at line 956 of file OSGWindow.cpp.

References osg::Window::_extensions, and osg::Window::_ignoredExtensions.

00957 {
00958     if(std::find(_ignoredExtensions.begin(),
00959                  _ignoredExtensions.end(),
00960                  s)                         != _ignoredExtensions.end())
00961     {
00962         return false;
00963     }
00964     
00965     if(std::find(_extensions.begin(),
00966                  _extensions.end(),
00967                  s)                         != _extensions.end())
00968     {
00969         return true;
00970     }
00971     
00972     return false;
00973 }

bool osg::Window::hasCommonExtension ( UInt32 id ) [inline, static, inherited]

Check if the window has the indicated extension.

Definition at line 71 of file OSGWindow.inl.

References osg::Window::_commonExtensions.

Referenced by osg::PhongMaterial::createChunkMaterial(), and osg::PhongMaterial::prepareLocalChunks().

00072 {
00073     if(id >= _commonExtensions.size())
00074         return false;
00075 
00076     return _commonExtensions[id];
00077 }

void * osg::Window::getFunction ( UInt32 id ) [inline, inherited]

Get the indicated extension function. The id and the returned functions are checked for sanity and a warning is issued if there are problems. Use getFunctionNoCheck if you're sure you don't need them.

Definition at line 84 of file OSGWindow.inl.

References osg::Window::_extFunctions, osg::Window::_registeredFunctions, and FINFO.

00085 {
00086     if(id >= _extFunctions.size())
00087     {
00088         FINFO(("Window::getFunction: illegal id %d!\n", id));
00089         return NULL;
00090     }
00091     if(_extFunctions[id] == NULL)
00092     {
00093         FINFO(("Window::getFunction: function \"%s\" is NULL!\n",
00094                     _registeredFunctions[id].c_str()));
00095         return NULL;
00096     }
00097     return _extFunctions[id];
00098 }

void * osg::Window::getFunctionNoCheck ( UInt32 id ) [inline, inherited]

Get the indicated extension function.

Warning:: No error checks are done on the passed index nor on the returned function!

Definition at line 104 of file OSGWindow.inl.

References osg::Window::_extFunctions.

00105 {
00106     return _extFunctions[ id ];
00107 }

void osg::Window::dumpExtensions ( void ) [inherited]

Dump all the registered extensions to std::cout.

See OpenGL Objects & Extension Handling for a description of the OpenGL object concept.

Definition at line 1128 of file OSGWindow.cpp.

References osg::Window::_extensions.

01129 {   
01130     std::vector<std::string>::iterator it;
01131     std::cout << "GL Extensions: ";
01132     for ( it = _extensions.begin(); it != _extensions.end(); it++ )
01133     {
01134         std::cout << it->c_str() << ", ";
01135     }
01136     std::cout << std::endl;       
01137 }

osg::Window::GLExtensionFunction osg::Window::getFunctionByName ( const Char8 * s ) [inherited]

Query OpenGL for the pointer to an extension function.

This is called internally when extension functions are first cached.

Reimplemented in osg::ClusterWindow.

Definition at line 1421 of file OSGWindow.cpp.

References osg::Window::_availExtensions, osg::Window::_glLibraryName, osg::Window::_registeredExtensions, FDEBUG, and FWARNING.

Referenced by osg::Window::frameInit().

01423 {
01424     GLExtensionFunction retval = NULL;
01425 
01426 #if defined(darwin)
01427 
01428     if (NSIsSymbolNameDefined(s))
01429     {
01430         NSSymbol symbol = NSLookupAndBindSymbol(s);
01431         if (symbol != 0)
01432             retval = GLExtensionFunction(NSAddressOfSymbol(symbol));
01433     }
01434 
01435 #elif defined(WIN32)
01436 
01437     retval = (void(__cdecl*)(void)) wglGetProcAddress(s);
01438     
01439 #elif defined(__sgi)   || defined(darwin) || defined(__hpux) || \
01440       defined(__linux) || defined(__sun)
01441 
01442     /* Workaround for multiple nVidia/Linux installation bugs, based on code by */
01443     /* Manfred Weiler (Patch 783637) */
01444     
01445     static void (*(*__GetProcAddress)(const GLubyte *))(void) = NULL; 
01446 
01447     static void *libHandle = NULL; 
01448 
01449     if(libHandle == NULL) 
01450     { 
01451         libHandle = dlopen(_glLibraryName, RTLD_NOW | RTLD_LOCAL); 
01452 
01453         if(!libHandle) 
01454         { 
01455             FWARNING(("Error in dlopen: %s\n",dlerror())); 
01456             abort(); 
01457         } 
01458         else
01459         {
01460             FDEBUG(("Opened lib %s for GL extension handling.\n", 
01461                     (_glLibraryName==NULL)?"(executable)":_glLibraryName));
01462         }
01463     } 
01464 
01465     if(__GetProcAddress == NULL) 
01466     { 
01467         __GetProcAddress = (void (*(*)(const GLubyte*))()) 
01468                             dlsym(libHandle, "glXGetProcAddressARB"); 
01469 
01470         if(__GetProcAddress == NULL) 
01471         { 
01472             __GetProcAddress = (void (*(*)(const GLubyte*))()) 
01473                                 dlsym(libHandle, "glXGetProcAddress"); 
01474             
01475             if(__GetProcAddress == NULL) 
01476             {
01477                 // Couldn't find it linked to the executable. Try to open
01478                 // libGL.so directly.
01479                 
01480                 dlclose(libHandle);
01481                 
01482                 libHandle = dlopen("libGL.so", RTLD_NOW | RTLD_GLOBAL); 
01483 
01484                 if(!libHandle) 
01485                 { 
01486                     FWARNING(("Error in dlopen: %s\n",dlerror())); 
01487                     abort(); 
01488                 } 
01489                 else
01490                 {
01491                     FDEBUG(("Opened lib libGL.so for GL extension handling.\n"));
01492                 }
01493                 
01494                 __GetProcAddress = (void (*(*)(const GLubyte*))()) 
01495                                     dlsym(libHandle, "glXGetProcAddressARB"); 
01496 
01497                 if(__GetProcAddress == NULL) 
01498                 { 
01499                     __GetProcAddress = (void (*(*)(const GLubyte*))()) 
01500                                         dlsym(libHandle, "glXGetProcAddress"); 
01501                 }
01502                 
01503                 if(__GetProcAddress == NULL)
01504                 {
01505                    FWARNING(("Neither glXGetProcAddress nor "
01506                            "glXGetProcAddressARB found! Disabling all "
01507                            " extensions for Window %p!\n")); 
01508                    _availExtensions.clear();
01509                    _availExtensions.resize(_registeredExtensions.size(), false);
01510                 }
01511             } 
01512             else
01513             {
01514                 FDEBUG(("Using glXGetProcAddress for GL extension handling.\n"));
01515             }
01516         } 
01517         else
01518         {
01519             FDEBUG(("Using glXGetProcAddressARB for GL extension handling.\n"));
01520         }
01521     } 
01522 
01523     if(__GetProcAddress != NULL) 
01524     { 
01525         retval = reinterpret_cast<GLExtensionFunction>(__GetProcAddress((const GLubyte*)s)); 
01526     } 
01527     else 
01528     { 
01529         retval = (GLExtensionFunction)(dlsym(libHandle, s)); 
01530     } 
01531 
01532 #else
01533 
01534     FWARNING(("Window::getFunctionByName: couldn't find implementation!\n"
01535               "Please contact the developers at info@opensg.org.\n"));
01536     retval = NULL;
01537 
01538 #endif
01539 
01540     if(retval == NULL)
01541     {
01542         FWARNING(("Window::getFunctionByName: Couldn't get function '%s' for "
01543                  "Window %p.\n", s, this));
01544     }
01545     else
01546     {
01547         FDEBUG(("Window::getFunctionByName: got function '%s' for "
01548                  "Window %p at %p.\n", s, this, retval));
01549     }
01550 
01551     return retval;
01552 }

Real32 osg::Window::getConstantValue ( GLenum id ) [inline, inherited]

Return the value of the registered constant, Inf if not registered or no value received yet.

Definition at line 112 of file OSGWindow.inl.

References osg::Window::getConstantValuev().

Referenced by osg::TextureTransformChunk::activate(), osg::TextureChunk::activate(), osg::TexGenChunk::activate(), osg::CubeTextureChunk::activate(), osg::TextureTransformChunk::changeFrom(), osg::TextureChunk::changeFrom(), osg::TexGenChunk::changeFrom(), osg::CubeTextureChunk::changeFrom(), osg::TextureTransformChunk::deactivate(), osg::TextureChunk::deactivate(), osg::TexGenChunk::deactivate(), and osg::CubeTextureChunk::deactivate().

00113 {
00114     return getConstantValuev(id)[0];
00115 }

const Vec2f & osg::Window::getConstantValuev ( GLenum id ) [inherited]

Return the value of the registered constant, (Inf, Inf) if not registered or no value received yet.

Definition at line 1558 of file OSGWindow.cpp.

References osg::Window::_availConstants, and osg::Inf.

Referenced by osg::Window::getConstantValue().

01559 {
01560     static Vec2f inf(Inf, Inf);
01561 
01562     ConstHash::iterator it = _availConstants.find(id);
01563 
01564     if(it != _availConstants.end())
01565         return _availConstants[id];
01566 
01567     return inf;
01568 }

const std::vector< std::string > & osg::Window::getRegisteredExtensions ( void ) [inline, static, inherited]

Access the registered extensions.

Definition at line 160 of file OSGWindow.inl.

References osg::Window::_registeredExtensions.

00161 {
00162     return _registeredExtensions;
00163 }

const std::vector< std::string > & osg::Window::getRegisteredFunctions ( void ) [inline, inherited]

Access the registered functions.

Definition at line 167 of file OSGWindow.inl.

References osg::Window::_registeredFunctions.

00168 {
00169     return _registeredFunctions;
00170 }

const std::vector< std::string > & osg::Window::getExtensions ( void ) [inline, inherited]

Access the available extensions.

Definition at line 153 of file OSGWindow.inl.

References osg::Window::_extensions.

00154 {
00155     return _extensions;
00156 }

const std::vector< std::string > & osg::Window::getIgnoredExtensions ( void ) [inline, inherited]

Access the ignored extensions.

Definition at line 174 of file OSGWindow.inl.

References osg::Window::_ignoredExtensions.

00175 {
00176     return _ignoredExtensions;
00177 }

UInt32 osg::Window::registerGLObject	(	GLObjectFunctor	functor,
		UInt32	num = `1`
	)			`[static, inherited]`

Register a number of OpenGL objects. By default the number is 1, but more can be necessary for things like text. It returns the first id of the contiguous reserved ID block.

See OpenGL Objects & Extension Handling for a description of the OpenGL object concept.

Definition at line 534 of file OSGWindow.cpp.

References osg::Window::_glObjects, osg::Window::GLObject, osg::Window::initRegisterGLObject(), osg::Window::staticAcquire(), and osg::Window::staticRelease().

Referenced by osg::TextureChunk::changed(), osg::SHLChunk::changed(), osg::Geometry::changed(), osg::VertexProgramChunk::onCreate(), osg::TextureChunk::onCreate(), osg::Surface::onCreate(), osg::SHLChunk::onCreate(), osg::Geometry::onCreate(), osg::FragmentProgramChunk::onCreate(), and osg::CubeTextureChunk::onCreate().

00535 {
00536     UInt32    id, i; 
00537     GLObject *pGLObject;
00538 
00539     staticAcquire();
00540     
00541     // reserve index 0, illegal for most OpenGL functions
00542     if(_glObjects.empty())
00543         _glObjects.push_back( NULL );
00544 
00545     id        = _glObjects.size();
00546     pGLObject = new GLObject(functor);
00547     
00548     // does the requested block fit into the capacity?
00549     
00550     if(_glObjects.capacity() >= id + num)
00551     {
00552         _glObjects.insert(_glObjects.end(), num, pGLObject );
00553         
00554         initRegisterGLObject(id, num);
00555 
00556         staticRelease();
00557 
00558         return id;
00559     }
00560     
00561     // doesn't fit, try to find a block in the middle
00562     
00563     UInt32 cnt = 0;
00564 
00565     // start searching at 1, id 0 is reserved for GL
00566     for(i = 1; i < _glObjects.size(); ++i)
00567     {       
00568         if(_glObjects[i] == NULL)
00569         {
00570             if(cnt == 0)
00571             {
00572                 id = i;
00573             }
00574 
00575             ++cnt;
00576 
00577             if(cnt == num) 
00578             {
00579                 // block of unused entries found ...
00580                         
00581                 while(i >= id) 
00582                 {
00583                     _glObjects[i] = pGLObject;
00584                     i = i - 1;
00585                 } 
00586                 
00587                 initRegisterGLObject(id, num);
00588 
00589                 staticRelease();
00590 
00591                 return id;
00592             }
00593         }
00594         else
00595         {
00596             cnt = 0;
00597             id = 0;
00598         }
00599     }
00600     
00601     // no block found, add at the end
00602 
00603     if(id > 0) // ok the last entries in the vector were empty
00604     {
00605         // fill the empty slots at the end
00606         i = id + cnt - 1;
00607         while ( i >= id )
00608         {
00609             _glObjects[i] = pGLObject;
00610             i = i - 1;
00611         }
00612     }
00613     else
00614     {
00615         // we found no empty entries so the new id is the size of the vector.
00616         id = _glObjects.size();
00617     }
00618 
00619     // expand the vector for the rest
00620     for ( i = 1; i <= num - cnt; i++ )
00621     {
00622         _glObjects.push_back( pGLObject );
00623     }
00624 
00625     initRegisterGLObject(id, num);
00626 
00627     staticRelease();
00628     
00629     return id;
00630 }

void osg::Window::validateGLObject ( UInt32 id ) [inherited]

Validate the given object, i.e. make sure it is up-to-date in the current context.

See OpenGL Objects & Extension Handling for a description of the OpenGL object concept.

Definition at line 638 of file OSGWindow.cpp.

References osg::Window::_glObjects, osg::Window::_lastValidate, osg::WindowBase::_mfGlObjectLastRefresh, osg::WindowBase::_mfGlObjectLastReinitialize, osg::TypedVoidFunctor2Base< CallArgT, ArgsT, SizeTraitsT >::call(), FDEBUG, osg::Window::GLObject::getFunctor(), osg::WindowBase::getGlObjectEventCounter(), osg::Window::GLObject::incRefCounter(), osg::Window::initialize, osg::Window::needrefresh, osg::Window::packIdStatus(), osg::Window::reinitialize, osg::MField< FieldTypeT, fieldNameSpace >::size(), and SWARNING.

Referenced by osg::TextureChunk::activate(), osg::SHLChunk::activate(), osg::ProgramChunk::activate(), osg::CubeTextureChunk::activate(), osg::TextureChunk::changeFrom(), osg::SHLChunk::changeFrom(), osg::ProgramChunk::changeFrom(), osg::CubeTextureChunk::changeFrom(), osg::TextureGrabBackground::clear(), osg::TextureGrabForeground::draw(), osg::Surface::drawPrimitives(), osg::Geometry::drawPrimitives(), osg::Geometry::drawVBO(), osg::FBOViewport::render(), osg::SHLChunk::update(), and osg::Window::validateAllGLObjects().

00639 {
00640     if ( id == 0 )
00641     {
00642         SWARNING << "Window::validateGLObject: id is 0!" << std::endl;
00643             return;
00644     }
00645     
00646     GLObject *obj = _glObjects[id];
00647     
00648     if(obj == NULL)
00649     {
00650         SWARNING << "Window::validateGLObject: obj with id " << id << " is NULL!" << std::endl;
00651         return;
00652     }
00653 
00654     if(id >= _lastValidate.size()) // can happen if multi-threading
00655     {
00656         _lastValidate.insert(_lastValidate.end(), 
00657                              id + 1 - _lastValidate.size(),
00658                              0);
00659     }
00660     
00661     FDEBUG(("Window 0x%p (event %d,ri:%d,rf:%d): "
00662             "Validating object %d: last reinit:%d, last validate:"
00663             "%d last refresh: %d => %s\n", 
00664             this, getGlObjectEventCounter(), 
00665             _mfGlObjectLastReinitialize.size(),
00666             _mfGlObjectLastRefresh.size(),
00667             id, 
00668             (_mfGlObjectLastReinitialize.size() > id)?
00669                 _mfGlObjectLastReinitialize[id]:0xffffffff,
00670             _lastValidate[id],
00671             (_mfGlObjectLastRefresh.size() > id)?
00672                 _mfGlObjectLastRefresh[id]:0xffffffff,
00673             (_mfGlObjectLastReinitialize[id] == 0)?"init":
00674             ((_mfGlObjectLastReinitialize[id] > _lastValidate[id])?"reinit":
00675             ((_mfGlObjectLastRefresh[id] > _lastValidate[id])?"refresh":
00676             "up-to-date"))
00677           ));
00678     
00679     if(_mfGlObjectLastReinitialize[id] == 0)
00680     {
00681         obj->incRefCounter();
00682         obj->getFunctor().call(this, packIdStatus(id, initialize));
00683         _mfGlObjectLastReinitialize[id] = 1;
00684         _lastValidate[id] = getGlObjectEventCounter();
00685     }
00686     else if(_mfGlObjectLastReinitialize[id] > _lastValidate[id])
00687     {
00688         obj->getFunctor().call(this, packIdStatus(id, reinitialize));
00689         _lastValidate[id] = getGlObjectEventCounter();
00690     }
00691     else if(_mfGlObjectLastRefresh[id] > _lastValidate[id])
00692     {
00693         obj->getFunctor().call(this, packIdStatus(id, needrefresh));
00694         _lastValidate[id] = getGlObjectEventCounter();
00695     }
00696 }

void osg::Window::validateAllGLObjects ( void ) [inherited]

Validate all existing GL objects. Use with care, and only if the correct OpenGL context is active.

See OpenGL Objects & Extension Handling for a description of the OpenGL object concept.

Definition at line 705 of file OSGWindow.cpp.

References osg::Window::_glObjects, osg::Window::activate(), osg::Window::frameExit(), osg::Window::frameInit(), and osg::Window::validateGLObject().

00706 {
00707     activate();
00708     frameInit();
00709 
00710     for (UInt32 i = 1; i < _glObjects.size(); ++i)
00711         validateGLObject(i);
00712     
00713     frameExit();
00714 }

void osg::Window::setGLObjectId	(	UInt32	id,
		UInt32	id2
	)			`[inline, inherited]`

Validate the given object, i.e. make sure it is up-to-date in the current context.

See OpenGL Objects & Extension Handling for a description of the OpenGL object concept.

Definition at line 179 of file OSGWindow.inl.

References osg::Window::_glObjects, osg::Window::_ids, and SWARNING.

Referenced by osg::Geometry::createVBO(), osg::Geometry::destroyVBO(), osg::TextureChunk::handleGL(), osg::SHLChunk::handleGL(), osg::ProgramChunk::handleGL(), osg::Geometry::handleGL(), osg::CubeTextureChunk::handleGL(), and osg::SHLChunk::updateProgram().

00180 {
00181     if(osgId < _ids.size())
00182     {
00183         _ids[osgId] = id2;
00184     }
00185     else
00186     {
00187         _ids.resize(_glObjects.size());
00188         if(osgId < _ids.size())
00189             _ids[osgId] = id2;
00190         else
00191             SWARNING << "Window::setGLObjectId: id (" << osgId << ") is not valid!" << std::endl;
00192     }
00193 }

UInt32 osg::Window::getGLObjectId ( UInt32 id ) [inline, inherited]

Validate the given object, i.e. make sure it is up-to-date in the current context.

See OpenGL Objects & Extension Handling for a description of the OpenGL object concept.

Definition at line 195 of file OSGWindow.inl.

References osg::Window::_ids.

Referenced by osg::TextureChunk::activate(), osg::SHLChunk::activate(), osg::ProgramChunk::activate(), osg::CubeTextureChunk::activate(), osg::TextureChunk::changeFrom(), osg::SHLChunk::changeFrom(), osg::ProgramChunk::changeFrom(), osg::CubeTextureChunk::changeFrom(), osg::TextureGrabBackground::clear(), osg::SHLChunk::deactivate(), osg::ProgramChunk::deactivate(), osg::Geometry::destroyVBO(), osg::TextureGrabForeground::draw(), osg::Geometry::drawPrimitives(), osg::Geometry::drawVBO(), osg::TextureChunk::handleGL(), osg::SHLChunk::handleGL(), osg::ProgramChunk::handleGL(), osg::Geometry::handleGL(), osg::CubeTextureChunk::handleGL(), osg::FBOViewport::render(), osg::SHLChunk::update(), osg::SHLChunk::updateParameterLocations(), osg::SHLChunk::updateParameters(), osg::SHLChunk::updateProgram(), osg::SHLChunk::updateProgramParameters(), and osg::Geometry::updateVBO().

00196 {
00197     if(osgId < _ids.size())
00198         return _ids[osgId];
00199 
00200     //SWARNING << "Window::getGLObjectId: id (" << osgId << ") is not valid!" << std::endl;
00201     return 0;
00202 }

UInt32 osg::Window::getGLObjectsSize ( void ) [inline, static, inherited]

Validate the given object, i.e. make sure it is up-to-date in the current context.

See OpenGL Objects & Extension Handling for a description of the OpenGL object concept.

Definition at line 204 of file OSGWindow.inl.

References osg::Window::_glObjects.

00205 {
00206     return _glObjects.size();
00207 }

void osg::Window::refreshGLObject ( UInt32 id ) [static, inherited]

Mark the given object for refresh. The next time it is validated the registered callback function will be called for a refresh action.

See OpenGL Objects & Extension Handling for a description of the OpenGL object concept.

Definition at line 722 of file OSGWindow.cpp.

References osg::Window::_allWindows, osg::beginEditCP(), osg::MField< FieldTypeT, fieldNameSpace >::end(), osg::endEditCP(), osg::MField< FieldTypeT, fieldNameSpace >::getValues(), osg::WindowBase::GlObjectEventCounterFieldMask, osg::WindowBase::GlObjectLastRefreshFieldMask, osg::MField< FieldTypeT, fieldNameSpace >::size(), and SWARNING.

Referenced by osg::TextureChunk::changed(), osg::Surface::changed(), osg::SHLChunk::changed(), osg::ProgramChunk::changed(), osg::Geometry::changed(), osg::Geometry::invalidateDlistCache(), osg::Window::refreshAllGLObjects(), and osg::BrickSet::reloadBrickTextures().

00723 {
00724     if ( id == 0 )
00725     {
00726         SWARNING << "Window::refreshGLObject: id is 0!" << std::endl;
00727         return;
00728     }
00729 
00730     std::vector<WindowPtr>::iterator it;
00731 
00732     for ( it = _allWindows.begin(); it != _allWindows.end(); ++it)
00733     {
00734         beginEditCP(*it, GlObjectEventCounterFieldMask|
00735                          GlObjectLastRefreshFieldMask);
00736 
00737         UInt32 lastinv = (*it)->getGlObjectEventCounter() + 1;
00738         MFUInt32 &field = (*it)->_mfGlObjectLastRefresh;
00739         if(field.size() <= id)
00740             field.getValues().insert(field.end(), id - field.size() + 1, 0 );
00741         field[id] = lastinv;
00742         (*it)->setGlObjectEventCounter(lastinv);
00743 
00744         endEditCP  (*it, GlObjectEventCounterFieldMask|
00745                          GlObjectLastRefreshFieldMask);
00746     }
00747 }

void osg::Window::refreshAllGLObjects ( void ) [static, inherited]

Refresh all existing GL objects.

See OpenGL Objects & Extension Handling for a description of the OpenGL object concept.

Definition at line 754 of file OSGWindow.cpp.

References osg::Window::_glObjects, and osg::Window::refreshGLObject().

00755 {
00756     for (UInt32 i = 1; i < _glObjects.size(); ++i)
00757         refreshGLObject(i);
00758 }

void osg::Window::reinitializeGLObject ( UInt32 id ) [static, inherited]

Mark the given object for reinitialisation. The next time it is validated the registered callback function will be called for a reinit action.

See OpenGL Objects & Extension Handling for a description of the OpenGL object concept.

Definition at line 766 of file OSGWindow.cpp.

References osg::Window::_allWindows, osg::beginEditCP(), osg::MField< FieldTypeT, fieldNameSpace >::end(), osg::endEditCP(), osg::MField< FieldTypeT, fieldNameSpace >::getValues(), osg::WindowBase::GlObjectEventCounterFieldMask, osg::WindowBase::GlObjectLastReinitializeFieldMask, osg::MField< FieldTypeT, fieldNameSpace >::size(), and SWARNING.

Referenced by osg::TextureChunk::changed(), osg::SHLChunk::changed(), osg::ProgramChunk::changed(), and osg::Window::reinitializeAllGLObjects().

00767 {
00768     if ( id == 0 )
00769     {
00770         SWARNING << "Window::reinitializeGLObject: id is 0!" << std::endl;
00771         return;
00772     }
00773 
00774     std::vector<WindowPtr>::iterator it;
00775 
00776     for(it = _allWindows.begin(); it != _allWindows.end(); ++it)
00777     {
00778         beginEditCP(*it, GlObjectEventCounterFieldMask|
00779                          GlObjectLastReinitializeFieldMask);
00780 
00781         UInt32 lastinv = (*it)->getGlObjectEventCounter() + 1;
00782 
00783         MFUInt32 &field = (*it)->_mfGlObjectLastReinitialize;
00784         if(field.size() <= id)
00785             field.getValues().insert(field.end(), id - field.size() + 1, 0 );
00786         // is it already validated?
00787         if(field[id] == 0)
00788             continue;
00789         field[id] = lastinv;
00790         (*it)->setGlObjectEventCounter(lastinv);
00791 
00792         endEditCP  (*it, GlObjectEventCounterFieldMask|
00793                          GlObjectLastReinitializeFieldMask);
00794     }
00795 }

void osg::Window::reinitializeAllGLObjects ( void ) [static, inherited]

Reinitialize all existing GL objects.

See OpenGL Objects & Extension Handling for a description of the OpenGL object concept.

Definition at line 802 of file OSGWindow.cpp.

References osg::Window::_glObjects, and osg::Window::reinitializeGLObject().

00803 {
00804     for (UInt32 i = 1; i < _glObjects.size(); ++i)
00805         reinitializeGLObject(i);
00806 }

void osg::Window::destroyGLObject	(	UInt32	id,
		UInt32	num = `1`
	)			`[static, inherited]`

Mark the given objects for destruction. The actual destruction will happen later.

See OpenGL Objects & Extension Handling for a description of the OpenGL object concept.

Definition at line 869 of file OSGWindow.cpp.

References osg::Window::_allWindows, osg::Window::_glObjects, and FWARNING.

Referenced by osg::Geometry::changed(), osg::TextureChunk::onDestroy(), osg::Surface::onDestroy(), osg::SHLChunk::onDestroy(), osg::Geometry::onDestroy(), and osg::ProgramChunk::~ProgramChunk().

00870 {
00871 #ifdef OSG_DEBUG
00872     if(id >= _glObjects.size() || _glObjects[id] == NULL)
00873     {
00874         FWARNING(("Window::destroyGLObject: object %d is NULL!\n", id));
00875         return;
00876     }
00877 #endif
00878 
00879     // Has this object ever been used?
00880     if(_glObjects[id] && _glObjects[id]->getRefCounter() == 0)
00881     {
00882         if(_glObjects[id])
00883             delete _glObjects[ id ];
00884         
00885         for ( UInt32 j = 0; j < num ; j++)
00886         {
00887             _glObjects[id+j] = NULL;
00888         }
00889 
00890         return;
00891     }
00892     
00893     std::vector<WindowPtr>::iterator it;
00894 
00895     for(it = _allWindows.begin(); it != _allWindows.end(); ++it)
00896     {
00897 #ifdef OSG_DEBUG
00898         if(id + num > (*it)->_mfGlObjectLastReinitialize.size())
00899         {
00900             FWARNING(("Window::destroyGLObject: id %d + num %d exceed"
00901                 "registered objects size %d!\n", id, num, 
00902                 (*it)->_mfGlObjectLastReinitialize.size()));
00903             return;
00904         }
00905 #endif
00906 
00907         // has the object been used in this context at all?
00908         if((*it)->getGlObjectLastReinitialize()[id] != 0) 
00909             (*it)->_glObjectDestroyList.push_back(DestroyEntry(id,num));
00910     }
00911 }

void osg::Window::unpackIdStatus	(	UInt32	idstatus,
		UInt32 &	osgId,
		GLObjectStatusE &	status
	)			`[inline, static, inherited]`

Unpack the id and the status from one UInt32 packed by packIdStatus

Definition at line 226 of file OSGWindow.inl.

References osg::Window::statusMask, and osg::Window::statusShift.

Referenced by osg::TextureChunk::handleGL(), osg::Surface::handleGL(), osg::SHLChunk::handleGL(), osg::ProgramChunk::handleGL(), osg::Geometry::handleGL(), osg::CubeTextureChunk::handleGL(), and osg::ProgramChunk::printCompileError().

00228 {
00229     osgId = idstatus >> statusShift;
00230     status = static_cast<GLObjectStatusE>(idstatus & statusMask);
00231 }

bool osg::Window::isResizePending ( void ) [inline, inherited]

Definition at line 56 of file OSGWindow.inl.

References osg::WindowBase::_sfResizePending, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::Window::resizeGL().

00057 {
00058     return _sfResizePending.getValue();
00059 }

void osg::Window::resize	(	int	width,
		int	height
	)			`[virtual, inherited]`

Resize notifier function.

As OpenSG does not do Window System event management it needs to be notified whenever the size of a Window changes.

Definition at line 1695 of file OSGWindow.cpp.

References osg::beginEditCP(), osg::endEditCP(), osg::WindowBase::HeightFieldMask, osg::WindowBase::ResizePendingFieldMask, osg::WindowBase::setHeight(), osg::WindowBase::setResizePending(), osg::WindowBase::setWidth(), and osg::WindowBase::WidthFieldMask.

01696 {
01697     WindowPtr win(*this);
01698     beginEditCP(win, WidthFieldMask|HeightFieldMask|ResizePendingFieldMask);
01699     setWidth( width );
01700     setHeight( height );
01701     setResizePending( true );
01702     endEditCP  (win, WidthFieldMask|HeightFieldMask|ResizePendingFieldMask);
01703 }

void osg::Window::resizeGL ( void ) [virtual, inherited]

Resize function.

This function needs to be called before a Window's Viewports are rendered, to ensure that eventual pending resizes are handled correctly.

Definition at line 1711 of file OSGWindow.cpp.

References osg::beginEditCP(), osg::endEditCP(), osg::WindowBase::getHeight(), osg::WindowBase::getWidth(), osg::Window::isResizePending(), osg::WindowBase::ResizePendingFieldMask, and osg::WindowBase::setResizePending().

Referenced by osg::Window::draw(), osg::FBOViewport::render(), and osg::RenderAction::start().

01712 {
01713     if ( isResizePending () )
01714     {
01715         glViewport( 0, 0, getWidth(), getHeight() );
01716         WindowPtr win(*this);
01717         beginEditCP(win, ResizePendingFieldMask);
01718         setResizePending( false );
01719         endEditCP  (win, ResizePendingFieldMask);
01720     }
01721 }

void osg::Window::setSize	(	UInt16	width,
		UInt16	height
	)			`[inline, inherited]`

Set the width and height of the Window. Only use if you really know what you're doing. In most cases resize() is a better choice.

Definition at line 50 of file OSGWindow.inl.

References osg::WindowBase::setHeight(), and osg::WindowBase::setWidth().

Referenced by osg::SortFirstWindow::clientPreSync().

00051 {
00052     setHeight(height);
00053     setWidth(width);
00054 }

void osg::Window::frameInit ( void ) [virtual, inherited]

Do everything that needs to be done before the Window is redrawn. This function has to be called for every frame the Window is drawn.

The convenience functions render and draw take care of it, if they are used.

The main task currently is checking and updating OpenGL extensions.

Reimplemented in osg::ClusterWindow.

Definition at line 1150 of file OSGWindow.cpp.

References osg::Window::_availConstants, osg::Window::_availExtensions, osg::Window::_commonExtensions, osg::Window::_extensions, osg::Window::_extFunctions, osg::Window::_glVersion, osg::Window::_ignoredExtensions, osg::Window::_numAvailConstants, osg::Window::_registeredConstants, osg::Window::_registeredExtensions, osg::Window::_registeredFunctionExts, osg::Window::_registeredFunctions, osg::Window::_registeredFunctionVersions, FDEBUG, FLOG, FPDEBUG, FWARNING, osg::Window::getFunctionByName(), osg::PointInterface< ValueTypeT, StorageInterfaceT >::getValues(), osg::Window::ignoreExtensions(), p, osg::Window::staticAcquire(), osg::Window::staticRelease(), and osg::Window::unknownConstant.

Referenced by osg::Window::draw(), osg::Window::render(), osg::Window::setupGL(), and osg::Window::validateAllGLObjects().

01151 {
01152     static bool ignoreEnvDone = false;
01153     
01154     if(!ignoreEnvDone)
01155     {
01156         ignoreEnvDone = true;
01157         char *p = getenv("OSG_IGNORE_EXTENSIONS");
01158         if(p)
01159             ignoreExtensions(p);
01160     }
01161     
01162     // get version/extensions and split them
01163     if(_extensions.empty())
01164     {
01165         const char *version = 
01166                 reinterpret_cast<const char *>(glGetString(GL_VERSION));
01167         
01168         int major = atoi(version);
01169         int minor = atoi(strchr(version, '.') + 1);
01170         
01171         _glVersion = (major << 8) + minor;
01172         
01173 #ifdef __APPLE__
01174 
01175     const char* glVendor = (const char*) glGetString(GL_VENDOR);
01176     const char* glRenderer = (const char*) glGetString(GL_RENDERER);
01177 
01178     // TODO; is there a better way to switch some
01179         // extentions for a specific os/vendor/renderer combo
01180         FLOG (( "GL Vendor/Renderer: %s/%s\n", glVendor, glRenderer ));
01181     
01182     if ( strstr(glVendor, "ATI") && strstr(glRenderer,"X1600") ) {
01183           FWARNING (("Switch of non_power_of_two for ATI\n"));
01184           ignoreExtensions("GL_ARB_texture_non_power_of_two");
01185     }
01186 
01187 #endif // __APPLE
01188 
01189         FDEBUG(("Window %p: GL Version: %4x ('%s')\n", this, 
01190                 _glVersion, glGetString(GL_VERSION) ));
01191          
01192         FDEBUG(("Window %p: GL Extensions: %s\n", this, 
01193                 glGetString(GL_EXTENSIONS) ));
01194 
01195         std::string foo(reinterpret_cast<const char*>
01196                         (glGetString(GL_EXTENSIONS)));
01197 
01198         FDEBUG(("Window %p: Ignored: ", this));
01199         
01200         for(string_token_iterator it = string_token_iterator(foo, ",. ");
01201             it != string_token_iterator(); ++it)
01202         {          
01203             if(! std::binary_search(_ignoredExtensions.begin(),
01204                                     _ignoredExtensions.end(),
01205                                     *it))
01206             {
01207                 _extensions.push_back(*it);
01208             }
01209             else
01210             {
01211                 FPDEBUG(("%s ", (*it).c_str()));
01212             }
01213         }
01214         FPDEBUG(("\n"));
01215         std::sort(_extensions.begin(), _extensions.end());
01216                  
01217         // if we don't have any extensions, add something anyway
01218         if(_extensions.empty())
01219             _availExtensions.resize(_registeredExtensions.size(), false);
01220     }
01221     
01222     // any new extension registered ? 
01223     if(_registeredExtensions.size() > _availExtensions.size())
01224     {
01225         staticAcquire();
01226         FDEBUG(("Window %p: exts: ", this));
01227 
01228         while(_registeredExtensions.size() > _availExtensions.size())
01229         {                          
01230             UInt32 s = _availExtensions.size();
01231 
01232             /* perform a binary search over the retrieved extension strings.
01233                Push back the result as an availability flag for the extension
01234                requested by the application */         
01235             bool supported = std::binary_search( 
01236                                 _extensions.begin(),
01237                                 _extensions.end(),
01238                                 _registeredExtensions[s]);
01239             
01240             /* Is this extension ignored? */
01241             bool ignored   = std::binary_search( 
01242                                 _ignoredExtensions.begin(),
01243                                 _ignoredExtensions.end(),
01244                                 _registeredExtensions[s]);
01245 
01246             _availExtensions.push_back(supported && !ignored);
01247             
01248             FPDEBUG(("%s:", _registeredExtensions[s].c_str()));
01249             if(_commonExtensions.size() <= s)
01250             {
01251                 _commonExtensions.push_back(supported && !ignored);
01252                 if(supported && !ignored)
01253                 {
01254                     FPDEBUG(("ok "));
01255                 }
01256                 else if(!supported)
01257                 {
01258                     FPDEBUG(("NF "));
01259                 }
01260                 else
01261                 {
01262                     FPDEBUG(("IGN "));
01263                 }
01264             }
01265             else if (!supported)
01266             {
01267                 _commonExtensions[s] = false;
01268                 FPDEBUG(("NF "));
01269             }
01270             else
01271             {
01272                 _commonExtensions[s] = false;
01273                 FPDEBUG(("IGN "));
01274             }
01275         }
01276         FPDEBUG(("\n"));
01277         staticRelease();
01278     }
01279     
01280     // any new functions registered ? 
01281     while(_registeredFunctions.size() > _extFunctions.size())
01282     {   
01283         const Char8 *s    = _registeredFunctions[_extFunctions.size()].c_str();
01284         Int32        ext  = _registeredFunctionExts[_extFunctions.size()];
01285         UInt32       ver  = _registeredFunctionVersions[_extFunctions.size()];
01286         void        *func = NULL;
01287         
01288         if(ext == -1 || _availExtensions[ext] == true || _glVersion >= ver)
01289             func = (void*)getFunctionByName(s);
01290 
01291         _extFunctions.push_back(func);
01292     }
01293 
01294     // any new constants registered ? 
01295     while(_registeredConstants.size() > _numAvailConstants)
01296     {   
01297         for(std::vector<GLenum>::iterator it = _registeredConstants.begin() + 
01298                                                _numAvailConstants;
01299             it != _registeredConstants.end();
01300             ++it)
01301         {
01302             Vec2f val(unknownConstant, unknownConstant); 
01303             glGetFloatv(*it, static_cast<GLfloat*>(val.getValues()));
01304             _availConstants[*it] = val;
01305             FDEBUG(("Window(%p): Constant 0x%x value is %.3f %.3f\n", this,
01306                     *it, val[0], val[1]));
01307         }
01308         _numAvailConstants = _registeredConstants.size();
01309         glGetError(); // clear the error flag 
01310     }
01311 }

void osg::Window::frameExit ( void ) [virtual, inherited]

Do everything that needs to be done after the Window is redrawn. This function has to be called for every frame the Window is drawn.

The convenience functions render and draw take care of it, if they are used.

The main task currently is deleting OpenGL objects.

Reimplemented in osg::ClusterWindow.

Definition at line 1321 of file OSGWindow.cpp.

References osg::Window::_glObjectDestroyList, osg::Window::_glObjects, osg::Window::destroy, FDEBUG, osg::Window::finaldestroy, FWARNING, osg::WindowBase::getGlObjectLastReinitialize(), osg::Window::GLObject::getRefCounter(), GLenum, p, and osg::Window::packIdStatus().

Referenced by osg::Window::draw(), osg::Window::render(), and osg::Window::validateAllGLObjects().

01322 {   
01323     std::list<DestroyEntry>::iterator st,en;
01324 
01325     st = _glObjectDestroyList.begin();
01326     en = _glObjectDestroyList.end  ();
01327 
01328     while(st != en)
01329     {
01330         UInt32 i = st->first, n = st->second;
01331 
01332         GLObject *obj = _glObjects[ i ];
01333         
01334         if(obj == NULL)
01335         {
01336             FDEBUG(("Window::frameExit: objects %d (%d) already destroyed?!?\n",
01337                     i, n));
01338             ++st;
01339             continue;
01340         }
01341            
01342         UInt32 rc = obj->getRefCounter();
01343 
01344         // has the object been used in this context at all?
01345         if(getGlObjectLastReinitialize()[i] != 0) 
01346         {                  
01347             _glObjects[i]->getFunctor().call( this, packIdStatus(i, destroy));
01348 
01349             if((rc = _glObjects[ i ]->decRefCounter()) <= 0)
01350             {           
01351                 // call functor with the final-flag
01352                 _glObjects[i]->getFunctor().call( this, 
01353                                                 packIdStatus(i, finaldestroy));
01354             }
01355         }
01356 
01357         // if the GLObject is removed from each GL-Context, free GLObject-IDs.
01358         if(rc <= 0)
01359         {
01360             delete _glObjects[ i ];
01361             for ( UInt32 j = 0; j < n ; j++)
01362             {
01363                 _glObjects[i+j] = NULL;
01364             }   
01365         }
01366 
01367         ++st;
01368     }
01369 
01370     _glObjectDestroyList.clear();
01371     
01372     // Test for OpenGL errors. Just a little precaution to catch
01373     // stray errors. This is the only OpenGL error test in opt mode
01374     // and it needs to be enabled using the OSG_TEST_GL_ERRORS envvar.
01375     // In debug mode it is always on.
01376     static bool inited = false;
01377 #ifndef OSG_DEBUG
01378     static bool testGLErrors = false;
01379 #else
01380     static bool testGLErrors = true;
01381 #endif
01382     
01383     if(!inited)
01384     {
01385         inited = true;
01386         char *p = getenv("OSG_DEBUG");
01387         if(p)
01388             testGLErrors = true;
01389     }
01390  
01391     if(testGLErrors)
01392     {
01393         GLenum glerr;
01394 
01395         while((glerr = glGetError()) != GL_NO_ERROR)
01396         {
01397             FWARNING(("Window::frameExit: Caught stray OpenGL error %s (%#x).\n",
01398                     gluErrorString(glerr),
01399                     glerr));
01400 #ifndef OSG_DEBUG
01401             FWARNING(("Rerun with debug-libraries to get more accurate "
01402                       "information.\n"));
01403 #endif
01404         }
01405     }
01406     
01407 }

void osg::Window::draw ( DrawAction * action = NULL ) [virtual, inherited]

Draw the Window using the given DrawAction.

It takes care of all initialisation and cleanup functions and contains just 6 lines of code. If you know that the correct context is active or you want to delay swaps you can just copy and manipulate it.

Definition at line 1603 of file OSGWindow.cpp.

References osg::Window::activate(), osg::Window::drawAllViewports(), osg::Window::frameExit(), osg::Window::frameInit(), osg::Window::resizeGL(), and osg::Window::swap().

01604 {
01605     activate();
01606     frameInit();    // query recently registered GL extensions
01607     
01608     resizeGL();
01609 
01610     drawAllViewports(action);
01611 
01612     swap();
01613     frameExit();    // after frame cleanup: delete GL objects, if needed
01614 }

void osg::Window::drawAllViewports ( DrawAction * action = NULL ) [virtual, inherited]

Draw all the Viewports of the Window using the given DrawAction.

A simple convenience function that loops all Viewports and call their draw method.

Definition at line 1621 of file OSGWindow.cpp.

References osg::WindowBase::_mfPort, osg::MField< FieldTypeT, fieldNameSpace >::begin(), osg::MField< FieldTypeT, fieldNameSpace >::end(), osg::DrawActionBase::setWindow(), and SWARNING.

Referenced by osg::Window::draw().

01622 {
01623     MFViewportPtr::iterator       portIt  = _mfPort.begin();
01624     MFViewportPtr::const_iterator portEnd = _mfPort.end();
01625 
01626     if(action != NULL)
01627     {
01628         action->setWindow(this);
01629         
01630         while(portIt != portEnd)
01631         {
01632             (*portIt)->draw(action);
01633 
01634             ++portIt;
01635         }
01636     }
01637     else
01638     {
01639         SWARNING << "Window::drawAllViewports: no action!" << std::endl;
01640     }
01641 }

void osg::Window::render ( RenderActionBase * action = NULL ) [virtual, inherited]

Render the Window using the given RenderAction.

It takes care of all initialisation and cleanup functions and contains just 5 lines of code. If you know that the correct context is active or you want to delay swaps you can just copy and manipulate it.

Reimplemented in osg::ClusterWindow.

Definition at line 1649 of file OSGWindow.cpp.

References osg::Window::activate(), osg::Window::frameExit(), osg::Window::frameInit(), osg::Window::renderAllViewports(), and osg::Window::swap().

01650 {
01651     activate();
01652     frameInit();    // query recently registered GL extensions
01653     
01654 //  resizeGL();
01655 
01656     renderAllViewports(action);
01657 
01658     swap();
01659     frameExit();    // after frame cleanup: delete GL objects, if needed
01660 }

void osg::Window::renderAllViewports ( RenderActionBase * action = NULL ) [virtual, inherited]

Render all the Viewports of the Window using the given RenderAction.

A simple convenience function that loops all Viewports and call their draw method.

Reimplemented in osg::ClusterWindow.

Definition at line 1668 of file OSGWindow.cpp.

References osg::WindowBase::_mfPort, osg::MField< FieldTypeT, fieldNameSpace >::begin(), osg::MField< FieldTypeT, fieldNameSpace >::end(), osg::DrawActionBase::setWindow(), and SWARNING.

Referenced by osg::Window::render().

01669 {
01670     MFViewportPtr::iterator       portIt  = _mfPort.begin();
01671     MFViewportPtr::const_iterator portEnd = _mfPort.end();
01672 
01673     if(action != NULL)
01674     {
01675         action->setWindow(this);
01676         
01677         while(portIt != portEnd)
01678         {
01679             (*portIt)->render(action);
01680             ++portIt;
01681         }
01682     }
01683     else
01684     {
01685         SWARNING << "Window::renderAllViewports: no action!" << std::endl;
01686     }
01687 }

void osg::Window::setupGL ( void ) [protected, virtual, inherited]

Initialize the OpenGL state OpenSG expects. This should be called once whenever a new Window is opened.

Don't call it directly, call the Window System-specific init() method instead.

Definition at line 1577 of file OSGWindow.cpp.

References osg::Window::frameInit().

Referenced by osg::XWindow::init(), osg::QTWindow::init(), and init().

01578 {   
01579     glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
01580     glPixelStorei( GL_PACK_ALIGNMENT, 1 );
01581     
01582     glDepthFunc( GL_LEQUAL );
01583     glEnable( GL_DEPTH_TEST );
01584     
01585     glEnable( GL_NORMALIZE );
01586     
01587     // switch off default light
01588     GLfloat nul[4]={0,0,0,0};
01589     glLightfv(GL_LIGHT0, GL_DIFFUSE, nul);
01590     glLightfv(GL_LIGHT0, GL_SPECULAR, nul);
01591     
01592     frameInit();    // call it to setup extensions
01593 }

void osg::Window::initRegisterGLObject	(	UInt32	id,
		UInt32	num
	)			`[static, protected, inherited]`

Initialize the GL object registration for the given objects in all Windows.

See OpenGL Objects & Extension Handling for a description of the OpenGL object concept.

Definition at line 814 of file OSGWindow.cpp.

References osg::Window::_allWindows, and SWARNING.

Referenced by osg::Window::registerGLObject().

00815 {
00816     if ( id == 0 )
00817     {
00818         SWARNING << "Window::initRegisterGLObject: id is 0!" << std::endl;
00819         return;
00820     }
00821 
00822     std::vector<WindowPtr>::iterator it;
00823 
00824     for(it = _allWindows.begin(); it != _allWindows.end(); ++it)
00825     {
00826         (*it)->doInitRegisterGLObject(id, num);
00827     }
00828 }

UInt32 osg::Window::packIdStatus	(	UInt32	osgId,
		GLObjectStatusE	status
	)			`[inline, static, protected, inherited]`

Pack the id and the status into one UInt32. Used to pass the id and status to the actual implementation functions.

Dev:

This packing is not really necessary and just done because I didn't want to change all the prototypes and implementations everywhere. Do it for 1.3.

Definition at line 219 of file OSGWindow.inl.

References osg::Window::statusShift.

Referenced by osg::Window::frameExit(), and osg::Window::validateGLObject().

00220 {
00221     return (osgId << statusShift) | status;
00222 }

void osg::Window::doInitRegisterGLObject	(	UInt32	id,
		UInt32	num
	)			`[protected, inherited]`

Initialize the GL object registration for the given objects in the given Window.

See OpenGL Objects & Extension Handling for a description of the OpenGL object concept.

Definition at line 836 of file OSGWindow.cpp.

References osg::Window::_lastValidate, osg::WindowBase::_mfGlObjectLastRefresh, osg::WindowBase::_mfGlObjectLastReinitialize, osg::beginEditCP(), osg::endEditCP(), osg::WindowBase::GlObjectLastRefreshFieldMask, osg::WindowBase::GlObjectLastReinitializeFieldMask, osg::MField< FieldTypeT, fieldNameSpace >::resize(), and osg::MField< FieldTypeT, fieldNameSpace >::size().

Referenced by osg::Window::operator=(), and osg::Window::Window().

00837 {
00838     WindowPtr win(this);
00839     
00840     beginEditCP(win, GlObjectLastReinitializeFieldMask|
00841                      GlObjectLastRefreshFieldMask);
00842 
00843     if(_mfGlObjectLastReinitialize.size() < id + num)
00844         _mfGlObjectLastReinitialize.resize(id + num);
00845         
00846     if(_mfGlObjectLastRefresh.size() < id + num)
00847         _mfGlObjectLastRefresh.resize(id + num);
00848         
00849     if(_lastValidate.size() < id + num)       
00850         _lastValidate.resize(id + num);
00851  
00852     for(UInt32 i = id; i < id + num; ++i)
00853     {
00854         _mfGlObjectLastReinitialize[i] = 0;
00855         _mfGlObjectLastRefresh     [i] = 0;
00856         _lastValidate[i] = 0;
00857    }
00858 
00859     endEditCP  (win, GlObjectLastReinitializeFieldMask|
00860                      GlObjectLastRefreshFieldMask);
00861 }

void osg::FieldContainer::onCreate ( const FieldContainer * source = NULL ) [inline, protected, inherited]

Definition at line 318 of file OSGFieldContainerImpl.inl.

Referenced by osg::ShaderParameterChunk::onCreate().

00319 {
00320 }

void osg::FieldContainer::onCreateAspect	(	const FieldContainer *	aspect0,
		const FieldContainer *	source = `NULL`
	)			`[inline, protected, inherited]`

Definition at line 323 of file OSGFieldContainerImpl.inl.

00325 {
00326 }

SFUInt16 * osg::WindowBase::getSFWidth ( void ) [inline, inherited]

Definition at line 75 of file OSGWindowBase.inl.

References osg::WindowBase::_sfWidth.

00076 {
00077     return &_sfWidth;
00078 }

SFUInt16 * osg::WindowBase::getSFHeight ( void ) [inline, inherited]

Definition at line 82 of file OSGWindowBase.inl.

References osg::WindowBase::_sfHeight.

00083 {
00084     return &_sfHeight;
00085 }

MFViewportPtr * osg::WindowBase::getMFPort ( void ) [inline, inherited]

Definition at line 89 of file OSGWindowBase.inl.

References osg::WindowBase::_mfPort.

00090 {
00091     return &_mfPort;
00092 }

SFBool * osg::WindowBase::getSFResizePending ( void ) [inline, inherited]

Definition at line 96 of file OSGWindowBase.inl.

References osg::WindowBase::_sfResizePending.

00097 {
00098     return &_sfResizePending;
00099 }

UInt16 & osg::WindowBase::getWidth ( void ) [inline, inherited]

Definition at line 125 of file OSGWindowBase.inl.

References osg::WindowBase::_sfWidth, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::SortFirstWindow::clientPreSync(), osg::Window::resizeGL(), and osg::MultiDisplayWindow::serverRender().

00126 {
00127     return _sfWidth.getValue();
00128 }

const UInt16 & osg::WindowBase::getWidth ( void ) const [inline, inherited]

Definition at line 132 of file OSGWindowBase.inl.

References osg::WindowBase::_sfWidth, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00133 {
00134     return _sfWidth.getValue();
00135 }

UInt16 & osg::WindowBase::getHeight ( void ) [inline, inherited]

Definition at line 146 of file OSGWindowBase.inl.

References osg::WindowBase::_sfHeight, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::SortFirstWindow::clientPreSync(), osg::Window::resizeGL(), and osg::MultiDisplayWindow::serverRender().

00147 {
00148     return _sfHeight.getValue();
00149 }

const UInt16 & osg::WindowBase::getHeight ( void ) const [inline, inherited]

Definition at line 153 of file OSGWindowBase.inl.

References osg::WindowBase::_sfHeight, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00154 {
00155     return _sfHeight.getValue();
00156 }

bool & osg::WindowBase::getResizePending ( void ) [inline, inherited]

Definition at line 167 of file OSGWindowBase.inl.

References osg::WindowBase::_sfResizePending, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00168 {
00169     return _sfResizePending.getValue();
00170 }

const bool & osg::WindowBase::getResizePending ( void ) const [inline, inherited]

Definition at line 174 of file OSGWindowBase.inl.

References osg::WindowBase::_sfResizePending, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00175 {
00176     return _sfResizePending.getValue();
00177 }

ViewportPtr & osg::WindowBase::getPort ( const UInt32 index ) [inline, inherited]

Definition at line 210 of file OSGWindowBase.inl.

References osg::WindowBase::_mfPort.

Referenced by osg::FBOViewport::render().

00211 {
00212     return _mfPort[index];
00213 }

MFViewportPtr & osg::WindowBase::getPort ( void ) [inline, inherited]

Definition at line 217 of file OSGWindowBase.inl.

References osg::WindowBase::_mfPort.

Referenced by osg::MultiDisplayWindow::clientInit(), osg::SortFirstWindow::clientPreSync(), osg::SortFirstWindow::clientSwap(), osg::SortFirstWindow::serverRender(), and osg::MultiDisplayWindow::serverRender().

00218 {
00219     return _mfPort;
00220 }

const MFViewportPtr & osg::WindowBase::getPort ( void ) const [inline, inherited]

Definition at line 224 of file OSGWindowBase.inl.

References osg::WindowBase::_mfPort.

00225 {
00226     return _mfPort;
00227 }

void osg::WindowBase::setWidth ( const UInt16 & value ) [inline, inherited]

Definition at line 139 of file OSGWindowBase.inl.

References osg::WindowBase::_sfWidth, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

Referenced by osg::Window::operator=(), osg::Window::resize(), osg::MultiDisplayWindow::serverRender(), and osg::Window::setSize().

00140 {
00141     _sfWidth.setValue(value);
00142 }

void osg::WindowBase::setHeight ( const UInt16 & value ) [inline, inherited]

Definition at line 160 of file OSGWindowBase.inl.

References osg::WindowBase::_sfHeight, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

Referenced by osg::Window::operator=(), osg::Window::resize(), osg::MultiDisplayWindow::serverRender(), and osg::Window::setSize().

00161 {
00162     _sfHeight.setValue(value);
00163 }

void osg::WindowBase::setResizePending ( const bool & value ) [inline, inherited]

Definition at line 181 of file OSGWindowBase.inl.

References osg::WindowBase::_sfResizePending, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

Referenced by osg::Window::resize(), and osg::Window::resizeGL().

00182 {
00183     _sfResizePending.setValue(value);
00184 }

SFUInt32 * osg::WindowBase::getSFGlObjectEventCounter ( void ) [inline, protected, inherited]

Definition at line 103 of file OSGWindowBase.inl.

References osg::WindowBase::_sfGlObjectEventCounter.

00104 {
00105     return &_sfGlObjectEventCounter;
00106 }

MFUInt32 * osg::WindowBase::getMFGlObjectLastRefresh ( void ) [inline, protected, inherited]

Definition at line 110 of file OSGWindowBase.inl.

References osg::WindowBase::_mfGlObjectLastRefresh.

00111 {
00112     return &_mfGlObjectLastRefresh;
00113 }

MFUInt32 * osg::WindowBase::getMFGlObjectLastReinitialize ( void ) [inline, protected, inherited]

Definition at line 117 of file OSGWindowBase.inl.

References osg::WindowBase::_mfGlObjectLastReinitialize.

00118 {
00119     return &_mfGlObjectLastReinitialize;
00120 }

UInt32 & osg::WindowBase::getGlObjectEventCounter ( void ) [inline, protected, inherited]

Definition at line 188 of file OSGWindowBase.inl.

References osg::WindowBase::_sfGlObjectEventCounter, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

Referenced by osg::Window::validateGLObject().

00189 {
00190     return _sfGlObjectEventCounter.getValue();
00191 }

const UInt32 & osg::WindowBase::getGlObjectEventCounter ( void ) const [inline, protected, inherited]

Definition at line 195 of file OSGWindowBase.inl.

References osg::WindowBase::_sfGlObjectEventCounter, and osg::SField< FieldTypeT, fieldNameSpace >::getValue().

00196 {
00197     return _sfGlObjectEventCounter.getValue();
00198 }

UInt32 & osg::WindowBase::getGlObjectLastRefresh ( UInt32 index ) [inline, protected, inherited]

Definition at line 231 of file OSGWindowBase.inl.

References osg::WindowBase::_mfGlObjectLastRefresh.

00232 {
00233     return _mfGlObjectLastRefresh[index];
00234 }

MFUInt32 & osg::WindowBase::getGlObjectLastRefresh ( void ) [inline, protected, inherited]

Definition at line 238 of file OSGWindowBase.inl.

References osg::WindowBase::_mfGlObjectLastRefresh.

00239 {
00240     return _mfGlObjectLastRefresh;
00241 }

const MFUInt32 & osg::WindowBase::getGlObjectLastRefresh ( void ) const [inline, protected, inherited]

Definition at line 245 of file OSGWindowBase.inl.

References osg::WindowBase::_mfGlObjectLastRefresh.

00246 {
00247     return _mfGlObjectLastRefresh;
00248 }

UInt32 & osg::WindowBase::getGlObjectLastReinitialize ( UInt32 index ) [inline, protected, inherited]

Definition at line 252 of file OSGWindowBase.inl.

References osg::WindowBase::_mfGlObjectLastReinitialize.

00253 {
00254     return _mfGlObjectLastReinitialize[index];
00255 }

MFUInt32 & osg::WindowBase::getGlObjectLastReinitialize ( void ) [inline, protected, inherited]

Definition at line 259 of file OSGWindowBase.inl.

References osg::WindowBase::_mfGlObjectLastReinitialize.

Referenced by osg::Window::frameExit(), and osg::Window::onDestroy().

00260 {
00261     return _mfGlObjectLastReinitialize;
00262 }

const MFUInt32 & osg::WindowBase::getGlObjectLastReinitialize ( void ) const [inline, protected, inherited]

Definition at line 266 of file OSGWindowBase.inl.

References osg::WindowBase::_mfGlObjectLastReinitialize.

00267 {
00268     return _mfGlObjectLastReinitialize;
00269 }

void osg::WindowBase::setGlObjectEventCounter ( const UInt32 & value ) [inline, protected, inherited]

Definition at line 202 of file OSGWindowBase.inl.

References osg::WindowBase::_sfGlObjectEventCounter, and osg::SField< FieldTypeT, fieldNameSpace >::setValue().

00203 {
00204     _sfGlObjectEventCounter.setValue(value);
00205 }

void AttachmentContainer::addAttachment	(	const AttachmentPtr &	fieldContainerP,
		UInt16	binding = `0`
	)			`[inherited]`

Definition at line 84 of file OSGAttachmentContainer.cpp.

References osg::addRefCP(), osg::beginEditCP(), osg::endEditCP(), osg::NullFC, and osg::subRefCP().

Referenced by osg::AttachmentContainer::AttachmentContainer(), osg::Node::onCreate(), and osg::Image::setAttachmentField().

00086 {
00087     UInt32 key;
00088 
00089     if(fieldContainerP == NullFC)
00090         return;
00091 
00092     key = (UInt32 (fieldContainerP->getGroupId()) << 16) | binding;
00093 
00094     addRefCP(fieldContainerP);
00095 
00096     beginEditCP(fieldContainerP, Attachment::ParentsFieldMask);
00097     {
00098         fieldContainerP->addParent(getPtr());
00099     }
00100     endEditCP  (fieldContainerP, Attachment::ParentsFieldMask);
00101 
00102     AttachmentMap::iterator fcI = _attachmentMap.getValue().find(key);
00103 
00104     if(fcI != _attachmentMap.getValue().end())
00105     {
00106         beginEditCP((*fcI).second, Attachment::ParentsFieldMask);
00107         {
00108             (*fcI).second->subParent(getPtr());
00109         }
00110         endEditCP  ((*fcI).second, Attachment::ParentsFieldMask);
00111 
00112         subRefCP((*fcI).second);
00113 
00114         (*fcI).second = fieldContainerP;
00115     }
00116     else
00117     {
00118         _attachmentMap.getValue()[key] = fieldContainerP;
00119     }
00120 }

void AttachmentContainer::subAttachment	(	const AttachmentPtr &	fieldContainerP,
		UInt16	binding = `0`
	)			`[inherited]`

Definition at line 122 of file OSGAttachmentContainer.cpp.

References osg::AttachmentContainer::_attachmentMap, osg::beginEditCP(), osg::endEditCP(), osg::AttachmentContainer::getPtr(), osg::SField< FieldTypeT, fieldNameSpace >::getValue(), osg::NullFC, osg::Attachment::ParentsFieldMask, and osg::subRefCP().

00124 {
00125     UInt32 key;
00126 
00127     AttachmentMap::iterator fcI;
00128 
00129     if(fieldContainerP == NullFC)
00130         return;
00131 
00132     key = (UInt32(fieldContainerP->getGroupId()) << 16) | binding;
00133 
00134     fcI = _attachmentMap.getValue().find(key);
00135 
00136     if(fcI != _attachmentMap.getValue().end())
00137     {
00138         beginEditCP(fieldContainerP, Attachment::ParentsFieldMask);
00139         {
00140             (*fcI).second->subParent(getPtr());
00141         }
00142         endEditCP  (fieldContainerP, Attachment::ParentsFieldMask);
00143 
00144         subRefCP((*fcI).second);
00145 
00146         _attachmentMap.getValue().erase(fcI);
00147     }
00148 }

AttachmentPtr AttachmentContainer::findAttachment	(	UInt32	groupId,
		UInt16	binding = `0`
	)			`[inherited]`

Definition at line 150 of file OSGAttachmentContainer.cpp.

References osg::AttachmentContainer::_attachmentMap, osg::SField< FieldTypeT, fieldNameSpace >::getValue(), and osg::NullFC.

Referenced by osg::Image::findAttachmentField(), and osg::Image::setAttachmentField().

00152 {
00153     UInt32 key = (UInt32(groupId) << 16) | binding;
00154 
00155     AttachmentMap::iterator fcI = _attachmentMap.getValue().find(key);
00156 
00157     if(fcI == _attachmentMap.getValue().end())
00158     {
00159         return NullFC;
00160     }
00161     else
00162     {
00163         return (*fcI).second;
00164     }
00165 }

AttachmentPtr osg::AttachmentContainer::findAttachment	(	const FieldContainerType &	type,
		UInt16	binding = `0`
	)			`[inline, inherited]`

Definition at line 57 of file OSGAttachmentContainerImpl.inl.

00060 {
00061     return findAttachment(type.getGroupId(), binding);
00062 }

SFAttachmentMap * AttachmentContainer::getSFAttachments ( void ) [inherited]

Field Access

Definition at line 170 of file OSGAttachmentContainer.cpp.

References osg::AttachmentContainer::_attachmentMap.

00171 {
00172     return &_attachmentMap;
00173 }

AttachmentContainerPtr AttachmentContainer::getPtr ( void ) [protected, inherited]

Definition at line 352 of file OSGAttachmentContainer.cpp.

Referenced by osg::FileGrabForeground::draw(), osg::FBOViewport::render(), osg::AttachmentContainer::subAttachment(), and osg::AttachmentContainer::~AttachmentContainer().

00353 {
00354     return AttachmentContainerPtr(*this);
00355 }

UInt16 osg::FieldContainer::getClassGroupId ( void ) [inline, static, inherited]

Definition at line 71 of file OSGFieldContainerImpl.inl.

References osg::FieldContainer::_type, and osg::FieldContainerType::getGroupId().

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

UInt32 osg::FieldContainer::getTypeId ( void ) const [inline, inherited]

Definition at line 77 of file OSGFieldContainerImpl.inl.

References osg::TypeBase::getId(), and osg::FieldContainer::getType().

Referenced by osg::TextureChunk::changeFrom(), and osg::CubeTextureChunk::changeFrom().

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

UInt16 osg::FieldContainer::getGroupId ( void ) const [inline, inherited]

Definition at line 83 of file OSGFieldContainerImpl.inl.

References osg::FieldContainerType::getGroupId(), and osg::FieldContainer::getType().

Referenced by osg::fcptrAttributeMap(), osg::Image::setAttachmentField(), and osg::stringAttributeMap().

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

const Char8 * osg::FieldContainer::getTypeName ( void ) const [inline, inherited]

Definition at line 89 of file OSGFieldContainerImpl.inl.

References osg::TypeBase::getCName(), and osg::FieldContainer::getType().

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

Field * osg::FieldContainer::getField ( UInt32 fieldId ) [inline, inherited]

Generic Field Access

Definition at line 95 of file OSGFieldContainerImpl.inl.

References osg::FieldDescription::getField(), osg::FieldContainerType::getFieldDescription(), and osg::FieldContainer::getType().

Referenced by osg::QFCItem::expand(), osg::VRMLShapeDesc::getFieldAndDesc(), osg::QFieldViewBase::getFieldPtr(), osg::QFieldEditorBase::getFieldPtr(), osg::getParentsField(), and osg::QFCItem::setup().

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

Field * osg::FieldContainer::getField ( const Char8 * fieldName ) [inline, inherited]

Generic Field Access

Definition at line 103 of file OSGFieldContainerImpl.inl.

References osg::FieldContainerType::findFieldDescription(), osg::FieldDescription::getField(), and osg::FieldContainer::getType().

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

template<class ObjectPtrT>

void osg::FieldContainer::newPtr	(	ObjectPtrT &	result,
		const typename ObjectPtrT::StoredObjectType *	prototypeP
	)			`[inline, static, protected, inherited]`

Definition at line 138 of file OSGFieldContainerImpl.inl.

References osg::ChangeList::addCreated(), osg::PThreadBase::getAspect(), osg::PThreadBase::getCurrentChangeList(), osg::ThreadManager::getNumAspects(), osg::FieldContainerFactory::registerFieldContainer(), and osg::FieldContainerFactory::the().

00141 {
00142     typedef typename ObjectPtrT::StoredObjectType ObjectType;
00143     
00144     UInt8 *pTmp;
00145     
00146     result._containerSize = sizeof(ObjectType);
00147     
00148     pTmp        = 
00149         static_cast<UInt8 *>(operator new(
00150             sizeof(Int32)      + // ReferenceCount
00151             sizeof(UInt32)     + // ContainerId
00152             sizeof(ObjectType) * ThreadManager::getNumAspects()));
00153     
00154     *(reinterpret_cast<Int32 *>(pTmp)) = 0;
00155     
00156     pTmp += sizeof(Int32);
00157     
00158     result._storeP = (pTmp + sizeof(UInt32));
00159 
00160 #ifdef OSG_DEBUG_FCPTR
00161     result._typedStoreP = reinterpret_cast<FieldContainer *>(result._storeP);
00162 #endif
00163 
00164     *(reinterpret_cast<UInt32 *>(pTmp)) = 
00165         FieldContainerFactory::the()->registerFieldContainer(result);
00166     
00167     Thread::getCurrentChangeList()->addCreated(
00168         *(reinterpret_cast<UInt32 *>(pTmp)));
00169     
00170     pTmp += sizeof(UInt32);
00171     
00172     ObjectType *aObject = reinterpret_cast<ObjectType *>(pTmp);
00173 
00174     for(UInt32 i = 0; i < ThreadManager::getNumAspects(); i++)
00175     {
00176         pTmp = 
00177             reinterpret_cast<UInt8 *>(new (pTmp) ObjectType(*prototypeP));
00178         
00179         pTmp += sizeof(ObjectType);
00180     }
00181     
00182     result->onCreate(prototypeP);
00183 
00184     for(UInt32 i = 0; i < ThreadManager::getNumAspects(); i++)
00185     {
00186         aObject[i].onCreateAspect(aObject, prototypeP);
00187     }
00188 
00189 #if defined(OSG_GV_BETA) && defined(OSG_DBG_MEM)
00190 
00191     fprintf(stderr, "GV_MEM_FC_DBG : (%u) cc (%p|%u)\n", 
00192             Thread::getAspect(),
00193             result._storeP,
00194 //            ObjectType::getClassType().getCName(),
00195             ObjectType::getClassType().getId());
00196 #endif
00197 
00198 #ifdef OSG_DEBUG_TYPED_FCPTR
00199     result.updateTypedStore();
00200 #endif
00201 }

template<class ObjectPtrT>

void osg::FieldContainer::newPtr ( ObjectPtrT & result ) [inline, static, protected, inherited]

Definition at line 204 of file OSGFieldContainerImpl.inl.

References osg::ChangeList::addCreated(), osg::PThreadBase::getAspect(), osg::PThreadBase::getCurrentChangeList(), osg::ThreadManager::getNumAspects(), osg::FieldContainerFactory::registerFieldContainer(), and osg::FieldContainerFactory::the().

00205 {
00206     typedef typename ObjectPtrT::StoredObjectType ObjectType;
00207     
00208     UInt8 *pTmp;
00209     
00210     result._containerSize = sizeof(ObjectType);
00211     
00212     pTmp        =             
00213         static_cast<UInt8 *>(operator new(
00214             sizeof(Int32)      + // ReferenceCount
00215             sizeof(UInt32)     + // ContainerId
00216             sizeof(ObjectType) * ThreadManager::getNumAspects()));
00217     
00218     *(reinterpret_cast<Int32 *>(pTmp)) = 0;
00219     
00220     pTmp  += sizeof(Int32);
00221     
00222     result._storeP = (pTmp + sizeof(UInt32));
00223     
00224 #ifdef OSG_DEBUG_FCPTR
00225     result._typedStoreP = reinterpret_cast<FieldContainer *>(result._storeP);
00226 #endif
00227 
00228     *(reinterpret_cast<UInt32 *>(pTmp)) = 
00229         FieldContainerFactory::the()->registerFieldContainer(result);
00230     
00231     Thread::getCurrentChangeList()->addCreated(
00232         *(reinterpret_cast<UInt32 *>(pTmp)));
00233     
00234     pTmp += sizeof(UInt32);
00235     
00236     ObjectType *aObject = reinterpret_cast<ObjectType *>(pTmp);
00237 
00238     for(UInt32 i = 0; i < ThreadManager::getNumAspects(); i++)
00239     {
00240         pTmp = reinterpret_cast<UInt8 *>(new (pTmp) ObjectType());
00241         
00242         pTmp += sizeof(ObjectType);
00243     }
00244     
00245     result->onCreate();
00246     
00247     for(UInt32 i = 0; i < ThreadManager::getNumAspects(); i++)
00248     {
00249         aObject[i].onCreateAspect(aObject);
00250     }
00251 
00252 #if defined(OSG_GV_BETA) && defined(OSG_DBG_MEM)
00253     fprintf(stderr, "GV_MEM_FC_DBG : (%u) c (%p|%u)\n", 
00254             Thread::getAspect(),
00255             result._storeP,
00256 //            ObjectType::getClassType().getCName(),
00257             ObjectType::getClassType().getId());
00258 #endif
00259     
00260 #ifdef OSG_DEBUG_TYPED_FCPTR
00261     result.updateTypedStore();
00262 #endif
00263 }

template<class FieldTypeT>

void osg::FieldContainer::beginEditX	(	const BitVector &	whichField,
		FieldTypeT &	field
	)			`[inline, protected, inherited]`

Definition at line 285 of file OSGFieldContainerImpl.inl.

00286 {
00287 //    fieldR.beginEdit();
00288 }

template<class FieldTypeT>

void osg::FieldContainer::endEditX	(	const BitVector &	whichField,
		FieldTypeT &	field
	)			`[inline, protected, inherited]`

Definition at line 291 of file OSGFieldContainerImpl.inl.

References osg::endEditCP().

00292 {
00293     FieldContainerPtr tmpPtr(this);
00294     endEditCP(tmpPtr, whichField);
00295 }

Friends And Related Function Documentation

friend class FieldContainer [friend]

Reimplemented from osg::PassiveWindowBase.

Definition at line 117 of file OSGPassiveWindow.h.

friend class PassiveWindowBase [friend]

Definition at line 118 of file OSGPassiveWindow.h.

friend class GLObject [friend, inherited]

Definition at line 294 of file OSGWindow.h.

Referenced by osg::Window::registerGLObject().

Member Data Documentation

const osg::BitVector PassiveWindowBase::MTInfluenceMask [static, inherited]

Initial value:

 
    (Inherited::MTInfluenceMask) | 
    (static_cast<BitVector>(0x0) << Inherited::NextFieldId)

Reimplemented from osg::WindowBase.

Definition at line 92 of file OSGPassiveWindowBase.h.

const Real32 osg::Window::unknownConstant = -1e100 [static, inherited]

Definition at line 94 of file OSGWindow.h.

Referenced by osg::TextureTransformChunk::activate(), osg::TextureChunk::activate(), osg::TexGenChunk::activate(), osg::CubeTextureChunk::activate(), osg::TextureTransformChunk::changeFrom(), osg::TextureChunk::changeFrom(), osg::TexGenChunk::changeFrom(), osg::CubeTextureChunk::changeFrom(), osg::TextureTransformChunk::deactivate(), osg::TextureChunk::deactivate(), osg::TexGenChunk::deactivate(), osg::CubeTextureChunk::deactivate(), and osg::Window::frameInit().

const osg::BitVector WindowBase::WidthFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << WindowBase::WidthFieldId)

Definition at line 110 of file OSGWindowBase.h.

Referenced by osg::SortFirstWindow::clientPreSync(), osg::WindowBase::copyFromBin(), osg::WindowBase::copyToBin(), osg::WindowBase::executeSyncImpl(), osg::WindowBase::getBinSize(), and osg::Window::resize().

const osg::BitVector WindowBase::HeightFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << WindowBase::HeightFieldId)

Definition at line 111 of file OSGWindowBase.h.

Referenced by osg::SortFirstWindow::clientPreSync(), osg::WindowBase::copyFromBin(), osg::WindowBase::copyToBin(), osg::WindowBase::executeSyncImpl(), osg::WindowBase::getBinSize(), and osg::Window::resize().

const osg::BitVector WindowBase::PortFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << WindowBase::PortFieldId)

Definition at line 112 of file OSGWindowBase.h.

Referenced by osg::WindowBase::copyFromBin(), osg::WindowBase::copyToBin(), osg::WindowBase::executeSyncImpl(), and osg::WindowBase::getBinSize().

const osg::BitVector WindowBase::ResizePendingFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << WindowBase::ResizePendingFieldId)

Definition at line 113 of file OSGWindowBase.h.

Referenced by osg::WindowBase::copyFromBin(), osg::WindowBase::copyToBin(), osg::WindowBase::executeSyncImpl(), osg::WindowBase::getBinSize(), osg::Window::resize(), and osg::Window::resizeGL().

const osg::BitVector WindowBase::GlObjectEventCounterFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << WindowBase::GlObjectEventCounterFieldId)

Definition at line 114 of file OSGWindowBase.h.

Referenced by osg::WindowBase::copyFromBin(), osg::WindowBase::copyToBin(), osg::WindowBase::executeSyncImpl(), osg::WindowBase::getBinSize(), osg::Window::refreshGLObject(), osg::Window::reinitializeGLObject(), and osg::RemoteAspect::RemoteAspect().

const osg::BitVector WindowBase::GlObjectLastRefreshFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << WindowBase::GlObjectLastRefreshFieldId)

Definition at line 115 of file OSGWindowBase.h.

Referenced by osg::WindowBase::copyFromBin(), osg::WindowBase::copyToBin(), osg::Window::doInitRegisterGLObject(), osg::WindowBase::executeSyncImpl(), osg::WindowBase::getBinSize(), osg::Window::refreshGLObject(), and osg::RemoteAspect::RemoteAspect().

const osg::BitVector WindowBase::GlObjectLastReinitializeFieldMask [static, inherited]

Initial value:

 
    (TypeTraits<BitVector>::One << WindowBase::GlObjectLastReinitializeFieldId)

Definition at line 116 of file OSGWindowBase.h.

Referenced by osg::WindowBase::copyFromBin(), osg::WindowBase::copyToBin(), osg::Window::doInitRegisterGLObject(), osg::WindowBase::executeSyncImpl(), osg::WindowBase::getBinSize(), osg::Window::reinitializeGLObject(), and osg::RemoteAspect::RemoteAspect().

UInt16 WindowBase::_sfWidth [protected, inherited]

Definition at line 192 of file OSGWindowBase.h.

Referenced by osg::WindowBase::copyFromBin(), osg::WindowBase::copyToBin(), osg::WindowBase::executeSyncImpl(), osg::WindowBase::getBinSize(), osg::WindowBase::getSFWidth(), osg::WindowBase::getWidth(), and osg::WindowBase::setWidth().

UInt16 WindowBase::_sfHeight [protected, inherited]

Definition at line 193 of file OSGWindowBase.h.

Referenced by osg::WindowBase::copyFromBin(), osg::WindowBase::copyToBin(), osg::WindowBase::executeSyncImpl(), osg::WindowBase::getBinSize(), osg::WindowBase::getHeight(), osg::WindowBase::getSFHeight(), and osg::WindowBase::setHeight().

ViewportPtr WindowBase::_mfPort [protected, inherited]

Definition at line 194 of file OSGWindowBase.h.

Referenced by osg::Window::addPort(), osg::Window::clearPorts(), osg::WindowBase::copyFromBin(), osg::WindowBase::copyToBin(), osg::Window::drawAllViewports(), osg::WindowBase::executeSyncImpl(), osg::WindowBase::getBinSize(), osg::WindowBase::getMFPort(), osg::WindowBase::getPort(), osg::Window::insertPort(), osg::Window::operator=(), osg::Window::renderAllViewports(), osg::Window::replacePort(), osg::Window::replacePortBy(), and osg::Window::subPort().

bool WindowBase::_sfResizePending [protected, inherited]

Definition at line 195 of file OSGWindowBase.h.

Referenced by osg::WindowBase::copyFromBin(), osg::WindowBase::copyToBin(), osg::WindowBase::executeSyncImpl(), osg::WindowBase::getBinSize(), osg::WindowBase::getResizePending(), osg::WindowBase::getSFResizePending(), osg::Window::isResizePending(), and osg::WindowBase::setResizePending().

UInt32 WindowBase::_sfGlObjectEventCounter [protected, inherited]

Counter for GL object events. Needed for multi-aspect updates. Is used in glObjectLastRefresh and glObjectLastReinitialize.

Definition at line 196 of file OSGWindowBase.h.

Referenced by osg::WindowBase::copyFromBin(), osg::WindowBase::copyToBin(), osg::WindowBase::executeSyncImpl(), osg::WindowBase::getBinSize(), osg::WindowBase::getGlObjectEventCounter(), osg::WindowBase::getSFGlObjectEventCounter(), and osg::WindowBase::setGlObjectEventCounter().

UInt32 WindowBase::_mfGlObjectLastRefresh [protected, inherited]

indicates the last refresh for the GL object

Definition at line 197 of file OSGWindowBase.h.

Referenced by osg::WindowBase::copyFromBin(), osg::WindowBase::copyToBin(), osg::Window::doInitRegisterGLObject(), osg::WindowBase::executeSyncImpl(), osg::WindowBase::getBinSize(), osg::WindowBase::getGlObjectLastRefresh(), osg::WindowBase::getMFGlObjectLastRefresh(), and osg::Window::validateGLObject().

UInt32 WindowBase::_mfGlObjectLastReinitialize [protected, inherited]

indicates the last reinit for the GL object

Definition at line 198 of file OSGWindowBase.h.

Referenced by osg::WindowBase::copyFromBin(), osg::WindowBase::copyToBin(), osg::Window::doInitRegisterGLObject(), osg::WindowBase::executeSyncImpl(), osg::WindowBase::getBinSize(), osg::WindowBase::getGlObjectLastReinitialize(), osg::WindowBase::getMFGlObjectLastReinitialize(), and osg::Window::validateGLObject().

const BitVector AttachmentContainer::AttachmentsFieldMask [static, inherited]

Initial value:

    (TypeTraits<BitVector>::One << 
        AttachmentContainer::AttachmentsFieldId)

Definition at line 84 of file OSGAttachmentContainerImpl.h.

Referenced by osg::VRMLFile::beginNode(), osg::AttachmentContainer::changed(), osg::AttachmentContainer::copyFromBin(), osg::AttachmentContainer::copyToBin(), osg::deepCloneAttachments(), osg::AttachmentContainer::executeSyncImpl(), osg::fcptrAttributeMap(), osg::AttachmentContainer::getBinSize(), and osg::stringAttributeMap().

SFAttachmentMap osg::AttachmentContainer::_attachmentMap [protected, inherited]

Definition at line 161 of file OSGAttachmentContainerImpl.h.

const BitVector osg::FieldContainer::NextFieldMask [static, inherited]

Initial value:

 
                    (TypeTraits<BitVector>::One << NextFieldId)

Definition at line 75 of file OSGFieldContainerImpl.h.

const bool osg::FieldContainer::isNodeCore = false [static, inherited]

Reimplemented in osg::NodeCore.

Definition at line 181 of file OSGFieldContainerImpl.h.

UInt32 osg::FieldContainer::_shares [protected, inherited]

Definition at line 199 of file OSGFieldContainerImpl.h.

The documentation for this class was generated from the following files:


Extension handling

UInt32	getGLVersion (void)
bool	hasExtension (UInt32 id)
bool	hasExtension (const Char8 *s)
void *	getFunction (UInt32 id)
void *	getFunctionNoCheck (UInt32 id)
void	dumpExtensions (void)
GLExtensionFunction	getFunctionByName (const Char8 *s)
Real32	getConstantValue (GLenum val)
const Vec2f &	getConstantValuev (GLenum val)
const std::vector< std::string > &	getRegisteredFunctions (void)
const std::vector< std::string > &	getExtensions (void)
const std::vector< std::string > &	getIgnoredExtensions (void)
static void	setGLLibraryName (const Char8 *s)
static Int32	getExtensionId (const Char8 *s)
static bool	hasCommonExtension (UInt32 id)
static const std::vector < std::string > &	getRegisteredExtensions (void)
GL object handling

void	validateGLObject (UInt32 id)
void	validateAllGLObjects (void)
void	setGLObjectId (UInt32 id, UInt32 id2)
UInt32	getGLObjectId (UInt32 id)
static UInt32	getGLObjectsSize (void)
static void	refreshGLObject (UInt32 id)
static void	refreshAllGLObjects (void)
static void	reinitializeGLObject (UInt32 id)
static void	reinitializeAllGLObjects (void)
static void	destroyGLObject (UInt32 id, UInt32 num=1)
static void	unpackIdStatus (UInt32 idstatus, UInt32 &id, GLObjectStatusE &status)
GL object handling

void	doInitRegisterGLObject (UInt32 id, UInt32 num)
static void	initRegisterGLObject (UInt32 id, UInt32 num)
static UInt32	packIdStatus (UInt32 id, GLObjectStatusE status)
Public Types
typedef PassiveWindowPtr	Ptr
enum	GLObjectStatusE { notused = 1, initialize, reinitialize, initialized, needrefresh, destroy, finaldestroy }
enum	{ invalidExtensionID = 0x7fffffff, invalidFunctionID = 0x7fffffff }
enum	{ statusShift = 3, statusMask = 7 }
typedef ArgsCollector< UInt32 >	GLObjectFunctorArgs
typedef TypedVoidFunctor2Base < PtrCallArg< Window > , GLObjectFunctorArgs >	GLObjectFunctor
typedef void(*	GLExtensionFunction )(void)
enum	{ WidthFieldId = Inherited::NextFieldId, HeightFieldId = WidthFieldId + 1, PortFieldId = HeightFieldId + 1, ResizePendingFieldId = PortFieldId + 1, GlObjectEventCounterFieldId = ResizePendingFieldId + 1, GlObjectLastRefreshFieldId = GlObjectEventCounterFieldId + 1, GlObjectLastReinitializeFieldId = GlObjectLastRefreshFieldId + 1, NextFieldId = GlObjectLastReinitializeFieldId + 1 }
enum	{ AttachmentsFieldId = Inherited::NextFieldId, NextFieldId = AttachmentsFieldId + 1 }
enum	{ NextFieldId = 1 }
Public Member Functions
Sync

virtual void	changed (BitVector whichField, UInt32 origin)
Output

virtual void	dump (UInt32 uiIndent=0, const BitVector bvFlags=0) const
Redefined

virtual void	init (void)
virtual void	activate (void)
virtual void	deactivate (void)
virtual void	swap (void)
FieldContainer Get

virtual FieldContainerType &	getType (void)
virtual const FieldContainerType &	getType (void) const
virtual UInt32	getContainerSize (void) const
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
Viewport handling

void	addPort (const ViewportPtr &portP)
void	insertPort (UInt32 portIndex, const ViewportPtr &portP)
void	replacePort (UInt32 portIndex, const ViewportPtr &portP)
void	replacePortBy (const ViewportPtr &portP, const ViewportPtr &newPortP)
void	subPort (const ViewportPtr &portP)
void	subPort (UInt32 portIndex)
void	clearPorts (void)
Size handling

bool	isResizePending (void)
virtual void	resize (int width, int height)
virtual void	resizeGL (void)
void	setSize (UInt16 width, UInt16 height)
Drawing

virtual void	frameInit (void)
virtual void	frameExit (void)
virtual void	draw (DrawAction *action=NULL)
virtual void	drawAllViewports (DrawAction *action=NULL)
virtual void	render (RenderActionBase *action=NULL)
virtual void	renderAllViewports (RenderActionBase *action=NULL)
Field Get

SFUInt16 *	getSFWidth (void)
	Get the Window::_sfWidth field.
SFUInt16 *	getSFHeight (void)
	Get the Window::_sfHeight field.
MFViewportPtr *	getMFPort (void)
	Get the Window::_mfPort field.
SFBool *	getSFResizePending (void)
	Get the Window::_sfResizePending field.
UInt16 &	getWidth (void)
	Get the value of the Window::_sfWidth field.
const UInt16 &	getWidth (void) const
	Get the value of the Window::_sfWidth field.
UInt16 &	getHeight (void)
	Get the value of the Window::_sfHeight field.
const UInt16 &	getHeight (void) const
	Get the value of the Window::_sfHeight field.
bool &	getResizePending (void)
	Get the value of the Window::_sfResizePending field.
const bool &	getResizePending (void) const
	Get the value of the Window::_sfResizePending field.
ViewportPtr &	getPort (const UInt32 index)
	Get the value of the index element the Window::_mfPort field.
MFViewportPtr &	getPort (void)
	Get the Window::_mfPort field.
const MFViewportPtr &	getPort (void) const
	Get the Window::_mfPort field.
Field Set

void	setWidth (const UInt16 &value)
	Set the value of the Window::_sfWidth field.
void	setHeight (const UInt16 &value)
	Set the value of the Window::_sfHeight field.
void	setResizePending (const bool &value)
	Set the value of the Window::_sfResizePending field.
Handle Attachments

void	addAttachment (const AttachmentPtr &fieldContainerP, UInt16 binding=0)
void	subAttachment (const AttachmentPtr &fieldContainerP, UInt16 binding=0)
AttachmentPtr	findAttachment (UInt32 groupId, UInt16 binding=0)
AttachmentPtr	findAttachment (const FieldContainerType &type, UInt16 binding=0)


SFAttachmentMap *	getSFAttachments (void)
Get Instance Type Information

UInt32	getTypeId (void) const
UInt16	getGroupId (void) const
const Char8 *	getTypeName (void) const


Field *	getField (UInt32 fieldId)
Field *	getField (const Char8 *fieldName)
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 PassiveWindowPtr	create (void)
	create a new instance of the class
static PassiveWindowPtr	createEmpty (void)
	create an empty new instance of the class, do not copy the prototype
Class Get

static const char *	getClassname (void)
Extension registration

static UInt32	registerExtension (const Char8 *s)
static void	ignoreExtensions (const Char8 *s)
static UInt32	registerFunction (const Char8 *s, Int32 ext=-1, UInt32 version=0xffff)
static void	registerConstant (GLenum val)
GL object registration

static UInt32	registerGLObject (GLObjectFunctor functor, UInt32 num=1)
Get Class Type Information

static UInt16	getClassGroupId (void)
Static Public Attributes
static const osg::BitVector	MTInfluenceMask
static const Real32	unknownConstant = -1e100
static const osg::BitVector	WidthFieldMask
static const osg::BitVector	HeightFieldMask
static const osg::BitVector	PortFieldMask
static const osg::BitVector	ResizePendingFieldMask
static const osg::BitVector	GlObjectEventCounterFieldMask
static const osg::BitVector	GlObjectLastRefreshFieldMask
static const osg::BitVector	GlObjectLastReinitializeFieldMask
static const BitVector	AttachmentsFieldMask
static const BitVector	NextFieldMask
CoredNodePtr helper

static const bool	isNodeCore = false
Protected Types
Map for GL cvonstant handling

typedef std::map< GLenum, Vec2f >	ConstHash
Protected Member Functions
Constructors

	PassiveWindow (void)
	PassiveWindow (const PassiveWindow &source)
Destructors

virtual	~PassiveWindow (void)
Sync

void	executeSyncImpl (PassiveWindowBase *pOther, const BitVector &whichField)
virtual void	executeSync (FieldContainer &other, const BitVector &whichField)
Sync

void	executeSyncImpl (WindowBase *pOther, const BitVector &whichField)
Sync

void	executeSyncImpl (AttachmentContainer *pOther, const BitVector &whichField)
Sync

void	executeSyncImpl (FieldContainer *pOther, const BitVector &whichField)
GL setup handling

virtual void	setupGL (void)
MT Construction

void	onCreate (const FieldContainer *source=NULL)
void	onCreateAspect (const FieldContainer aspect0, const FieldContainer source=NULL)
Field Get

SFUInt32 *	getSFGlObjectEventCounter (void)
	Get the Window::_sfGlObjectEventCounter field.
MFUInt32 *	getMFGlObjectLastRefresh (void)
	Get the Window::_mfGlObjectLastRefresh field.
MFUInt32 *	getMFGlObjectLastReinitialize (void)
	Get the Window::_mfGlObjectLastReinitialize field.
UInt32 &	getGlObjectEventCounter (void)
	Get the value of the Window::_sfGlObjectEventCounter field.
const UInt32 &	getGlObjectEventCounter (void) const
	Get the value of the Window::_sfGlObjectEventCounter field.
UInt32 &	getGlObjectLastRefresh (UInt32 index)
	Get the value of the index element the Window::_mfGlObjectLastRefresh field.
MFUInt32 &	getGlObjectLastRefresh (void)
	Get the Window::_mfGlObjectLastRefresh field.
const MFUInt32 &	getGlObjectLastRefresh (void) const
	Get the Window::_mfGlObjectLastRefresh field.
UInt32 &	getGlObjectLastReinitialize (UInt32 index)
	Get the value of the index element the Window::_mfGlObjectLastReinitialize field.
MFUInt32 &	getGlObjectLastReinitialize (void)
	Get the Window::_mfGlObjectLastReinitialize field.
const MFUInt32 &	getGlObjectLastReinitialize (void) const
	Get the Window::_mfGlObjectLastReinitialize field.
Field Set

void	setGlObjectEventCounter (const UInt32 &value)
	Set the value of the Window::_sfGlObjectEventCounter field.
Pointer

AttachmentContainerPtr	getPtr (void)
MT Edit

template<class FieldTypeT>
void	beginEditX (const BitVector &whichField, FieldTypeT &field)
template<class FieldTypeT>
void	endEditX (const BitVector &whichField, FieldTypeT &field)
Static Protected Member Functions
Create Fieldcontainer

template<class ObjectPtrT>
static void	newPtr (ObjectPtrT &result, const typename ObjectPtrT::StoredObjectType *prototypeP)
template<class ObjectPtrT>
static void	newPtr (ObjectPtrT &result)
Protected Attributes
Fields

SFUInt16	_sfWidth
SFUInt16	_sfHeight
MFViewportPtr	_mfPort
SFBool	_sfResizePending
SFUInt32	_sfGlObjectEventCounter
MFUInt32	_mfGlObjectLastRefresh
MFUInt32	_mfGlObjectLastReinitialize
Fields

SFAttachmentMap	_attachmentMap
Member

UInt32	_shares
Private Types
typedef PassiveWindowBase	Inherited
Private Member Functions
void	operator= (const PassiveWindow &source)
Static Private Member Functions
static void	initMethod (void)
Friends
class	FieldContainer
class	PassiveWindowBase
GL object handling helper class

class	GLObject