00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039 #include <stdlib.h>
00040 #include <stdio.h>
00041
00042 #include "OSGStdShadowMapHandler.h"
00043 #include "OSGRenderAction.h"
00044 #include "OSGShadowStage.h"
00045 #include "OSGShadowStageData.h"
00046 #include "OSGSpotLight.h"
00047
00048 OSG_BEGIN_NAMESPACE
00049
00050 #include "ShaderCode/OSGStdShadowMapShaderCode.cinl"
00051
00052 StdShadowMapHandler::StdShadowMapHandler(ShadowStage *pSource,
00053 ShadowStageData *pData ) :
00054 Inherited (pSource,
00055 pData ),
00056 _tiledeco (NULL ),
00057 _matrixDeco (NULL ),
00058 _blender (NULL ),
00059 _shadowCmat (NULL ),
00060 _shadowSHL (NULL ),
00061 _shadowCubeSHL(NULL ),
00062 _shadowSHL2 (NULL ),
00063 _shadowSHL3 (NULL ),
00064 _shadowSHL4 (NULL ),
00065 _shadowSHL5 (NULL ),
00066 _shadowSHL6 (NULL ),
00067 _shadowSHL7 (NULL ),
00068 _pPoly (NULL ),
00069 _firstRun (1 )
00070 {
00071 _uiMode = ShadowStage::STD_SHADOW_MAP;
00072
00073 _blender = BlendChunk::createLocal();
00074 {
00075 _blender->setAlphaFunc(GL_GEQUAL);
00076 _blender->setAlphaValue(0.99f);
00077 }
00078
00079 _tiledeco = NULL;
00080
00081
00082 _shadowFactorMap2O = TextureObjChunk::createLocal();
00083 _shadowFactorMapImage2 = Image ::createLocal();
00084
00085 _shadowFactorMap2O->setImage (_shadowFactorMapImage2);
00086 _shadowFactorMap2O->setInternalFormat(GL_RGB);
00087 _shadowFactorMap2O->setExternalFormat(GL_RGB);
00088 _shadowFactorMap2O->setMinFilter (GL_LINEAR);
00089 _shadowFactorMap2O->setMagFilter (GL_LINEAR);
00090 _shadowFactorMap2O->setWrapS (GL_REPEAT);
00091 _shadowFactorMap2O->setWrapT (GL_REPEAT);
00092 _shadowFactorMap2O->setTarget (GL_TEXTURE_2D);
00093
00094
00095
00096
00097 _shadowSHL = SimpleSHLChunk::createLocal();
00098 _shadowSHL->setVertexProgram (_std_shadow_vp);
00099 _shadowSHL->setFragmentProgram(_std_shadow_fp);
00100
00101 _shadowSHL2 = SimpleSHLChunk::createLocal();
00102 _shadowSHL2->setVertexProgram (_std_shadow2_vp);
00103 _shadowSHL2->setFragmentProgram(_std_shadow2_fp);
00104
00105 _shadowSHL3 = SimpleSHLChunk::createLocal();
00106 _shadowSHL3->setVertexProgram (_std_shadow3_vp);
00107 _shadowSHL3->setFragmentProgram(_std_shadow3_fp);
00108
00109 _shadowSHL4 = SimpleSHLChunk::createLocal();
00110 _shadowSHL4->setVertexProgram (_std_shadow4_vp);
00111 _shadowSHL4->setFragmentProgram(_std_shadow4_fp);
00112
00113 _shadowSHL5 = SimpleSHLChunk::createLocal();
00114 _shadowSHL5->setVertexProgram (_std_shadow5_vp);
00115 _shadowSHL5->setFragmentProgram(_std_shadow5_fp);
00116
00117 _shadowSHL6 = SimpleSHLChunk::createLocal();
00118 _shadowSHL6->setVertexProgram (_std_shadow6_vp);
00119 _shadowSHL6->setFragmentProgram(_std_shadow6_fp);
00120
00121 _shadowSHL7 = SimpleSHLChunk::createLocal();
00122 _shadowSHL7->setVertexProgram (_std_shadow7_vp);
00123 _shadowSHL7->setFragmentProgram(_std_shadow7_fp);
00124
00125
00126 _shadowCubeSHL = SimpleSHLChunk::createLocal();
00127 _shadowCubeSHL->setVertexProgram (_std_shadowCube_vp);
00128 _shadowCubeSHL->setFragmentProgram(_std_shadowCube_fp);
00129
00130 _shadowCmat = ChunkMaterial::createLocal();
00131
00132 _matrixDeco = MatrixCameraDecorator::createLocal();
00133
00134 _pPoly = PolygonChunk::createLocal();
00135
00136 _unlitMat->addChunk(_pPoly);
00137 }
00138
00139 StdShadowMapHandler::~StdShadowMapHandler(void)
00140 {
00141 _tiledeco = NULL;
00142 _matrixDeco = NULL;
00143 _blender = NULL;
00144 _shadowCmat = NULL;
00145 _shadowSHL = NULL;
00146 _shadowCubeSHL = NULL;
00147 _shadowSHL2 = NULL;
00148 _shadowSHL3 = NULL;
00149 _shadowSHL4 = NULL;
00150 _shadowSHL5 = NULL;
00151 _shadowSHL6 = NULL;
00152 _shadowSHL7 = NULL;
00153 _pPoly = NULL;
00154 }
00155
00156
00157 void StdShadowMapHandler::createShadowMapsFBO(RenderAction *a,
00158 DrawEnv *pEnv)
00159 {
00160
00161
00162
00163
00164 std::vector<bool> vLocalLightStates;
00165
00166 const ShadowStageData::LightStore &vLights =
00167 _pStageData->getLights();
00168
00169 const ShadowStageData::LStateStore &vLightStates =
00170 _pStageData->getLightStates();
00171
00172 const ShadowStageData::StatusStore &vRealPLight =
00173 _pStageData->getRealPointLight();
00174
00175 const ShadowStageData::CamStore &vLCams =
00176 _pStageData->getLightCameras();
00177
00178 const ShadowStageData::StatusStore &vExclActive =
00179 _pStageData->getExcludeNodeActive();
00180
00181 for(UInt32 i = 0;i < vLights.size();++i)
00182 {
00183
00184 vLocalLightStates.push_back(vLights[i].second->getOn());
00185
00186 vLights[i].second->setOn(false);
00187 }
00188
00189
00190 for(UInt32 i = 0;i < _pStage->getMFExcludeNodes()->size();++i)
00191 {
00192 Node *exnode = _pStage->getExcludeNodes(i);
00193
00194 if(exnode != NULL)
00195 exnode->setTravMask(0);
00196 }
00197
00198 ShadowStageData::ShadowMapStore &vShadowMaps = _pStageData->getShadowMaps();
00199
00200 for(UInt32 i = 0;i < vLights.size();++i)
00201 {
00202 if(vLightStates[i])
00203 {
00204 if(_pStage->getGlobalShadowIntensity() != 0.0 ||
00205 vLights[i].second->getShadowIntensity() != 0.0)
00206 {
00207
00208
00209 if(vLights[i].second->getType() != PointLight::getClassType() ||
00210 vRealPLight[i] == false)
00211 {
00212 a->pushPartition();
00213 {
00214 RenderPartition *pPart = a->getActivePartition();
00215
00216 pPart->addPreRenderCallback(
00217 &ShadowTreeHandler::setupAmbientModelAndMasks);
00218 pPart->addPostRenderCallback(
00219 &ShadowTreeHandler::endAmbientModelAndMasks);
00220
00221 pPart->setRenderTarget(vShadowMaps[i].pFBO);
00222
00223 pPart->setWindow (a->getWindow());
00224
00225 pPart->calcViewportDimension(0.f,
00226 0.f,
00227 _pStage->getMapSize()-1,
00228 _pStage->getMapSize()-1,
00229
00230 _pStage->getMapSize(),
00231 _pStage->getMapSize() );
00232
00233
00234 Matrix m, t;
00235
00236
00237 vLCams[i]->getProjection(
00238 m,
00239 pPart->getViewportWidth (),
00240 pPart->getViewportHeight());
00241
00242 vLCams[i]->getProjectionTranslation(
00243 t,
00244 pPart->getViewportWidth (),
00245 pPart->getViewportHeight());
00246
00247 pPart->setupProjection(m, t);
00248
00249 vLCams[i]->getViewing(
00250 m,
00251 pPart->getViewportWidth (),
00252 pPart->getViewportHeight());
00253
00254
00255 pPart->setupViewing(m);
00256
00257 pPart->setNear (vLCams[i]->getNear());
00258 pPart->setFar (vLCams[i]->getFar ());
00259
00260 pPart->calcFrustum();
00261
00262 pPart->setBackground(_pClearBackground);
00263
00264 Node *light = vLights[i].first;
00265 Node *parent = light->getParent();
00266
00267 if(parent != NULL)
00268 {
00269 a->pushMatrix(parent->getToWorld());
00270 }
00271
00272
00273 a->overrideMaterial(_unlitMat, a->getActNode());
00274 _pStage->recurse(a, light);
00275 a->overrideMaterial( NULL, a->getActNode());
00276
00277 if(parent != NULL)
00278 {
00279 a->popMatrix();
00280 }
00281 }
00282 a->popPartition();
00283 }
00284 else
00285 {
00286 for(UInt32 j = 0;j < 6;j++)
00287 {
00288 UInt32 xOffset, yOffset;
00289
00290 if(j == 0)
00291 {
00292 xOffset = 0;
00293 yOffset = 0;
00294 }
00295 else if(j == 1)
00296 {
00297 xOffset = _PLMapSize;
00298 yOffset = 0;
00299 }
00300 else if(j == 2)
00301 {
00302 xOffset = 2 * _PLMapSize;
00303 yOffset = 0;
00304 }
00305 else if(j == 3)
00306 {
00307 xOffset = 3 * _PLMapSize;
00308 yOffset = 0;
00309 }
00310 else if(j == 4)
00311 {
00312 xOffset = 0;
00313 yOffset = _PLMapSize;
00314 }
00315 else
00316 {
00317 xOffset = _PLMapSize;
00318 yOffset = _PLMapSize;
00319 }
00320
00321 _matrixDeco->setDecoratee ( vLCams[i] );
00322 _matrixDeco->setPreProjection(_aCubeTrans[j]);
00323
00324 a->pushPartition();
00325 {
00326 RenderPartition *pPart = a->getActivePartition();
00327
00328 pPart->addPreRenderCallback(
00329 &ShadowTreeHandler::setupAmbientModelAndMasks);
00330 pPart->addPostRenderCallback(
00331 &ShadowTreeHandler::endAmbientModelAndMasks);
00332
00333 pPart->setRenderTarget(vShadowMaps[i].pFBO);
00334
00335 pPart->setWindow (a->getWindow());
00336
00337 pPart->calcViewportDimension(
00338 xOffset,
00339 yOffset,
00340 xOffset + _PLMapSize,
00341 yOffset + _PLMapSize,
00342
00343 _pStage->getMapSize(),
00344 _pStage->getMapSize() );
00345
00346
00347 Matrix m, t;
00348
00349
00350 _matrixDeco->getProjection (
00351 m,
00352 pPart->getViewportWidth (),
00353 pPart->getViewportHeight());
00354
00355 _matrixDeco->getProjectionTranslation(
00356 t,
00357 pPart->getViewportWidth (),
00358 pPart->getViewportHeight());
00359
00360 pPart->setupProjection(m, t);
00361
00362 _matrixDeco->getViewing(
00363 m,
00364 pPart->getViewportWidth (),
00365 pPart->getViewportHeight());
00366
00367 pPart->setupViewing(m);
00368
00369 pPart->setNear (
00370 _matrixDeco->getNear());
00371 pPart->setFar (
00372 _matrixDeco->getFar ());
00373
00374 pPart->calcFrustum();
00375
00376 pPart->setBackground(_pClearBackground);
00377
00378 Node *light = vLights[i].first;
00379 Node *parent = light->getParent();
00380
00381 if(parent != NULL)
00382 {
00383 a->pushMatrix(parent->getToWorld());
00384 }
00385
00386
00387 a->overrideMaterial(_unlitMat, a->getActNode());
00388 _pStage->recurse(a, light);
00389 a->overrideMaterial( NULL, a->getActNode());
00390
00391 if(parent != NULL)
00392 {
00393 a->popMatrix();
00394 }
00395 }
00396 a->popPartition();
00397 }
00398 }
00399 }
00400 }
00401 }
00402
00403
00404
00405
00406 for(UInt32 i = 0;i < vLights.size();++i)
00407 {
00408
00409 vLights[i].second->setOn(vLocalLightStates[i]);
00410 }
00411
00412
00413 for(UInt32 i = 0;i < _pStage->getMFExcludeNodes()->size();++i)
00414 {
00415 Node *exnode = _pStage->getExcludeNodes(i);
00416 if(exnode != NULL)
00417 {
00418 if(vExclActive[i])
00419 {
00420 exnode->setTravMask(TypeTraits<UInt32>::BitsSet);
00421 }
00422 }
00423 }
00424 }
00425
00426
00427 void StdShadowMapHandler::createColorMapFBO(RenderAction *a,
00428 DrawEnv *pEnv)
00429 {
00430 a->pushPartition((RenderPartition::CopyWindow |
00431 RenderPartition::CopyViewing |
00432 RenderPartition::CopyProjection |
00433 RenderPartition::CopyFrustum |
00434 RenderPartition::CopyNearFar |
00435 RenderPartition::CopyViewportSize),
00436 RenderPartition::StateSorting);
00437 {
00438 RenderPartition *pPart = a->getActivePartition();
00439
00440 pPart->addPreRenderCallback (&ShadowTreeHandler::setupAmbientModel);
00441 pPart->addPostRenderCallback(&ShadowTreeHandler::endAmbientModel );
00442
00443 pPart->setRenderTarget(_pSceneFBO);
00444 pPart->setDrawBuffer ( GL_COLOR_ATTACHMENT0_EXT);
00445
00446 Node *parent = a->getActNode()->getParent();
00447
00448 if(parent != NULL)
00449 {
00450 a->pushMatrix(parent->getToWorld());
00451 }
00452
00453 pPart->setBackground(a->getBackground());
00454
00455 _pStage->recurseFromThis(a);
00456
00457 if(parent != NULL)
00458 {
00459 a->popMatrix();
00460 }
00461 }
00462 a->popPartition();
00463 }
00464
00465
00466 void StdShadowMapHandler::createShadowFactorMapFBO(RenderAction *a,
00467 DrawEnv *pEnv)
00468 {
00469 _activeFactorMap = 0;
00470
00471 const ShadowStageData::LightStore &vLights =
00472 _pStageData->getLights();
00473
00474 const ShadowStageData::LStateStore &vLightStates =
00475 _pStageData->getLightStates();
00476
00477 const ShadowStageData::StatusStore &vRealPLight =
00478 _pStageData->getRealPointLight();
00479
00480 const ShadowStageData::CamStore &vLCams =
00481 _pStageData->getLightCameras();
00482
00483
00484 Real32 activeLights = 0;
00485
00486 if(_pStage->getGlobalShadowIntensity() != 0.0)
00487 {
00488 for(UInt32 i = 0;i < vLights.size();i++)
00489 {
00490 if(vLightStates[i] != 0)
00491 activeLights++;
00492 }
00493 }
00494 else
00495 {
00496 for(UInt32 i = 0;i < vLights.size();i++)
00497 {
00498 if(vLightStates[i] != 0 &&
00499 vLights [i].second->getShadowIntensity() != 0.0)
00500 {
00501 activeLights++;
00502 }
00503 }
00504 }
00505
00506 bool bCA1Cleared = false;
00507 bool bCA2Cleared = false;
00508
00509 ShadowStageData::ShadowMapStore &vShadowMaps = _pStageData->getShadowMaps();
00510
00511
00512 for(UInt32 i = 0;i < vLights.size();i++)
00513 {
00514 if(vLightStates[i] != 0)
00515 {
00516 if((_pStage->getGlobalShadowIntensity() != 0.0 ||
00517 vLights[i].second->getShadowIntensity() != 0.0) &&
00518 vRealPLight[i])
00519 {
00520 Real32 shadowIntensity;
00521 if(_pStage->getGlobalShadowIntensity() != 0.0)
00522 {
00523 shadowIntensity = (_pStage->getGlobalShadowIntensity() /
00524 activeLights);
00525 }
00526 else
00527 {
00528 shadowIntensity =
00529 (vLights[i].second->getShadowIntensity() /
00530 activeLights);
00531 }
00532
00533 Matrix LVM, LPM, CVM;
00534
00535 vLCams[i]->getViewing(
00536 LVM,
00537 pEnv->getPixelWidth(),
00538 pEnv->getPixelHeight());
00539
00540 vLCams[i]->getProjection(
00541 LPM,
00542 pEnv->getPixelWidth(),
00543 pEnv->getPixelHeight());
00544
00545 CVM = pEnv->getCameraViewing();
00546
00547 Matrix iCVM = CVM;
00548 iCVM.invert();
00549
00550 Real32 texFactor;
00551 if(vLights[i].second->getType() == PointLight::getClassType()||
00552 vLights[i].second->getType() == SpotLight ::getClassType() )
00553 {
00554 texFactor = Real32(_width) / Real32(_height);
00555 }
00556 else
00557 {
00558 texFactor = 1.0;
00559 }
00560
00561 Matrix shadowMatrix = LPM;
00562 shadowMatrix.mult(LVM);
00563 shadowMatrix.mult(iCVM);
00564
00565 Real32 xFactor = 1.0;
00566 Real32 yFactor = 1.0;
00567
00568 Matrix m = pEnv->getCameraToWorld();
00569
00570 Matrix shadowMatrixOP = LVM;
00571 shadowMatrix.mult(iCVM);
00572
00573 Matrix shadowMatrixA = LPM;
00574 shadowMatrixA.mult(_aCubeTrans[0]);
00575 shadowMatrixA.mult(LVM);
00576 shadowMatrixA.mult(iCVM);
00577
00578 Matrix shadowMatrixB = LPM;
00579 shadowMatrixB.mult(_aCubeTrans[1]);
00580 shadowMatrixB.mult(LVM);
00581 shadowMatrixB.mult(iCVM);
00582
00583 Matrix shadowMatrixC = LPM;
00584 shadowMatrixC.mult(_aCubeTrans[2]);
00585 shadowMatrixC.mult(LVM);
00586 shadowMatrixC.mult(iCVM);
00587
00588 Matrix shadowMatrixD = LPM;
00589 shadowMatrixD.mult(_aCubeTrans[3]);
00590 shadowMatrixD.mult(LVM);
00591 shadowMatrixD.mult(iCVM);
00592
00593 Matrix shadowMatrixE = LPM;
00594 shadowMatrixE.mult(_aCubeTrans[4]);
00595 shadowMatrixE.mult(LVM);
00596 shadowMatrixE.mult(iCVM);
00597
00598 Matrix shadowMatrixF = LPM;
00599 shadowMatrixF.mult(_aCubeTrans[5]);
00600 shadowMatrixF.mult(LVM);
00601 shadowMatrixF.mult(iCVM);
00602
00603 _shadowCubeSHL->addUniformVariable("shadowMap", 0);
00604 _shadowCubeSHL->addUniformVariable("oldFactorMap", 1);
00605 _shadowCubeSHL->addUniformVariable("firstRun", _firstRun);
00606 _shadowCubeSHL->addUniformVariable("intensity",
00607 shadowIntensity);
00608 _shadowCubeSHL->addUniformVariable("texFactor", texFactor);
00609 _shadowCubeSHL->addUniformVariable("lightPMA", shadowMatrixA);
00610 _shadowCubeSHL->addUniformVariable("lightPMB", shadowMatrixB);
00611 _shadowCubeSHL->addUniformVariable("lightPMC", shadowMatrixC);
00612 _shadowCubeSHL->addUniformVariable("lightPMD", shadowMatrixD);
00613 _shadowCubeSHL->addUniformVariable("lightPME", shadowMatrixE);
00614 _shadowCubeSHL->addUniformVariable("lightPMF", shadowMatrixF);
00615 _shadowCubeSHL->addUniformVariable("lightPMOP",
00616 shadowMatrixOP);
00617 _shadowCubeSHL->addUniformVariable("KKtoWK", m);
00618 _shadowCubeSHL->addUniformVariable("xFactor",
00619 Real32(xFactor));
00620 _shadowCubeSHL->addUniformVariable("yFactor",
00621 Real32(yFactor));
00622
00623 _shadowCmat->clearChunks();
00624 _shadowCmat->addChunk(_shadowCubeSHL);
00625 _shadowCmat->addChunk(vShadowMaps[i].pTexO);
00626 _shadowCmat->addChunk(vShadowMaps[i].pTexE);
00627
00628 if(_activeFactorMap == 0)
00629 {
00630 _shadowCmat->addChunk(_shadowFactorMap2O);
00631 }
00632 else
00633 {
00634 _shadowCmat->addChunk(_shadowFactorMapO);
00635 }
00636
00637 GLenum dBuffers = GL_COLOR_ATTACHMENT1_EXT;
00638
00639 if(_activeFactorMap == 0)
00640 dBuffers = GL_COLOR_ATTACHMENT1_EXT;
00641 else
00642 dBuffers = GL_COLOR_ATTACHMENT2_EXT;
00643
00644 a->pushPartition((RenderPartition::CopyWindow |
00645 RenderPartition::CopyViewing |
00646 RenderPartition::CopyProjection |
00647 RenderPartition::CopyFrustum |
00648 RenderPartition::CopyNearFar |
00649 RenderPartition::CopyViewportSize),
00650 RenderPartition::StateSorting);
00651 {
00652 RenderPartition *pPart = a->getActivePartition();
00653
00654 pPart->addPreRenderCallback (
00655 &ShadowTreeHandler::setupAmbientModel);
00656 pPart->addPostRenderCallback(
00657 &ShadowTreeHandler::endAmbientModel );
00658
00659 pPart->setRenderTarget(_pSceneFBO);
00660 pPart->setDrawBuffer ( dBuffers );
00661
00662 Node *light = vLights[i].first;
00663 Node *parent = light->getParent();
00664
00665 if(parent != NULL)
00666 {
00667 a->pushMatrix(parent->getToWorld());
00668 }
00669
00670 if(_activeFactorMap == 0 && bCA1Cleared == false)
00671 {
00672 pPart->setBackground(_pClearBackground);
00673 bCA1Cleared = true;
00674 }
00675 else if(bCA2Cleared == false)
00676 {
00677 pPart->setBackground(_pClearBackground);
00678 bCA2Cleared = true;
00679 }
00680
00681 a->overrideMaterial(_shadowCmat, a->getActNode());
00682 _pStage->recurse(a, light);
00683 a->overrideMaterial( NULL, a->getActNode());
00684
00685 if(parent != NULL)
00686 {
00687 a->popMatrix();
00688 }
00689 }
00690 a->popPartition();
00691
00692 _firstRun = 0;
00693
00694 if(_activeFactorMap == 0)
00695 _activeFactorMap = 1;
00696 else
00697 _activeFactorMap = 0;
00698 }
00699 }
00700 }
00701
00702 std::vector<Real32> shadowIntensityF;
00703 std::vector<Real32> texFactorF;
00704 std::vector<Real32> mapFactorF;
00705 std::vector<Matrix> shadowMatrixF;
00706
00707 UInt32 lightCounter = 0;
00708
00709 Real32 xFactor = 1.0;
00710 Real32 yFactor = 1.0;
00711
00712
00713 for(UInt32 i = 0;i < vLights.size();i++)
00714 {
00715 if(vLightStates[i] != 0 &&
00716 ((_pStage->getGlobalShadowIntensity() != 0.0 ||
00717 vLights[i].second->getShadowIntensity() != 0.0) &&
00718 vRealPLight[i]) == false)
00719 {
00720
00721 Real32 shadowIntensity;
00722 if(_pStage->getGlobalShadowIntensity() != 0.0)
00723 {
00724 shadowIntensity = (_pStage->getGlobalShadowIntensity() /
00725 activeLights);
00726 }
00727 else
00728 {
00729 shadowIntensity =
00730 (vLights[i].second->getShadowIntensity() /
00731 activeLights);
00732 }
00733
00734 shadowIntensityF.push_back(shadowIntensity);
00735
00736 Matrix LVM, LPM, CVM;
00737 vLCams[i]->getViewing(LVM,
00738 pEnv->getPixelWidth(),
00739 pEnv->getPixelHeight());
00740 vLCams[i]->getProjection(LPM,
00741 pEnv->getPixelWidth(),
00742 pEnv->getPixelHeight());
00743
00744 CVM = pEnv->getCameraViewing();
00745
00746 Matrix iCVM = CVM;
00747 iCVM.invert();
00748
00749 Real32 texFactor;
00750 if(vLights[i].second->getType() == PointLight::getClassType() ||
00751 vLights[i].second->getType() == SpotLight ::getClassType() )
00752 {
00753 texFactor = Real32(_width) / Real32(_height);
00754 }
00755 else
00756 {
00757 texFactor = 1.0;
00758 }
00759
00760 texFactorF.push_back(texFactor);
00761
00762 Matrix shadowMatrix = LPM;
00763 shadowMatrix.mult(LVM);
00764 shadowMatrix.mult(iCVM);
00765
00766 shadowMatrixF.push_back(shadowMatrix);
00767
00768 Real32 mapFactor;
00769 mapFactor =
00770 Real32(_pStage->getMapSize()) /
00771 Real32(vShadowMaps[i].pImage->getWidth());
00772 mapFactorF.push_back(mapFactor);
00773 lightCounter++;
00774 }
00775 }
00776
00777 if(lightCounter != 0)
00778 {
00779 GLenum dBuffers = GL_COLOR_ATTACHMENT1_EXT;
00780
00781 if(_activeFactorMap == 0)
00782 dBuffers = GL_COLOR_ATTACHMENT1_EXT;
00783 else
00784 dBuffers = GL_COLOR_ATTACHMENT2_EXT;
00785
00786 UInt32 renderTimes = 1;
00787 if(lightCounter > 7)
00788 renderTimes = UInt32(ceil(Real32(lightCounter) / 7.0f));
00789
00790 for(UInt32 i = 0;i < renderTimes;i++)
00791 {
00792
00793 UInt32 lightOffset = lightCounter - (i * 7);
00794
00795
00796 _shadowCmat->clearChunks();
00797
00798 UInt32 lightNum = 0;
00799 for(UInt32 j = 0;j < vLights.size();j++)
00800 {
00801 if(vLightStates[j] != 0)
00802 {
00803 if((_pStage->getGlobalShadowIntensity() != 0.0 ||
00804 vLights[j].second->getShadowIntensity() != 0.0) &&
00805 vRealPLight[j] == false)
00806 {
00807 if(lightNum >= (i * 7) && lightNum < ((i + 1) * 7))
00808 {
00809 _shadowCmat->addChunk(
00810 vShadowMaps[j].pTexO);
00811 _shadowCmat->addChunk(
00812 vShadowMaps[j].pTexE);
00813 }
00814 lightNum++;
00815 }
00816 }
00817 }
00818
00819 if(lightOffset == 1)
00820 {
00821 _shadowCmat->addChunk(_shadowSHL);
00822 if(_activeFactorMap == 0)
00823 {
00824 _shadowCmat->addChunk(_shadowFactorMap2O);
00825 }
00826 else
00827 {
00828 _shadowCmat->addChunk(_shadowFactorMapO);
00829 }
00830
00831 _shadowSHL->addUniformVariable("oldFactorMap", 1);
00832 _shadowSHL->addUniformVariable("shadowMap", 0);
00833 _shadowSHL->addUniformVariable("firstRun", _firstRun);
00834 _shadowSHL->addUniformVariable("intensity",
00835 shadowIntensityF[0 + (i * 7)]);
00836 _shadowSHL->addUniformVariable("texFactor", texFactorF[0 +
00837 (i * 7)]);
00838 _shadowSHL->addUniformVariable("lightPM", shadowMatrixF[0 +
00839 (i * 7)]);
00840 _shadowSHL->addUniformVariable("xFactor", Real32(xFactor));
00841 _shadowSHL->addUniformVariable("yFactor", Real32(yFactor));
00842 _shadowSHL->addUniformVariable("mapFactor",
00843 Real32(mapFactorF[0 +
00844 (i * 7)]));
00845 }
00846
00847 else if(lightOffset == 2)
00848 {
00849 _shadowCmat->addChunk(_shadowSHL2);
00850 if(_activeFactorMap == 0)
00851 {
00852 _shadowCmat->addChunk(_shadowFactorMap2O);
00853 }
00854 else
00855 {
00856 _shadowCmat->addChunk(_shadowFactorMapO);
00857 }
00858
00859 _shadowSHL2->addUniformVariable("oldFactorMap", 2);
00860 _shadowSHL2->addUniformVariable("shadowMap1", 0);
00861 _shadowSHL2->addUniformVariable("shadowMap2", 1);
00862 _shadowSHL2->addUniformVariable("firstRun", _firstRun);
00863 _shadowSHL2->addUniformVariable("intensity1",
00864 shadowIntensityF[0 +
00865 (i * 7)]);
00866 _shadowSHL2->addUniformVariable("intensity2",
00867 shadowIntensityF[1 +
00868 (i * 7)]);
00869 _shadowSHL2->addUniformVariable("texFactor1", texFactorF[0 +
00870 (i * 7)]);
00871 _shadowSHL2->addUniformVariable("texFactor2", texFactorF[1 +
00872 (i * 7)]);
00873 _shadowSHL2->addUniformVariable("lightPM1", shadowMatrixF[0 +
00874 (i * 7)]);
00875 _shadowSHL2->addUniformVariable("lightPM2", shadowMatrixF[1 +
00876 (i * 7)]);
00877 _shadowSHL2->addUniformVariable("xFactor", Real32(xFactor));
00878 _shadowSHL2->addUniformVariable("yFactor", Real32(yFactor));
00879 _shadowSHL2->addUniformVariable("mapFactor1",
00880 Real32(mapFactorF[0 + (i *
00881 7)]));
00882 _shadowSHL2->addUniformVariable("mapFactor2",
00883 Real32(mapFactorF[1 + (i *
00884 7)]));
00885 }
00886
00887 else if(lightOffset == 3)
00888 {
00889 _shadowCmat->addChunk(_shadowSHL3);
00890 if(_activeFactorMap == 0)
00891 {
00892 _shadowCmat->addChunk(_shadowFactorMap2O);
00893 }
00894 else
00895 {
00896 _shadowCmat->addChunk(_shadowFactorMapO);
00897 }
00898
00899 _shadowSHL3->addUniformVariable("oldFactorMap", 3);
00900 _shadowSHL3->addUniformVariable("shadowMap1", 0);
00901 _shadowSHL3->addUniformVariable("shadowMap2", 1);
00902 _shadowSHL3->addUniformVariable("shadowMap3", 2);
00903 _shadowSHL3->addUniformVariable("firstRun", _firstRun);
00904 _shadowSHL3->addUniformVariable("intensity1",
00905 shadowIntensityF[0 +
00906 (i * 7)]);
00907 _shadowSHL3->addUniformVariable("intensity2",
00908 shadowIntensityF[1 +
00909 (i * 7)]);
00910 _shadowSHL3->addUniformVariable("intensity3",
00911 shadowIntensityF[2 +
00912 (i * 7)]);
00913 _shadowSHL3->addUniformVariable("texFactor1", texFactorF[0 +
00914 (i * 7)]);
00915 _shadowSHL3->addUniformVariable("texFactor2", texFactorF[1 +
00916 (i * 7)]);
00917 _shadowSHL3->addUniformVariable("texFactor3", texFactorF[2 +
00918 (i * 7)]);
00919 _shadowSHL3->addUniformVariable("lightPM1", shadowMatrixF[0 +
00920 (i * 7)]);
00921 _shadowSHL3->addUniformVariable("lightPM2", shadowMatrixF[1 +
00922 (i * 7)]);
00923 _shadowSHL3->addUniformVariable("lightPM3", shadowMatrixF[2 +
00924 (i * 7)]);
00925 _shadowSHL3->addUniformVariable("xFactor", Real32(xFactor));
00926 _shadowSHL3->addUniformVariable("yFactor", Real32(yFactor));
00927 _shadowSHL3->addUniformVariable("mapFactor1",
00928 Real32(mapFactorF[0 + (i *
00929 7)]));
00930 _shadowSHL3->addUniformVariable("mapFactor2",
00931 Real32(mapFactorF[1 + (i *
00932 7)]));
00933 _shadowSHL3->addUniformVariable("mapFactor3",
00934 Real32(mapFactorF[2 + (i *
00935 7)]));
00936 }
00937
00938 else if(lightCounter == 4)
00939 {
00940 _shadowCmat->addChunk(_shadowSHL4);
00941 if(_activeFactorMap == 0)
00942 {
00943 _shadowCmat->addChunk(_shadowFactorMap2O);
00944 }
00945 else
00946 {
00947 _shadowCmat->addChunk(_shadowFactorMapO);
00948 }
00949
00950 _shadowSHL4->addUniformVariable("oldFactorMap", 4);
00951 _shadowSHL4->addUniformVariable("shadowMap1", 0);
00952 _shadowSHL4->addUniformVariable("shadowMap2", 1);
00953 _shadowSHL4->addUniformVariable("shadowMap3", 2);
00954 _shadowSHL4->addUniformVariable("shadowMap4", 3);
00955 _shadowSHL4->addUniformVariable("firstRun", _firstRun);
00956 _shadowSHL4->addUniformVariable("intensity1",
00957 shadowIntensityF[0 +
00958 (i * 7)]);
00959 _shadowSHL4->addUniformVariable("intensity2",
00960 shadowIntensityF[1 +
00961 (i * 7)]);
00962 _shadowSHL4->addUniformVariable("intensity3",
00963 shadowIntensityF[2 +
00964 (i * 7)]);
00965 _shadowSHL4->addUniformVariable("intensity4",
00966 shadowIntensityF[3 +
00967 (i * 7)]);
00968 _shadowSHL4->addUniformVariable("texFactor1", texFactorF[0 +
00969 (i * 7)]);
00970 _shadowSHL4->addUniformVariable("texFactor2", texFactorF[1 +
00971 (i * 7)]);
00972 _shadowSHL4->addUniformVariable("texFactor3", texFactorF[2 +
00973 (i * 7)]);
00974 _shadowSHL4->addUniformVariable("texFactor4", texFactorF[3 +
00975 (i * 7)]);
00976 _shadowSHL4->addUniformVariable("lightPM1", shadowMatrixF[0 +
00977 (i * 7)]);
00978 _shadowSHL4->addUniformVariable("lightPM2", shadowMatrixF[1 +
00979 (i * 7)]);
00980 _shadowSHL4->addUniformVariable("lightPM3", shadowMatrixF[2 +
00981 (i * 7)]);
00982 _shadowSHL4->addUniformVariable("lightPM4", shadowMatrixF[3 +
00983 (i * 7)]);
00984 _shadowSHL4->addUniformVariable("xFactor", Real32(xFactor));
00985 _shadowSHL4->addUniformVariable("yFactor", Real32(yFactor));
00986 _shadowSHL4->addUniformVariable("mapFactor1",
00987 Real32(mapFactorF[0 + (i *
00988 7)]));
00989 _shadowSHL4->addUniformVariable("mapFactor2",
00990 Real32(mapFactorF[1 + (i *
00991 7)]));
00992 _shadowSHL4->addUniformVariable("mapFactor3",
00993 Real32(mapFactorF[2 + (i *
00994 7)]));
00995 _shadowSHL4->addUniformVariable("mapFactor4",
00996 Real32(mapFactorF[3 + (i *
00997 7)]));
00998 }
00999
01000 else if(lightCounter == 5)
01001 {
01002 _shadowCmat->addChunk(_shadowSHL5);
01003 if(_activeFactorMap == 0)
01004 {
01005 _shadowCmat->addChunk(_shadowFactorMap2O);
01006 }
01007 else
01008 {
01009 _shadowCmat->addChunk(_shadowFactorMapO);
01010 }
01011
01012 _shadowSHL5->addUniformVariable("oldFactorMap", 5);
01013 _shadowSHL5->addUniformVariable("shadowMap1", 0);
01014 _shadowSHL5->addUniformVariable("shadowMap2", 1);
01015 _shadowSHL5->addUniformVariable("shadowMap3", 2);
01016 _shadowSHL5->addUniformVariable("shadowMap4", 3);
01017 _shadowSHL5->addUniformVariable("shadowMap5", 4);
01018 _shadowSHL5->addUniformVariable("firstRun", _firstRun);
01019 _shadowSHL5->addUniformVariable("intensity1",
01020 shadowIntensityF[0 +
01021 (i * 7)]);
01022 _shadowSHL5->addUniformVariable("intensity2",
01023 shadowIntensityF[1 +
01024 (i * 7)]);
01025 _shadowSHL5->addUniformVariable("intensity3",
01026 shadowIntensityF[2 +
01027 (i * 7)]);
01028 _shadowSHL5->addUniformVariable("intensity4",
01029 shadowIntensityF[3 +
01030 (i * 7)]);
01031 _shadowSHL5->addUniformVariable("intensity5",
01032 shadowIntensityF[4 +
01033 (i * 7)]);
01034 _shadowSHL5->addUniformVariable("texFactor1", texFactorF[0 +
01035 (i * 7)]);
01036 _shadowSHL5->addUniformVariable("texFactor2", texFactorF[1 +
01037 (i * 7)]);
01038 _shadowSHL5->addUniformVariable("texFactor3", texFactorF[2 +
01039 (i * 7)]);
01040 _shadowSHL5->addUniformVariable("texFactor4", texFactorF[3 +
01041 (i * 7)]);
01042 _shadowSHL5->addUniformVariable("texFactor5", texFactorF[4 +
01043 (i * 7)]);
01044 _shadowSHL5->addUniformVariable("lightPM1", shadowMatrixF[0 +
01045 (i * 7)]);
01046 _shadowSHL5->addUniformVariable("lightPM2", shadowMatrixF[1 +
01047 (i * 7)]);
01048 _shadowSHL5->addUniformVariable("lightPM3", shadowMatrixF[2 +
01049 (i * 7)]);
01050 _shadowSHL5->addUniformVariable("lightPM4", shadowMatrixF[3 +
01051 (i * 7)]);
01052 _shadowSHL5->addUniformVariable("lightPM5", shadowMatrixF[4 +
01053 (i * 7)]);
01054 _shadowSHL5->addUniformVariable("xFactor", Real32(xFactor));
01055 _shadowSHL5->addUniformVariable("yFactor", Real32(yFactor));
01056 _shadowSHL5->addUniformVariable("mapFactor1",
01057 Real32(mapFactorF[0 + (i *
01058 7)]));
01059 _shadowSHL5->addUniformVariable("mapFactor2",
01060 Real32(mapFactorF[1 + (i *
01061 7)]));
01062 _shadowSHL5->addUniformVariable("mapFactor3",
01063 Real32(mapFactorF[2 + (i *
01064 7)]));
01065 _shadowSHL5->addUniformVariable("mapFactor4",
01066 Real32(mapFactorF[3 + (i *
01067 7)]));
01068 _shadowSHL5->addUniformVariable("mapFactor5",
01069 Real32(mapFactorF[4 + (i *
01070 7)]));
01071 }
01072
01073 else if(lightCounter == 6)
01074 {
01075 _shadowCmat->addChunk(_shadowSHL6);
01076 if(_activeFactorMap == 0)
01077 {
01078 _shadowCmat->addChunk(_shadowFactorMap2O);
01079 }
01080 else
01081 {
01082 _shadowCmat->addChunk(_shadowFactorMapO);
01083 }
01084
01085 _shadowSHL6->addUniformVariable("oldFactorMap", 6);
01086 _shadowSHL6->addUniformVariable("shadowMap1", 0);
01087 _shadowSHL6->addUniformVariable("shadowMap2", 1);
01088 _shadowSHL6->addUniformVariable("shadowMap3", 2);
01089 _shadowSHL6->addUniformVariable("shadowMap4", 3);
01090 _shadowSHL6->addUniformVariable("shadowMap5", 4);
01091 _shadowSHL6->addUniformVariable("shadowMap6", 5);
01092 _shadowSHL6->addUniformVariable("firstRun", _firstRun);
01093 _shadowSHL6->addUniformVariable("intensity1",
01094 shadowIntensityF[0 +
01095 (i * 7)]);
01096 _shadowSHL6->addUniformVariable("intensity2",
01097 shadowIntensityF[1 +
01098 (i * 7)]);
01099 _shadowSHL6->addUniformVariable("intensity3",
01100 shadowIntensityF[2 +
01101 (i * 7)]);
01102 _shadowSHL6->addUniformVariable("intensity4",
01103 shadowIntensityF[3 +
01104 (i * 7)]);
01105 _shadowSHL6->addUniformVariable("intensity5",
01106 shadowIntensityF[4 +
01107 (i * 7)]);
01108 _shadowSHL6->addUniformVariable("intensity6",
01109 shadowIntensityF[5 +
01110 (i * 7)]);
01111 _shadowSHL6->addUniformVariable("texFactor1", texFactorF[0 +
01112 (i * 7)]);
01113 _shadowSHL6->addUniformVariable("texFactor2", texFactorF[1 +
01114 (i * 7)]);
01115 _shadowSHL6->addUniformVariable("texFactor3", texFactorF[2 +
01116 (i * 7)]);
01117 _shadowSHL6->addUniformVariable("texFactor4", texFactorF[3 +
01118 (i * 7)]);
01119 _shadowSHL6->addUniformVariable("texFactor5", texFactorF[4 +
01120 (i * 7)]);
01121 _shadowSHL6->addUniformVariable("texFactor6", texFactorF[5 +
01122 (i * 7)]);
01123 _shadowSHL6->addUniformVariable("lightPM1", shadowMatrixF[0 +
01124 (i * 7)]);
01125 _shadowSHL6->addUniformVariable("lightPM2", shadowMatrixF[1 +
01126 (i * 7)]);
01127 _shadowSHL6->addUniformVariable("lightPM3", shadowMatrixF[2 +
01128 (i * 7)]);
01129 _shadowSHL6->addUniformVariable("lightPM4", shadowMatrixF[3 +
01130 (i * 7)]);
01131 _shadowSHL6->addUniformVariable("lightPM5", shadowMatrixF[4 +
01132 (i * 7)]);
01133 _shadowSHL6->addUniformVariable("lightPM6", shadowMatrixF[5 +
01134 (i * 7)]);
01135 _shadowSHL6->addUniformVariable("xFactor", Real32(xFactor));
01136 _shadowSHL6->addUniformVariable("yFactor", Real32(yFactor));
01137 _shadowSHL6->addUniformVariable("mapFactor1",
01138 Real32(mapFactorF[0 + (i *
01139 7)]));
01140 _shadowSHL6->addUniformVariable("mapFactor2",
01141 Real32(mapFactorF[1 + (i *
01142 7)]));
01143 _shadowSHL6->addUniformVariable("mapFactor3",
01144 Real32(mapFactorF[2 + (i *
01145 7)]));
01146 _shadowSHL6->addUniformVariable("mapFactor4",
01147 Real32(mapFactorF[3 + (i *
01148 7)]));
01149 _shadowSHL6->addUniformVariable("mapFactor5",
01150 Real32(mapFactorF[4 + (i *
01151 7)]));
01152 _shadowSHL6->addUniformVariable("mapFactor6",
01153 Real32(mapFactorF[5 + (i *
01154 7)]));
01155 }
01156
01157 else
01158 {
01159 _shadowCmat->addChunk(_shadowSHL7);
01160 if(_activeFactorMap == 0)
01161 {
01162 _shadowCmat->addChunk(_shadowFactorMap2O);
01163 }
01164 else
01165 {
01166 _shadowCmat->addChunk(_shadowFactorMapO);
01167 }
01168
01169 _shadowSHL7->addUniformVariable("oldFactorMap", 7);
01170 _shadowSHL7->addUniformVariable("shadowMap1", 0);
01171 _shadowSHL7->addUniformVariable("shadowMap2", 1);
01172 _shadowSHL7->addUniformVariable("shadowMap3", 2);
01173 _shadowSHL7->addUniformVariable("shadowMap4", 3);
01174 _shadowSHL7->addUniformVariable("shadowMap5", 4);
01175 _shadowSHL7->addUniformVariable("shadowMap6", 5);
01176 _shadowSHL7->addUniformVariable("shadowMap7", 6);
01177 _shadowSHL7->addUniformVariable("firstRun", _firstRun);
01178 _shadowSHL7->addUniformVariable("intensity1",
01179 shadowIntensityF[0 +
01180 (i * 7)]);
01181 _shadowSHL7->addUniformVariable("intensity2",
01182 shadowIntensityF[1 +
01183 (i * 7)]);
01184 _shadowSHL7->addUniformVariable("intensity3",
01185 shadowIntensityF[2 +
01186 (i * 7)]);
01187 _shadowSHL7->addUniformVariable("intensity4",
01188 shadowIntensityF[3 +
01189 (i * 7)]);
01190 _shadowSHL7->addUniformVariable("intensity5",
01191 shadowIntensityF[4 +
01192 (i * 7)]);
01193 _shadowSHL7->addUniformVariable("intensity6",
01194 shadowIntensityF[5 +
01195 (i * 7)]);
01196 _shadowSHL7->addUniformVariable("intensity7",
01197 shadowIntensityF[6 +
01198 (i * 7)]);
01199 _shadowSHL7->addUniformVariable("texFactor1", texFactorF[0 +
01200 (i * 7)]);
01201 _shadowSHL7->addUniformVariable("texFactor2", texFactorF[1 +
01202 (i * 7)]);
01203 _shadowSHL7->addUniformVariable("texFactor3", texFactorF[2 +
01204 (i * 7)]);
01205 _shadowSHL7->addUniformVariable("texFactor4", texFactorF[3 +
01206 (i * 7)]);
01207 _shadowSHL7->addUniformVariable("texFactor5", texFactorF[4 +
01208 (i * 7)]);
01209 _shadowSHL7->addUniformVariable("texFactor6", texFactorF[5 +
01210 (i * 7)]);
01211 _shadowSHL7->addUniformVariable("texFactor7", texFactorF[6 +
01212 (i * 7)]);
01213 _shadowSHL7->addUniformVariable("lightPM1", shadowMatrixF[0 +
01214 (i * 7)]);
01215 _shadowSHL7->addUniformVariable("lightPM2", shadowMatrixF[1 +
01216 (i * 7)]);
01217 _shadowSHL7->addUniformVariable("lightPM3", shadowMatrixF[2 +
01218 (i * 7)]);
01219 _shadowSHL7->addUniformVariable("lightPM4", shadowMatrixF[3 +
01220 (i * 7)]);
01221 _shadowSHL7->addUniformVariable("lightPM5", shadowMatrixF[4 +
01222 (i * 7)]);
01223 _shadowSHL7->addUniformVariable("lightPM6", shadowMatrixF[5 +
01224 (i * 7)]);
01225 _shadowSHL7->addUniformVariable("lightPM7", shadowMatrixF[6 +
01226 (i * 7)]);
01227 _shadowSHL7->addUniformVariable("xFactor", Real32(xFactor));
01228 _shadowSHL7->addUniformVariable("yFactor", Real32(yFactor));
01229 _shadowSHL7->addUniformVariable("mapFactor1",
01230 Real32(mapFactorF[0 + (i *
01231 7)]));
01232 _shadowSHL7->addUniformVariable("mapFactor2",
01233 Real32(mapFactorF[1 + (i *
01234 7)]));
01235 _shadowSHL7->addUniformVariable("mapFactor3",
01236 Real32(mapFactorF[2 + (i *
01237 7)]));
01238 _shadowSHL7->addUniformVariable("mapFactor4",
01239 Real32(mapFactorF[3 + (i *
01240 7)]));
01241 _shadowSHL7->addUniformVariable("mapFactor5",
01242 Real32(mapFactorF[4 + (i *
01243 7)]));
01244 _shadowSHL7->addUniformVariable("mapFactor6",
01245 Real32(mapFactorF[5 + (i *
01246 7)]));
01247 _shadowSHL7->addUniformVariable("mapFactor7",
01248 Real32(mapFactorF[6 + (i *
01249 7)]));
01250 }
01251
01252 a->pushPartition((RenderPartition::CopyWindow |
01253 RenderPartition::CopyViewing |
01254 RenderPartition::CopyProjection |
01255 RenderPartition::CopyFrustum |
01256 RenderPartition::CopyNearFar |
01257 RenderPartition::CopyViewportSize),
01258 RenderPartition::StateSorting);
01259 {
01260 RenderPartition *pPart = a->getActivePartition();
01261
01262 pPart->addPreRenderCallback (
01263 &ShadowTreeHandler::setupAmbientModel);
01264 pPart->addPostRenderCallback(
01265 &ShadowTreeHandler::endAmbientModel );
01266
01267 pPart->setRenderTarget(_pSceneFBO);
01268 pPart->setDrawBuffer ( dBuffers );
01269
01270 Node *light = vLights[i].first;
01271 Node *parent = light->getParent();
01272
01273 if(parent != NULL)
01274 {
01275 a->pushMatrix(parent->getToWorld());
01276 }
01277
01278 if(_activeFactorMap == 0 && bCA1Cleared == false)
01279 {
01280 pPart->setBackground(_pClearBackground);
01281 bCA1Cleared = true;
01282 }
01283 else if(bCA2Cleared == false)
01284 {
01285 pPart->setBackground(_pClearBackground);
01286 bCA2Cleared = true;
01287 }
01288
01289 a->overrideMaterial(_shadowCmat, a->getActNode());
01290 _pStage->recurse(a, light);
01291 a->overrideMaterial( NULL, a->getActNode());
01292
01293 if(parent != NULL)
01294 {
01295 a->popMatrix();
01296 }
01297 }
01298 a->popPartition();
01299
01300 _firstRun = 0;
01301 if(_activeFactorMap == 0)
01302 _activeFactorMap = 1;
01303 else
01304 _activeFactorMap = 0;
01305 }
01306 }
01307
01308 shadowIntensityF.clear();
01309 texFactorF.clear();
01310 mapFactorF.clear();
01311 shadowMatrixF.clear();
01312 }
01313
01314
01315 void StdShadowMapHandler::render(RenderAction *a,
01316 DrawEnv *pEnv)
01317 {
01318 const ShadowStageData::LightStore &vLights =
01319 _pStageData->getLights();
01320
01321 const ShadowStageData::NodeStore &vTransparents =
01322 _pStageData->getTransparents();
01323
01324
01325 if(_pStageData->getShadowMaps().size() != vLights.size())
01326 {
01327 initShadowMaps();
01328 }
01329
01330 if(_bShadowMapsConfigured == false)
01331 {
01332 configureShadowMaps();
01333 }
01334
01335 if(_uiMapSize != _pStage->getMapSize())
01336 {
01337 updateShadowMapSize();
01338 }
01339
01340 if(_pSceneFBO == NULL)
01341 initSceneFBO(pEnv, true);
01342
01343 if(_width != pEnv->getPixelWidth () ||
01344 _height != pEnv->getPixelHeight() )
01345 {
01346 updateSceneFBOSize(pEnv, true);
01347 }
01348
01349 commitChanges();
01350
01351 if((_pStage->getMapSize() / 4) > _maxPLMapSize)
01352 _PLMapSize = _maxPLMapSize;
01353 else
01354 _PLMapSize = _pStage->getMapSize() / 4;
01355
01356
01357 _firstRun = 1;
01358
01359
01360 if(_pStage->getMapAutoUpdate() == true ||
01361 _pStage->_trigger_update == true )
01362 {
01363 _pPoly->setOffsetFill (true );
01364 _pPoly->setOffsetFactor(_pStage->getOffFactor());
01365 _pPoly->setOffsetBias (_pStage->getOffBias ());
01366
01367 createColorMapFBO(a, pEnv);
01368
01369
01370
01371 for(UInt32 t = 0;t < vTransparents.size();++t)
01372 {
01373 vTransparents[t]->setTravMask(0);
01374 }
01375
01376
01377 createShadowMapsFBO(a, pEnv);
01378
01379
01380
01381 for(UInt32 t = 0;t < vTransparents.size();++t)
01382 {
01383 vTransparents[t]->setTravMask(TypeTraits<UInt32>::BitsSet);
01384 }
01385
01386
01387 createShadowFactorMapFBO(a, pEnv);
01388
01389 _pStage->_trigger_update = false;
01390 }
01391
01392 setupDrawCombineMap2(a);
01393 }
01394
01395 OSG_END_NAMESPACE
