KSG-Framework/DX11GraphicsApi.cpp

#include "GraphicsApi.h"
#include "TexturModel.h"
#include "TexturList.h"
#include "Bild.h"
#include "Fenster.h"
#include "Shader.h"
#include "DXBuffer.h"
#include "Textur.h"
#include "Globals.h"
#include "DLLRegister.h"
#include "UIVertexShader.h"
#include "UIPixelShader.h"
#include "Kam3D.h"
#include "Welt3D.h"
#include "Model3DList.h"

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

using namespace Framework;

struct TexturEffect
{
    bool enabled;
    float percentage;
};

DirectX11::DirectX11()
    : GraphicsApi( DIRECTX11 ),
    d3d11Device( 0 ),
    d3d11Context( 0 ),
    d3d11SpawChain( 0 ),
    uiTextur( 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 TexturList() ),
    texturRS( 0 ),
    meshRS( 0 ),
    defaultTextur( 0 ),
    diffuseLights( 0 ),
    pointLights( 0 )
{}

DirectX11::~DirectX11()
{
    if( diffuseLights )
        diffuseLights->release();
    if( pointLights )
        pointLights->release();
    if( defaultTextur )
        defaultTextur->release();
    if( texturRS )
        texturRS->Release();
    if( meshRS )
        meshRS->Release();
    if( texturModel )
        texturModel->release();
    texturRegister->release();
    if( blendStateAlphaBlend )
    {
        blendStateAlphaBlend->Release();
        blendStateAlphaBlend = NULL;
    }
    if( uiTextur )
    {
        uiTextur->release();
        uiTextur = 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" );
    }
}

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( WFenster* fenster, Vec2<int> backBufferSize, bool fullScreen )
{
    if( d3d11Device )
        return GraphicsApi::initialize( fenster, backBufferSize, fullScreen );
    GraphicsApi::initialize( fenster, backBufferSize, fullScreen );
    //--------------------------------------------------------------------
    // Create Device

    HINSTANCE dll = getDLLRegister()->ladeDLL( "d3d11.dll", "d3d11.dll" );
    if( !dll )
    {
        WMessageBox( fenster->getFensterHandle(), 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" );
        WMessageBox( fenster->getFensterHandle(), 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->getFensterHandle() : 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( NULL,
                                               D3D_DRIVER_TYPE_HARDWARE,
                                               NULL,
                                               flag,
                                               &featureLevel,
                                               1,
                                               D3D11_SDK_VERSION,
                                               &scd,
                                               &d3d11SpawChain,
                                               &d3d11Device,
                                               &support,
                                               &d3d11Context );
    if( result != S_OK )
    {
        getDLLRegister()->releaseDLL( "d3d11.dll" );
        std::cout << "ERROR: D3D11CreateDeviceAndSwapChain returned " << result << "\n";
        WMessageBox( fenster->getFensterHandle(), 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 )
    {
        std::cout << "ERROR: d3d11SpawChain->GetBuffer returned " << result << "\n";
        WMessageBox( fenster->getFensterHandle(), 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;
    d3d11Context->RSSetViewports( 1, vp );

    // Create the render target view with the back buffer pointer.
    result = d3d11Device->CreateRenderTargetView( backBufferPtr, NULL, &rtview );
    if( result != S_OK )
    {
        std::cout << "ERROR: d3d11Device->CreateRenderTargetView returned " << result << "\n";
        WMessageBox( fenster->getFensterHandle(), 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.
    result = d3d11Device->CreateTexture2D( &depthBufferDesc, NULL, &depthStencilBuffer );
    if( result != S_OK )
    {
        std::cout << "ERROR: d3d11Device->CreateTexture2D returned " << result << "\n";
        WMessageBox( fenster->getFensterHandle(), 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.
    result = d3d11Device->CreateDepthStencilState( &depthStencilDesc, &depthStencilState );
    if( result != S_OK )
    {
        std::cout << "ERROR: d3d11Device->CreateDepthStencilState returned " << result << "\n";
        WMessageBox( fenster->getFensterHandle(), new Text( "Fehler" ), new Text( "DirectX 11 konnte nicht initialisiert werden." ), MB_ICONERROR );
        return;
    }
    d3d11Context->OMSetDepthStencilState( depthStencilState, 1 );

    // 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.
    result = d3d11Device->CreateDepthStencilView( depthStencilBuffer, &depthStencilViewDesc, &dsView );
    if( result != S_OK )
    {
        std::cout << "ERROR: d3d11Device->CreateDepthStencilView returned " << result << "\n";
        WMessageBox( fenster->getFensterHandle(), new Text( "Fehler" ), new Text( "DirectX 11 konnte nicht initialisiert werden." ), MB_ICONERROR );
        return;
    }
    d3d11Context->OMSetRenderTargets( 1, &rtview, dsView );

    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.
    result = d3d11Device->CreateDepthStencilState( &depthDisabledStencilDesc, &depthDisabledStencilState );
    if( result != S_OK )
    {
        std::cout << "ERROR: d3d11Device->CreateDepthStencilState returned " << result << "\n";
        WMessageBox( fenster->getFensterHandle(), new Text( "Fehler" ), new Text( "DirectX 11 konnte nicht initialisiert werden." ), MB_ICONERROR );
        return;
    }
    //-------------------------------------------------
    // Shaders
    vertexShader = new DX11VertexShader( d3d11Device, d3d11Context );
    vertexShader->setCompiledByteArray( (unsigned char*)UIVertexShader, sizeof( UIVertexShader ) );

    pixelShader = new DX11PixelShader( d3d11Device, d3d11Context );
    pixelShader->setCompiledByteArray( (unsigned char*)UIPixelShader, sizeof( UIPixelShader ) );

    D3D11_INPUT_ELEMENT_DESC polygonLayout[ 4 ];
    // 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;

    vertexShader->erstelleInputLayout( polygonLayout, 4 );
    vertexShader->erstelleConstBuffer( sizeof( Mat4< float > ) * MAX_KNOCHEN_ANZ, 0 ); // matrizen für skelett annimationen
    vertexShader->erstelleConstBuffer( sizeof( Mat4< float > ) * 2, 1 ); // View and Projection Matrix

    pixelShader->erstelleConstBuffer( sizeof( float ) * 3, 0 ); // Kamera Position
    pixelShader->erstelleConstBuffer( sizeof( float ) * 3, 1 ); // materialkonstanten nach phong model
    pixelShader->erstelleConstBuffer( sizeof( int ) * 2, 2 );
    pixelShader->erstelleConstBuffer( sizeof( TexturEffect ), 3 );
    // TODO: Remove Following Test Code
    int lc[] = { 0, 0 };
    pixelShader->füllConstBuffer( (char*)lc, 2, sizeof( int ) * 2 );
    TexturEffect e = { 0, 0.f };
    pixelShader->füllConstBuffer( (char*)&e, 3, sizeof( TexturEffect ) );


    // 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.
    result = d3d11Device->CreateSamplerState( &samplerDesc, &sampleState );
    if( result != S_OK )
    {
        std::cout << "ERROR: d3d11Device->CreateSamplerState returned " << result << "\n";
        WMessageBox( fenster->getFensterHandle(), new Text( "Fehler" ), new Text( "DirectX 11 konnte nicht initialisiert werden." ), MB_ICONERROR );
        return;
    }
    //---------------------------------------------------------------
    // Framework Backbuffer Texture
    Bild* renderB = new Bild( 1 );
    renderB->setAlpha3D( 1 );
    renderB->neuBild( this->backBufferSize.x, this->backBufferSize.y, 0 );

    uiTextur = createOrGetTextur( "_f_Render_Bild", renderB );

    texturModel = new TexturModel( this );
    texturModel->setSize( this->backBufferSize );
    texturModel->setTextur( dynamic_cast<Textur*>(uiTextur->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;

    d3d11Device->CreateBlendState( &blendState, &blendStateAlphaBlend );
    d3d11Context->OMSetBlendState( blendStateAlphaBlend, 0, 0xFFFFFFFF );

    // Setup Render Objekt

    vertexShader->benutzeShader();
    d3d11Context->PSSetSamplers( 0, 1, &sampleState );
    pixelShader->benutzeShader();

    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;
    d3d11Device->CreateRasterizerState( &rasterDesc, &texturRS );

    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;
    d3d11Device->CreateRasterizerState( &rasterDesc, &meshRS );

    d3d11Context->RSSetState( texturRS );

    Bild* b = new Bild();
    b->neuBild( 10, 10, 0xFFFFFFFF );
    defaultTextur = createOrGetTextur( "_default_textur", b );

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

void DirectX11::update()
{
    modelList->removeAll();
    if( texturModel )
    {
        texturModel->release();
        texturModel = 0;
    }
    if( pointLights )
        pointLights = (DX11StructuredBuffer*)pointLights->release();
    if( diffuseLights )
        diffuseLights = (DX11StructuredBuffer*)diffuseLights->release();
    if( texturRS )
    {
        texturRS->Release();
        texturRS = NULL;
    }
    if( meshRS )
    {
        meshRS->Release();
        meshRS = NULL;
    }
    texturRegister->leeren();
    if( defaultTextur )
        defaultTextur = (Textur*)defaultTextur->release();
    if( blendStateAlphaBlend )
    {
        blendStateAlphaBlend->Release();
        blendStateAlphaBlend = NULL;
    }
    if( uiTextur )
    {
        uiTextur->release();
        uiTextur = 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;
    }
    initialize( dynamic_cast<WFenster*>(fenster->getThis()), backBufferSize, fullScreen );
}

void DirectX11::beginFrame( bool fill2D, bool fill3D, int fillColor )
{
    if( fill2D )
        uiTextur->zBild()->setFarbe( 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
        d3d11Context->ClearRenderTargetView( rtview, color );
    }
    // Clear the depth buffer.
    d3d11Context->ClearDepthStencilView( dsView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1, 0 );
    // Bind the render target view and depth stencil buffer to the output render pipeline.
    d3d11Context->OMSetRenderTargets( 1, &rtview, dsView );
    // Set the depth stencil state.
    d3d11Context->OMSetDepthStencilState( depthStencilState, 1 );
}

void DirectX11::renderObject( Model3D* zObj )
{
    if( !zObj->zModelData() )
        return;
    int curId = zObj->zModelData()->getId();
    zObj->zModelData()->zDXVertexBuffer()->copieren();
    zObj->zModelData()->zDXIndexBuffer()->copieren();
    Mat4< float > trans = Mat4< float >::identity();
    int anz = zObj->errechneMatrizen( trans, matrixBuffer );
    if( vertexShader )
        vertexShader->füllConstBuffer( (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->füllConstBuffer( (char*)matirialBuffer, 1, sizeof( float ) * 3 );
    unsigned int offset = 0;
    unsigned int es = (unsigned)zObj->zModelData()->zDXVertexBuffer()->getElementLength();
    ID3D11Buffer* vBuffer = ((DX11Buffer*)zObj->zModelData()->zDXVertexBuffer())->zBuffer();
    d3d11Context->IASetVertexBuffers( 0, 1, &vBuffer, &es, &offset );
    Model3DTextur* zTextur = zObj->zTextur();
    int ind = 0;
    int current = 0;
    if( zObj->zEffectTextur() )
    {
        ID3D11ShaderResourceView* v[ 1 ];
        DX11Textur* zEffectTextur = (DX11Textur*)zObj->zEffectTextur();
        if( zEffectTextur && zEffectTextur->brauchtUpdate() )
            zEffectTextur->updateTextur();
        v[ 0 ] = *zEffectTextur;
        d3d11Context->PSSetShaderResources( 3, 1, v );
        TexturEffect e = { 1, zObj->getEffectPercentage() };
        if( pixelShader )
            pixelShader->füllConstBuffer( (char*)&e, 3, sizeof( TexturEffect ) );
    }
    else
    {
        TexturEffect e = { 0, 0.f };
        if( pixelShader )
            pixelShader->füllConstBuffer( (char*)&e, 3, sizeof( TexturEffect ) );
    }
    for( auto i = zObj->zModelData()->getPolygons(); i; i++ )
    {
        if( zObj->needRenderPolygon( ind ) )
        {
            Textur* t = zTextur->zPolygonTextur( ind );
            if( t && t->brauchtUpdate() )
                t->updateTextur();
            DXGI_FORMAT f = DXGI_FORMAT_R32_UINT;
            if( zObj->zModelData()->zDXIndexBuffer()->getElementLength() == 2 )
                f = DXGI_FORMAT_R16_UINT;
            if( zObj->zModelData()->zDXIndexBuffer()->getElementLength() == 1 )
                f = DXGI_FORMAT_R8_UINT;
            d3d11Context->IASetIndexBuffer( ((DX11Buffer*)zObj->zModelData()->zDXIndexBuffer())->zBuffer(), f, 0 );
            d3d11Context->IASetPrimitiveTopology( D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
            if( t )
            {
                ID3D11ShaderResourceView* v[ 3 ];
                v[ 0 ] = *(DX11Textur*)t;
                v[ 1 ] = *diffuseLights;
                v[ 2 ] = *pointLights;
                d3d11Context->PSSetShaderResources( 0, 3, v );
                d3d11Context->DrawIndexed( i->indexAnz, current, 0 );
            }
            else
            {
                d3d11Context->RSSetState( meshRS );
                ID3D11ShaderResourceView* v[ 3 ];
                v[ 0 ] = *(DX11Textur*)defaultTextur;
                v[ 1 ] = *diffuseLights;
                v[ 2 ] = *pointLights;
                d3d11Context->PSSetShaderResources( 0, 3, v );
                d3d11Context->DrawIndexed( i->indexAnz, current, 0 );
                d3d11Context->RSSetState( texturRS );
            }
        }
        ind++;
        current += i->indexAnz;
    }
}

// Überprüft, ob eine Kugel in dem Sichtbaren Raum der Welt liegt und gezeichnet werden muss
//  pos: Der Mittelpunkt der Kugel
//  radius: Der Radius der Kugel
//  dist: Einen Zeiger auf einen float, in dem das quadrat des Abstands zur Kammeraposition gespeichert wird, falls diese Funktion true zurückgiebt und der Zeiger nicht 0 ist
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.abstand( pos );
    return 1;
}

void DirectX11::renderKamera( Kam3D* zKamera )
{
    d3d11Context->RSSetViewports( 1, (D3D11_VIEWPORT*)zKamera->zViewPort() );

    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->füllConstBuffer( (char*)viewAndProj, 1, sizeof( Mat4< float > ) * 2 );
    if( pixelShader )
        pixelShader->füllConstBuffer( (char*)&kamPos, 0, sizeof( float ) * 3 );
    Welt3D* w = zKamera->zWelt();
    w->lock();
    int lc[] = { w->getDiffuseLightCount(), w->getPointLightCount() };
    pixelShader->füllConstBuffer( (char*)lc, 2, sizeof( int ) * 2 );
    w->copyLight( diffuseLights, pointLights );
    int maxDist = 0;
    int minDist = 0x7FFFFFFF;
    Model3DIterator* iterator = w->getIterator();
    Array<Model3D*> alphaModels;
    while( iterator->hasNext() )
    {
        Model3D* obj = iterator->getNext();
        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->hatAlpha() )
                alphaModels.add( obj );
            else
                renderObject( obj );
        }
    }
    iterator->release();
    maxDist++;
    if( alphaModels.getEintragAnzahl() )
    {
        int size = maxDist - minDist;
        int* index = new int[ size ];
        memset( index, 0, size * 4 );
        Model3D** sorted = new Model3D * [ size * alphaModels.getEintragAnzahl() ];
        for( auto obj : alphaModels )
        {
            float dist;
            dist = kamPos.abstand( obj->getPos() );
            if( isInFrustrum( obj->getPos(), obj->getRadius(), &dist ) )
            {
                int pos = (int)dist - minDist;
                sorted[ pos * alphaModels.getEintragAnzahl() + index[ pos ]++ ] = obj;
            }
        }
        for( int i = 0; i < size; i++ )
        {
            for( int j = 0; j < index[ i ]; j++ )
            {
                renderObject( sorted[ i * alphaModels.getEintragAnzahl() + j ] );
            }
        }
        delete[] index;
        delete[] sorted;
    }
    w->unlock();
}

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

    uiTextur->updateTextur();

    d3d11Context->RSSetViewports( 1, vp );

    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->füllConstBuffer( (char*)viewAndProj, 1, sizeof( Mat4< float > ) * 2 );
    if( pixelShader )
        pixelShader->füllConstBuffer( (char*)&kamPos, 0, sizeof( float ) * 3 );

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

Bild* DirectX11::zUIRenderBild() const
{
    return uiTextur->zBild();
}

Textur* DirectX11::createOrGetTextur( const char* name, Bild* b )
{
    if( !d3d11Device )
    {
        if( b )
            b->release();
        return 0;
    }
    if( texturRegister->hatTextur( name ) )
    {
        Textur* ret = texturRegister->getTextur( name );
        if( b )
            ret->setBildZ( b );
        return ret;
    }
    Textur* ret = new DX11Textur( d3d11Device, d3d11Context );
    if( b )
        ret->setBildZ( b );
    texturRegister->addTextur( dynamic_cast<Textur*>(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()->ladeDLL( "dxgi.dll", "dxgi.dll" );
    if( !dxgiDLL )
        return 0;
    HINSTANCE d3d11DLL = getDLLRegister()->ladeDLL( "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;
}

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

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