KSG-Framework/DX11GraphicsApi.cpp

#include <d3d11.h>
#include <dxgi1_5.h>

#include "Camera3D.h"
#include "DLLRegister.h"
#include "DXBuffer.h"
#include "Globals.h"
#include "GraphicsApi.h"
#include "Image.h"
#include "Logging.h"
#include "Model3DList.h"
#include "Shader.h"
#include "Texture.h"
#include "TextureList.h"
#include "TextureModel.h"
#include "UIPixelShader.h"
#include "UIVertexShader.h"
#include "Window.h"
#include "World3D.h"

using namespace Framework;

struct TextureEffect
{
    bool enabled;
    float percentage;
};

DirectX11::DirectX11()
    : GraphicsApi(DIRECTX11),
      d3d11Device(0),
      d3d11Context(0),
      d3d11SpawChain(0),
      uiTexture(0),
      vertexShader(0),
      pixelShader(0),
      sampleState(0),
      rtview(0),
      dsView(0),
      depthStencilBuffer(0),
      depthStencilState(0),
      depthDisabledStencilState(0),
      blendStateAlphaBlend(0),
      vp(0),
      texturModel(0),
      texturRegister(new TextureList()),
      texturRS(0),
      meshRS(0),
      defaultTexture(0),
      diffuseLights(0),
      pointLights(0),
      indexBuffers(0),
      vertexBuffers(0)
{}

DirectX11::~DirectX11()
{
    for (int i = 0; i <= lastModelId; i++)
    {
        indexBuffers[i]->release();
        vertexBuffers[i]->release();
    }
    delete[] indexBuffers;
    delete[] vertexBuffers;
    if (diffuseLights) diffuseLights->release();
    if (pointLights) pointLights->release();
    if (defaultTexture) defaultTexture->release();
    if (texturRS) texturRS->Release();
    if (meshRS) meshRS->Release();
    if (texturModel) texturModel->release();
    texturRegister->release();
    if (blendStateAlphaBlend)
    {
        blendStateAlphaBlend->Release();
        blendStateAlphaBlend = NULL;
    }
    if (uiTexture)
    {
        uiTexture->release();
        uiTexture = NULL;
    }
    if (sampleState)
    {
        sampleState->Release();
        sampleState = NULL;
    }
    if (pixelShader)
    {
        pixelShader->release();
        pixelShader = NULL;
    }
    if (vertexShader)
    {
        vertexShader->release();
        vertexShader = NULL;
    }
    if (depthDisabledStencilState)
    {
        depthDisabledStencilState->Release();
        depthDisabledStencilState = NULL;
    }
    delete vp;
    vp = 0;
    if (dsView)
    {
        dsView->Release();
        dsView = NULL;
    }
    if (depthStencilState)
    {
        depthStencilState->Release();
        depthStencilState = NULL;
    }
    if (depthStencilBuffer)
    {
        depthStencilBuffer->Release();
        depthStencilBuffer = NULL;
    }
    if (rtview)
    {
        rtview->Release();
        rtview = NULL;
    }
    if (d3d11SpawChain)
    {
        d3d11SpawChain->Release();
        d3d11SpawChain = NULL;
    }
    if (d3d11Device)
    {
        d3d11Device->Release();
        d3d11Device = NULL;
    }
    if (d3d11Context)
    {
        d3d11Context->Release();
        d3d11Context = NULL;
        getDLLRegister()->releaseDLL("d3d11.dll");
        getDLLRegister()->releaseDLL("dxgi.dll");
    }
}

typedef HRESULT(__stdcall* CreateDXGIFactory2Function)(UINT, REFIID, void**);

typedef HRESULT(__stdcall* D3D11CreateDeviceAndSwapChainFunction)(IDXGIAdapter*,
    D3D_DRIVER_TYPE,
    HMODULE,
    UINT,
    const D3D_FEATURE_LEVEL*,
    UINT,
    UINT,
    const DXGI_SWAP_CHAIN_DESC*,
    IDXGISwapChain**,
    ID3D11Device**,
    D3D_FEATURE_LEVEL*,
    ID3D11DeviceContext**);

void DirectX11::initialize(
    NativeWindow* fenster, Vec2<int> backBufferSize, bool fullScreen)
{
    GraphicsApi::initialize(fenster, backBufferSize, fullScreen);
    //--------------------------------------------------------------------
    // Create Device

    HINSTANCE dxgiDLL = getDLLRegister()->loadDLL("dxgi.dll", "dxgi.dll");
    if (!dxgiDLL)
    {
        WMessageBox(fenster->getWindowHandle(),
            new Text("Fehler"),
            new Text("dxgi.dll konnte nicht gefunden werden."),
            MB_ICONERROR);
        return;
    }
    CreateDXGIFactory2Function createFactory
        = (CreateDXGIFactory2Function)GetProcAddress(
            dxgiDLL, "CreateDXGIFactory2");
    if (!createFactory)
    {
        getDLLRegister()->releaseDLL("dxgi.dll");
        WMessageBox(fenster->getWindowHandle(),
            new Text("Fehler"),
            new Text(
                "Der Einstiegspunkt CreateDXGIFactory2 fon dxgi.dll konnte "
                "nicht gefunden werden."),
            MB_ICONERROR);
        return;
    }
    IDXGIFactory5* factory;
    HRESULT res = createFactory(0, __uuidof(IDXGIFactory5), (void**)&factory);
    if (FAILED(res))
    {
        getDLLRegister()->releaseDLL("dxgi.dll");
        Logging::error() << "ERROR DXGI: createFactory returned " << res
                         << "\n";
        WMessageBox(fenster->getWindowHandle(),
            new Text("Fehler"),
            new Text("createFactory ist Fehlgeschlagen."),
            MB_ICONERROR);
        return;
    }
    // search for gpu with max dedicated memory
    IDXGIAdapter* adapter = 0;
    IDXGIAdapter* usedAdapter = 0;
    unsigned __int64 dedicatedMemoryCount = 0;
    for (UINT adapterID = 0;
        DXGI_ERROR_NOT_FOUND != factory->EnumAdapters(adapterID, &adapter);
        ++adapterID)
    {
        DXGI_ADAPTER_DESC desc;
        adapter->GetDesc(&desc);

        if (dedicatedMemoryCount > desc.DedicatedVideoMemory)
        {
            continue;
        }
        dedicatedMemoryCount = desc.DedicatedVideoMemory;
        if (usedAdapter) usedAdapter->Release();
        usedAdapter = adapter;
    }

    HINSTANCE dll = getDLLRegister()->loadDLL("d3d11.dll", "d3d11.dll");
    if (!dll)
    {
        WMessageBox(fenster->getWindowHandle(),
            new Text("Fehler"),
            new Text("DirectX 11 konnte nicht gefunden werden."),
            MB_ICONERROR);
        return;
    }
    D3D11CreateDeviceAndSwapChainFunction createDeviceAndSwapChain
        = (D3D11CreateDeviceAndSwapChainFunction)GetProcAddress(
            dll, "D3D11CreateDeviceAndSwapChain");
    if (!createDeviceAndSwapChain)
    {
        getDLLRegister()->releaseDLL("d3d11.dll");
        getDLLRegister()->releaseDLL("dxgi.dll");
        WMessageBox(fenster->getWindowHandle(),
            new Text("Fehler"),
            new Text("Der Einstiegspunkt D3D11CreateDeviceAndSwapChain fon "
                     "DirectX 11 konnte nicht gefunden werden."),
            MB_ICONERROR);
        return;
    }

    // create a struct to hold information about the swap chain
    DXGI_SWAP_CHAIN_DESC scd;

    // clear out the struct for use
    ZeroMemory(&scd, sizeof(DXGI_SWAP_CHAIN_DESC));

    scd.Windowed = !fullScreen;
    scd.BufferCount = 2;
    scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    scd.SampleDesc.Count = 1;   // multisampling setting
    scd.SampleDesc.Quality = 0; // vendor-specific flag
    scd.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
    scd.OutputWindow = fenster ? fenster->getWindowHandle() : 0;
    scd.BufferDesc.Width = this->backBufferSize.x;
    scd.BufferDesc.Height = this->backBufferSize.y; // windowed/full-screen mode

    D3D_FEATURE_LEVEL featureLevel = D3D_FEATURE_LEVEL_11_0;
    D3D_FEATURE_LEVEL support = D3D_FEATURE_LEVEL_11_0;
    // create a device, device context and swap chain using the information in
    // the scd struct
    UINT flag = 0;
#ifdef _DEBUG
    if (debugDX) flag |= D3D11_CREATE_DEVICE_DEBUG;
#endif
    HRESULT result = createDeviceAndSwapChain(usedAdapter,
        D3D_DRIVER_TYPE_UNKNOWN,
        NULL,
        flag,
        &featureLevel,
        1,
        D3D11_SDK_VERSION,
        &scd,
        &d3d11SpawChain,
        &d3d11Device,
        &support,
        &d3d11Context);
    if (result != S_OK)
    {
        getDLLRegister()->releaseDLL("d3d11.dll");
        getDLLRegister()->releaseDLL("dxgi.dll");
        Logging::error() << "ERROR: D3D11CreateDeviceAndSwapChain returned "
                         << result << "\n";
        WMessageBox(fenster->getWindowHandle(),
            new Text("Fehler"),
            new Text("DirectX 11 konnte nicht initialisiert werden."),
            MB_ICONERROR);
        return;
    }
    ID3D11Texture2D* backBufferPtr;
    // Get the pointer to the back buffer.
    result = d3d11SpawChain->GetBuffer(
        0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr);
    if (result != S_OK)
    {
        Logging::error() << "ERROR: d3d11SpawChain->GetBuffer returned "
                         << result << "\n";
        WMessageBox(fenster->getWindowHandle(),
            new Text("Fehler"),
            new Text("DirectX 11 konnte nicht initialisiert werden."),
            MB_ICONERROR);
        return;
    }

    vp = new D3D11_VIEWPORT();
    memset(vp, 0, sizeof(D3D11_VIEWPORT));
    vp->Width = (float)this->backBufferSize.x;
    vp->Height = (float)this->backBufferSize.y;
    vp->MinDepth = 0.0f;
    vp->MaxDepth = 1.0f;
    deviceLock.lock();
    d3d11Context->RSSetViewports(1, vp);
    deviceLock.unlock();

    // Create the render target view with the back buffer pointer.
    deviceLock.lock();
    result = d3d11Device->CreateRenderTargetView(backBufferPtr, NULL, &rtview);
    deviceLock.unlock();
    if (result != S_OK)
    {
        Logging::error()
            << "ERROR: d3d11Device->CreateRenderTargetView returned " << result
            << "\n";
        WMessageBox(fenster->getWindowHandle(),
            new Text("Fehler"),
            new Text("DirectX 11 konnte nicht initialisiert werden."),
            MB_ICONERROR);
        return;
    }
    // Release pointer to the back buffer as we no longer need it.
    backBufferPtr->Release();
    // Initialize the description of the depth buffer.
    D3D11_TEXTURE2D_DESC depthBufferDesc;
    ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
    // Set up the description of the depth buffer.
    depthBufferDesc.Width = this->backBufferSize.x;
    depthBufferDesc.Height = this->backBufferSize.y;
    depthBufferDesc.MipLevels = 1;
    depthBufferDesc.ArraySize = 1;
    depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
    depthBufferDesc.SampleDesc.Count = 1;
    depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
    // Create the texture for the depth buffer using the filled out description.
    deviceLock.lock();
    result = d3d11Device->CreateTexture2D(
        &depthBufferDesc, NULL, &depthStencilBuffer);
    deviceLock.unlock();
    if (result != S_OK)
    {
        Logging::error() << "ERROR: d3d11Device->CreateTexture2D returned "
                         << result << "\n";
        WMessageBox(fenster->getWindowHandle(),
            new Text("Fehler"),
            new Text("DirectX 11 konnte nicht initialisiert werden."),
            MB_ICONERROR);
        return;
    }
    // Initialize the description of the stencil state.
    D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
    ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));

    // Set up the description of the stencil state.
    depthStencilDesc.DepthEnable = true;
    depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
    depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS_EQUAL;
    depthStencilDesc.StencilEnable = true;
    depthStencilDesc.StencilReadMask = 0xFF;
    depthStencilDesc.StencilWriteMask = 0xFF;
    // Stencil operations if pixel is front-facing.
    depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
    depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
    depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
    depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
    // Stencil operations if pixel is back-facing.
    depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
    depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
    depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
    depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
    // Create the depth stencil state.
    deviceLock.lock();
    result = d3d11Device->CreateDepthStencilState(
        &depthStencilDesc, &depthStencilState);
    deviceLock.unlock();
    if (result != S_OK)
    {
        Logging::error()
            << "ERROR: d3d11Device->CreateDepthStencilState returned " << result
            << "\n";
        WMessageBox(fenster->getWindowHandle(),
            new Text("Fehler"),
            new Text("DirectX 11 konnte nicht initialisiert werden."),
            MB_ICONERROR);
        return;
    }
    deviceLock.lock();
    d3d11Context->OMSetDepthStencilState(depthStencilState, 1);
    deviceLock.unlock();

    // Initialize the depth stencil view.
    D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
    ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));

    // Set up the depth stencil view description.
    depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
    depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;

    // Create the depth stencil view.
    deviceLock.lock();
    result = d3d11Device->CreateDepthStencilView(
        depthStencilBuffer, &depthStencilViewDesc, &dsView);
    deviceLock.unlock();
    if (result != S_OK)
    {
        Logging::error()
            << "ERROR: d3d11Device->CreateDepthStencilView returned " << result
            << "\n";
        WMessageBox(fenster->getWindowHandle(),
            new Text("Fehler"),
            new Text("DirectX 11 konnte nicht initialisiert werden."),
            MB_ICONERROR);
        return;
    }
    deviceLock.lock();
    d3d11Context->OMSetRenderTargets(1, &rtview, dsView);
    deviceLock.unlock();

    D3D11_DEPTH_STENCIL_DESC depthDisabledStencilDesc;
    // Clear the second depth stencil state before setting the parameters.
    ZeroMemory(&depthDisabledStencilDesc, sizeof(depthDisabledStencilDesc));

    // Now create a second depth stencil state which turns off the Z buffer for
    // 2D rendering.  The only difference is that DepthEnable is set to false,
    // all other parameters are the same as the other depth stencil state.
    depthDisabledStencilDesc.DepthEnable = false;
    depthDisabledStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
    depthDisabledStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
    depthDisabledStencilDesc.StencilEnable = true;
    depthDisabledStencilDesc.StencilReadMask = 0xFF;
    depthDisabledStencilDesc.StencilWriteMask = 0xFF;
    depthDisabledStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
    depthDisabledStencilDesc.FrontFace.StencilDepthFailOp
        = D3D11_STENCIL_OP_INCR;
    depthDisabledStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
    depthDisabledStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
    depthDisabledStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
    depthDisabledStencilDesc.BackFace.StencilDepthFailOp
        = D3D11_STENCIL_OP_DECR;
    depthDisabledStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
    depthDisabledStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;

    // Create the state using the device.
    deviceLock.lock();
    result = d3d11Device->CreateDepthStencilState(
        &depthDisabledStencilDesc, &depthDisabledStencilState);
    deviceLock.unlock();
    if (result != S_OK)
    {
        Logging::error()
            << "ERROR: d3d11Device->CreateDepthStencilState returned " << result
            << "\n";
        WMessageBox(fenster->getWindowHandle(),
            new Text("Fehler"),
            new Text("DirectX 11 konnte nicht initialisiert werden."),
            MB_ICONERROR);
        return;
    }
    //-------------------------------------------------
    // Shaders

    vertexShader = initializeVertexShader(
        (unsigned char*)UIVertexShader, sizeof(UIVertexShader));
    pixelShader = initializePixelShader(
        (unsigned char*)UIPixelShader, sizeof(UIPixelShader));

    // Create a texture sampler state description.
    D3D11_SAMPLER_DESC samplerDesc;
    samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
    samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.MipLODBias = 0.0f;
    samplerDesc.MaxAnisotropy = 1;
    samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
    samplerDesc.BorderColor[0] = 0;
    samplerDesc.BorderColor[1] = 0;
    samplerDesc.BorderColor[2] = 0;
    samplerDesc.BorderColor[3] = 0;
    samplerDesc.MinLOD = 0;
    samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;

    // Create the texture sampler state.
    deviceLock.lock();
    result = d3d11Device->CreateSamplerState(&samplerDesc, &sampleState);
    deviceLock.unlock();
    if (result != S_OK)
    {
        Logging::error() << "ERROR: d3d11Device->CreateSamplerState returned "
                         << result << "\n";
        WMessageBox(fenster->getWindowHandle(),
            new Text("Fehler"),
            new Text("DirectX 11 konnte nicht initialisiert werden."),
            MB_ICONERROR);
        return;
    }
    //---------------------------------------------------------------
    // Framework Backbuffer Texture
    Image* renderB = new Image(1);
    renderB->setAlpha3D(1);
    renderB->newImage(this->backBufferSize.x, this->backBufferSize.y, 0);

    uiTexture = createOrGetTexture("_f_Render_Image", renderB);
    ((DX11Texture*)uiTexture)->setUseMips(0);

    texturModel = new TextureModel(this, "_framework_gui_");
    texturModel->setSize(this->backBufferSize);
    texturModel->setTexture(dynamic_cast<Texture*>(uiTexture->getThis()));

    D3D11_BLEND_DESC blendState;
    ZeroMemory(&blendState, sizeof(D3D11_BLEND_DESC));
    blendState.AlphaToCoverageEnable = false;
    blendState.IndependentBlendEnable = false;
    blendState.RenderTarget[0].BlendEnable = true;
    blendState.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
    blendState.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
    blendState.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
    blendState.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ZERO;
    blendState.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ONE;
    blendState.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
    blendState.RenderTarget[0].RenderTargetWriteMask
        = D3D11_COLOR_WRITE_ENABLE_ALL;

    deviceLock.lock();
    d3d11Device->CreateBlendState(&blendState, &blendStateAlphaBlend);
    d3d11Context->OMSetBlendState(blendStateAlphaBlend, 0, 0xFFFFFFFF);
    deviceLock.unlock();

    // Setup Render Objekt

    vertexShader->useShader();
    deviceLock.lock();
    d3d11Context->PSSetSamplers(0, 1, &sampleState);
    deviceLock.unlock();
    pixelShader->useShader();

    D3D11_RASTERIZER_DESC rasterDesc;
    ZeroMemory(&rasterDesc, sizeof(rasterDesc));
    rasterDesc.AntialiasedLineEnable = false;
    rasterDesc.CullMode = D3D11_CULL_BACK;
    rasterDesc.DepthBiasClamp = 0.0f;
    rasterDesc.DepthClipEnable = true;
    rasterDesc.FillMode = D3D11_FILL_SOLID;
    rasterDesc.FrontCounterClockwise = false;
    rasterDesc.MultisampleEnable = false;
    rasterDesc.ScissorEnable = false;
    rasterDesc.SlopeScaledDepthBias = 0.0f;
    deviceLock.lock();
    d3d11Device->CreateRasterizerState(&rasterDesc, &texturRS);
    deviceLock.unlock();

    ZeroMemory(&rasterDesc, sizeof(rasterDesc));
    rasterDesc.AntialiasedLineEnable = false;
    rasterDesc.CullMode = D3D11_CULL_BACK;
    rasterDesc.DepthBiasClamp = 0.0f;
    rasterDesc.DepthClipEnable = true;
    rasterDesc.FillMode = D3D11_FILL_WIREFRAME;
    rasterDesc.FrontCounterClockwise = false;
    rasterDesc.MultisampleEnable = false;
    rasterDesc.ScissorEnable = false;
    rasterDesc.SlopeScaledDepthBias = 0.0f;
    deviceLock.lock();
    d3d11Device->CreateRasterizerState(&rasterDesc, &meshRS);

    d3d11Context->RSSetState(texturRS);
    deviceLock.unlock();

    Image* b = new Image();
    b->newImage(10, 10, 0xFFFFFFFF);
    defaultTexture = createOrGetTexture("_default_textur", b);

    diffuseLights = new DX11StructuredBuffer(
        sizeof(DiffuseLight), d3d11Device, d3d11Context, deviceLock);
    pointLights = new DX11StructuredBuffer(
        sizeof(PointLight), d3d11Device, d3d11Context, deviceLock);
}

void DirectX11::beginFrame(bool fill2D, bool fill3D, int fillColor)
{
    if (fill2D) uiTexture->zImage()->setColor(fillColor);
    if (fill3D || true)
    {
        float color[4];
        // Setup the color to clear the buffer.
        color[0] = ((fillColor >> 16) & 0xFF) / 255.f; // R
        color[1] = ((fillColor >> 8) & 0xFF) / 255.f;  // G
        color[2] = (fillColor & 0xFF) / 255.f;         // B
        color[3] = ((fillColor >> 24) & 0xFF) / 255.f; // A
        deviceLock.lock();
        d3d11Context->ClearRenderTargetView(rtview, color);
        deviceLock.unlock();
    }
    deviceLock.lock();
    // Bind the render target view and depth stencil buffer to the output render
    // pipeline.
    d3d11Context->OMSetRenderTargets(1, &rtview, dsView);
    // Clear the depth buffer.
    d3d11Context->ClearDepthStencilView(
        dsView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1, 0);
    // Set the depth stencil state.
    d3d11Context->OMSetDepthStencilState(depthStencilState, 1);
    deviceLock.unlock();
}

void DirectX11::renderObject(Model3D* zObj)
{
    if (!zObj->zModelData()) return;
    int curId = zObj->zModelData()->getId();
    if (curId < 0 || curId > lastModelId)
    {
        Framework::Logging::warning()
            << "DirectX11::renderObject: Model ID out of range: " << curId
            << " The model was not properly registered with DirectX11 during "
               "its creation. It can not be rendered by DirectX11.";
        return;
    }
    if (zObj->zModelData()->wasIndexBufferChanged())
    {
        this->indexBuffers[curId]->setData(
            (void*)zObj->zModelData()->getIndexBuffer());
        this->indexBuffers[curId]->setLength(
            zObj->zModelData()->getIndexCount() * sizeof(int));
        this->indexBuffers[curId]->copyToGPU();
    }
    if (zObj->zModelData()->wasVertexBufferChanged())
    {
        this->vertexBuffers[curId]->setData(
            (void*)zObj->zModelData()->zVertexBuffer());
        this->vertexBuffers[curId]->setLength(
            zObj->zModelData()->getVertexCount() * sizeof(Vertex3D));
        this->vertexBuffers[curId]->copyToGPU();
    }
    Mat4<float> trans = Mat4<float>::identity();
    int anz = zObj->calculateMatrices(trans, matrixBuffer);
    if (vertexShader)
        vertexShader->fillConstBuffer(
            (char*)matrixBuffer, 0, sizeof(Mat4<float>) * anz);
    float matirialBuffer[3]; // light factors (phong model)
    matirialBuffer[0] = zObj->getAmbientFactor();
    matirialBuffer[1] = zObj->getDiffusFactor();
    matirialBuffer[2] = zObj->getSpecularFactor();
    if (pixelShader)
        pixelShader->fillConstBuffer(
            (char*)matirialBuffer, 1, sizeof(float) * 3);
    unsigned int offset = 0;
    unsigned int es = (unsigned)this->vertexBuffers[curId]->getElementLength();
    ID3D11Buffer* vBuffer = this->vertexBuffers[curId]->zBuffer();
    deviceLock.lock();
    d3d11Context->IASetVertexBuffers(0, 1, &vBuffer, &es, &offset);
    deviceLock.unlock();
    Model3DTexture* zTexture = zObj->zTexture();
    int ind = 0;
    int current = 0;
    if (zObj->zEffectTexture())
    {
        ID3D11ShaderResourceView* v[1];
        DX11Texture* zEffectTexture = (DX11Texture*)zObj->zEffectTexture();
        if (zEffectTexture && zEffectTexture->needsUpdate())
            zEffectTexture->updateTextur();
        v[0] = *zEffectTexture;
        deviceLock.lock();
        d3d11Context->PSSetShaderResources(3, 1, v);
        deviceLock.unlock();
        TextureEffect e = {1, zObj->getEffectPercentage()};
        if (pixelShader)
            pixelShader->fillConstBuffer((char*)&e, 3, sizeof(TextureEffect));
    }
    else
    {
        TextureEffect e = {0, 0.f};
        if (pixelShader)
            pixelShader->fillConstBuffer((char*)&e, 3, sizeof(TextureEffect));
    }
    DXGI_FORMAT f = DXGI_FORMAT_R32_UINT;
    if (this->indexBuffers[curId]->getElementLength() == 2)
        f = DXGI_FORMAT_R16_UINT;
    if (this->indexBuffers[curId]->getElementLength() == 1)
        f = DXGI_FORMAT_R8_UINT;
    deviceLock.lock();
    d3d11Context->IASetIndexBuffer(this->indexBuffers[curId]->zBuffer(), f, 0);
    d3d11Context->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
    deviceLock.unlock();
    zObj->beforeRender(this, vertexShader, pixelShader);
    for (auto i = zObj->zModelData()->getPolygons(); i; ++i)
    {
        if (zObj->needRenderPolygon(ind))
        {
            Texture* t = zTexture->zPolygonTexture(ind);
            if (t && t->needsUpdate()) t->updateTextur();
            if (t)
            {
                ID3D11ShaderResourceView* v[3];
                v[0] = *(DX11Texture*)t;
                v[1] = *diffuseLights;
                v[2] = *pointLights;
                deviceLock.lock();
                d3d11Context->PSSetShaderResources(0, 3, v);
                d3d11Context->DrawIndexed(i->indexAnz, current, 0);
                deviceLock.unlock();
            }
            else
            {
                deviceLock.lock();
                d3d11Context->RSSetState(meshRS);
                ID3D11ShaderResourceView* v[3];
                v[0] = *(DX11Texture*)defaultTexture;
                v[1] = *diffuseLights;
                v[2] = *pointLights;
                d3d11Context->PSSetShaderResources(0, 3, v);
                d3d11Context->DrawIndexed(i->indexAnz, current, 0);
                d3d11Context->RSSetState(texturRS);
                deviceLock.unlock();
            }
        }
        ind++;
        current += i->indexAnz;
    }
    zObj->afterRender(this, pixelShader, vertexShader);
}

// Checks whether a sphere is in the visible space of the world and needs to be
// drawn
//  pos: The center of the sphere
//  radius: The radius of the sphere
//  dist: A pointer to a float where the square of the distance to the
//  camera position is stored if this function returns true and
//  the pointer is not 0
bool DirectX11::isInFrustrum(
    const Vec3<float>& pos, float radius, float* dist) const
{
    for (int i = 0; i < 6; i++)
    {
        if (frustrum[i] * pos + radius < 0) return 0;
    }
    if (dist) *dist = kamPos.distance(pos);
    return 1;
}

bool DirectX11::isInFrustrum(
    const Vec3<float>& pos, Vec3<float> radius, float* dist) const
{
    for (int i = 0; i < 6; i++)
    {
        float r = abs(frustrum[i].normal() * radius);
        if (frustrum[i] * pos + r < 0) return 0;
    }
    if (dist) *dist = kamPos.distance(pos);
    return 1;
}

void DirectX11::renderKamera(Cam3D* zKamera)
{
    deviceLock.lock();
    d3d11Context->RSSetViewports(1, (D3D11_VIEWPORT*)zKamera->zViewPort());
    deviceLock.unlock();

    Mat4<float> tmp = zKamera->getProjectionMatrix() * zKamera->getViewMatrix();

    frustrum[0].x = tmp.elements[3][0] + tmp.elements[0][0];
    frustrum[0].y = tmp.elements[3][1] + tmp.elements[0][1];
    frustrum[0].z = tmp.elements[3][2] + tmp.elements[0][2];
    frustrum[0].w = tmp.elements[3][3] + tmp.elements[0][3];

    frustrum[1].x = tmp.elements[3][0] - tmp.elements[0][0];
    frustrum[1].y = tmp.elements[3][1] - tmp.elements[0][1];
    frustrum[1].z = tmp.elements[3][2] - tmp.elements[0][2];
    frustrum[1].w = tmp.elements[3][3] - tmp.elements[0][3];

    frustrum[2].x = tmp.elements[3][0] - tmp.elements[1][0];
    frustrum[2].y = tmp.elements[3][1] - tmp.elements[1][1];
    frustrum[2].z = tmp.elements[3][2] - tmp.elements[1][2];
    frustrum[2].w = tmp.elements[3][3] - tmp.elements[1][3];

    frustrum[3].x = tmp.elements[3][0] + tmp.elements[1][0];
    frustrum[3].y = tmp.elements[3][1] + tmp.elements[1][1];
    frustrum[3].z = tmp.elements[3][2] + tmp.elements[1][2];
    frustrum[3].w = tmp.elements[3][3] + tmp.elements[1][3];

    frustrum[4].x = tmp.elements[2][0];
    frustrum[4].y = tmp.elements[2][1];
    frustrum[4].z = tmp.elements[2][2];
    frustrum[4].w = tmp.elements[2][3];

    frustrum[5].x = tmp.elements[3][0] - tmp.elements[2][0];
    frustrum[5].y = tmp.elements[3][1] - tmp.elements[2][1];
    frustrum[5].z = tmp.elements[3][2] - tmp.elements[2][2];
    frustrum[5].w = tmp.elements[3][3] - tmp.elements[2][3];

    for (int i = 0; i < 6; i++)
        frustrum[i].normalize();

    viewAndProj[0] = zKamera->getViewMatrix();
    viewAndProj[1] = zKamera->getProjectionMatrix();
    kamPos = zKamera->getWorldPosition();
    if (vertexShader)
        vertexShader->fillConstBuffer(
            (char*)viewAndProj, 1, sizeof(Mat4<float>) * 2);
    if (pixelShader)
        pixelShader->fillConstBuffer((char*)&kamPos, 0, sizeof(float) * 3);
    World3D* w = zKamera->zWorld();
    w->readLock().lock();
    int lc[] = {w->getDiffuseLightCount(), w->getPointLightCount()};
    pixelShader->fillConstBuffer((char*)lc, 2, sizeof(int) * 2);
    w->copyLight(diffuseLights, pointLights);
    int maxDist = 0;
    int minDist = 0x7FFFFFFF;
    Array<Model3D*> alphaModels;
    Array<int> distances;
    w->render([this, &minDist, &maxDist, &alphaModels, &lc, &distances](
                  Model3D* obj) {
        float dist;
        if (isInFrustrum(obj->getPos(), obj->getRadius(), &dist))
        {
            if ((int)dist > maxDist) maxDist = (int)dist;
            if ((int)dist < minDist) minDist = (int)dist;
            if (obj->hasAlpha())
            {
                alphaModels.add(obj);
                distances.add((int)dist);
            }
            else
            {
                pixelShader->fillConstBuffer((char*)lc, 2, sizeof(int) * 2);
                renderObject(obj);
            }
        }
    });
    maxDist++;
    if (alphaModels.getEntryCount())
    {
        int size = maxDist - minDist;
        int* index = new int[size];
        memset(index, 0, size * 4);
        Model3D** sorted = new Model3D*[size * alphaModels.getEntryCount()];
        auto dist = distances.begin();
        for (auto obj : alphaModels)
        {
            sorted[dist.val() * alphaModels.getEntryCount()
                   + index[dist.val()]++] = obj;
            dist++;
        }
        for (int i = 0; i < size; i++)
        {
            for (int j = 0; j < index[i]; j++)
            {
                renderObject(sorted[i * alphaModels.getEntryCount() + j]);
            }
        }
        delete[] index;
        delete[] sorted;
    }
    w->readLock().unlock();
}

void DirectX11::renderKamera(Cam3D* zKamera, Texture* zTarget)
{
    ID3D11RenderTargetView* texturRtView;
    DX11Texture* d11Textur = dynamic_cast<DX11Texture*>(zTarget);
    if (!d11Textur)
        throw "incompatible textur object was passed to renderKamera of "
              "DirectX11 GPU API";
    d11Textur->setRenderTarget(1);
    if (d11Textur->needsUpdate()) d11Textur->updateTextur();

    D3D11_TEXTURE2D_DESC depthBufferDesc;
    ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
    // Set up the description of the depth buffer.
    depthBufferDesc.Width = zTarget->zImage()->getWidth();
    depthBufferDesc.Height = zTarget->zImage()->getHeight();
    depthBufferDesc.MipLevels = 1;
    depthBufferDesc.ArraySize = 1;
    depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
    depthBufferDesc.SampleDesc.Count = 1;
    depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
    ID3D11Texture2D* txtDepthStencilBuffer;
    // Create the texture for the depth buffer using the filled out description.
    deviceLock.lock();
    HRESULT result = d3d11Device->CreateTexture2D(
        &depthBufferDesc, NULL, &txtDepthStencilBuffer);
    deviceLock.unlock();
    if (result != S_OK) throw "could not create depth Stencil buffer";
    // Initialize the depth stencil view.
    D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
    ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));

    // Set up the depth stencil view description.
    depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
    depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;

    ID3D11DepthStencilView* txtDsView;
    // Create the depth stencil view.
    deviceLock.lock();
    result = d3d11Device->CreateDepthStencilView(
        txtDepthStencilBuffer, &depthStencilViewDesc, &txtDsView);
    deviceLock.unlock();
    if (result != S_OK) throw "could not create depth stencil view";

    D3D11_RENDER_TARGET_VIEW_DESC renderTargetViewDesc;
    renderTargetViewDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
    renderTargetViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
    renderTargetViewDesc.Texture2D.MipSlice = 0;
    deviceLock.lock();
    result = d3d11Device->CreateRenderTargetView(
        (ID3D11Texture2D*)*d11Textur, &renderTargetViewDesc, &texturRtView);
    deviceLock.unlock();
    if (result != S_OK)
        throw "could not create render target view for given texture";
    deviceLock.lock();
    d3d11Context->OMSetRenderTargets(1, &texturRtView, txtDsView);

    float color[4] = {0, 0, 0, 0};
    d3d11Context->ClearRenderTargetView(texturRtView, color);
    d3d11Context->ClearDepthStencilView(
        txtDsView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1, 0);
    deviceLock.unlock();
    renderKamera(zKamera);
    result = d3d11SpawChain->Present(0, 0);
    if (result != S_OK) throw "could not present the rendered content";
    deviceLock.lock();
    d3d11Context->OMSetRenderTargets(1, &rtview, dsView);
    deviceLock.unlock();
    texturRtView->Release();
    txtDsView->Release();
    txtDepthStencilBuffer->Release();
}

void DirectX11::presentFrame()
{
    // Set the depth stencil state.
    deviceLock.lock();
    d3d11Context->OMSetDepthStencilState(depthDisabledStencilState, 1);
    deviceLock.unlock();

    uiTexture->updateTextur();

    deviceLock.lock();
    d3d11Context->RSSetViewports(1, vp);
    deviceLock.unlock();

    float screenAspect = (float)backBufferSize.x / (float)backBufferSize.y;
    Mat4<float> view
        = view.translation(Vec3<float>(0.f, 0.f, backBufferSize.y * 1.2075f));
    viewAndProj[0] = view;
    viewAndProj[1]
        = view.projektion((float)PI / 4.0f, screenAspect, 0.1f, 10000.f);
    kamPos = Vec3<float>(0.f, 0.f, backBufferSize.y * 1.2075f);
    if (vertexShader)
        vertexShader->fillConstBuffer(
            (char*)viewAndProj, 1, sizeof(Mat4<float>) * 2);
    if (pixelShader)
        pixelShader->fillConstBuffer((char*)&kamPos, 0, sizeof(float) * 3);

    if (fenster && !IsIconic(fenster->getWindowHandle()))
        renderObject(texturModel);
    HRESULT result = d3d11SpawChain->Present(0, 0);
    if (!SUCCEEDED(result))
    {
        deviceLock.lock();
        HRESULT res = d3d11Device->GetDeviceRemovedReason();
        deviceLock.unlock();
        WMessageBox(fenster ? fenster->getWindowHandle() : 0,
            new Text("Fehler"),
            new Text("Es ist ein Fehler beim rendern aufgetreten."),
            MB_ICONERROR);
    }
}

Image* DirectX11::zUIRenderImage() const
{
    return uiTexture->zImage();
}

Texture* DirectX11::createOrGetTexture(const char* name, Image* b)
{
    if (!d3d11Device)
    {
        if (b) b->release();
        return 0;
    }
    if (texturRegister->hasTexture(name))
    {
        Texture* ret = texturRegister->getTexture(name);
        if (b) ret->setImageZ(b);
        return ret;
    }
    Texture* ret = new DX11Texture(d3d11Device, d3d11Context, deviceLock);
    if (b) ret->setImageZ(b);
    texturRegister->addTexture(dynamic_cast<Texture*>(ret->getThis()), name);
    return ret;
}

typedef HRESULT(__stdcall* CreateDXGIFactory2Function)(UINT, REFIID, void**);

typedef HRESULT(__stdcall* D3D11CreateDeviceFunction)(IDXGIAdapter*,
    D3D_DRIVER_TYPE,
    HMODULE,
    UINT,
    D3D_FEATURE_LEVEL*,
    UINT,
    UINT,
    ID3D11Device**,
    D3D_FEATURE_LEVEL*,
    ID3D11DeviceContext**);

bool DirectX11::isAvailable()
{
    HINSTANCE dxgiDLL = getDLLRegister()->loadDLL("dxgi.dll", "dxgi.dll");
    if (!dxgiDLL) return 0;
    HINSTANCE d3d11DLL = getDLLRegister()->loadDLL("d3d11.dll", "d3d11.dll");
    if (!d3d11DLL)
    {
        getDLLRegister()->releaseDLL("dxgi.dll");
        return 0;
    }
    CreateDXGIFactory2Function createFactory
        = (CreateDXGIFactory2Function)GetProcAddress(
            dxgiDLL, "CreateDXGIFactory2");
    if (!createFactory)
    {
        getDLLRegister()->releaseDLL("dxgi.dll");
        getDLLRegister()->releaseDLL("d3d11.dll");
        return 0;
    }
    D3D11CreateDeviceFunction createDevice
        = (D3D11CreateDeviceFunction)GetProcAddress(
            d3d11DLL, "D3D11CreateDevice");
    if (!createDevice)
    {
        getDLLRegister()->releaseDLL("dxgi.dll");
        getDLLRegister()->releaseDLL("d3d11.dll");
        return 0;
    }
    IDXGIFactory4* factory;
    UINT createFactoryFlags = 0;
#if defined(_DEBUG)
    createFactoryFlags = DXGI_CREATE_FACTORY_DEBUG;
#endif
    HRESULT res = createFactory(
        createFactoryFlags, __uuidof(IDXGIFactory4), (void**)&factory);
    if (FAILED(res))
    {
        getDLLRegister()->releaseDLL("dxgi.dll");
        getDLLRegister()->releaseDLL("d3d11.dll");
        return 0;
    }
    int index = 0;
    UINT flag = 0;
#ifdef _DEBUG
    flag |= D3D11_CREATE_DEVICE_DEBUG;
#endif
    do
    {
        IDXGIAdapter1* current;
        res = factory->EnumAdapters1(index++, &current);
        if (res == S_OK)
        {
            DXGI_ADAPTER_DESC1 dxgiAdapterDesc1;
            current->GetDesc1(&dxgiAdapterDesc1);
            ID3D11Device* device = 0;
            ID3D11DeviceContext* context = 0;
            D3D_FEATURE_LEVEL level = D3D_FEATURE_LEVEL_11_0;
            if ((dxgiAdapterDesc1.Flags & DXGI_ADAPTER_FLAG_SOFTWARE) == 0
                && SUCCEEDED(createDevice(current,
                    D3D_DRIVER_TYPE_UNKNOWN,
                    0,
                    flag,
                    &level,
                    1,
                    D3D11_SDK_VERSION,
                    &device,
                    0,
                    &context)))
            {
                context->Release();
                device->Release();
                current->Release();
                factory->Release();
                getDLLRegister()->releaseDLL("dxgi.dll");
                getDLLRegister()->releaseDLL("d3d11.dll");
                return 1;
            }
            current->Release();
        }
    } while (res != DXGI_ERROR_NOT_FOUND);
    factory->Release();
    getDLLRegister()->releaseDLL("dxgi.dll");
    getDLLRegister()->releaseDLL("d3d11.dll");
    return 0;
}

DX11Buffer* DirectX11::createIndexBuffer()
{
    return new DX11Buffer(sizeof(int),
        d3d11Device,
        d3d11Context,
        D3D11_BIND_INDEX_BUFFER,
        deviceLock);
}

DX11Buffer* DirectX11::createVertexBuffer()
{
    return new DX11Buffer(sizeof(Vertex3D),
        d3d11Device,
        d3d11Context,
        D3D11_BIND_VERTEX_BUFFER,
        deviceLock);
}

DX11VertexShader* DirectX11::initializeVertexShader(
    unsigned char* byteCode, int size)
{
    DX11VertexShader* vertexShader
        = new DX11VertexShader(d3d11Device, d3d11Context, deviceLock);
    vertexShader->setCompiledByteArray(byteCode, size);
    D3D11_INPUT_ELEMENT_DESC polygonLayout[5];
    // Create the vertex input layout description.
    // This setup needs to match the VertexType stucture in the ModelClass and
    // in the shader.
    polygonLayout[0].SemanticName = "POSITION";
    polygonLayout[0].SemanticIndex = 0;
    polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
    polygonLayout[0].InputSlot = 0;
    polygonLayout[0].AlignedByteOffset = 0;
    polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[0].InstanceDataStepRate = 0;

    polygonLayout[1].SemanticName = "TEXCOORD";
    polygonLayout[1].SemanticIndex = 0;
    polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
    polygonLayout[1].InputSlot = 0;
    polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[1].InstanceDataStepRate = 0;

    polygonLayout[2].SemanticName = "NORMAL";
    polygonLayout[2].SemanticIndex = 0;
    polygonLayout[2].Format = DXGI_FORMAT_R32G32B32_FLOAT;
    polygonLayout[2].InputSlot = 0;
    polygonLayout[2].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[2].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[2].InstanceDataStepRate = 0;

    polygonLayout[3].SemanticName = "KNOCHEN_ID";
    polygonLayout[3].SemanticIndex = 0;
    polygonLayout[3].Format = DXGI_FORMAT_R32_UINT;
    polygonLayout[3].InputSlot = 0;
    polygonLayout[3].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[3].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[3].InstanceDataStepRate = 0;

    polygonLayout[4].SemanticName = "VERTEX_ID";
    polygonLayout[4].SemanticIndex = 0;
    polygonLayout[4].Format = DXGI_FORMAT_R32_UINT;
    polygonLayout[4].InputSlot = 0;
    polygonLayout[4].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
    polygonLayout[4].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
    polygonLayout[4].InstanceDataStepRate = 0;

    vertexShader->createInputLayout(polygonLayout, 5);
    vertexShader->createConstBuffer(sizeof(Mat4<float>) * MAX_KNOCHEN_ANZ,
        vertexShader
            ->getFirstUninitializedBufferIndex()); // matrices for skeleton
                                                   // animations
    vertexShader->createConstBuffer(sizeof(Mat4<float>) * 2,
        vertexShader
            ->getFirstUninitializedBufferIndex()); // View and Projection Matrix
    return vertexShader;
}

DX11PixelShader* DirectX11::initializePixelShader(
    unsigned char* byteCode, int size)
{
    DX11PixelShader* pixelShader
        = new DX11PixelShader(d3d11Device, d3d11Context, deviceLock);
    pixelShader->setCompiledByteArray((unsigned char*)byteCode, size);

    pixelShader->createConstBuffer(sizeof(float) * 3,
        pixelShader->getFirstUninitializedBufferIndex()); // Camera position
    pixelShader->createConstBuffer(sizeof(float) * 3,
        pixelShader->getFirstUninitializedBufferIndex()); // material constants
                                                          // using phong model
    pixelShader->createConstBuffer(
        sizeof(int) * 2, pixelShader->getFirstUninitializedBufferIndex());
    pixelShader->createConstBuffer(
        sizeof(TextureEffect), pixelShader->getFirstUninitializedBufferIndex());
    // TODO: Remove Following Test Code
    int lc[] = {0, 0};
    pixelShader->fillConstBuffer((char*)lc, 2, sizeof(int) * 2);
    TextureEffect e = {0, 0.f};
    pixelShader->fillConstBuffer((char*)&e, 3, sizeof(TextureEffect));
    return pixelShader;
}

ID3D11DeviceContext* DirectX11::zContext()
{
    return d3d11Context;
}

DXBuffer* DirectX11::createStructuredBuffer(int eSize)
{
    return new DX11StructuredBuffer(
        eSize, d3d11Device, d3d11Context, deviceLock);
}

Model3DData* DirectX11::createModel(const char* name)
{
    Model3DData* result = GraphicsApi::createModel(name);
    if (result)
    {
        DX11Buffer** newIndexBuffers = new DX11Buffer*[lastModelId + 1];
        DX11Buffer** newVertexBuffers = new DX11Buffer*[lastModelId + 1];
        memcpy(
            newIndexBuffers, indexBuffers, sizeof(DX11Buffer*) * lastModelId);
        memcpy(
            newVertexBuffers, vertexBuffers, sizeof(DX11Buffer*) * lastModelId);
        indexBuffers[lastModelId] = createIndexBuffer();
        vertexBuffers[lastModelId] = createVertexBuffer();
    }
    return result;
}