Graphics.cpp

Go to the documentation of this file.

#include "Graphics.h"
#include "GameClass.h"
#include "gui.h" 

#include <WinSock2.h>
#include <WS2tcpip.h>
#include <Windows.h>

#include "DXUT.h"
//#include "SDKmisc.h"  // For DXUTFindDXSDKMediaFileCch
#include "DXUTgui.h"

#include "resource.h"
#include "polyobj.h"

Graphics::Graphics(HMI* g)
{
        gui = g;
        logger = g->game->logger;

        m_pddsLightningAndBackground[0] = m_pddsLightningAndBackground[1] = m_pddsLightningAndBackground[2] = nullptr;
        g_pEffect = nullptr;
        m_pddsCloudBaseMapAndNetwork = nullptr;
        for (short t = 0; t < humantextureC; t++)
                m_pddsAvatar[t] = nullptr;

        AddFontsToSystem();
}

Graphics::~Graphics()
{
        RemoveFontsFromSystem();
}

void Graphics::AddFontsToSystem() const
{
        logger->Log("Adding font resources...");

        // EuroseWide Heavy
        if (AddFontResourceEx(L"Fonts\\euroswh.ttf", FR_PRIVATE, nullptr) == 0)
        {
                MessageBoxW(nullptr, L"Error loading euroswh.ttf in Fonts\\...", L"Error loading font!", MB_ICONERROR | MB_OK);
                logger->Log("Error loading \"euroswh.ttf\" in Fonts\\...", Logger::Level::Error);
        }

        // DejaVu Sans Mono
        if (AddFontResourceEx(L"Fonts\\DejaVuSansMono.ttf", FR_PRIVATE, nullptr) == 0)
        {
                MessageBoxW(nullptr, L"Error loading DejaVuSansMono.ttf in Fonts\\...", L"Error loading font!", MB_ICONERROR | MB_OK);
                logger->Log("Error loading \"DejaVuSansMono.ttf\" in Fonts\\...", Logger::Level::Error);
        }

        // Lucida Handwriting
        if (AddFontResourceEx(L"Fonts\\lhandw.ttf", FR_PRIVATE, nullptr) == 0)
        {
                MessageBoxW(nullptr, L"Error loading lhandw.ttf in Fonts\\...", L"Error loading font!", MB_ICONERROR | MB_OK);
                logger->Log("Error loading \"lhandw.ttf\" in Fonts\\...", Logger::Level::Error);
        }
}

void Graphics::RemoveFontsFromSystem() const
{
        logger->Log("Removing font resources...");

        RemoveFontResourceEx(L"Fonts\\LicensePlate.ttf", FR_PRIVATE, nullptr);
        RemoveFontResourceEx(L"Fonts\\rcaf6-GIMP.ttf", FR_PRIVATE, nullptr);

        RemoveFontResourceEx(L"Fonts\\euroswh.ttf", FR_PRIVATE, nullptr);
        RemoveFontResourceEx(L"Fonts\\DejaVuSansMono.ttf", FR_PRIVATE, nullptr);
        RemoveFontResourceEx(L"Fonts\\lhandw.ttf", FR_PRIVATE, nullptr);

        RemoveFontResourceEx(L"Fonts\\cour.ttf", FR_PRIVATE, nullptr);
        RemoveFontResourceEx(L"Fonts\\pala.ttf", FR_PRIVATE, nullptr);
}

//--------------------------------------------------------------------------------------
// This function loads the mesh and ensures the mesh has normals; it also optimizes the 
// mesh for the graphics card's vertex cache, which improves performance by organizing 
// the internal triangle list for less cache misses.
//--------------------------------------------------------------------------------------
/*
HRESULT Graphics::LoadMesh(IDirect3DDevice9* pd3dDevice, WCHAR* strFileName, ID3DXMesh** ppMesh)
{
        ID3DXMesh* pMesh = nullptr;
        WCHAR str[MAX_PATH];
        HRESULT hr;

        // ChangeCockpit the mesh with D3DX and get back a ID3DXMesh*.  For this
        // sample we'll ignore the X file's embedded materials since we know 
        // exactly the model we're loading.  See the mesh samples such as
        // "OptimizedMesh" for a more generic mesh loading example.
        V_RETURN(DXUTFindDXSDKMediaFileCch(str, MAX_PATH, strFileName));

        V_RETURN(D3DXLoadMeshFromX(str, D3DXMESH_MANAGED, pd3dDevice, NULL, NULL, NULL, NULL, &pMesh));

        // Make sure there are normals which are required for lighting
        if (!(pMesh->GetFVF() & D3DFVF_NORMAL))
        {
                ID3DXMesh* pTempMesh;
                V(pMesh->CloneMeshFVF(pMesh->GetOptions(),
                        pMesh->GetFVF() | D3DFVF_NORMAL,
                        pd3dDevice, &pTempMesh));
                V(D3DXComputeNormals(pTempMesh, NULL));

                SAFE_RELEASE(pMesh);
                pMesh = pTempMesh;
        }

        // Optimize the mesh for this graphics card's vertex cache 
        // so when rendering the mesh's triangle list the vertices will 
        // cache hit more often so it won't have to re-execute the vertex shader 
        // on those vertices so it will improve perf.     
        DWORD *rgdwAdjacency = new DWORD[pMesh->GetNumFaces() * 3];
        if (rgdwAdjacency == nullptr)
                return E_OUTOFMEMORY;
        V(pMesh->GenerateAdjacency(1e-6f, rgdwAdjacency));
        V(pMesh->OptimizeInplace(D3DXMESHOPT_VERTEXCACHE, rgdwAdjacency, NULL, NULL, NULL));

        SAFE_DELETE_ARRAY(rgdwAdjacency);

        *ppMesh = pMesh;

        return S_OK;
}
*/

HRESULT Graphics::OnResetDevice(void) const
{
        HRESULT hr;
        if (g_pEffect)
        {
                V_RETURN(g_pEffect->OnResetDevice());
                gui->game->UpdateTrackedResource("g_pEffect", 2);
        }
        return S_OK;
}

void Graphics::OnDestroyDevice(void)
{
        SAFE_RELEASE(g_pEffect);
        gui->game->UpdateTrackedResource("g_pEffect", 3);

        char msg[99];

        // These are released once we get to STATUS_LOADING
        if (gui->game->displaystage < GameState::STATUS_LOADING)
        {
                for (short t = 0; t < 3; t++)
                {
                        SAFE_RELEASE(m_pddsLightningAndBackground[t]);
                        sprintf_s(msg, 99, "m_pddsLightningAndBackground[%i]", t);
                        gui->game->UpdateTrackedResource(msg, 3);
                }

                SAFE_RELEASE(m_pddsCloudBaseMapAndNetwork);
                gui->game->UpdateTrackedResource("m_pddsCloudBaseMapAndNetwork", 3);
        }

        for (short t = 1; t < humantextureC; t++)
        {
                if (m_pddsAvatar[t])
                {
                        SAFE_RELEASE(m_pddsAvatar[t]);
                        sprintf_s(msg, 99, "m_pddsAvatar[%i]", t);
                        gui->game->UpdateTrackedResource(msg, 3);
                }
        }
}

void Graphics::DrawImmigration(IDirect3DDevice9* pd3dDevice, float fElapsedTime)
{
        logger->AddToCallStack("Graphics::DrawImmigration");

        D3DXMATRIX matScale;
        D3DXMatrixScaling(&matScale, gui->game->displayscale, gui->game->displayscale, 1.0f); // both use Y due to locked 7x5 aspect
        gui->g_pTextSprite->SetTransform(&matScale);

        gui->g_pTextSprite->Begin(D3DXSPRITE_ALPHABLEND);

        gui->g_pTextSprite->Draw(gui->m_pddsGUIInterlace, nullptr, nullptr, nullptr, 0xFFFFFFFF);

        gui->DrawRXTXLights(&m_pddsCloudBaseMapAndNetwork);

        if (!gui->immigrationPassed)
                gui->DrawErrorBoxes();

        gui->g_pTextSprite->End();

        logger->AddToCallStack("Graphics::DrawImmigration HUD");

        gui->g_HUD.OnRender(fElapsedTime);

        if (!gui->tempobject.VB)
                return;

        logger->AddToCallStack("Graphics::DrawImmigration HUMAN");

#pragma region Human
        pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, false);
        pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW);
        pd3dDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESS);

        // Turn off D3D lighting, since we are providing our own vertex colors
        pd3dDevice->SetRenderState(D3DRS_LIGHTING, false);

        // ReSharper disable once CppEntityAssignedButNoRead
        HRESULT hr;
        D3DVIEWPORT9 mvp, oldmvp;
        // 49,271 and 128x128
        // all of these use displayscaley because the aspect is locked
        mvp.X = static_cast<DWORD>(49.0f * gui->game->displayscale);
        mvp.Y = static_cast<DWORD>(271.0f * gui->game->displayscale); 
        mvp.Width = static_cast<DWORD>(128.0f * gui->game->displayscale);
        mvp.Height = static_cast<DWORD>(128.0f * gui->game->displayscale);
        mvp.MinZ = 0.0001f; mvp.MaxZ = 0.01f;
        V(pd3dDevice->GetViewport(&oldmvp));
        V(pd3dDevice->SetViewport(&mvp));

        V(pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xFFC0B19C, 1.0f, 0));

        D3DXMATRIX matWorld, matrixBase;
        D3DXMatrixScaling(&matrixBase, gui->weight, gui->weight, gui->height);

        // Set up the rotation matrix to generate 1 full rotation (2*PI radians) 
        // every 1000 ms. To avoid the loss of precision inherent in very high 
        // floating point numbers, the system time is modulated by the rotation 
        // period before conversion to a radian angle.

        // Set up our view matrix. A view matrix can be defined given an eye point,
        // a point to lookat, and a direction for which way is up. Here, we set the
        // eye five units back along the z-axis and up three units, look at the
        // origin, and define "up" to be in the y-direction.
        D3DXVECTOR3 vEyePt(0.0f, 0.0f, 0.0005f);
        D3DXVECTOR3 vLookatPt(0.0f, 0.0f, 0.0f);
        D3DXVECTOR3 vUpVec(0.0f, 1.0f, 0.0f);
        D3DXMATRIX matView;
        D3DXMatrixLookAtRH(&matView, &vEyePt, &vLookatPt, &vUpVec);


        // For the projection matrix, we set up a perspective transform (which
        // transforms geometry from 3D view space to 2D viewport space, with
        // a perspective divide making objects smaller in the distance). To build
        // a perpsective transform, we need the field of view (1/4 pi is common),
        // the aspect ratio, and the near and far clipping planes (which define at
        // what distances geometry should be no longer be rendered).
        D3DXMATRIXA16 matProj;
        D3DXMatrixPerspectiveFovRH(&matProj, D3DX_PI / 4, 1.0f, 0.0001f, 0.01f);


        pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
        pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE); // TEXTURE is default
        pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_TFACTOR); // TEXTURE is default
        pd3dDevice->SetRenderState(D3DRS_TEXTUREFACTOR, gui->skintone);

        // Render the vertex buffer contents
        pd3dDevice->SetStreamSource(0, gui->tempobject.VB, 0, sizeof(D3DVERTEX));
        pd3dDevice->SetFVF(D3DFVF_VERTEX);
        bool firstone = true;
        static float fTimer = 0.0f;
        if (!gui->pBuffer)
                fTimer += fElapsedTime*1.0472f;

        for (short t = 0; t < gui->polyobj.GetComponents(); t++)
        {
                const s_mesh_component tempcomponent = gui->polyobj.GetComponent(t);
                if (tempcomponent.type == 100 || // torso
                        tempcomponent.type == 101 || // head
                        tempcomponent.type == 103 || // UL
                        tempcomponent.type == 104) // UR
                {
                        float fAngle = sinf(fTimer)*D3DX_PI*0.125f;
                        D3DXMatrixRotationX(&matWorld, -D3DX_HALFPI);
                        matWorld = matrixBase * matWorld;
                        D3DXMATRIX matTemp;
                        if (tempcomponent.type == 100 && !firstone && gui->g_HUD.GetRadioButton(IDC_MALE)->GetChecked())
                                D3DXMatrixTranslation(&matTemp, tempcomponent.nominalxyz.x, tempcomponent.nominalxyz.y + 0.00009f, tempcomponent.nominalxyz.z - 0.00165f);
                        else
                        {
                                D3DXMatrixTranslation(&matTemp, tempcomponent.nominalxyz.x, tempcomponent.nominalxyz.y, tempcomponent.nominalxyz.z - 0.00165f);
                                if (tempcomponent.type == 100 && gui->g_HUD.GetRadioButton(IDC_MALE)->GetChecked())
                                        firstone = false;
                        }
                        matWorld = matTemp * matWorld;
                        D3DXMatrixRotationY(&matTemp, fAngle);
                        matWorld = matWorld * matTemp;

                        if (tempcomponent.attachto == 0 || // unassigned
                                (tempcomponent.type == 100 && tempcomponent.attachto == 250) || // bare torso
                                tempcomponent.attachto == gui->g_HUD.GetSlider(IDC_NOSE)->GetValue() ||
                                tempcomponent.attachto == gui->g_HUD.GetSlider(IDC_EARS)->GetValue() ||
                                tempcomponent.attachto == gui->g_HUD.GetSlider(IDC_JAWLINE)->GetValue() ||
                                tempcomponent.attachto == gui->g_HUD.GetSlider(IDC_HAIRSTYLE)->GetValue() ||
                                tempcomponent.attachto == gui->g_HUD.GetSlider(IDC_HEAD)->GetValue() ||
                                tempcomponent.attachto == gui->g_HUD.GetSlider(IDC_FEATURE)->GetValue())
                        {
                                D3DXMATRIX mWorldViewProj = matWorld * matView * matProj;
                                V(g_pEffect->SetMatrix("matWorldViewProj", &mWorldViewProj));
                                V(g_pEffect->SetTexture("ColorMap", m_pddsAvatar[tempcomponent.texture]));
                                D3DXVECTOR4 tempvec4;
                                // age 18-88 is 0-1, 
                                float powage = powf(gui->age, 2.0f);
                                tempvec4.x = gui->haircolor.r*(1.0f - powage) + 1.0f*powage; // hair/lips
                                tempvec4.y = gui->haircolor.g*(1.0f - powage) + 1.0f*powage;
                                tempvec4.z = gui->haircolor.b*(1.0f - powage) + 1.0f*powage;
                                tempvec4.w = gui->stubbleFreckle;
                                V(g_pEffect->SetVector("Radiosity", &tempvec4));
                                tempvec4.x = gui->skintone.r; // skin
                                tempvec4.y = gui->skintone.g;
                                tempvec4.z = gui->skintone.b;
                                tempvec4.w = gui->age;
                                V(g_pEffect->SetVector("shiplight", &tempvec4));
                                tempvec4.x = gui->eyecolor.r; // eyes
                                tempvec4.y = gui->eyecolor.g;
                                tempvec4.z = gui->eyecolor.b;
                                tempvec4.w = 0.0f; // unused but used in Makeship to signal whether to use alpha as transparency or colorization
                                V(g_pEffect->SetVector("ambient", &tempvec4));
                                g_pEffect->Begin(nullptr, 0);
                                g_pEffect->BeginPass(7);
                                pd3dDevice->DrawPrimitive(D3DPT_TRIANGLELIST, tempcomponent.startvertex, tempcomponent.primitives);
                                g_pEffect->EndPass();
                                g_pEffect->End();
                        }
                        else if (tempcomponent.attachto == gui->g_HUD.GetSlider(IDC_FRAMETYPE)->GetValue() &&
                                gui->g_HUD.GetSlider(IDC_FRAMETYPE)->GetVisible())
                        {
                                // eye glasses
                                pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
                                pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
                                pd3dDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);

                                pd3dDevice->SetTransform(D3DTS_WORLD, &matWorld);
                                pd3dDevice->SetTransform(D3DTS_VIEW, &matView);
                                pd3dDevice->SetTransform(D3DTS_PROJECTION, &matProj);

                                pd3dDevice->SetTexture(0, m_pddsAvatar[tempcomponent.texture]);

                                pd3dDevice->DrawPrimitive(D3DPT_TRIANGLELIST, tempcomponent.startvertex, tempcomponent.primitives);
                        }
                }
        }

        V(pd3dDevice->SetViewport(&oldmvp)); // restore

        pd3dDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS);
        pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
        pd3dDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
        pd3dDevice->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);

#pragma endregion

        logger->AddToCallStack("Graphics::DrawImmigration DONE");
}

HRESULT Graphics::LoadShaderFile()
{
        HRESULT hr;
        D3DCAPS9 caps;
        V_RETURN(DXUTGetD3D9Device()->GetDeviceCaps(&caps));

        // Test for vs and ps versions
        if (caps.VertexShaderVersion >= D3DVS_VERSION(3, 0) &&
                caps.PixelShaderVersion >= D3DPS_VERSION(3, 0))
        {
                DWORD dwShaderFlags = D3DXSHADER_OPTIMIZATION_LEVEL3;

#ifdef DEBUG_VS
                dwShaderFlags |= D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT;
#endif
#ifdef DEBUG_PS
                dwShaderFlags |= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT;
#endif

                hr = D3DXCreateEffectFromResource(DXUTGetD3D9Device(), nullptr, MAKEINTRESOURCE(IDR_RCDATA1), nullptr, nullptr, dwShaderFlags, nullptr, &g_pEffect, nullptr);
                if (!SUCCEEDED(hr))
                {
                        gui->game->logger->Log("Graphics::LoadShaderFile D3DXCreateEffectFromResource", Logger::Level::Error, hr);
                        return hr;
                }
                gui->game->AddTrackedResource("g_pEffect", D3DPOOL_FORCE_DWORD);

                logger->Log("D3DXCreateEffectFromFile() succeeded...");
                V_RETURN(g_pEffect->SetTechnique("TShader"));
        }
        else
        {
                // if we are getting here it may be because a DLL is missing ... we package _43 of dx9 and dx10 as well as d3dcompiler
                MessageBox(nullptr, L"Requires a graphics adapter with DirectX 9.0c (vs3.0 and ps3.0 support) or higher!", L"HLSL Error", MB_ICONERROR | MB_OK);
                return E_FAIL;
        }

        return S_OK;
}