dx11minimal.cpp

//#include "matrix.cpp"

#include <windows.h>
#include <d3d11.h>
#include <dxgi.h>
#include <stdint.h>
#include <d3dcompiler.h>

#define assert(expr) if(!(expr)) { *((int *)0) = 0; }
#define invalidCodePath assert(false);
#define arrlen(arr) (sizeof(arr)/sizeof((arr)[0]))

#pragma comment(lib, "d3dcompiler") 
#pragma comment(lib, "D3D11")
#pragma comment(lib, "DXGI")

LRESULT CALLBACK winEventHandler(HWND hwnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

int WinMain(HINSTANCE inst, HINSTANCE prevInst, char *cmdLine, int cmdShow)
{
	int width = 800;
	int height = 600;

	WNDCLASSEX wndClass = {};
	wndClass.cbSize = sizeof(WNDCLASSEX);
	wndClass.style = 0;
	wndClass.lpfnWndProc = winEventHandler;
	wndClass.hInstance = inst;
	wndClass.lpszClassName = "anim test";
	if (RegisterClassEx(&wndClass))
	{
		HWND hwnd = CreateWindowEx(WS_EX_OVERLAPPEDWINDOW, wndClass.lpszClassName, "anim test", WS_OVERLAPPEDWINDOW | WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, width, height, 0, 0, inst, 0);
		if (hwnd)
		{
			D3D_FEATURE_LEVEL featureLevels[] =
			{
				D3D_FEATURE_LEVEL_11_1,
				D3D_FEATURE_LEVEL_11_0,
				D3D_FEATURE_LEVEL_10_1,
				D3D_FEATURE_LEVEL_10_0,
				D3D_FEATURE_LEVEL_9_3,
				D3D_FEATURE_LEVEL_9_2,
				D3D_FEATURE_LEVEL_9_1
			};

			DXGI_SWAP_CHAIN_DESC swapChainDesc = {};
			swapChainDesc.BufferDesc.Width = width;
			swapChainDesc.BufferDesc.Height = height;
			swapChainDesc.BufferDesc.RefreshRate.Numerator = 60;
			swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
			swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
			swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
			swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_CENTERED;
			swapChainDesc.SampleDesc.Count = 1;
			swapChainDesc.SampleDesc.Quality = 0;
			swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
			swapChainDesc.BufferCount = 2;
			swapChainDesc.OutputWindow = hwnd;
			swapChainDesc.Windowed = TRUE;
			swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;

			IDXGISwapChain *swapChain = 0;
			ID3D11Device *device = 0;
			ID3D11DeviceContext *deviceContext = 0;

			HRESULT result = D3D11CreateDeviceAndSwapChain(0, D3D_DRIVER_TYPE_HARDWARE, 0, D3D11_CREATE_DEVICE_BGRA_SUPPORT| D3D11_CREATE_DEVICE_DEBUG, featureLevels, 7, D3D11_SDK_VERSION,
				&swapChainDesc, &swapChain, &device, 0, &deviceContext);

			if (!FAILED(result))
			{
				// create render target
				ID3D11Texture2D *backBuffer = 0;
				swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void **)&backBuffer);
				ID3D11RenderTargetView *renderTargetView = 0;
				device->CreateRenderTargetView(backBuffer, 0, &renderTargetView);

				// viewport settings
				D3D11_VIEWPORT viewport = {};
				viewport.Width = (float)width;
				viewport.Height = (float)height;
				viewport.MinDepth = 0.0f;
				viewport.MaxDepth = 1.0f;
				viewport.TopLeftX = 0;
				viewport.TopLeftY = 0;
				deviceContext->RSSetViewports(1, &viewport);

				// rasterizer settings
				ID3D11RasterizerState *rasterizer;
				D3D11_RASTERIZER_DESC rasterizerDesc;
				rasterizerDesc.FillMode = D3D11_FILL_SOLID;
				rasterizerDesc.CullMode = D3D11_CULL_FRONT;
				rasterizerDesc.FrontCounterClockwise = false;
				rasterizerDesc.DepthBias = false;
				rasterizerDesc.DepthBiasClamp = 0;
				rasterizerDesc.SlopeScaledDepthBias = 0;
				rasterizerDesc.DepthClipEnable = true;
				rasterizerDesc.ScissorEnable = false;
				rasterizerDesc.MultisampleEnable = false;
				rasterizerDesc.AntialiasedLineEnable = false;
				device->CreateRasterizerState(&rasterizerDesc, &rasterizer);
				deviceContext->RSSetState(rasterizer);

				// create vertex buffer
				float vertexBufferData[] =
				{
					0.0f, 0.5f, 0.5f,		1.0f, 0.0f, 0.0f,
					-0.5f, -0.5f, 0.5f,		0.0f, 1.0f, 0.0f,
					0.5f, -0.5f, 0.5f,		0.0f, 0.0f, 1.0f
				};
				uint32_t vertexBufferStride = 24;

				D3D11_BUFFER_DESC bufferDesc = {};
				bufferDesc.Usage = D3D11_USAGE_DEFAULT;
				bufferDesc.ByteWidth = sizeof(vertexBufferData);
				bufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
				bufferDesc.CPUAccessFlags = 0;
				bufferDesc.MiscFlags = 0;

				D3D11_SUBRESOURCE_DATA bufferResource = {};
				bufferResource.pSysMem = vertexBufferData;

				ID3D11Buffer *vertexBuffer = 0;
				result = device->CreateBuffer(&bufferDesc, &bufferResource, &vertexBuffer);
				assert(!FAILED(result));

				// create vertex shader
				char vertexShaderCode[] = R"STR(
struct VertexShaderInput
{
	float3 pos : POSITION;
	float3 color : COLOR;
};

struct VertexShaderOuput
{
	float4 pos : SV_POSITION;
	float3 color : COLOR;
};

VertexShaderOuput main(VertexShaderInput input)
{
	VertexShaderOuput output;
	output.pos = float4(input.pos, 1.0f);
	output.color = input.color;
	return output;
}
				)STR";

				ID3DBlob *vsBuffer = 0;
				ID3DBlob *vsErrorBuffer = 0;
				D3D_SHADER_MACRO macros[] = { 0 };
				result = D3DCompile(vertexShaderCode, sizeof(vertexShaderCode), "vs", macros, 0, "main", "vs_5_0", (1 << 0) | (1 << 11), 0, &vsBuffer, &vsErrorBuffer);
				if (vsErrorBuffer != 0)
				{
					OutputDebugString((char *)vsErrorBuffer->GetBufferPointer());
					invalidCodePath;
				}
				assert(!FAILED(result));
				ID3D11VertexShader *vertexShader = 0;
				result = device->CreateVertexShader(vsBuffer->GetBufferPointer(), vsBuffer->GetBufferSize(), 0, &vertexShader);
				assert(!FAILED(result))

				// create vertex buffer laoyout
				D3D11_INPUT_ELEMENT_DESC inputLayoutData[] =
				{
					{"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}
				};
				ID3D11InputLayout *layout = 0;
				result = device->CreateInputLayout(inputLayoutData, arrlen(inputLayoutData), (void *)vsBuffer->GetBufferPointer(), vsBuffer->GetBufferSize(), &layout);
				assert(!FAILED(result));

				// create pixel shader
				char pixelShaderCode[] = R"STR(
struct PixelShaderInput
{
	float4 pos : SV_POSITION;
	float3 color : COLOR;
};

float3 main(PixelShaderInput input) : SV_TARGET
{
	return input.color;
};

)STR";
				ID3DBlob *psBuffer = 0;
				ID3DBlob *psErrorBuffer = 0;
				result = D3DCompile(pixelShaderCode, sizeof(pixelShaderCode), "ps", macros, 0, "main", "ps_5_0", (1 << 0) | (1 << 11), 0, &psBuffer, &psErrorBuffer);
				if (psErrorBuffer != 0)
				{
					OutputDebugString((char *)psErrorBuffer->GetBufferPointer());
					invalidCodePath;
				}
				assert(!FAILED(result));
				ID3D11PixelShader *pixelShader = 0;
				result = device->CreatePixelShader(psBuffer->GetBufferPointer(), psBuffer->GetBufferSize(), 0, &pixelShader);
				assert(!FAILED(result));

				float clearColor[] = { 0.0f, 0.0f, 0.0f, 0.0f };
				while (1)
				{
					deviceContext->OMSetRenderTargets(1, &renderTargetView, 0);

					// clear the back buffer
					//clearColor[0] -= 1.0f / 300.0f;
					deviceContext->ClearRenderTargetView(renderTargetView, clearColor);

					// setup IA
					uint32_t zero = 0;
					deviceContext->IASetVertexBuffers(0, 1, &vertexBuffer, &vertexBufferStride, &zero);
					deviceContext->IASetInputLayout(layout);
					deviceContext->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

					// setup VS
					deviceContext->VSSetShader(vertexShader, 0, 0);

					// setup PS
					//deviceContext->RSSetState(rasterizer);
					deviceContext->PSSetShader(pixelShader, 0, 0);

					deviceContext->Draw(3, 0);
					swapChain->Present(1, 0);
				}
			}
		}
	}

	

	
}