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

#include "dxstdafx.h"
#include ".\OceanRenderer.h"
#include "GameManager.h"

OceanRenderer::OceanRenderer(void) : Renderer()
{ 
        this->setRenderPriority(20);
        this->rendererType |= Renderer::RENDERER_OCEAN;
}

OceanRenderer::~OceanRenderer(void)
{
        this->myScene->manager->releaseEffect(this->OceanEffect);
        this->OceanEffect = NULL;
}

void OceanRenderer::init() 
{
 
}

void OceanRenderer::setEffect(ID3DXEffect* effect) {
        this->OceanEffect = effect;

        //set technique handles:
        ShaderTechHandle = OceanEffect->GetTechniqueByName("PS20");
        ShaderTechHandleDepth = OceanEffect->GetTechniqueByName("PS20_Depth");

        //matrix handles:
        WorldViewProjectionHandle = OceanEffect->GetParameterByName(0, "wvpMatrix");
        WorldHandle = OceanEffect->GetParameterByName(0, "worldMatrix");
        WorldViewHandle = OceanEffect->GetParameterByName(0, "worldViewMatrix");
        ViewInverseHandle = OceanEffect->GetParameterByName(0, "viewInverseMatrix");

        //float handles:
        TimeHandle = OceanEffect->GetParameterByName(0, "time");
        RayHandle = OceanEffect->GetParameterByName(0, "forRaytracer");

        float nearPlane = this->myScene->getActiveCamera()->getNearClipping();
        float farPlane = this->myScene->getActiveCamera()->getFarClipping();
        FarPlaneMinusNearPlaneHandle = OceanEffect->GetParameterByName(0, "FarPlaneMinusNearPlane");
        OceanEffect->SetFloat(FarPlaneMinusNearPlaneHandle, farPlane - nearPlane);

        this->angle = 0;
}

void OceanRenderer::render() 
{
        this->device->BeginScene();
        SPTR<Node> node = this->myNode.lock();
        Object3d *obj = (Object3d *) (node.get());
    if(obj!=NULL && obj->isModelLoaded()) {
                //if(this->myScene->getActiveRenderPass() == NULL) {
                UINT numPasses = 0;
                switch(this->myScene->getActivePassId()) {
                        case Scene::PASS_NORMAL:
                                // set the technique to use
                                OceanEffect->SetTechnique( ShaderTechHandle );
                                
                                D3DXMatrixMultiply(&this->worldViewMat, &this->myScene->getWorldMatrix(), &this->myScene->getViewMatrix());
                                D3DXMatrixMultiply(&this->worldViewProjMat, &this->worldViewMat, &this->myScene->getProjectionMatrix());
                                D3DXMatrixInverse(&viewInverseMatrix, 0, &this->myScene->getViewMatrix());

                                OceanEffect->SetMatrix(WorldViewHandle, &this->worldViewMat);
                                OceanEffect->SetMatrix(WorldViewProjectionHandle, &this->worldViewProjMat);
                                OceanEffect->SetMatrix(WorldHandle, &this->myScene->getWorldMatrix());
                                OceanEffect->SetMatrix(ViewInverseHandle, &this->viewInverseMatrix);
                                
                                //this->angle += 0.01f;
                                //OceanEffect->SetFloat(TimeHandle, angle);
                                //textur-wellen:
                                this->angle += 0.05f;
                                OceanEffect->SetFloat(TimeHandle, (float)sin(angle / 4.0f));
                                
                                OceanEffect->SetBool(RayHandle, false);
                                
                                OceanEffect->Begin(&numPasses, 0);
                                for(UINT j = 0; j < numPasses; j++)
                                {               
                                        this->device->SetTexture(0, obj->Textures[0]);
                                        // begin effect render pass
                                        OceanEffect->BeginPass(j);
                                        
                                        this->device->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW );
                                        this->device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);

                                        this->device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
                                        this->device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
                                                                                
                                        if(obj->isPMesh()) {
                                                (*obj->getProgressiveMesh())->DrawSubset(0);    
                                        } else {
                                                (*obj->getMesh())->DrawSubset(0);
                                        }
                                        
                                        this->device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);

                                        // end effect render pass
                                        OceanEffect->EndPass();
                                }

                                this->device->SetRenderState(D3DRS_FOGENABLE, FALSE);

                                OceanEffect->End();
                                break;
                        case Scene::PASS_RAYTRACE:
                                // set the technique to use
                                //this->device->SetRenderState( D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_BLUE|D3DCOLORWRITEENABLE_GREEN|D3DCOLORWRITEENABLE_RED );
                                OceanEffect->SetTechnique( ShaderTechHandle );
                                
                                D3DXMatrixMultiply(&this->worldViewMat, &this->myScene->getWorldMatrix(), &this->myScene->getViewMatrix());
                                D3DXMatrixMultiply(&this->worldViewProjMat, &this->worldViewMat, &this->myScene->getProjectionMatrix());
                                D3DXMatrixInverse(&viewInverseMatrix, 0, &this->myScene->getViewMatrix());

                                OceanEffect->SetMatrix(WorldViewHandle, &this->worldViewMat);
                                OceanEffect->SetMatrix(WorldViewProjectionHandle, &this->worldViewProjMat);
                                OceanEffect->SetMatrix(WorldHandle, &this->myScene->getWorldMatrix());
                                OceanEffect->SetMatrix(ViewInverseHandle, &this->viewInverseMatrix);
                                
                                //this->angle += 0.01f;
                                //OceanEffect->SetFloat(TimeHandle, (float)sin(angle / 4.0f));
                                //OceanEffect->SetFloat(TimeHandle, angle);
                                OceanEffect->SetBool(RayHandle, true);
                                OceanEffect->CommitChanges();
                                
                                OceanEffect->Begin(&numPasses, 0);
                                for(UINT j = 0; j < numPasses; j++)
                                {               
                                        this->device->SetTexture(0, obj->Textures[0]);
                                        // begin effect render pass
                                        OceanEffect->BeginPass(j);
                                        
                                        this->device->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW );
                                        
                                        if(obj->isPMesh()) {
                                                (*obj->getProgressiveMesh())->DrawSubset(0);    
                                        } else {
                                                (*obj->getMesh())->DrawSubset(0);
                                        }
                                        
                                        // end effect render pass
                                        OceanEffect->EndPass();
                                }

                                this->device->SetRenderState(D3DRS_FOGENABLE, FALSE);

                                OceanEffect->End();
                                //this->device->SetRenderState( D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_ALPHA|D3DCOLORWRITEENABLE_BLUE|D3DCOLORWRITEENABLE_GREEN|D3DCOLORWRITEENABLE_RED );
                                break;
                        case Scene::PASS_DEPTH:
                                // set the technique to use
                                OceanEffect->SetTechnique( ShaderTechHandleDepth );
                                this->device->SetRenderState(D3DRS_FOGENABLE, FALSE);
                                D3DXMatrixMultiply(&this->worldViewMat, &this->myScene->getWorldMatrix(), &this->myScene->getViewMatrix());
                                D3DXMatrixMultiply(&this->worldViewProjMat, &this->worldViewMat, &this->myScene->getProjectionMatrix());
                                
                                OceanEffect->SetMatrix(WorldViewProjectionHandle, &this->worldViewProjMat);

                                D3DXMATRIX worldMat;
                                D3DXMatrixIdentity(&worldMat);
                                this->device->SetTransform( D3DTS_WORLD, &worldMat);
                                this->device->SetTransform( D3DTS_PROJECTION, this->myScene->getActiveCamera()->getProjectionMatrix());
                                this->device->SetTransform( D3DTS_VIEW, this->myScene->getActiveCamera()->getViewMatrix());
                                
                                //this->angle += 0.01f;
                                //OceanEffect->SetFloat(TimeHandle, (float)sin(angle / 4.0f));
                                //OceanEffect->SetFloat(TimeHandle, angle);
                                OceanEffect->SetBool(RayHandle, false);
                                OceanEffect->CommitChanges();
                                
                                OceanEffect->Begin(&numPasses, 0);
                                for(UINT j = 0; j < numPasses; j++)
                                {               
                                        this->device->SetTexture(0, obj->Textures[0]);
                                        // begin effect render pass
                                        OceanEffect->BeginPass(j);
                                        
                                        this->device->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW );
                                        
                                        if(obj->isPMesh()) {
                                                (*obj->getProgressiveMesh())->DrawSubset(0);    
                                        } else {
                                                (*obj->getMesh())->DrawSubset(0);
                                        }
                                        
                                        // end effect render pass
                                        OceanEffect->EndPass();
                                }

                                this->device->SetRenderState(D3DRS_FOGENABLE, FALSE);

                                OceanEffect->End();
                                break;
                }
        }
        this->device->EndScene();
}

void OceanRenderer::OnLostDevice( void* pUserContext )
{
        HRESULT hr;
        this->myScene->manager->printToConsole(" OnLostDevice OceanRenderer");
        V( this->OceanEffect->OnLostDevice() );
}

void OceanRenderer::OnDestroyDevice( void* pUserContext )
{
        this->myScene->manager->printToConsole(" OnDestroyDevice OceanRenderer");
        this->myScene->manager->releaseEffect(this->OceanEffect);
        this->OceanEffect = NULL;
}

HRESULT OceanRenderer::OnResetDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext )
{
        this->device = pd3dDevice;
        this->OceanEffect = this->myScene->manager->getEffect(GameManager::EFFECT_OCEAN);
        if(!this->OceanEffect) {
                this->OceanEffect = this->myScene->manager->loadEffect(GameManager::EFFECT_OCEAN, L"shaders/Ocean.obj");
        }
        this->setEffect(this->OceanEffect);
        return S_OK;
}

bool OceanRenderer::isLowerThan(Renderer* renderer)
{
        return this->getRenderPriority() < renderer->getRenderPriority();
}