00001 #include "Profiler.h"
00002 #include "Rendergroup.h"
00003 #include "Renderpass.h"
00004 #include "Error.h"
00005 #include "StopWatch.h"
00006 #include "StateSet.h"
00007 #include "Program.h"
00008 #include "Factory.h"
00009 #include "Camera.h"
00010 #include "Framebuffer.h"
00011 #include "Renderbuffer.h"
00012 #include "Vertexbuffer.h"
00013 #include "Rendernode.h"
00014 #include "Sampler.h"
00015 #include "Property.h"
00016
00017 namespace RenderTools{
00018
00019 RendergroupWeakList Rendergroup::s_groups;
00020 int Rendergroup::s_activeGroup = 0;
00021 int Rendergroup::s_activePass = 0;
00022 bool Rendergroup::s_doExperiment = false;
00023
00024 Rendergroup::Rendergroup( void ):
00025 AbstractPropertyContainer(){
00026
00027 }
00028
00029 PropertyPtr Rendergroup::create( const XMLNodePtr & xml ){
00030 RendergroupPtr p( new Rendergroup() );
00031
00032 s_groups.push_back( p );
00033 s_activeGroup = s_groups.size() - 1;
00034
00035 p->setName( xml );
00036 p->createProperties();
00037 p->setProperties( xml, false );
00038
00039 return( dynamic_pointer_cast< AbstractProperty, Rendergroup >( p ) );
00040 }
00041
00042 void Rendergroup::createProperties( void ){
00043 createProperty( this, "cameras", & m_cameras );
00044 createProperty( this, "statesets", & m_statesets );
00045 createProperty( this, "samplers", & m_samplers );
00046 createProperty( this, "framebuffers", & m_framebuffers );
00047 createProperty( this, "renderbuffers", & m_renderbuffers );
00048 createProperty( this, "vertexbuffers", & m_vertexbuffers );
00049 createProperty( this, "rendernodes", & m_rendernodes );
00050 createProperty( this, "renderpasses", & m_renderpasses );
00051 #ifndef RT_GLES1
00052 createProperty( this, "programs", & m_programs );
00053 #endif
00054 }
00055
00056 const string Rendergroup::getTypeName( bool ofComponent ) const {
00057 return( "Rendergroup" );
00058 }
00059
00060 Rendergroup::~Rendergroup( void ){
00061 RendergroupPtr thisPtr = getNullDeletingSharedPtr< Rendergroup >();
00062 removeRendergroup( thisPtr );
00063 }
00064
00065 void Rendergroup::onPropertyEvent( const PropertyEvent & e ){
00066
00067 }
00068
00069 void Rendergroup::onInitialize( void ){
00071 Rendergroup::setActiveRendergroup( getSharedPtr< Rendergroup >() );
00072
00073 for( unsigned int i = 0; i < m_cameras->size(); i++ ){
00074 m_cameras->getItem( i )->initialize();
00075 }
00076 for( unsigned int i = 0; i < m_statesets->size(); i++ ){
00077 m_statesets->getItem( i )->initialize();
00078 }
00079 for( unsigned int i = 0; i < m_samplers->size(); i++ ){
00080 m_samplers->getItem( i )->initialize();
00081 }
00082 for( unsigned int i = 0; i < m_renderbuffers->size(); i++ ){
00083 m_renderbuffers->getItem( i )->initialize();
00084 }
00085 for( unsigned int i = 0; i < m_framebuffers->size(); i++ ){
00086 m_framebuffers->getItem( i )->initialize();
00087 }
00088 for( unsigned int i = 0; i < m_vertexbuffers->size(); i++ ){
00089 m_vertexbuffers->getItem( i )->initialize();
00090 }
00091 for( unsigned int i = 0; i < m_rendernodes->size(); i++ ){
00092 m_rendernodes->getItem( i )->initialize();
00093 }
00094 for( unsigned int i = 0; i < m_renderpasses->size(); i++ ){
00095 m_renderpasses->getItem( i )->initialize();
00096 }
00097 #ifndef RT_GLES1
00098 for( unsigned int i = 0; i < m_programs->size(); i++ ){
00099 m_programs->getItem( i )->initialize();
00100 }
00101 #endif
00102 }
00103
00104 void Rendergroup::onUpdate( void ){
00105 for( unsigned int i = 0; i < m_rendernodes->size(); i++ ){
00106 m_rendernodes->getItem( i )->transform();
00107 }
00108 }
00109
00110 void Rendergroup::onRender( void ){
00111
00112 Error::assertNoErrors( __FILE__, __LINE__ );
00113 if( getActiveRendergroup() != getSharedPtr< Rendergroup >() ){
00114 setActiveRendergroup( getSharedPtr< Rendergroup >() );
00115 }
00117 StatesetPtr stateset = findStateset( "default" );
00118 if( stateset ){
00119 stateset->bind();
00120 }
00121 #ifndef RT_GLES1
00122 ProgramPtr program = findProgram( "default" );
00123 if( program ){
00124 Error::assertNoErrors( __FILE__, __LINE__ );
00125 program->bind();
00126 program->bind( "modelViewProjectionMatrix", toString( get( Matrix::PROJECTION ) * get( Matrix::MODELVIEW ) ) );
00127 if( stateset ){
00128 program->bind( "currentColor", toString( stateset->currentColor.xyz() ) );
00129 }
00130 }
00131 #endif
00132 CameraPtr camera = findCamera( "default" );
00133 if( camera ){
00134 camera->bind();
00135 }
00136 for( unsigned int i = 0; i < m_renderpasses->size(); i++ ){
00137 Error::assertNoErrors( __FILE__, __LINE__ );
00138
00139 setActiveRenderpass( m_renderpasses->getItem( i ) );
00140 RenderpassPtr pass = getActiveRenderpass();
00141 Error::assertNoErrors( __FILE__, __LINE__ );
00142 PROFILER_BEGIN_OBJECT()
00144 pass->bind();
00145 RendernodeProxyContainerPtr nodes = pass->getRendernodeProxies();
00146 for( unsigned int j = 0; j < nodes->size(); j++ ){
00147 RendernodeProxyPtr rendernode = nodes->getItem( j );
00148 if( rendernode->getPointer() ){
00149
00150 rendernode->getPointer()->render( );
00151 }
00152 }
00153 Error::assertNoErrors( __FILE__, __LINE__ );
00154 pass->unbind();
00155 PROFILER_END_OBJECT()
00156 Error::assertNoErrors( __FILE__, __LINE__ );
00157 }
00158
00160 s_doExperiment = false;
00161 Error::assertNoErrors( __FILE__, __LINE__ );
00162 }
00163
00164
00165 const RendergroupList Rendergroup::findRendergroups( const string name ){
00166 RendergroupList list;
00167 for( unsigned int i = 0; i < s_groups.size(); i++ ){
00168 if( s_groups[ i ].lock()->getName() == name ){
00169 list.push_back( shared_ptr< Rendergroup >( s_groups[ i ] ) );
00170 }
00171 }
00172 return( list );
00173 }
00174
00175 const RendergroupPtr Rendergroup::findRendergroup( const string name ){
00176 for( unsigned int i = 0; i < s_groups.size(); i++ ){
00177 if( s_groups[ i ].lock() ){
00178 if( s_groups[ i ].lock()->getName() == name ){
00179 return( shared_ptr< Rendergroup >( s_groups[ i ] ) );
00180 }
00181 }
00182 }
00183 return( RendergroupPtr() );
00184 }
00185
00186 const int Rendergroup::findRendergroupIndex( const string name ){
00187 for( unsigned int i = 0; i < s_groups.size(); i++ ){
00188 if( s_groups[ i ].lock() ){
00189 if( s_groups[ i ].lock()->getName() == name ){
00190 return( i );
00191 }
00192 }
00193 }
00194 return( -1 );
00195 }
00196
00197 const RendergroupPtr Rendergroup::getRendergroup( unsigned int index ){
00198 if( index >= s_groups.size() ){
00199 Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
00200 }
00201 return( s_groups[ index ].lock() );
00202 }
00203
00204 bool Rendergroup::isPointer( const CameraPtr & pointer ) const {
00205 return( m_cameras->isProperty( pointer ) );
00206 }
00207
00208 void Rendergroup::findPointer( const string name, CameraPtr & pointer ) const {
00209 pointer = dynamic_pointer_cast< Camera, AbstractProperty >( m_cameras->findProperty( name ) );
00210 }
00211
00212 const CameraList Rendergroup::findCameras( const string name ) const {
00213 CameraList list;
00214 m_cameras->findPointers( name, ( PropertyList & )list );
00215 return( list );
00216 }
00217
00218 const CameraPtr Rendergroup::findCamera( const string name ) const {
00219 return( dynamic_pointer_cast< Camera, AbstractProperty >( m_cameras->findProperty( name ) ) );
00220 }
00221
00222 const int Rendergroup::findCameraIndex( const string name ) const{
00223 return( m_cameras->findIndex( name ) );
00224 }
00225
00226 void Rendergroup::addPointer( const CameraPtr & p, bool send ){
00227 addCamera( p, send );
00228 }
00229
00230 void Rendergroup::addCamera( const CameraPtr & p, bool send ){
00231 if( isPointer( p ) ){
00232 Error::warning( Error::ITEM_ALREADY_EXISTS, __FILE__, __LINE__ );
00233 }
00234 m_cameras->addProperty( p, send );
00235 }
00236
00237 void Rendergroup::setCameras( const CameraContainerPtr & container, bool send ){
00238 m_cameras = container;
00239 }
00240
00241 const CameraPtr Rendergroup::getCamera( unsigned int index ) const {
00242 if( index >= m_cameras->size() ){
00243 Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
00244 }
00245 return( m_cameras->getItem( index ) );
00246 }
00247
00248 const CameraContainerPtr Rendergroup::getCameras( void ) const {
00249 return( m_cameras );
00250 }
00251
00252 void Rendergroup::removeCamera( const CameraPtr & pointer, bool send ){
00253 m_cameras->removeProperty( pointer, send );
00254 }
00255
00256 void Rendergroup::removeCameras( bool send ){
00257 m_cameras->removeProperties( send );
00258 }
00259
00260 bool Rendergroup::isPointer( const StatesetPtr & pointer ) const {
00261 return( m_statesets->isProperty( pointer ) );
00262 }
00263
00264 void Rendergroup::findPointer( const string name, StatesetPtr & pointer ) const {
00265 pointer = dynamic_pointer_cast< Stateset, AbstractProperty >( m_statesets->findProperty( name ) );
00266 }
00267
00268 const StatesetList Rendergroup::findStatesets( const string name ) const {
00269 StatesetList list;
00270 m_statesets->findPointers( name, ( PropertyList & )list );
00271 return( list );
00272 }
00273
00274 const StatesetPtr Rendergroup::findStateset( const string name ) const {
00275 return( dynamic_pointer_cast< Stateset, AbstractProperty >( m_statesets->findProperty( name ) ) );
00276 }
00277
00278 const int Rendergroup::findStatesetIndex( const string name ) const{
00279 return( m_statesets->findIndex( name ) );
00280 }
00281
00282 void Rendergroup::addPointer( const StatesetPtr & p, bool send ){
00283 addStateset( p, send );
00284 }
00285
00286 void Rendergroup::addStateset( const StatesetPtr & p, bool send ){
00287 if( isPointer( p ) ){
00288 Error::warning( Error::ITEM_ALREADY_EXISTS, __FILE__, __LINE__ );
00289 }
00290 m_statesets->addProperty( p, send );
00291 }
00292
00293 void Rendergroup::setStatesets( const StatesetContainerPtr & container, bool send ){
00294 m_statesets = container;
00295 }
00296
00297 const StatesetPtr Rendergroup::getStateset( unsigned int index ) const {
00298 if( index >= m_statesets->size() ){
00299 Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
00300 }
00301 return( m_statesets->getItem( index ) );
00302 }
00303
00304 const StatesetContainerPtr Rendergroup::getStatesets( void ) const {
00305 return( m_statesets );
00306 }
00307
00308 void Rendergroup::removeStateset( const StatesetPtr & pointer, bool send ){
00309 m_statesets->removeProperty( pointer, send );
00310 }
00311
00312 void Rendergroup::removeStatesets( bool send ){
00313 m_statesets->removeProperties( send );
00314 }
00315
00316 bool Rendergroup::isPointer( const SamplerPtr & pointer ) const {
00317 return( m_samplers->isProperty( pointer ) );
00318 }
00319
00320 void Rendergroup::findPointer( const string name, SamplerPtr & pointer ) const {
00321 pointer = dynamic_pointer_cast< Sampler, AbstractProperty >( m_samplers->findProperty( name ) );
00322 }
00323
00324 const SamplerList Rendergroup::findSamplers( const string name ) const {
00325 SamplerList list;
00326 m_samplers->findPointers( name, ( PropertyList & )list );
00327 return( list );
00328 }
00329
00330 const SamplerPtr Rendergroup::findSampler( const string name ) const {
00331 return( dynamic_pointer_cast< Sampler, AbstractProperty >( m_samplers->findProperty( name ) ) );
00332 }
00333
00334 const int Rendergroup::findSamplerIndex( const string name ) const{
00335 return( m_samplers->findIndex( name ) );
00336 }
00337
00338 void Rendergroup::addPointer( const SamplerPtr & p, bool send ){
00339 addSampler( p, send );
00340 }
00341
00342 void Rendergroup::addSampler( const SamplerPtr & p, bool send ){
00343 if( isPointer( p ) ){
00344 Error::warning( Error::ITEM_ALREADY_EXISTS, __FILE__, __LINE__ );
00345 }
00346 m_samplers->addProperty( p, send );
00347 }
00348
00349 void Rendergroup::setSamplers( const SamplerContainerPtr & container, bool send ){
00350 m_samplers = container;
00351 }
00352
00353 const SamplerPtr Rendergroup::getSampler( unsigned int index ) const {
00354 if( index >= m_samplers->size() ){
00355 Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
00356 }
00357 return( m_samplers->getItem( index ) );
00358 }
00359
00360 const SamplerContainerPtr Rendergroup::getSamplers( void ) const {
00361 return( m_samplers );
00362 }
00363
00364 void Rendergroup::removeSampler( const SamplerPtr & pointer, bool send ){
00365 m_samplers->removeProperty( pointer, send );
00366 }
00367
00368 void Rendergroup::removeSamplers( bool send ){
00369 m_samplers->removeProperties( send );
00370 }
00371
00372 bool Rendergroup::isPointer( const FramebufferPtr & pointer ) const {
00373 return( m_framebuffers->isProperty( pointer ) );
00374 }
00375
00376 void Rendergroup::findPointer( const string name, FramebufferPtr & pointer ) const {
00377 pointer = dynamic_pointer_cast< Framebuffer, AbstractProperty >( m_framebuffers->findProperty( name ) );
00378 }
00379
00380 const FramebufferList Rendergroup::findFramebuffers( const string name ) const {
00381 FramebufferList list;
00382 m_framebuffers->findPointers( name, ( PropertyList & )list );
00383 return( list );
00384 }
00385
00386 const FramebufferPtr Rendergroup::findFramebuffer( const string name ) const {
00387 return( dynamic_pointer_cast< Framebuffer, AbstractProperty >( m_framebuffers->findProperty( name ) ) );
00388 }
00389
00390 const int Rendergroup::findFramebufferIndex( const string name ) const{
00391 return( m_framebuffers->findIndex( name ) );
00392 }
00393
00394 void Rendergroup::addPointer( const FramebufferPtr & p, bool send ){
00395 addFramebuffer( p, send );
00396 }
00397
00398 void Rendergroup::addFramebuffer( const FramebufferPtr & p, bool send ){
00399 if( isPointer( p ) ){
00400 Error::warning( Error::ITEM_ALREADY_EXISTS, __FILE__, __LINE__ );
00401 }
00402 m_framebuffers->addProperty( p, send );
00403 }
00404
00405 void Rendergroup::setFramebuffers( const FramebufferContainerPtr & container, bool send ){
00406 m_framebuffers = container;
00407 }
00408
00409 const FramebufferPtr Rendergroup::getFramebuffer( unsigned int index ) const {
00410 if( index >= m_framebuffers->size() ){
00411 Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
00412 }
00413 return( m_framebuffers->getItem( index ) );
00414 }
00415
00416 const FramebufferContainerPtr Rendergroup::getFramebuffers( void ) const {
00417 return( m_framebuffers );
00418 }
00419
00420 void Rendergroup::removeFramebuffer( const FramebufferPtr & pointer, bool send ){
00421 m_framebuffers->removeProperty( pointer, send );
00422 }
00423
00424 void Rendergroup::removeFramebuffers( bool send ){
00425 m_framebuffers->removeProperties( send );
00426 }
00427
00428 bool Rendergroup::isPointer( const RenderbufferPtr & pointer ) const {
00429 return( m_renderbuffers->isProperty( pointer ) );
00430 }
00431
00432 void Rendergroup::findPointer( const string name, RenderbufferPtr & pointer ) const {
00433 pointer = dynamic_pointer_cast< Renderbuffer, AbstractProperty >( m_renderbuffers->findProperty( name ) );
00434 }
00435
00436 const RenderbufferList Rendergroup::findRenderbuffers( const string name ) const {
00437 RenderbufferList list;
00438 m_renderbuffers->findPointers( name, ( PropertyList & )list );
00439 return( list );
00440 }
00441
00442 const RenderbufferPtr Rendergroup::findRenderbuffer( const string name ) const {
00443 return( dynamic_pointer_cast< Renderbuffer, AbstractProperty >( m_renderbuffers->findProperty( name ) ) );
00444 }
00445
00446 const int Rendergroup::findRenderbufferIndex( const string name ) const{
00447 return( m_renderbuffers->findIndex( name ) );
00448 }
00449
00450 void Rendergroup::addPointer( const RenderbufferPtr & p, bool send ){
00451 addRenderbuffer( p, send );
00452 }
00453
00454 void Rendergroup::addRenderbuffer( const RenderbufferPtr & p, bool send ){
00455 if( isPointer( p ) ){
00456 Error::warning( Error::ITEM_ALREADY_EXISTS, __FILE__, __LINE__ );
00457 }
00458 m_renderbuffers->addProperty( p, send );
00459 }
00460
00461 void Rendergroup::setRenderbuffers( const RenderbufferContainerPtr & container, bool send ){
00462 m_renderbuffers = container;
00463 }
00464
00465 const RenderbufferPtr Rendergroup::getRenderbuffer( unsigned int index ) const {
00466 if( index >= m_renderbuffers->size() ){
00467 Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
00468 }
00469 return( m_renderbuffers->getItem( index ) );
00470 }
00471
00472 const RenderbufferContainerPtr Rendergroup::getRenderbuffers( void ) const {
00473 return( m_renderbuffers );
00474 }
00475
00476 void Rendergroup::removeRenderbuffer( const RenderbufferPtr & pointer, bool send ){
00477 m_renderbuffers->removeProperty( pointer, send );
00478 }
00479
00480 void Rendergroup::removeRenderbuffers( bool send ){
00481 m_renderbuffers->removeProperties( send );
00482 }
00483
00484 bool Rendergroup::isPointer( const VertexbufferPtr & pointer ) const {
00485 return( m_vertexbuffers->isProperty( pointer ) );
00486 }
00487
00488 void Rendergroup::findPointer( const string name, VertexbufferPtr & pointer ) const {
00489 pointer = dynamic_pointer_cast< Vertexbuffer, AbstractProperty >( m_vertexbuffers->findProperty( name ) );
00490 }
00491
00492 const VertexbufferList Rendergroup::findVertexbuffers( const string name ) const {
00493 VertexbufferList list;
00494 m_vertexbuffers->findPointers( name, ( PropertyList & )list );
00495 return( list );
00496 }
00497
00498 const VertexbufferPtr Rendergroup::findVertexbuffer( const string name ) const {
00499 return( dynamic_pointer_cast< Vertexbuffer, AbstractProperty >( m_vertexbuffers->findProperty( name ) ) );
00500 }
00501
00502 const int Rendergroup::findVertexbufferIndex( const string name ) const{
00503 return( m_vertexbuffers->findIndex( name ) );
00504 }
00505
00506 void Rendergroup::addPointer( const VertexbufferPtr & p, bool send ){
00507 addVertexbuffer( p, send );
00508 }
00509
00510 void Rendergroup::addVertexbuffer( const VertexbufferPtr & p, bool send ){
00511 if( isPointer( p ) ){
00512 Error::warning( Error::ITEM_ALREADY_EXISTS, __FILE__, __LINE__ );
00513 }
00514 m_vertexbuffers->addProperty( p, send );
00515 }
00516
00517 void Rendergroup::setVertexbuffers( const VertexbufferContainerPtr & container, bool send ){
00518 m_vertexbuffers = container;
00519 }
00520
00521 const VertexbufferPtr Rendergroup::getVertexbuffer( unsigned int index ) const {
00522 if( index >= m_vertexbuffers->size() ){
00523 Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
00524 }
00525 return( m_vertexbuffers->getItem( index ) );
00526 }
00527
00528 const VertexbufferContainerPtr Rendergroup::getVertexbuffers( void ) const {
00529 return( m_vertexbuffers );
00530 }
00531
00532 void Rendergroup::removeVertexbuffer( const VertexbufferPtr & pointer, bool send ){
00533 m_vertexbuffers->removeProperty( pointer, send );
00534 }
00535
00536 void Rendergroup::removeVertexbuffers( bool send ){
00537 m_vertexbuffers->removeProperties( send );
00538 }
00539
00540 bool Rendergroup::isPointer( const RendernodePtr & pointer ) const {
00541 return( m_rendernodes->isProperty( pointer ) );
00542 }
00543
00544 void Rendergroup::findPointer( const string name, RendernodePtr & pointer ) const {
00545 pointer = dynamic_pointer_cast< Rendernode, AbstractProperty >( m_rendernodes->findProperty( name ) );
00546 }
00547
00548 const RendernodeList Rendergroup::findRendernodes( const string name ) const {
00549 RendernodeList list;
00550 m_rendernodes->findPointers( name, ( PropertyList & )list );
00551 return( list );
00552 }
00553
00554 const RendernodePtr Rendergroup::findRendernode( const string name ) const {
00555 return( dynamic_pointer_cast< Rendernode, AbstractProperty >( m_rendernodes->findProperty( name ) ) );
00556 }
00557
00558 const int Rendergroup::findRendernodeIndex( const string name ) const{
00559 return( m_rendernodes->findIndex( name ) );
00560 }
00561
00562 void Rendergroup::addPointer( const RendernodePtr & p, bool send ){
00563 addRendernode( p, send );
00564 }
00565
00566 void Rendergroup::addRendernode( const RendernodePtr & p, bool send ){
00567 if( isPointer( p ) ){
00568 Error::warning( Error::ITEM_ALREADY_EXISTS, __FILE__, __LINE__ );
00569 }
00570 m_rendernodes->addProperty( p, send );
00571 }
00572
00573 void Rendergroup::setRendernodes( const RendernodeContainerPtr & container, bool send ){
00574 m_rendernodes = container;
00575 }
00576
00577 const RendernodePtr Rendergroup::getRendernode( unsigned int index ) const {
00578 if( index >= m_rendernodes->size() ){
00579 Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
00580 }
00581 return( m_rendernodes->getItem( index ) );
00582 }
00583
00584 const RendernodeContainerPtr Rendergroup::getRendernodes( void ) const {
00585 return( m_rendernodes );
00586 }
00587
00588 void Rendergroup::removeRendernode( const RendernodePtr & pointer, bool send ){
00589 m_rendernodes->removeProperty( pointer, send );
00590 }
00591
00592 void Rendergroup::removeRendernodes( bool send ){
00593 m_rendernodes->removeProperties( send );
00594 }
00595
00596 bool Rendergroup::isPointer( const RenderpassPtr & pointer ) const {
00597 return( m_renderpasses->isProperty( pointer ) );
00598 }
00599
00600 void Rendergroup::findPointer( const string name, RenderpassPtr & pointer ) const {
00601 pointer = dynamic_pointer_cast< Renderpass, AbstractProperty >( m_renderpasses->findProperty( name ) );
00602 }
00603
00604 const RenderpassList Rendergroup::findRenderpasses( const string name ) const {
00605 RenderpassList list;
00606 m_renderpasses->findPointers( name, ( PropertyList & )list );
00607 return( list );
00608 }
00609
00610 const RenderpassPtr Rendergroup::findRenderpass( const string name ) const {
00611 return( dynamic_pointer_cast< Renderpass, AbstractProperty >( m_renderpasses->findProperty( name ) ) );
00612 }
00613
00614 const int Rendergroup::findRenderpassIndex( const string name ) const{
00615 return( m_renderpasses->findIndex( name ) );
00616 }
00617
00618 void Rendergroup::addPointer( const RenderpassPtr & p, bool send ){
00619 addRenderpass( p, send );
00620 }
00621
00622 void Rendergroup::addRenderpass( const RenderpassPtr & p, bool send ){
00623 if( isPointer( p ) ){
00624 Error::warning( Error::ITEM_ALREADY_EXISTS, __FILE__, __LINE__ );
00625 }
00626 m_renderpasses->addProperty( p, send );
00627 }
00628
00629 void Rendergroup::setRenderpasses( const RenderpassContainerPtr & container, bool send ){
00630 m_renderpasses = container;
00631 }
00632
00633 const RenderpassPtr Rendergroup::getRenderpass( unsigned int index ) const {
00634 if( index >= m_renderpasses->size() ){
00635 Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
00636 }
00637 return( m_renderpasses->getItem( index ) );
00638 }
00639
00640 const RenderpassContainerPtr Rendergroup::getRenderpasses( void ) const {
00641 return( m_renderpasses );
00642 }
00643
00644 void Rendergroup::removeRenderpass( const RenderpassPtr & pointer, bool send ){
00645 m_renderpasses->removeProperty( pointer, send );
00646 }
00647
00648 void Rendergroup::removeRenderpasses( bool send ){
00649 m_renderpasses->removeProperties( send );
00650 }
00651
00652 #ifndef RT_GLES1
00653
00654 bool Rendergroup::isPointer( const ProgramPtr & pointer ) const {
00655 return( m_programs->isProperty( pointer ) );
00656 }
00657
00658 void Rendergroup::findPointer( const string name, ProgramPtr & pointer ) const {
00659 pointer = dynamic_pointer_cast< Program, AbstractProperty >( m_programs->findProperty( name ) );
00660 }
00661
00662 const ProgramList Rendergroup::findPrograms( const string name ) const {
00663 ProgramList list;
00664 m_programs->findPointers( name, ( PropertyList & )list );
00665 return( list );
00666 }
00667
00668 const ProgramPtr Rendergroup::findProgram( const string name ) const {
00669 return( dynamic_pointer_cast< Program, AbstractProperty >( m_programs->findProperty( name ) ) );
00670 }
00671
00672 const int Rendergroup::findProgramIndex( const string name ) const{
00673 return( m_programs->findIndex( name ) );
00674 }
00675
00676 void Rendergroup::addPointer( const ProgramPtr & p, bool send ){
00677 addProgram( p, send );
00678 }
00679
00680 void Rendergroup::addProgram( const ProgramPtr & p, bool send ){
00681 if( isPointer( p ) ){
00682 Error::warning( Error::ITEM_ALREADY_EXISTS, __FILE__, __LINE__ );
00683 }
00684 m_programs->addProperty( p, send );
00685 }
00686
00687 void Rendergroup::setPrograms( const ProgramContainerPtr & container, bool send ){
00688 m_programs = container;
00689 }
00690
00691 const ProgramPtr Rendergroup::getProgram( unsigned int index ) const {
00692 if( index >= m_programs->size() ){
00693 Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
00694 }
00695 return( m_programs->getItem( index ) );
00696 }
00697
00698 const ProgramContainerPtr Rendergroup::getPrograms( void ) const {
00699 return( m_programs );
00700 }
00701
00702 void Rendergroup::removeProgram( const ProgramPtr & pointer, bool send ){
00703 m_programs->removeProperty( pointer, send );
00704 }
00705
00706 void Rendergroup::removePrograms( bool send ){
00707 m_programs->removeProperties( send );
00708 }
00709
00710 #endif
00711
00712 void Rendergroup::updateAllGroups( void ){
00713 unsigned int i;
00714 for( i = 0; i < s_groups.size(); i++ ){
00715 setActiveRendergroup( i );
00716 s_groups[ i ].lock()->update();
00717 }
00718 }
00719
00720 void Rendergroup::renderAllGroups( void ){
00721
00722 unsigned int i;
00723 for( i = 0; i < s_groups.size(); i++ ){
00724 setActiveRendergroup( i );
00725 s_groups[ i ].lock()->render( );
00726 }
00727
00728 Error::assertNoErrors( __FILE__, __LINE__ );
00729 }
00730
00731 void Rendergroup::updateSingleGroup( unsigned int i ){
00732 if( i >= 0 && i < s_groups.size() ){
00733 setActiveRendergroup( i );
00734 s_groups[ i ].lock()->update();
00735 }
00736 else{
00737 Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
00738 }
00739 }
00740
00741 void Rendergroup::renderSingleGroup( string name ){
00742 renderSingleGroup( findRendergroupIndex( name ) );
00743 }
00744
00745 void Rendergroup::renderSingleGroup( unsigned int i ){
00746 Error::assertNoErrors( __FILE__, __LINE__ );
00747
00748 if( i >= 0 && i < s_groups.size() ){
00749 setActiveRendergroup( i );
00750 s_groups[ i ].lock()->render();
00751 }
00752 else{
00753 Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
00754 }
00755
00756 Error::assertNoErrors( __FILE__, __LINE__ );
00757 }
00758
00759 void Rendergroup::addRendergroup( const RendergroupPtr & group, bool send ){
00760 if( ! group ){
00761 Error::error( Error::NULL_POINTER, __FILE__, __LINE__ );
00762 return;
00763 }
00764
00765 if( ! findRendergroup( group->getName() ) ){
00766 s_groups.push_back( group );
00767 s_activeGroup = s_groups.size() - 1;
00768 }
00769
00770 if( ! group->isInitialized() ){
00772 group->initialize();
00773 }
00774
00775 #ifndef RT_GLES1
00776 group->bindSamplersToUniforms();
00777 #endif
00778
00779 }
00780
00781 void Rendergroup::removeRendergroup( const RendergroupPtr & group, bool send ){
00782 for( unsigned int i = 0; i < s_groups.size(); i++ ){
00783 if( s_groups[ i ].lock() == group ){
00784 s_groups[ i ] = s_groups[ s_groups.size() - 1 ];
00785 s_groups.pop_back();
00787 s_activeGroup = -1;
00788 }
00789 }
00790 }
00791
00792 void Rendergroup::clear( bool send ){
00793 s_groups.clear();
00794 s_activeGroup = -1;
00795 s_activePass = 0;
00796 }
00797
00798 bool Rendergroup::setActiveRendergroup( int i ){
00799 s_activeGroup = i;
00800 if( i >= 0 && i < (int)s_groups.size() ){
00801 #ifndef RT_GLES1
00802 bindUniforms( "group", toString( i ) );
00803 #endif
00804 return( true );
00805 }
00806 else{
00807 Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
00808 }
00809 return( false );
00810 }
00811
00812 bool Rendergroup::setActiveRendergroup( const RendergroupPtr & group ){
00813 for( unsigned int i = 0; i < s_groups.size(); i++ ){
00814 if( s_groups[ i ].lock() == group ){
00815 return( setActiveRendergroup( i ) );
00816 }
00817 }
00819 addRendergroup( group, true );
00820
00822 for( unsigned int i = 0; i < s_groups.size(); i++ ){
00823 if( s_groups[ i ].lock() == group ){
00824 return( setActiveRendergroup( i ) );
00825 }
00826 }
00827
00829 Error::error( Error::ITEM_NOT_IN_MANAGER, __FILE__, __LINE__ );
00830 return( false );
00831 }
00832
00833 bool Rendergroup::setActiveRenderpass( int i ){
00834 if( i >= 0 && i < (int)getActiveRendergroup()->getRenderpasses()->size() ){
00835 s_activePass = i;
00836 #ifndef RT_GLES1
00837 bindUniforms( "pass", toString( i ) );
00838 #endif
00839 return( true );
00840 }
00841 else{
00842 Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
00843 }
00844 return( false );
00845 }
00846
00847 bool Rendergroup::setActiveRenderpass( const RenderpassPtr & pass ){
00848
00849 const RenderpassContainerPtr passes = getActiveRendergroup()->getRenderpasses();
00850 for( unsigned int i = 0; i < passes->size(); i++ ){
00851 if( ( * passes )[ i ] == pass ){
00852 s_activePass = i;
00853 #ifndef RT_GLES1
00854 const GLint index = ( const GLint ) i;
00855 bindUniforms( "pass", toString( index ) );
00856 #endif
00857 return( true );
00858 }
00859 }
00860
00861 Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
00862 return( false );
00863 }
00864
00865 const RendergroupPtr Rendergroup::getActiveRendergroup( void ){
00866 if( s_activeGroup >= 0 && s_activeGroup < (int)s_groups.size() ){
00867 return( s_groups[ s_activeGroup ].lock() );
00868 }
00869 else if( s_groups.size() ){
00870 Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
00871 }
00872 else{
00873 Error::warning( Error::NO_ACTIVE_GROUP, __FILE__, __LINE__ );
00874 }
00875 return( RendergroupPtr() );
00876 }
00877
00878 const int Rendergroup::getActiveRendergroupIndex( void ){
00879 return( s_activeGroup );
00880 }
00881
00882 const RenderpassPtr Rendergroup::getActiveRenderpass( void ){
00883 if( s_activeGroup >= 0 && s_activeGroup < (int)s_groups.size() ){
00884 if( s_activePass >= 0 && s_activePass < (int)s_groups[ s_activeGroup ].lock()->getRenderpasses()->size() ){
00885 return( s_groups[ s_activeGroup ].lock()->getRenderpasses()->getItem( s_activePass ) );
00886 }
00887 else{
00888 Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
00889 }
00890 }
00891 else{
00892 Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
00893 }
00894 return( RenderpassPtr() );
00895 }
00896
00897 const int Rendergroup::getActiveRenderpassIndex( void ){
00898 return( s_activePass );
00899 }
00900
00901 #ifndef RT_GLES1
00902
00903 const PropertyList Rendergroup::findUniforms( const string name ) const{
00904 PropertyList list;
00905 if( m_programs ){
00906 for( unsigned int i = 0; i < m_programs->size(); i++ ){
00907 const PropertyContainerPtr & uniforms = m_programs->getItem( i )->getUniforms();
00908 for( unsigned int j = 0; j < uniforms->size(); j++ ){
00909 if( uniforms->getProperty( j )->getName() == name || name == "" ){
00910 list.push_back( uniforms->getProperty( j ) );
00911 }
00912 }
00913 }
00914 }
00915 return( list );
00916 }
00917
00918 const PropertyPtr Rendergroup::findUniform( string name ) const{
00919 for( unsigned int i = 0; i < m_programs->size(); i++ ){
00920 const PropertyContainerPtr & uniforms = m_programs->getItem( i )->getUniforms();
00921 for( unsigned int j = 0; j < uniforms->size(); j++ ){
00922 if( uniforms->getProperty( j )->getName() == name || name == "" ){
00923 return( uniforms->getProperty( j ) );
00924 }
00925 }
00926 }
00927 return( PropertyPtr() );
00928 }
00929
00930 void Rendergroup::bindSamplersToUniforms( void ){
00931 for( unsigned int i = 0; i < m_samplers->size(); i++ ){
00933 PropertyList unif = findUniforms( m_samplers->getItem( i )->getName() );
00934 for( unsigned int j = 0; j < unif.size(); j++ ){
00935
00936 unif[ j ]->setValue( m_samplers->getItem( i )->getName() );
00937 }
00938 }
00939 }
00940
00941 #endif
00942
00943 RendergroupPtr Rendergroup::operator << ( const CameraPtr & p ){
00944 addCamera( p );
00945 return( getSharedPtr< Rendergroup >() );
00946 }
00947
00948 RendergroupPtr Rendergroup::operator << ( const StatesetPtr & p ){
00949 addStateset( p );
00950 return( getSharedPtr< Rendergroup >() );
00951 }
00952
00953 RendergroupPtr Rendergroup::operator << ( const RendernodePtr & p ){
00954 addRendernode( p );
00955 return( getSharedPtr< Rendergroup >() );
00956 }
00957
00958 RendergroupPtr Rendergroup::operator << ( const RenderpassPtr & p ){
00959 addRenderpass( p );
00960 return( getSharedPtr< Rendergroup >() );
00961 }
00962
00963 RendergroupPtr Rendergroup::operator << ( const FramebufferPtr & p ){
00964 addFramebuffer( p );
00965 return( getSharedPtr< Rendergroup >() );
00966 }
00967
00968 RendergroupPtr Rendergroup::operator << ( const RenderbufferPtr & p ){
00969 addRenderbuffer( p );
00970 return( getSharedPtr< Rendergroup >() );
00971 }
00972
00973 RendergroupPtr Rendergroup::operator << ( const VertexbufferPtr & p ){
00974 addVertexbuffer( p );
00975 return( getSharedPtr< Rendergroup >() );
00976 }
00977
00978 RendergroupPtr Rendergroup::operator << ( const SamplerPtr & p ){
00979 addSampler( p );
00980 return( getSharedPtr< Rendergroup >() );
00981 }
00982
00983 #ifndef RT_GLES1
00984 RendergroupPtr Rendergroup::operator << ( const ProgramPtr & p ){
00985 addProgram( p );
00986 return( getSharedPtr< Rendergroup >() );
00987 }
00988 #endif
00989
00990 RendergroupPtr Rendergroup::operator << ( const XMLNodePtr & xml ){
00991 if( xml->getTagName() == "Camera" ){
00992 addCamera( dynamic_pointer_cast< Camera, AbstractProperty >( Factory::create( xml ) ) );
00993 }
00994 else if( xml->getTagName() == "Sampler" ){
00995 addSampler( dynamic_pointer_cast< Sampler, AbstractProperty >( Factory::create( xml ) ) );
00996 }
00997 else if( xml->getTagName() == "Stateset" ){
00998 addStateset( dynamic_pointer_cast< Stateset, AbstractProperty >( Factory::create( xml ) ) );
00999 }
01000 else if( xml->getTagName() == "Rendernode" ){
01001 addRendernode( dynamic_pointer_cast< Rendernode, AbstractProperty >( Factory::create( xml ) ) );
01002 }
01003 else if( xml->getTagName() == "Renderpass" ){
01004 addRenderpass( dynamic_pointer_cast< Renderpass, AbstractProperty >( Factory::create( xml ) ) );
01005 }
01006 else if( xml->getTagName() == "Framebuffer" ){
01007 addFramebuffer( dynamic_pointer_cast< Framebuffer, AbstractProperty >( Factory::create( xml ) ) );
01008 }
01009 else if( xml->getTagName() == "Renderbuffer" ){
01010 addRenderbuffer( dynamic_pointer_cast< Renderbuffer, AbstractProperty >( Factory::create( xml ) ) );
01011 }
01012 else if( xml->getTagName() == "Vertexbuffer" ){
01013 addVertexbuffer( dynamic_pointer_cast< Vertexbuffer, AbstractProperty >( Factory::create( xml ) ) );
01014 }
01015 #ifndef RT_GLES1
01016 else if( xml->getTagName() == "Program" ){
01017 addProgram( dynamic_pointer_cast< Program, AbstractProperty >( Factory::create( xml ) ) );
01018 }
01019 #endif
01020 return( getSharedPtr< Rendergroup >() );
01021 }
01022
01023 };