KSG-Framework/DX9GraphicsApi.cpp

#include "DX9GraphicsApi.h"

#include <d3d9.h>

#include "Camera3D.h"
#include "DLLRegister.h"
#include "DX9Texture.h"
#include "Globals.h"
#include "Image.h"
#include "Screen.h"
#include "Timer.h"
#include "Window.h"
#include "World3D.h"

using namespace Framework;

DirectX9::DirectX9()
    : GraphicsApi(DIRECTX9),
      pDirect3D(0),
      pDevice(0),
      pBackBuffer(0),
      backRect(new D3DLOCKED_RECT())
{
    uiImage = new Image(1);
}

DirectX9::~DirectX9()
{
    backRect->pBits = NULL;
    delete backRect;
    if (pBackBuffer)
    {
        pBackBuffer->Release();
        pBackBuffer = NULL;
    }
    if (pDevice)
    {
        pDevice->Release();
        pDevice = NULL;
    }
    if (pDirect3D)
    {
        pDirect3D->Release();
        pDirect3D = NULL;
        getDLLRegister()->releaseDLL("d3d9.dll");
    }
    uiImage->release();
}

typedef IDirect3D9*(__stdcall* D3D9CreateFunction)(UINT);

void DirectX9::initialize(
    NativeWindow* fenster, Vec2<int> backBufferSize, bool fullScreen)
{
    GraphicsApi::initialize(fenster, backBufferSize, fullScreen);

    HINSTANCE dll = getDLLRegister()->loadDLL("d3d9.dll", "d3d9.dll");
    if (!dll)
    {
        WMessageBox(fenster ? fenster->getWindowHandle() : 0,
            new Text("Fehler"),
            new Text("DirectX 9 konnte nicht gefunden werden."),
            MB_ICONERROR);
        return;
    }
    D3D9CreateFunction direct3DCreate9
        = (D3D9CreateFunction)GetProcAddress(dll, "Direct3DCreate9");
    if (!direct3DCreate9)
    {
        getDLLRegister()->releaseDLL("d3d9.dll");
        WMessageBox(fenster ? fenster->getWindowHandle() : 0,
            new Text("Fehler"),
            new Text("Der Einstiegspunkt Direct3DCreate9 fon DirectX 9 konnte "
                     "nicht gefunden werden."),
            MB_ICONERROR);
        return;
    }
    pDirect3D = direct3DCreate9(D3D_SDK_VERSION);

    D3DPRESENT_PARAMETERS d3dpp;
    ZeroMemory(&d3dpp, sizeof(d3dpp));
    d3dpp.Windowed = !fullScreen;
    d3dpp.hDeviceWindow = fenster ? fenster->getWindowHandle() : 0;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
    d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
    d3dpp.Flags = D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;
    d3dpp.BackBufferHeight = this->backBufferSize.y;
    d3dpp.BackBufferWidth = this->backBufferSize.x;

    uiImage->newImage(
        this->backBufferSize.x, this->backBufferSize.y, 0xFF000000);

    HRESULT result = pDirect3D->CreateDevice(D3DADAPTER_DEFAULT,
        D3DDEVTYPE_HAL,
        fenster->getWindowHandle(),
        D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE,
        &d3dpp,
        &pDevice);
    if (result != S_OK)
        WMessageBox(fenster ? fenster->getWindowHandle() : 0,
            new Text("Fehler"),
            new Text("DirectX 9 konnte nicht initialisiert werden."),
            MB_ICONERROR);
    if (pDevice)
        result = pDevice->GetBackBuffer(
            0, 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer);
    if (result != S_OK)
        WMessageBox(fenster ? fenster->getWindowHandle() : 0,
            new Text("Fehler"),
            new Text("DirectX 9 konnte nicht initialisiert werden."),
            MB_ICONERROR);
}

void DirectX9::beginFrame(bool fill2D, bool fill3D, int fillColor)
{
    if (fill2D) uiImage->setColor(fillColor);
}

void DirectX9::renderKamera(Cam3D* zKamera)
{
    Mat4<float> mat = zKamera->getProjectionMatrix();
    Mat4<float> inv = zKamera->getViewMatrix().getInverse();
    World3D* welt = zKamera->zWorld();
    Timer zm = Timer();
    zm.measureStart();
    for (int x = 0; x < zKamera->zViewPort()->width; x++)
    {
        for (int y = 0; y < zKamera->zViewPort()->height; y++)
        {
            Vec3<float> wPoint
                = Vec3<float>(x / (0.5f * zKamera->zViewPort()->width) - 1,
                    y / (0.5f * zKamera->zViewPort()->height) - 1,
                    0.1f);
            Vec3<float> wPoint2 = Vec3<float>(wPoint.x, wPoint.y, 1.f);
            wPoint.x = (wPoint.x * 0.1f) / mat.elements[0][0];
            wPoint.y = (wPoint.y * 0.1f) / mat.elements[1][1];
            wPoint2.x = wPoint2.x / mat.elements[0][0];
            wPoint2.y = wPoint2.y / mat.elements[1][1];
            wPoint = inv * wPoint;
            wPoint2 = inv * wPoint2;
            Vec3<float> wDir = wPoint2 - wPoint;
            uiImage->setPixelDP(x + (int)zKamera->zViewPort()->x,
                y + (int)zKamera->zViewPort()->y,
                welt->traceRay(wPoint, wDir));
        }
    }
    zm.measureEnd();
    Logging::error() << zm.getSekunden() << "\n";
}

void DirectX9::presentFrame()
{
    if (!uiImage->getBuffer()) return;
    HRESULT result;
    result = pBackBuffer->LockRect(backRect, 0, 0);
    if (result != S_OK)
    {
        WMessageBox(fenster ? fenster->getWindowHandle() : 0,
            new Text("Fehler"),
            new Text("Es ist ein Fehler beim rendern aufgetreten."),
            MB_ICONERROR);
    }
    // kopieren zum Screen
    int* bgBuff = uiImage->getBuffer();
    int tmpBr = sizeof(D3DCOLOR) * uiImage->getWidth();
    for (int y = 0, pitch = 0, bry = 0; y < uiImage->getHeight();
        ++y, pitch += backRect->Pitch, bry += uiImage->getWidth())
        memcpy(&((BYTE*)backRect->pBits)[pitch], (void*)&(bgBuff[bry]), tmpBr);
    // Beende Image
    result = pBackBuffer->UnlockRect();
    if (result != S_OK)
    {
        WMessageBox(fenster ? fenster->getWindowHandle() : 0,
            new Text("Fehler"),
            new Text("Es ist ein Fehler beim rendern aufgetreten."),
            MB_ICONERROR);
    }
    if (result != S_OK)
    {
        WMessageBox(fenster ? fenster->getWindowHandle() : 0,
            new Text("Fehler"),
            new Text("Es ist ein Fehler beim rendern aufgetreten."),
            MB_ICONERROR);
    }
    result = pDevice->Present(0, 0, 0, 0);
    if (result != S_OK)
    {
        WMessageBox(fenster ? fenster->getWindowHandle() : 0,
            new Text("Fehler"),
            new Text("Es ist ein Fehler beim rendern aufgetreten."),
            MB_ICONERROR);
    }
}

Texture* DirectX9::createOrGetTexture(
    const char* name, Image* b, TextureDirection dir)
{
    Texture* ret = new DX9Texture(dir);
    ret->setImageZ(b);
    return ret;
}

Image* DirectX9::zUIRenderImage() const
{
    return uiImage;
}

DXBuffer* DirectX9::createStructuredBuffer(int eSize)
{
    throw "Unsupported Operation for DirectX9 Graphics API. Use DirectX11 or "
          "12";
}