spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include "wasdPipeline.h"
#include "Declarations.h"
#include "..\shared\Structs.h"
#include <D3D11.h>
#include <D3D10.h>
#include <D3DX11.h>
#include <vector>
#include <fstream>
#include "wasdDevice.h"

using namespace wasd;
using namespace std;

wasdPipeline::wasdPipeline(wasdDevice* device, vector<Vertex> vertices)
{
    setUpBuffers(vertices, device);
    setUpShaders(device);
    createInputLayout(device);
}

wasdPipeline::~wasdPipeline()
{
    VertexBuffer->Release();
    VertexBuffer = 0;
    IndexBuffer->Release();
    IndexBuffer = 0;
    pVS->Release();
    pPS->Release();
    VS->Release();
}

void wasdPipeline::createInputLayout(wasdDevice* device)
{
    D3D11_INPUT_ELEMENT_DESC layout[] = 
    {
        {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
        {"COLOR", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0},
    };
    device->CreateInputLayout(layout, 2, VS, &pLayout);
}

void wasdPipeline::setUpShaders(wasdDevice* device)
{
    ifstream pshader("pixelshader.cso", std::ios::in | std::ios::binary | std::ios::ate);
    if(!pshader)
    {
        MessageBox(NULL, L"Shaderdatei fehlt", L"Error", MB_ICONERROR | MB_OK);
        exit(0);
    }

    size_t fileSizeP = pshader.tellg();
    pshader.seekg(0, std::ios::beg);
    char* dataP = new char[fileSizeP];
    pshader.read(dataP, fileSizeP);
    pshader.close();

    D3D10CreateBlob(sizeof(dataP), &PS);
    delete[] dataP;

    ifstream shader("vertexshader.cso", std::ios::in | std::ios::binary | std::ios::ate);
    if(!shader)
    {
        MessageBox(NULL, L"Shaderdatei fehlt", L"Error", MB_ICONERROR | MB_OK);
        exit(0);
    }

    size_t fileSize = shader.tellg();
    shader.seekg(0, std::ios::beg);
    char* data = new char[fileSize];
    shader.read(data, fileSize);
    shader.close();

    D3D10CreateBlob(sizeof(data), &VS);
    delete[] data;

    device->CreateVertexAndPixelShader(VS, PS, &pVS, &pPS);
}

void wasdPipeline::setUpBuffers(vector<Vertex> vertices, wasdDevice* device)
{
    D3D11_BUFFER_DESC VertexBufferDesc, IndexBufferDesc;
    D3D11_SUBRESOURCE_DATA vertexData, IndexData;
    unsigned long* indices;

    Vertex* ver = new Vertex[vertices.size()];
    indices = new unsigned long[vertices.size()];
    for(int i = 0; i < vertices.size(); i++)
    {
        indices[i] = i;
        ver[i] = vertices[i];
    }

    VertexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    VertexBufferDesc.ByteWidth = sizeof(Vertex) * vertices.size();
    VertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    VertexBufferDesc.CPUAccessFlags = 0;
    VertexBufferDesc.MiscFlags = 0;

    vertexData.pSysMem = ver;
    vertexData.SysMemPitch = 0;
    vertexData.SysMemSlicePitch = 0;

    device->CreateBuffer(&VertexBufferDesc, &vertexData, &VertexBuffer);

    IndexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    IndexBufferDesc.ByteWidth = sizeof(unsigned long) * vertices.size();
    IndexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
    IndexBufferDesc.CPUAccessFlags = 0;
    IndexBufferDesc.MiscFlags = 0;

    IndexData.pSysMem = indices;
    device->CreateBuffer(&IndexBufferDesc, &IndexData, &IndexBuffer);

    delete[] ver;
    ver = 0;
    delete[] indices;
    indices = 0;

    UINT stride = sizeof(VertexBuffer);
    UINT offset = 0;
    device->IASetVertexBuffers(1, &VertexBuffer, &stride, &offset, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
    device->IASetIndexBuffer(IndexBuffer, DXGI_FORMAT_R32_TYPELESS);
}

void wasdPipeline::RenderFrame(wasdDevice* device, UINT vertexCount)
{
    device->RenderFrame(vertexCount);
}

C-/C++-Quelltext

#include "wasdDevice.h"
#include "..\shared\Structs.h"
#include "Declarations.h"
#include <iostream>

using namespace wasd;

wasdDevice::wasdDevice(HWND hWnd, bool fullscreen, int width, int height)
{
    delta = 0;
    fps = 0;
    last = 0;
    aktuell = 0;

    ZeroMemory(&scd, sizeof(DXGI_SWAP_CHAIN_DESC));

    scd.BufferCount = 1;
    scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    scd.OutputWindow = hWnd;
    scd.SampleDesc.Count = 4;
    if(fullscreen)
    {
        scd.Windowed = FALSE;
    }
    else
    {
        scd.Windowed = TRUE;  
    }

    D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_REFERENCE, NULL, NULL, NULL, NULL, D3D11_SDK_VERSION, &scd, &swapchain, &dev, NULL, &devcon);

    //Adresse des Backbuffers bekommen
    ID3D11Texture2D* pBackBuffer;
    swapchain->GetBuffer(0, _uuidof(ID3D11Texture2D), (LPVOID*) &pBackBuffer);

    //bufferadresse benutzen um Render-Taget zu setzen
    dev->CreateRenderTargetView(pBackBuffer, NULL, &backbuffer);
    pBackBuffer->Release();

    //Backbuffer als Rendertarget setzen
    devcon->OMSetRenderTargets(1, &backbuffer, NULL);

    //Viewport setzen
    D3D11_VIEWPORT viewport;
    ZeroMemory(&viewport, sizeof(D3D11_VIEWPORT));

    viewport.TopLeftX = 0;
    viewport.TopLeftY = 0;
    viewport.Width = (float) width;
    viewport.Height = (float) height;

    devcon->RSSetViewports(1, &viewport);

    std::cout<<"Initialisierung des wasdDevice erfolgreich"<<std::endl;

    last = GetCurrentTime();
}

wasdDevice::~wasdDevice()
{
    swapchain->Release();
    dev->Release();
    devcon->Release();
    backbuffer->Release();
}

void wasdDevice::computeDelta()
{
    aktuell = GetTickCount();
    delta = last - aktuell;
    last = aktuell;
    fps = 1000/delta;
}

DWORD wasdDevice::getDelta()
{
    return delta;
}

DWORD wasdDevice::getFPS()
{
    return fps;
}

void wasdDevice::IASetVertexBuffers(int numBuffers, ID3D11Buffer** buffer, UINT* strides, UINT* offsets, D3D_PRIMITIVE_TOPOLOGY tp)
{
    devcon->IASetVertexBuffers(0, numBuffers, buffer, strides, offsets);
    devcon->IASetPrimitiveTopology(tp);
}

void wasdDevice::IASetIndexBuffer(ID3D11Buffer* buffer, DXGI_FORMAT format)
{
    devcon->IASetIndexBuffer(buffer, format, 0);
}

void wasdDevice::CreateBuffer(D3D11_BUFFER_DESC* desc, D3D11_SUBRESOURCE_DATA* data, ID3D11Buffer** vertexBuffer)
{
    dev->CreateBuffer(desc, data, vertexBuffer);
}

void wasdDevice::RenderFrame(UINT vertexCount)
{
    //computeDelta();
    float color[4] = {1.0, 0 , 0 , 0};
    //devcon->ClearRenderTargetView(NULL, color);
    devcon->DrawIndexed(vertexCount, 0, 0);
    
}

void wasdDevice::CreateInputLayout(D3D11_INPUT_ELEMENT_DESC* ied, UINT numElements, ID3D10Blob* VS, ID3D11InputLayout** pLayout)
{
    dev->CreateInputLayout(ied, numElements, VS->GetBufferPointer(), VS->GetBufferSize(), pLayout);
    devcon->IASetInputLayout(*pLayout);
}

void wasdDevice::MapAndUnmap(ID3D11Buffer** VertexBuffer, Vertex vertices[])
{
    D3D11_MAPPED_SUBRESOURCE ms;
    devcon->Map(*VertexBuffer, NULL, D3D11_MAP_WRITE_DISCARD, NULL, &ms);
    memcpy(ms.pData, vertices, sizeof(vertices));
    devcon->Unmap(*VertexBuffer, NULL);
}

void wasdDevice::CreateVertexAndPixelShader(ID3D10Blob* VS, ID3D10Blob* PS, ID3D11VertexShader** pVS, ID3D11PixelShader** pPS)
{
    dev->CreateVertexShader(VS->GetBufferPointer(), VS->GetBufferSize(), NULL, pVS);
    dev->CreatePixelShader(PS->GetBufferPointer(), PS->GetBufferSize(), NULL, pPS);

    devcon->VSSetShader(*pVS, 0, 0);
    devcon->PSSetShader(*pPS, 0, 0);
}

void wasdDevice::present()
{
    swapchain->Present(0, 0);
}

C-/C++-Quelltext

#include "wasdGraphics.h"
#include <string>
#include <stdio.h>
#include "Declarations.h"
#include <iostream>
#include "..\shared\Structs.h"
#include "wasdDevice.h"
#include <SDL.h>
#include <SDL_syswm.h>
#include <stdlib.h>
#include "wasdPipeline.h"


using namespace wasd;

wasdGraphics::wasdGraphics(GraphicsInput i, std::vector<Vertex> vertices)
{
    if(i.initializeGraphics)
    {
        width = i.width;
        height = i.height;
        //SDL initialisieren
        SDL_Init(SDL_INIT_VIDEO);
        //Erzeugung der SDL_Surface
        if(i.fullscreen)
        {
            screen = SDL_CreateWindow(i.title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, i.width, i.height, SDL_WINDOW_FULLSCREEN | SDL_WINDOW_SHOWN);
        }
        else
        {
            screen = SDL_CreateWindow(i.title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, i.width, i.height, SDL_WINDOW_SHOWN);
        }
        if(!screen)
        {
            MessageBox(NULL, L"Erstellung des SDLWindows fehlgeschlagen", L"Error", MB_ICONERROR | MB_OK);
            exit(0);
        }
        else
        {
            std::cout<<"Initialisierung der SDLSurface erfolgreich\n";
        }
        wchar_t wtext[200];
        std::mbstowcs(wtext, i.title, strlen(i.title)+1);
        hWnd = FindWindow(NULL, wtext);

        //wasdDevice erzeugen
        device = new wasdDevice(hWnd, i.fullscreen, i.width, i.height);
        if(!device)
        {
            MessageBox(NULL, L"Erstellung des wasdDevices fehlgeschlagen", L"Error", MB_ICONERROR | MB_OK);
            exit(0);
        }

        //wasdPipeline erzeugen
        pipeline = new wasdPipeline(device, vertices);
        if(!pipeline)
        {
            MessageBox(NULL, L"Erstellung der wasdPipeline fehlgeschlagen", L"Error", MB_ICONERROR | MB_OK);
            exit(0);
        }
    }
}

wasdGraphics::~wasdGraphics()
{
    delete device;

    SDL_Quit();
}

HWND wasdGraphics::getHWND() {return hWnd;}

void wasdGraphics::RenderFrame(std::vector<Vertex> vertices)
{
    pipeline->RenderFrame(device, vertices.size());
    device->present();
}