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

#include "dxstdafx.h"
#include ".\HUDRenderer.h"
#include "GameManager.h"
#include "UserPlayer.h"
#include "HUD.h"

HUDRenderer::HUDRenderer(void) : Renderer()
{
        this->setRenderPriority(300);
        this->rendererType |= Renderer::RENDERER_HUD;
        this->sprite = NULL;
}

HUDRenderer::~HUDRenderer(void)
{
        SAFE_RELEASE(this->myFont);
        SAFE_RELEASE(sprite);
        this->myFont = NULL;
        this->sprite = NULL;
}

void HUDRenderer::init() {
        // Create a D3DX font object
        this->setRenderPriority(60);
        D3DXCreateSprite(DXUTGetD3DDevice(),&sprite);
        D3DXCreateFont( this->device, 26, 0, FW_BOLD, 0, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, TEXT("Arial"), &myFont );
        fontColor = D3DCOLOR_ARGB(255,255,255,255);
        SetRect(&textRectangle, 0, this->myScene->manager->screenHeight-200, this->myScene->manager->screenWidth, this->myScene->manager->screenHeight);
        SetRect(&timeRectangle, 0, this->myScene->manager->screenHeight-100, this->myScene->manager->screenWidth - 20, this->myScene->manager->screenHeight);
        SetRect(&ammoRectangle, 0, this->myScene->manager->screenHeight-60, this->myScene->manager->screenWidth - 20, this->myScene->manager->screenHeight);
        SetRect(&helpRectangle, 10, this->myScene->manager->screenHeight-500, this->myScene->manager->screenWidth - 20, this->myScene->manager->screenHeight);

        
}

void HUDRenderer::render() 
{
        if(this->myScene->getActivePassId()==Scene::PASS_NORMAL) {
                this->device->BeginScene();
                SPTR<Node> node = this->myNode.lock();
                HUD *hud = (HUD *) (node.get());
                if(hud!=NULL) {
                        //disable z buffer:
                        this->device->SetRenderState(D3DRS_ZENABLE, FALSE);

                        // get the scene in order to receive players
                        GameScene* gs = (GameScene*)(this->myScene);
                        //get the sprite:
                        //LPD3DXSPRITE sprite = *hud->getSprite();
                        //create scale/rotate matrices
                        D3DXMATRIX mat;
                        D3DXMATRIX mat2;
                        //create surface descriptor
                        D3DSURFACE_DESC desc;
                        D3DSURFACE_DESC desc2;
                        
                        //draw crosshair:
                        hud->Textures[0]->GetLevelDesc(0, &desc);       //get texture size              
                        //calculate transfomation:
                        D3DXVECTOR3 center((FLOAT)desc.Width/2, (FLOAT)desc.Height/2, 0);
                        D3DXVECTOR2 trans((float)(this->myScene->getMousePos()[0]),(float)(this->myScene->getMousePos()[1]));
                        D3DXVECTOR2 scaling(hud->getScaleCrosshairX(),hud->getScaleCrosshairY());
                        //set matrix:
                        D3DXMatrixTransformation2D(&mat,NULL,0.0,&scaling,NULL,0,&trans);
                        sprite->SetTransform(&mat);
                        //draw crosshair:
                        sprite->Begin(D3DXSPRITE_ALPHABLEND);
                        sprite->Draw(hud->Textures[0], NULL, &center, NULL, 0xFFFFFFFF);

                        //draw radar:
                        hud->Textures[1]->GetLevelDesc(0, &desc);       //get texture size              
                        //calculate transfomation:
                        D3DXVECTOR2 rotPoint((FLOAT)desc.Width/2*hud->getScaleRadarX() + hud->getRadarOffsetX(), (FLOAT) this->myScene->manager->screenHeight - (desc.Height/2*hud->getScaleRadarY() + hud->getRadarOffsetY()));
                        trans = D3DXVECTOR2(rotPoint.x - (FLOAT)(gs->player->getPosition().x/this->myScene->getWidth()*desc.Width*hud->getScaleRadarX()),rotPoint.y - (FLOAT)(desc.Height*hud->getScaleRadarY() - (gs->player->getPosition().z/this->myScene->getDepth()*desc.Height*hud->getScaleRadarY())));
                        D3DXVECTOR2 trans2(trans.x, trans.y);
                        scaling = D3DXVECTOR2(hud->getScaleRadarX(),hud->getScaleRadarY());
                        float rotation = -(gs->player->myRotation.y);
                        //reset matrix:
                        D3DXMatrixIdentity(&mat);
                        D3DXMatrixIdentity(&mat2);
                        D3DXMATRIX res;
                        D3DXMatrixTransformation2D(&mat,0,0.0,&scaling,0,0.0f,&trans);
                        D3DXMatrixTransformation2D(&mat2,0,0.0,0,&rotPoint,rotation,0);
                        D3DXMatrixMultiply(&res, &mat, &mat2);
                        sprite->SetTransform(&res);
                        //draw radar:
                        sprite->Draw(hud->Textures[1], NULL, 0, 0, 0xFFFFFFFF);
                        
                        //draw ai players (enemies)
                        hud->Textures[2]->GetLevelDesc(0, &desc2);      //get texture size
                        //calculate location:
                        center = D3DXVECTOR3((FLOAT)desc2.Width/2, (FLOAT)desc2.Height/2, 0);
                        //get list:
                        std::list<SPTR<Node> > *playerList = ((GameScene *)this->myScene)->getPlayerList();
                        std::list<SPTR<Node> >::iterator it;
                        Player *activeOpponent = NULL;
                        for(it=playerList->begin();it!=playerList->end();it++) {
                                activeOpponent = ((Player *) (*it).get());
                                if(activeOpponent != (Player *)gs->player) {
                                        trans = D3DXVECTOR2(trans2.x + activeOpponent->getPosition().x/this->myScene->getWidth()*desc.Width*hud->getScaleRadarX(), trans2.y + (desc.Height*hud->getScaleRadarY() - (activeOpponent->getPosition().z/this->myScene->getDepth()*desc.Height*hud->getScaleRadarY())));
                                        //reset matrix:
                                        D3DXMatrixIdentity(&mat);
                                        D3DXMatrixIdentity(&mat2);
                                        D3DXMATRIX res;
                                        D3DXMatrixTransformation2D(&mat,0,0.0,0,0,0.0f,&trans);
                                        D3DXMatrixTransformation2D(&mat2,0,0.0,0,&rotPoint,rotation,0);
                                        D3DXMatrixMultiply(&res, &mat, &mat2);
                                        sprite->SetTransform(&res);
                                        //draw player:
                                        sprite->Draw(hud->Textures[2], NULL, &center, NULL, 0xFF0000FF);
                                }
                        }

                        //draw player:
                        trans = D3DXVECTOR2((FLOAT)(desc.Width/2*hud->getScaleRadarX() + hud->getRadarOffsetX()),(FLOAT) this->myScene->manager->screenHeight - (desc.Height/2*hud->getScaleRadarY() + hud->getRadarOffsetY()));
                        //reset matrix:
                        D3DXMatrixIdentity(&mat);
                        D3DXMatrixTransformation2D(&mat,0,0.0,0,0,0,&trans);
                        sprite->SetTransform(&mat);
                        //draw player:
                        sprite->Draw(hud->Textures[2], NULL, &center, NULL, 0xFFFF0000);
                        
                        //draw human player health logo & health bar:
                        hud->Textures[3]->GetLevelDesc(0, &desc);       //get texture size
                        hud->Textures[4]->GetLevelDesc(0, &desc2);
                        float offset = 20;
                        RECT rectangle;
                        float health = gs->player->getHealth();
                        if(health>100.0f) {
                                this->myScene->manager->printToConsole("Health over 100 percent!!!!");
                                health = 100.0f;
                        }
                        if (health<0.0f) {
                                this->myScene->manager->printToConsole("Health under 0 percent!!!!");
                                health = 0.0f;
                        }
                        SetRect(&rectangle, 0, 0, (int)(desc2.Width*health/100), (int)(desc2.Height)); 
                        scaling = D3DXVECTOR2(hud->getScaleUserPlayer(),hud->getScaleUserPlayer());
                        //reset matrix:
                        D3DXMatrixIdentity(&mat);
                        D3DXMatrixTransformation2D(&mat,0,0.0,&scaling,0,0.0f,0);
                        sprite->SetTransform(&mat);
                        //set logo position:
                        D3DXVECTOR3 pos (offset,offset,0.0f);
                        //draw health logo:
                        sprite->Draw(hud->Textures[3], NULL, NULL, &pos, 0xFFFFFFFF);
                        //set bar position:
                        pos = D3DXVECTOR3(offset + desc.Width + offset, offset, 0);
                        sprite->Draw(hud->Textures[4], &rectangle, NULL, &pos, 0xFFFFFFFF);

                        //draw ai players health logos & health bars:
                        hud->Textures[5]->GetLevelDesc(0, &desc);       //get texture size
                        hud->Textures[6]->GetLevelDesc(0, &desc2);      //get texture size
                        //scale according to xml settings
                        scaling = D3DXVECTOR2(hud->getScaleAIPlayer(),hud->getScaleAIPlayer());
                        D3DXVECTOR2 scalepos((float)this->myScene->manager->screenWidth, 0);
                        D3DXMatrixIdentity(&mat);
                        D3DXMatrixTransformation2D(&mat,&scalepos,0.0,&scaling,0,0.0f,0);
                        sprite->SetTransform(&mat);
                        //draw info for alle opponents:
                        float sum = offset;
                        for(it=playerList->begin();it!=playerList->end();it++) {
                                activeOpponent = ((Player *) (*it).get());
                                if(activeOpponent != (Player *)gs->player) {
                                        //set logo position:
                                        pos = D3DXVECTOR3((float)this->myScene->manager->screenWidth - desc.Width - offset,sum,0);
                                        //draw logo:
                                        sprite->Draw(hud->Textures[5], NULL, NULL, &pos, 0xFFFFFFFF);
                                        //set health bar position:
                                        health = activeOpponent->getHealth();
                                        if(health>100.0f) {
                                                this->myScene->manager->printToConsole("Health over 100 percent!!!!");
                                                health = 100.0f;
                                        }
                                        if (health<0.0f) {
                                                this->myScene->manager->printToConsole("Health under 0 percent!!!!");
                                                health = 0.0f;
                                        }
                                        SetRect(&rectangle, (int)(desc2.Width - desc2.Width*health/100), 0, (int)desc2.Width, (int)(desc2.Height));
                                        pos = D3DXVECTOR3((float)this->myScene->manager->screenWidth - desc.Width - 2*offset - desc2.Width + (int)(desc2.Width - desc2.Width*health/100),sum, 0);
                                        //draw health bar:
                                        sprite->Draw(hud->Textures[6], &rectangle, NULL, &pos, 0xFFFFFFFF);
                                        //next player position:
                                        sum += desc.Width + offset;
                                }
                        }

                        //reset matrix:
                        D3DXMatrixIdentity(&mat);
                        sprite->SetTransform(&mat);
                        
                        //time output:
                        std::ostringstream ostr;
                        ostr.str("");
                        ostr << "Time left: ";
                        ostr << hud->minutes;
                        ostr << " min ";
                        ostr << hud->seconds;
                        ostr << " sec";
                        std::string temp = ostr.str();
                        std::wstring time(temp.begin(), temp.end());
                        myFont->DrawText(sprite, time.c_str(), -1, &timeRectangle, DT_RIGHT, fontColor);
                        
                        //ammunition output:
                        ostr.str("");
                        ostr << "Ammo: ";
                        ostr << hud->ammoAmount;
                        temp = ostr.str();
                        std::wstring ammo(temp.begin(), temp.end());
                        myFont->DrawText(sprite, ammo.c_str(), -1, &ammoRectangle, DT_RIGHT, fontColor);

                        //message output:
                        if (hud->messagetimer < hud->messagethreshold) {
                                hud->messagetimer += hud->messagedt;
                                if(!hud->bHelp) {
                    myFont->DrawText(sprite, hud->messagestring.c_str(), -1, &textRectangle, DT_CENTER | DT_WORDBREAK, fontColor);
                                } else {
                                        myFont->DrawText(sprite, hud->messagestring.c_str(), -1, &helpRectangle, DT_LEFT | DT_WORDBREAK, fontColor);
                                }
                        }

                        //you win output:
                        if (hud->youwintimer < hud->youwinthreshold) {
                                hud->youwintimer += hud->youwindt;
                                //now draw the you win stuff:
                                std::list<HUD::Letter>::iterator iter;
                                for(UINT i = 0; i < hud->YouWin.size(); i++) {
                                        HUD::Letter *tempLetter = &hud->YouWin.at(i);
                                        scaling = D3DXVECTOR2(tempLetter->scale,tempLetter->scale);
                                        scalepos = D3DXVECTOR2(tempLetter->x - tempLetter->centerX,tempLetter->y - tempLetter->centerY);
                                        rotPoint = D3DXVECTOR2(tempLetter->x,tempLetter->y);
                                        rotation = hud->youwintimer * tempLetter->rotation;
                                        D3DXMatrixIdentity(&mat);
                                        D3DXMatrixTransformation2D(&mat,&scalepos,0.0,&scaling,&rotPoint,rotation,0);
                                        sprite->SetTransform(&mat);
                                        pos = D3DXVECTOR3(tempLetter->x, tempLetter->y, 0);
                                        center = D3DXVECTOR3((FLOAT)tempLetter->centerX, (FLOAT)tempLetter->centerY, 0);
                                        sprite->Draw(tempLetter->texture, NULL, &center, &pos, 0xFFFFFFFF);
                                }
                        }
                        //you lose output:
                        if (hud->youlosetimer < hud->youlosethreshold) {
                                hud->youlosetimer += hud->youlosedt;
                                //now draw the you lose stuff:
                                std::list<HUD::Letter>::iterator iter;
                                for(UINT i = 0; i < hud->YouLose.size(); i++) {
                                        HUD::Letter *tempLetter = &hud->YouLose.at(i);
                                        scaling = D3DXVECTOR2(tempLetter->scale,tempLetter->scale);
                                        scalepos = D3DXVECTOR2(tempLetter->x - tempLetter->centerX,tempLetter->y - tempLetter->centerY);
                                        rotPoint = D3DXVECTOR2(tempLetter->x,tempLetter->y);
                                        rotation = hud->youlosetimer * tempLetter->rotation;
                                        D3DXMatrixIdentity(&mat);
                                        D3DXMatrixTransformation2D(&mat,&scalepos,0.0,&scaling,&rotPoint,rotation,0);
                                        sprite->SetTransform(&mat);
                                        pos = D3DXVECTOR3(tempLetter->x, tempLetter->y, 0);
                                        center = D3DXVECTOR3((FLOAT)tempLetter->centerX, (FLOAT)tempLetter->centerY, 0);
                                        sprite->Draw(tempLetter->texture, NULL, &center, &pos, 0xFFFFFFFF);
                                }
                        }

                        //toasted output:
                        if (hud->toastedtimer < hud->toastedthreshold) {
                                hud->toastedtimer += hud->toasteddt;
                                //now draw the you lose stuff:
                                std::list<HUD::Letter>::iterator iter;
                                for(UINT i = 0; i < hud->Toasted.size(); i++) {
                                        HUD::Letter *tempLetter = &hud->Toasted.at(i);
                                        scaling = D3DXVECTOR2(tempLetter->scale,tempLetter->scale);
                                        scalepos = D3DXVECTOR2(tempLetter->x - tempLetter->centerX,tempLetter->y - tempLetter->centerY);
                                        rotPoint = D3DXVECTOR2(tempLetter->x,tempLetter->y);
                                        rotation = hud->toastedtimer * tempLetter->rotation;
                                        D3DXMatrixIdentity(&mat);
                                        D3DXMatrixTransformation2D(&mat,&scalepos,0.0,&scaling,&rotPoint,rotation,0);
                                        sprite->SetTransform(&mat);
                                        pos = D3DXVECTOR3(tempLetter->x, tempLetter->y, 0);
                                        center = D3DXVECTOR3((FLOAT)tempLetter->centerX, (FLOAT)tempLetter->centerY, 0);
                                        sprite->Draw(tempLetter->texture, NULL, &center, &pos, 0xFFFFFFFF);
                                }
                        }

                        sprite->End();

                        //deactivate textures
                        this->device->SetTexture(0, 0);

                        //enable z buffer:
                        this->device->SetRenderState(D3DRS_ZENABLE, TRUE);
                }
                this->device->EndScene();
        }
}

void HUDRenderer::OnLostDevice( void* pUserContext )
{
        this->myFont->OnLostDevice();
        this->sprite->OnLostDevice();
}

void HUDRenderer::OnDestroyDevice( void* pUserContext )
{
        SAFE_RELEASE(this->myFont);
        SAFE_RELEASE(sprite);
        this->myFont = NULL;
        this->sprite = NULL;
}

HRESULT HUDRenderer::OnResetDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext )
{
        this->device = pd3dDevice;
        D3DXCreateSprite(this->device,&sprite);
        D3DXCreateFont( this->device, 26, 0, FW_BOLD, 0, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, TEXT("Arial"), &myFont );
        fontColor = D3DCOLOR_ARGB(255,255,255,255);
        return S_OK;
}

bool HUDRenderer::isLowerThan(Renderer* renderer)
{
        //Unter der Annahme, dass es kein zweites HUD gibt!
        return this->getRenderPriority() < renderer->getRenderPriority();
}