#define WIN32_LEAN_AND_MEAN
#define NOMINMAX
#include <windows.h>
#include <d3d11_1.h>
#include <assert.h>
#include <d3dcompiler.h>
#pragma comment(lib, "d3d11.lib")
#pragma comment(lib, "d3dcompiler.lib")
// https://github.com/nothings/stb/blob/master/stb_image.h
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);
int CALLBACK WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
// Create a window
HWND hwnd;
{
WNDCLASSEXW winClass = {};
winClass.cbSize = sizeof(WNDCLASSEXW);
winClass.style = CS_HREDRAW | CS_VREDRAW;
winClass.lpfnWndProc = &WndProc;
winClass.hInstance = hInstance;
winClass.hCursor = LoadCursorW(0, IDC_ARROW);
winClass.lpszClassName = L"WindowClassName";
if (!RegisterClassEx(&winClass)) {
MessageBoxA(0, "RegisterClassEx failed", "Fatal Error", MB_OK);
return GetLastError();
}
RECT rect = { 0, 0, 1024, 768 };
AdjustWindowRectEx(&rect, WS_OVERLAPPEDWINDOW, FALSE, WS_EX_OVERLAPPEDWINDOW);
LONG width = rect.right - rect.left;
LONG height = rect.bottom - rect.top;
hwnd = CreateWindowExW(WS_EX_OVERLAPPEDWINDOW,
winClass.lpszClassName,
L"Direct3D 11 - Drawe a Texture (.png)",
WS_OVERLAPPEDWINDOW | WS_VISIBLE,
CW_USEDEFAULT, CW_USEDEFAULT,
width,
height,
0, 0, hInstance, 0);
if (!hwnd) {
MessageBoxA(0, "CreateWindowEx failed", "Fatal Error", MB_OK);
return GetLastError();
}
}
// Create Direct3D 11 Device and Context
ID3D11Device1* d3d11Device;
ID3D11DeviceContext1* d3d11DeviceContext;
{
ID3D11Device* device;
ID3D11DeviceContext* deviceContext;
D3D_FEATURE_LEVEL featureLevels[] = { D3D_FEATURE_LEVEL_11_0 };
UINT creationFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
HRESULT hResult = D3D11CreateDevice(0, D3D_DRIVER_TYPE_HARDWARE,
0, creationFlags,
featureLevels, ARRAYSIZE(featureLevels),
D3D11_SDK_VERSION, &device,
0, &deviceContext);
if (FAILED(hResult)) {
MessageBoxA(0, "D3D11CreateDevice() failed", "Fatal Error", MB_OK);
return GetLastError();
}
// Get interface of D3D11 Device and Context
hResult = device->QueryInterface(__uuidof(ID3D11Device1), (void**)&d3d11Device);
assert(SUCCEEDED(hResult));
device->Release();
// A query interface queries information from the GPU
hResult = deviceContext->QueryInterface(__uuidof(ID3D11DeviceContext1), (void**)&d3d11DeviceContext);
assert(SUCCEEDED(hResult));
deviceContext->Release();
}
// Create Swap Chain
IDXGISwapChain1* d3d11SwapChain;
{
IDXGIFactory2* dxgiFactory;
{
IDXGIDevice1* dxgiDevice;
HRESULT hResult = d3d11Device->QueryInterface(__uuidof(IDXGIDevice1), (void**)&dxgiDevice);
assert(SUCCEEDED(hResult));
IDXGIAdapter* dxgiAdapter;
hResult = dxgiDevice->GetAdapter(&dxgiAdapter);
assert(SUCCEEDED(hResult));
dxgiDevice->Release();
DXGI_ADAPTER_DESC adapterDesc;
dxgiAdapter->GetDesc(&adapterDesc);
OutputDebugStringA("(adapterDesc.Description) Graphics Device: ");
OutputDebugStringW(adapterDesc.Description);
hResult = dxgiAdapter->GetParent(__uuidof(IDXGIFactory2), (void**)&dxgiFactory);
assert(SUCCEEDED(hResult));
dxgiAdapter->Release();
}
DXGI_SWAP_CHAIN_DESC1 d3d11SwapChainDesc = {};
d3d11SwapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
d3d11SwapChainDesc.SampleDesc.Count = 1;
d3d11SwapChainDesc.SampleDesc.Quality = 0;
d3d11SwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
d3d11SwapChainDesc.BufferCount = 2;
d3d11SwapChainDesc.Scaling = DXGI_SCALING_STRETCH;
d3d11SwapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
d3d11SwapChainDesc.AlphaMode = DXGI_ALPHA_MODE_UNSPECIFIED;
d3d11SwapChainDesc.Flags = 0;
HRESULT hResult = dxgiFactory->CreateSwapChainForHwnd(d3d11Device, hwnd, &d3d11SwapChainDesc, 0, 0, &d3d11SwapChain);
assert(SUCCEEDED(hResult));
dxgiFactory->Release();
}
// Create Render Target View
ID3D11RenderTargetView* d3d11FrameBufferView;
{
ID3D11Texture2D* d3d11FrameBuffer;
HRESULT hResult = d3d11SwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&d3d11FrameBuffer);
assert(SUCCEEDED(hResult));
// Creates a render-target view for accessing resource data
hResult = d3d11Device->CreateRenderTargetView(d3d11FrameBuffer, 0, &d3d11FrameBufferView);
assert(SUCCEEDED(hResult));
d3d11FrameBuffer->Release();
}
// Create Vertex Shader
ID3DBlob* vsBlob;
ID3D11VertexShader* vertexShader;
{
ID3DBlob* shaderCompileErrorsBlob;
HRESULT hResult = D3DCompileFromFile(L"shader.hlsl", nullptr, nullptr, "vs_main", "vs_5_0", 0, 0, &vsBlob, &shaderCompileErrorsBlob);
if (FAILED(hResult)) {
const char* errorString = NULL;
if (hResult == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)) {
errorString = "Could not compile shader; file not found";
}
else if (shaderCompileErrorsBlob) {
errorString = (const char*)shaderCompileErrorsBlob->GetBufferPointer();
shaderCompileErrorsBlob->Release();
}
MessageBoxA(0, errorString, "Shader Compiler Error", MB_ICONERROR | MB_OK);
return 1;
}
hResult = d3d11Device->CreateVertexShader(vsBlob->GetBufferPointer(), vsBlob->GetBufferSize(), nullptr, &vertexShader);
assert(SUCCEEDED(hResult));
}
// Create Pixel Shader
ID3D11PixelShader* pixelShader;
{
ID3DBlob* psBlob;
ID3DBlob* shaderCompileErrorsBlob;
HRESULT hResult = D3DCompileFromFile(L"shader.hlsl", nullptr, nullptr, "ps_main", "ps_5_0", 0, 0, &psBlob, &shaderCompileErrorsBlob);
if (FAILED(hResult))
{
const char* errorString = NULL;
if (hResult == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
errorString = "Could not compile shader; file not found";
else if (shaderCompileErrorsBlob) {
errorString = (const char*)shaderCompileErrorsBlob->GetBufferPointer();
shaderCompileErrorsBlob->Release();
}
MessageBoxA(0, errorString, "Shader Compiler Error", MB_ICONERROR | MB_OK);
return 1;
}
hResult = d3d11Device->CreatePixelShader(psBlob->GetBufferPointer(), psBlob->GetBufferSize(), nullptr, &pixelShader);
assert(SUCCEEDED(hResult));
psBlob->Release();
}
// Create Input Layout
ID3D11InputLayout* inputLayout;
{
D3D11_INPUT_ELEMENT_DESC inputElementDesc[] =
{
{ "POS", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEX", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
// Create an input-layout object to describe the input-buffer data for the input-assembler stage
HRESULT hResult = d3d11Device->CreateInputLayout(inputElementDesc, ARRAYSIZE(inputElementDesc), vsBlob->GetBufferPointer(), vsBlob->GetBufferSize(), &inputLayout);
assert(SUCCEEDED(hResult));
vsBlob->Release();
}
// Create Vertex Buffer
ID3D11Buffer* vertexBuffer;
UINT totalVertices;
UINT stride;
UINT offset;
{
float vertexData[] = {
// draw 2 triangle for quad with a texture
// x, y, u, v
-0.5f, 0.5f, 0.f, 0.f,
0.5f, -0.5f, 1.f, 1.f,
-0.5f, -0.5f, 0.f, 1.f,
-0.5f, 0.5f, 0.f, 0.f,
0.5f, 0.5f, 1.f, 0.f,
0.5f, -0.5f, 1.f, 1.f
};
stride = 4 * sizeof(float);
totalVertices = sizeof(vertexData) / stride; // 6
offset = 0;
D3D11_BUFFER_DESC vertexBufferDesc = {};
vertexBufferDesc.ByteWidth = sizeof(vertexData);
vertexBufferDesc.Usage = D3D11_USAGE_IMMUTABLE;
vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
D3D11_SUBRESOURCE_DATA vertexSubresourceData = { vertexData };
HRESULT hResult = d3d11Device->CreateBuffer(&vertexBufferDesc, &vertexSubresourceData, &vertexBuffer);
assert(SUCCEEDED(hResult));
}
// Create Sampler Desc
D3D11_SAMPLER_DESC samplerDesc = {}; // Describes a sampler state
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_BORDER;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_BORDER;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_BORDER;
samplerDesc.BorderColor[0] = 1.0f;
samplerDesc.BorderColor[1] = 1.0f;
samplerDesc.BorderColor[2] = 1.0f;
samplerDesc.BorderColor[3] = 1.0f;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
ID3D11SamplerState* samplerState;
// Create a sampler-state object that encapsulates sampling information for a texture
d3d11Device->CreateSamplerState(&samplerDesc, &samplerState);
// Load Image
int textureWidth, textureHeight, textureNumChannels;
int textureForceNumChannels = 4;
unsigned char* testTextureBytes = stbi_load("texture.png", &textureWidth, &textureHeight,
&textureNumChannels, textureForceNumChannels); // Add and image (texture.png) to project library
assert(testTextureBytes);
int textureBytesPerRow = 4 * textureWidth;
// Create Texture
D3D11_TEXTURE2D_DESC textureDesc = {};
textureDesc.Width = textureWidth;
textureDesc.Height = textureHeight;
textureDesc.MipLevels = 1;
textureDesc.ArraySize = 1;
textureDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
textureDesc.SampleDesc.Count = 1;
textureDesc.Usage = D3D11_USAGE_IMMUTABLE;
textureDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
D3D11_SUBRESOURCE_DATA textureSubresourceData = {};
textureSubresourceData.pSysMem = testTextureBytes;
textureSubresourceData.SysMemPitch = textureBytesPerRow;
ID3D11Texture2D* texture;
d3d11Device->CreateTexture2D(&textureDesc, &textureSubresourceData, &texture);
ID3D11ShaderResourceView* textureView;
d3d11Device->CreateShaderResourceView(texture, nullptr, &textureView);
free(testTextureBytes);
bool running = true;
while (running) {
MSG msg = {};
while (PeekMessageW(&msg, 0, 0, 0, PM_REMOVE)) {
if (msg.message == WM_QUIT) {
running = false;
}
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
FLOAT backgroundColor[4] = { 0.3f, 0.1f, 0.7f, 1.0f };
d3d11DeviceContext->ClearRenderTargetView(d3d11FrameBufferView, backgroundColor);
RECT winClientRect;
GetClientRect(hwnd, &winClientRect);
D3D11_VIEWPORT viewport = { 0.0f, 0.0f, (FLOAT)(winClientRect.right - winClientRect.left), (FLOAT)(winClientRect.bottom - winClientRect.top), 0.0f, 1.0f };
// An array of D3D11_VIEWPORT structures to bind to the device
d3d11DeviceContext->RSSetViewports(1, &viewport);
// Bind one or more render targets atomically and the depth-stencil buffer to the output-merger stage
d3d11DeviceContext->OMSetRenderTargets(1, &d3d11FrameBufferView, nullptr);
// Bind information about the primitive type
d3d11DeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
d3d11DeviceContext->IASetInputLayout(inputLayout);
d3d11DeviceContext->VSSetShader(vertexShader, nullptr, 0);
d3d11DeviceContext->PSSetShader(pixelShader, nullptr, 0);
d3d11DeviceContext->PSSetShaderResources(0, 1, &textureView);
d3d11DeviceContext->PSSetSamplers(0, 1, &samplerState); // Set an array of sampler states to the pixel shader pipeline stage
d3d11DeviceContext->IASetVertexBuffers(0, 1, &vertexBuffer, &stride, &offset);
d3d11DeviceContext->Draw(totalVertices, 0);
d3d11SwapChain->Present(1, 0); // Presents a rendered image to the user
}
return 0;
}
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
LRESULT result = 0;
switch (msg)
{
case WM_KEYDOWN:
{
if (wparam == VK_ESCAPE)
DestroyWindow(hwnd);
break;
}
case WM_DESTROY:
{
PostQuitMessage(0);
break;
}
default:
result = DefWindowProcW(hwnd, msg, wparam, lparam);
}
return result;
}
/*
run:
*/
// shader.hlsl
struct VS_Input {
float2 pos : POS;
float2 uv : TEX;
};
struct VS_Output {
float4 pos : SV_POSITION;
float2 uv : TEXCOORD;
};
Texture2D thetexture : register(t0);
SamplerState thesampler : register(s0);
VS_Output vs_main(VS_Input input)
{
VS_Output output;
output.pos = float4(input.pos, 0.0f, 1.0f);
output.uv = input.uv;
return output;
}
float4 ps_main(VS_Output input) : SV_Target
{
return thetexture.Sample(thesampler, input.uv);
}
