source: GTP/trunk/App/Games/Jungle_Rumble/src/RenderPass.cpp @ 1378

#include "dxstdafx.h"
#include ".\renderpass.h"

#include "Scene.h"
#include "GameScene.h"
#include "SkyBox.h"
#include "Renderer.h"

RenderPass::RenderPass(void)
{
        this->renderTargetSurfaceOld = NULL;    
        this->depthStencilSurfaceOld = NULL;

        this->renderTarget = NULL;
        this->dephStencilSurface = NULL;

        for(int i=0;i<SIZEOFCMD;i++)
        {
                this->executeCommand[i] = false;
        }

        D3DXMatrixIdentity(&this->viewMat);
        D3DXMatrixIdentity(&this->projMat);
        this->renderPassId = -1;

        this->usedRendererList = &this->myRendererList;
}

RenderPass::~RenderPass(void)
{
}

void RenderPass::setRenderer(Renderer* _renderer)
{
        this->renderer = _renderer;
        this->scene = this->renderer->myScene;
        this->device = this->scene->device;
}

void RenderPass::setSafeAndRestoreRenderTarget(bool _safeRenderTarget)
{
        this->safeRenderTarget = _safeRenderTarget;
}

void RenderPass::setRenderTarget(LPDIRECT3DSURFACE9 _renderTarget)
{
        this->renderTarget = _renderTarget;
}

void RenderPass::setDepthStencilSurface(LPDIRECT3DSURFACE9 _depthStencilSurface)
{
        this->dephStencilSurface = _depthStencilSurface;
}

void RenderPass::setViewMatrix(D3DXMATRIX &_viewMat) 
{
        this->viewMat = _viewMat;
}

void RenderPass::setProjectionMatrix(D3DXMATRIX &_projMat)
{
        this->projMat = _projMat;
}

void RenderPass::execute(int command, bool _execute)
{
        this->executeCommand[command] = _execute;
}

void RenderPass::executePass()
{
        this->device = this->scene->device;
        if(this->scene->activeRenderPass!=this) {
                this->scene->manager->printToConsole("activeRenderPass != executed RenderPass!!! -> call setActiveRenderPass in Scene!");
                return;
        }
        //asdf++;
        
        HRESULT hr;

        if(!this->device)
        {
                this->device = this->scene->device;
        }

        if(this->safeRenderTarget) {
                V( this->device->GetRenderTarget(0, &this->renderTargetSurfaceOld));
                V( this->device->GetDepthStencilSurface(&this->depthStencilSurfaceOld)) 
        }
        V( this->device->SetRenderTarget( 0, this->renderTarget) );

        if(this->dephStencilSurface!=NULL) {
                V( this->device->SetDepthStencilSurface( this->dephStencilSurface ) );
        }
        for(int i=0;i<SIZEOFCMD;i++)
        {
                if(this->executeCommand[i])
                {
                        switch(i)
                        {
                                case this->CMD_CLEARRENDERTARGETANDZBUFFER:
                                        this->scene->clearRenderTargetAndZBuffer();
                                        break;
                                case this->CMD_DOFRUSTUMCULLING:
                                        this->scene->doFrustumCulling();
                                        break;
                                case this->CMD_RENDERNODES:
                                        this->scene->renderNodes();
                                        break;
                        }
                }
        }

        //Restore old RenderTarget
        if(this->safeRenderTarget) {
                if(this->depthStencilSurfaceOld)
                {
                        V(this->device->SetDepthStencilSurface(this->depthStencilSurfaceOld));
                        SAFE_RELEASE(this->depthStencilSurfaceOld);
                }
                V(this->device->SetRenderTarget( 0, this->renderTargetSurfaceOld));
                SAFE_RELEASE(this->renderTargetSurfaceOld);
        }
}

D3DXMATRIX* RenderPass::getViewMatrix() 
{
        return &this->viewMat;
}

D3DXMATRIX* RenderPass::getProjectionMatrix()
{
        return &this->projMat;
}

D3DXMATRIX* RenderPass::getViewProjectionMatrix()
{
        return &this->viewProjMat;
}

D3DXMATRIX  RenderPass::getWorldViewMatrix(D3DXMATRIX *worldMat)
{
        D3DXMATRIX temp;
        D3DXMatrixMultiply(&temp, worldMat, &this->viewMat);
        return temp;
}

D3DXMATRIX  RenderPass::getWorldViewProjectionMatrix(D3DXMATRIX *worldMat)
{
        D3DXMATRIX temp;
        D3DXMatrixMultiply(&temp, worldMat, &this->viewProjMat);
        return temp;
}

void RenderPass::setRenderPassId(int _passId)
{
        this->renderPassId = _passId;
}

int RenderPass::getRenderPassId()
{
        if(this->renderPassId==-1) {
                this->scene->manager->printToConsole("RenderPass ID not set!!!!!");
        }
        return this->renderPassId;
}

void RenderPass::setScene(Scene &_scene)
{
        this->scene = &_scene;
        this->device = this->scene->device;
}

void RenderPass::calculateMatrices()
{
        D3DXMatrixMultiply(&this->viewProjMat, &this->viewMat, &this->projMat);
}

void RenderPass::useThisRendererList(std::vector<Renderer *>* _otherList)
{
        this->usedRendererList = _otherList;
}