MyDemo

//RenderSystem.hpp
#ifndef RENDERSYSTEM_HPP
#define RENDERSYSTEM_HPP

#include <d3d11.h>
#include <d3dcompiler.h>
#include <DirectXMath.h>

#include "Sprite.hpp"

using namespace DirectX;

class RenderSystem
{
public:
    RenderSystem();
    ~RenderSystem();

    bool Initialize(HINSTANCE hInstance, HWND hWnd, LPCWSTR shaderFileName);

    void Clear();
    void Present();

    ID3D11Device *GetDevice() {return d3dDevice;};
    ID3D11DeviceContext *GetDeviceContext() {return d3dDeviceContext;};
    ID3D11VertexShader *GetVertexShader() {return vertexShader;};
    ID3D11PixelShader *GetPixelShader() {return pixelShader;};
    ID3D11InputLayout *GetInputLayout() {return inputLayout;};
    ID3D11Buffer *GetModelViewProjectionBuffer() {return modelViewProjectionBuffer;};

    void DrawSprite(Sprite *sprite);

private:
    D3D_FEATURE_LEVEL featureLevel;

    ID3D11Device *d3dDevice;
    ID3D11DeviceContext *d3dDeviceContext;
    IDXGISwapChain *swapChain;
    ID3D11RenderTargetView *backBufferTarget;

    ID3D11VertexShader *vertexShader;
    ID3D11PixelShader *pixelShader;
    ID3D11InputLayout *inputLayout;

    ID3D11Buffer *modelViewProjectionBuffer;
    XMMATRIX viewProjectionMatrix;
};

#endif

//RenderSystem.cpp
#include "RenderSystem.hpp"

RenderSystem::RenderSystem()
{
    featureLevel = D3D_FEATURE_LEVEL_11_1;

    d3dDevice = NULL;
    d3dDeviceContext = NULL;
    swapChain = NULL;
    backBufferTarget = NULL;

    vertexShader = NULL;
    pixelShader = NULL;
    inputLayout = NULL;

    modelViewProjectionBuffer = NULL;
}

bool RenderSystem::Initialize(HINSTANCE hInstance, HWND hWnd, LPCWSTR shaderFileName)
{
    D3D_FEATURE_LEVEL featureLevels[] =
    {
        D3D_FEATURE_LEVEL_11_1,
        D3D_FEATURE_LEVEL_11_0,
        D3D_FEATURE_LEVEL_10_1,
        D3D_FEATURE_LEVEL_10_0
    };

    UINT totalFeatureLevels = ARRAYSIZE(featureLevels);

    DXGI_SWAP_CHAIN_DESC swapChainDesc;
    ZeroMemory( &swapChainDesc, sizeof( swapChainDesc ) );
    swapChainDesc.BufferCount = 1;
    swapChainDesc.BufferDesc.Width = 800;
    swapChainDesc.BufferDesc.Height = 600;
    swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    swapChainDesc.BufferDesc.RefreshRate.Numerator = 60;
    swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
    swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    swapChainDesc.OutputWindow = hWnd;
    swapChainDesc.Windowed = true;
    swapChainDesc.SampleDesc.Count = 1;
    swapChainDesc.SampleDesc.Quality = 0;

    HRESULT result;

    result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, NULL, featureLevels, totalFeatureLevels, D3D11_SDK_VERSION,
                                           &swapChainDesc, &swapChain, &d3dDevice, &featureLevel, &d3dDeviceContext);

    if(FAILED(result))
        return false;

    ID3D11Texture2D* backBufferTexture;

    result = swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferTexture);

    if(FAILED(result ))
    {
        return false;
    }

    result = d3dDevice->CreateRenderTargetView(backBufferTexture, 0, &backBufferTarget);

    if(backBufferTexture)
        backBufferTexture->Release();

    if(FAILED(result))
    {
        return false;
    }

    d3dDeviceContext->OMSetRenderTargets(1, &backBufferTarget, 0);

    D3D11_VIEWPORT viewport;
    viewport.Width = static_cast<float>(800);
    viewport.Height = static_cast<float>(600);
    viewport.MinDepth = 0.0f;
    viewport.MaxDepth = 1.0f;
    viewport.TopLeftX = 0.0f;
    viewport.TopLeftY = 0.0f;

    d3dDeviceContext->RSSetViewports( 1, &viewport );

    //Shader Buffers
    ID3DBlob *vertexShaderBuffer = NULL;
    ID3DBlob *pixelShaderBuffer = NULL;

    //Compile and create the vertex shader
    result = D3DCompileFromFile(shaderFileName, NULL, NULL, "VSMain", "vs_5_0", NULL, NULL, &vertexShaderBuffer, NULL);

    if(FAILED(result))
        return false;

    result = d3dDevice->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertexShader);

    if(FAILED(result))
        return false;

    //Create the input layout
    D3D11_INPUT_ELEMENT_DESC simpleShaderLayout[] =
    {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
        { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 }
    };

    result = d3dDevice->CreateInputLayout(simpleShaderLayout, ARRAYSIZE(simpleShaderLayout), vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &inputLayout);

    if(FAILED(result))
        return false;

    vertexShaderBuffer->Release();

    //Compile and create the pixel shader
    result = D3DCompileFromFile(shaderFileName, NULL, NULL, "PSMain", "ps_5_0", NULL, NULL, &pixelShaderBuffer, NULL);

    if(FAILED(result))
        return false;

    result = d3dDevice->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixelShader);

    if(FAILED(result))
        return false;

    pixelShaderBuffer->Release();

    //Create the constant buffer
    D3D11_BUFFER_DESC constantBufferDesc;
    ZeroMemory(&constantBufferDesc, sizeof(constantBufferDesc));
    constantBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    constantBufferDesc.ByteWidth = sizeof(XMMATRIX);
    constantBufferDesc.Usage = D3D11_USAGE_DEFAULT;

    result = d3dDevice->CreateBuffer(&constantBufferDesc, NULL, &modelViewProjectionBuffer);

    if(FAILED(result))
        return false;

    XMMATRIX view = XMMatrixIdentity();
    XMMATRIX projection = XMMatrixOrthographicOffCenterLH(0.0f, 800.0f, 0.0f, 600.0f, 0.1f, 100.0f);

    viewProjectionMatrix = XMMatrixMultiply(view, projection);

    return true;
}

void RenderSystem::DrawSprite(Sprite *sprite)
{
    d3dDeviceContext->IASetInputLayout(inputLayout);
    sprite->SetVertexBuffer(d3dDeviceContext);
    d3dDeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

    d3dDeviceContext->VSSetShader(vertexShader, NULL, NULL);
    d3dDeviceContext->PSSetShader(pixelShader, NULL, NULL);
    sprite->SetShaderResourceAndSampler(d3dDeviceContext);

    XMMATRIX world = sprite->GetWorldMatrix();
    XMMATRIX modelViewProjectionMatrix = XMMatrixMultiply(world, viewProjectionMatrix);
    modelViewProjectionMatrix = XMMatrixTranspose(modelViewProjectionMatrix);

    d3dDeviceContext->UpdateSubresource(modelViewProjectionBuffer, 0, 0, &modelViewProjectionMatrix, 0, 0);
    d3dDeviceContext->VSSetConstantBuffers(0, 1, &modelViewProjectionBuffer);

    d3dDeviceContext->Draw(6, 0);
}

void RenderSystem::Clear()
{
    float clearColor[4] = { 0.0f, 0.0f, 0.25f, 1.0f };
    d3dDeviceContext->ClearRenderTargetView(backBufferTarget, clearColor);
}

void RenderSystem::Present()
{
    swapChain->Present(0, 0);
}

RenderSystem::~RenderSystem()
{
    d3dDevice->Release();
    d3dDeviceContext->Release();
    swapChain->Release();
    backBufferTarget->Release();
}

//Sprite.hpp
#include <d3d11.h>
#include <DirectXMath.h>
#include "FreeImage.h"

using namespace DirectX;

class RenderSystem;

class Sprite
{
public:
    Sprite();
    ~Sprite();

    bool Load(ID3D11Device *d3dDevice, ID3D11DeviceContext *d3dDeviceContext, char* filename);

    XMMATRIX GetWorldMatrix();

    void SetPosition(XMFLOAT2 position_);
    void SetRotation(float rotation_);
    void SetScale(XMFLOAT2 scale_);

    void SetVertexBuffer(ID3D11DeviceContext *d3dDeviceContext);
    void SetShaderResourceAndSampler(ID3D11DeviceContext *d3dDeviceContext);

private:
    XMFLOAT2 position;
    float rotation;
    XMFLOAT2 scale;

    ID3D11Buffer *vertexBuffer;
    ID3D11Texture2D *texture;

    ID3D11ShaderResourceView *shaderResourceView;
    ID3D11SamplerState *samplerState;
    ID3D11BlendState *alphaBlendState;
};

#endif

//Sprite.cpp
#include "Sprite.hpp"

struct Vertex
{
    XMFLOAT3 pos;
    XMFLOAT2 tex0;
};

Sprite::Sprite()
{
    texture = NULL;
    vertexBuffer = NULL;
    shaderResourceView = NULL;
    samplerState = NULL;

    scale.x = scale.y = 1;
    rotation = 0;
}

bool Sprite::Load(ID3D11Device *d3dDevice, ID3D11DeviceContext *d3dDeviceContext, char* filename)
{
    HRESULT result;

    //Load the image
    FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;
    FIBITMAP *dib = NULL;
    BYTE *bits = NULL;
    unsigned int width, height;

    fif = FreeImage_GetFileType(filename, 0);

    if(fif == FIF_UNKNOWN)
        fif = FreeImage_GetFIFFromFilename(filename);

    if(fif == FIF_UNKNOWN)
        return false;

    if(FreeImage_FIFSupportsReading(fif))
        dib = FreeImage_Load(fif, filename);

    if(!dib)
        return false;

    bits = FreeImage_GetBits(dib);

    width = FreeImage_GetWidth(dib);
    height = FreeImage_GetHeight(dib);

    if((bits == 0) || (width == 0) || (height == 0))
        return false;

    //Create the texture
    D3D11_TEXTURE2D_DESC textureDesc;
    textureDesc.Width = width;
    textureDesc.Height = height;
    textureDesc.MipLevels = 1;
    textureDesc.ArraySize = 1;
    textureDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
    textureDesc.SampleDesc.Count = 1;
    textureDesc.SampleDesc.Quality = 0;
    textureDesc.Usage = D3D11_USAGE_IMMUTABLE;
    textureDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
    textureDesc.CPUAccessFlags = 0;
    textureDesc.MiscFlags = 0;

    D3D11_SUBRESOURCE_DATA textureResourceData;
    textureResourceData.pSysMem = bits;
    textureResourceData.SysMemPitch = width * 4;
    textureResourceData.SysMemSlicePitch = 0;

    result = d3dDevice->CreateTexture2D(&textureDesc, &textureResourceData, &texture);

    if(FAILED(result))
        return false;

    float halfWidth = width/2;
    float halfHeight = height/2;

    //Create the geometry
    Vertex vertices[] =
    {
        {XMFLOAT3(halfWidth, halfHeight, 1.0f), XMFLOAT2(1.0f, 0.0f)},
        {XMFLOAT3(halfWidth, -halfHeight, 1.0f), XMFLOAT2(1.0f, 1.0f)},
        {XMFLOAT3(-halfWidth, -halfHeight, 1.0f), XMFLOAT2(0.0f, 1.0f)},
        {XMFLOAT3(-halfWidth, -halfHeight, 1.0f), XMFLOAT2(0.0f, 1.0f)},
        {XMFLOAT3(-halfWidth, halfHeight, 1.0f), XMFLOAT2(0.0f, 0.0f)},
        {XMFLOAT3(halfWidth, halfHeight, 1.0f), XMFLOAT2(1.0f, 0.0f)}
    };

    D3D11_BUFFER_DESC vertexDesc;
    ZeroMemory(&vertexDesc, sizeof(vertexDesc));
    vertexDesc.Usage = D3D11_USAGE_DEFAULT;
    vertexDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    vertexDesc.ByteWidth = sizeof(Vertex) * 6;

    D3D11_SUBRESOURCE_DATA resourceData;
    ZeroMemory( &resourceData, sizeof(resourceData));
    resourceData.pSysMem = vertices;

    result = d3dDevice->CreateBuffer(&vertexDesc, &resourceData, &vertexBuffer);

    if(FAILED(result))
        return false;

    //Create the shader resource view
    D3D11_SHADER_RESOURCE_VIEW_DESC shaderResourceViewDesc;
    shaderResourceViewDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
    shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
    shaderResourceViewDesc.Texture2D.MipLevels = -1;
    shaderResourceViewDesc.Texture2D.MostDetailedMip = 0;

    result = d3dDevice->CreateShaderResourceView(texture, &shaderResourceViewDesc, &shaderResourceView);

    if(FAILED(result))
        return false;

    //Create the sampler state
    D3D11_SAMPLER_DESC samplerDesc;
    samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
    samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
    samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
    samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
    samplerDesc.MipLODBias = 0;
    samplerDesc.MaxAnisotropy = 1;
    samplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
    samplerDesc.MinLOD = 0;
    samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;

    result = d3dDevice->CreateSamplerState(&samplerDesc, &samplerState);

    if(FAILED(result))
        return false;

    D3D11_BLEND_DESC blendDesc;
    ZeroMemory( &blendDesc, sizeof( blendDesc ) );
    blendDesc.RenderTarget[0].BlendEnable = TRUE;
    blendDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
    blendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
    blendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_ONE;
    blendDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
    blendDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ZERO;
    blendDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
    blendDesc.RenderTarget[0].RenderTargetWriteMask = 0x0F;

    float blendFactor[4] = {0.0f, 0.0f, 0.0f, 0.0f};

    d3dDevice->CreateBlendState(&blendDesc, &alphaBlendState);
    d3dDeviceContext->OMSetBlendState(alphaBlendState, blendFactor, 0xFFFFFFFF);

    return true;
}

XMMATRIX Sprite::GetWorldMatrix()
{
    XMMATRIX translation_ = XMMatrixTranslation(position.x, position.y, 0.0f);
    XMMATRIX rotation_ = XMMatrixRotationZ(rotation);
    XMMATRIX scale_ = XMMatrixScaling(scale.x, scale.y, 0.0f);

    return translation_ * rotation_ * scale_;
}

void Sprite::SetPosition(XMFLOAT2 position_)
{
    position = position_;
}
void Sprite::SetRotation(float rotation_)
{
    rotation = rotation_;
}
void Sprite::SetScale(XMFLOAT2 scale_)
{
    scale = scale_;
}

void Sprite::SetVertexBuffer(ID3D11DeviceContext *d3dDeviceContext)
{
    UINT stride = sizeof(Vertex);
    UINT offset = 0;

    d3dDeviceContext->IAGetVertexBuffers(0, 1, &vertexBuffer, &stride, &offset);
}

void Sprite::SetShaderResourceAndSampler(ID3D11DeviceContext *d3dDeviceContext)
{
    d3dDeviceContext->PSSetShaderResources(0, 1, &shaderResourceView);
    d3dDeviceContext->PSSetSamplers(0, 1, &samplerState);
}

Sprite::~Sprite()
{
    vertexBuffer->Release();
    delete texture;
    shaderResourceView->Release();
    samplerState->Release();
}

//main.cpp
#include <Windows.h>

#include "RenderSystem.hpp"
#include "Sprite.hpp"

LRESULT CALLBACK WndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam );


int WINAPI wWinMain( HINSTANCE hInstance, HINSTANCE prevInstance, LPWSTR cmdLine, int cmdShow )
{
#pragma region WindowStuff
    WNDCLASSEX wndClass = { 0 };
    wndClass.cbSize = sizeof( WNDCLASSEX ) ;
    wndClass.style = CS_HREDRAW | CS_VREDRAW;
    wndClass.lpfnWndProc = WndProc;
    wndClass.hInstance = hInstance;
    wndClass.hCursor = LoadCursor( NULL, IDC_ARROW );
    wndClass.hbrBackground = ( HBRUSH )( COLOR_WINDOW + 1 );
    wndClass.lpszMenuName = NULL;
    wndClass.lpszClassName = L"WindowClass";

    if(!RegisterClassEx(&wndClass ))
        return -1;

    HWND hWnd = CreateWindowA( "WindowClass", "My Demo", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 800, 600, NULL, NULL, hInstance, NULL );

    if(!hWnd)
        return -1;

    ShowWindow(hWnd, cmdShow);
#pragma endregion

    RenderSystem *renderSystem = new RenderSystem;
    if(!renderSystem->Initialize(hInstance, hWnd, L"simpleShader.hlsl"))
    {
        MessageBox(NULL, L"Failed to initialize the render sytem!", L"Error", MB_ICONWARNING);
        return 0;
    }

    Sprite *sprite = new Sprite;
    if(!sprite->Load(renderSystem->GetDevice(), renderSystem->GetDeviceContext(), "Stickman.png"))
    {
        MessageBox(NULL, L"Failed to load a sprite!", L"Error", MB_ICONWARNING);
        return 0;
    }

    sprite->SetPosition(XMFLOAT2(100.0f, 400.0f));

    //MainLoop
    MSG msg = {0};

    while(msg.message != WM_QUIT)
    {
        if(PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

        //Update
        //Render
        renderSystem->Clear();
        renderSystem->DrawSprite(sprite);
        renderSystem->Present();
    }
}


LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch(message)
    {
        case WM_DESTROY:
            PostQuitMessage(0);
            break;

        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
    }

    return 0;
}