Here is the entire file

#define UNICODE
#define DEBUG
#include <d3d11_4.h>		 // D3D interface
#include <d3dcompiler.h> // shader compiler
#include <DirectXMath.h>
#include <winerror.h>
#include "WICTextureLoader.h"

using namespace DirectX;

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

ID3D11Device* device_ptr = nullptr;
ID3D11DeviceContext* device_context_ptr = nullptr;
IDXGISwapChain* swap_chain_ptr = nullptr;
ID3D11RenderTargetView* render_target_view_ptr = nullptr;

INT APIENTRY wWinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPWSTR lpCmdLine, _In_ int nCmdShow)
{
	// Register the window class.
	LPWSTR CLASS_NAME = L"Sample Window Class";
	WNDCLASS wc = {};
	wc.lpfnWndProc = WindowProc;
	wc.hInstance = hInstance;
	wc.lpszClassName = CLASS_NAME;
	RegisterClass(&wc);
	OutputDebugStringW(lpCmdLine);

	// Create the window.
	HWND hwnd = CreateWindowEx(
		0,						 // Optional window styles.
		CLASS_NAME,			 // Window class
		L"Hello Triangle!",	 // Window text
		WS_OVERLAPPEDWINDOW, // Window style

		// Size and position
		CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
		nullptr,	// Parent window
		nullptr,	// Menu
		hInstance, // Instance handle
		nullptr		// Additional application data
	);


	if (!hwnd)
		return 0;

	ShowWindow(hwnd, nCmdShow);

	DXGI_SWAP_CHAIN_DESC swap_chain_descr = { 0 };
	swap_chain_descr.BufferDesc.RefreshRate.Numerator = 0;
	swap_chain_descr.BufferDesc.RefreshRate.Denominator = 1;
	swap_chain_descr.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
	swap_chain_descr.SampleDesc.Count = 1;
	swap_chain_descr.SampleDesc.Quality = 0;
	swap_chain_descr.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
	swap_chain_descr.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
	swap_chain_descr.BufferCount = 2;
	swap_chain_descr.OutputWindow = hwnd;
	swap_chain_descr.Windowed = true;

	D3D_FEATURE_LEVEL feature_level[] = { D3D_FEATURE_LEVEL_11_1 };
	UINT flags = D3D11_CREATE_DEVICE_SINGLETHREADED;
#if defined(DEBUG) || defined(_DEBUG)
	flags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
	HRESULT hr = D3D11CreateDeviceAndSwapChain(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, flags, nullptr, 0, D3D11_SDK_VERSION, &swap_chain_descr, &swap_chain_ptr, &device_ptr, feature_level, &device_context_ptr);
	assert(S_OK == hr && swap_chain_ptr && device_ptr && device_context_ptr);

	ID3D11Texture2D* framebuffer;
	hr = swap_chain_ptr->GetBuffer(0, __uuidof(ID3D11Texture2D), (VOID**)&framebuffer);
	assert(SUCCEEDED(hr));

	hr = device_ptr->CreateRenderTargetView(framebuffer, 0, &render_target_view_ptr);
	assert(SUCCEEDED(hr));

	flags = D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_WARNINGS_ARE_ERRORS;
#if defined(DEBUG) || defined(_DEBUG)
	flags |= D3DCOMPILE_DEBUG; // add more debug output
#endif
	ID3DBlob* vs_blob_ptr = nullptr, * ps_blob_ptr = nullptr, * error_blob = nullptr;

	// COMPILE VERTEX SHADER
	hr = D3DCompileFromFile(L"..\\Shaders\\shaders.hlsl", nullptr, D3D_COMPILE_STANDARD_FILE_INCLUDE, "vs_main", "vs_5_0", flags, 0, &vs_blob_ptr, &error_blob);

	LPWSTR messageBuffer;
	DWORD size = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_ALLOCATE_BUFFER, nullptr, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR)&messageBuffer, 0, nullptr);
	OutputDebugStringW(messageBuffer);

	if (FAILED(hr))
	{
		if (error_blob)
		{
			OutputDebugStringA((PCSTR)error_blob->GetBufferPointer());
			error_blob->Release();
		}
		if (vs_blob_ptr)
			vs_blob_ptr->Release();
		assert(false);
	}

	// COMPILE PIXEL SHADER
	hr = D3DCompileFromFile(L"..\\Shaders\\shaders.hlsl", nullptr, D3D_COMPILE_STANDARD_FILE_INCLUDE, "ps_main", "ps_5_0", flags, 0, &ps_blob_ptr, &error_blob);
	if (FAILED(hr))
	{
		if (error_blob)
		{
			OutputDebugStringA((PCSTR)error_blob->GetBufferPointer());
			error_blob->Release();
		}
		if (ps_blob_ptr)
			ps_blob_ptr->Release();
		assert(false);
	}

	ID3D11VertexShader* vertex_shader_ptr;
	ID3D11PixelShader* pixel_shader_ptr;

	hr = device_ptr->CreateVertexShader(vs_blob_ptr->GetBufferPointer(), vs_blob_ptr->GetBufferSize(), nullptr, &vertex_shader_ptr);
	assert(SUCCEEDED(hr));

	hr = device_ptr->CreatePixelShader(ps_blob_ptr->GetBufferPointer(), ps_blob_ptr->GetBufferSize(), nullptr, &pixel_shader_ptr);
	assert(SUCCEEDED(hr));

	// Vertex information

	ID3D11InputLayout* input_layout_ptr;
	D3D11_INPUT_ELEMENT_DESC inputElementDesc[] =
	{
		 {"POS", 0, DXGI_FORMAT_R32G32B32_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},
		 {"NOR", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0}
		 //{ "COL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
	};

	hr = device_ptr->CreateInputLayout(inputElementDesc, ARRAYSIZE(inputElementDesc), vs_blob_ptr->GetBufferPointer(), vs_blob_ptr->GetBufferSize(), &input_layout_ptr);
	assert(SUCCEEDED(hr));

	FLOAT vertex_data_array[] = {
		 -0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f,	 // Upper Left
		 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, -1.0f,	 // Upper right
		 0.5f, -0.5f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, -1.0f,	 // Lower right
		 -0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, -1.0f, // Lower left
		 -0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f,	 // Upper left
		 0.5f, -0.5f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, -1.0f	 // Lower right
	};

	UINT vertex_stride = 8 * sizeof(FLOAT);
	UINT vertex_offset = 0;
	UINT vertex_count = 6;

	ID3D11Buffer* vertex_buffer_ptr;
	{ /*** load mesh data into vertex buffer ***/
		D3D11_BUFFER_DESC vertex_buff_descr = {};
		vertex_buff_descr.ByteWidth = sizeof(vertex_data_array);
		vertex_buff_descr.Usage = D3D11_USAGE_DEFAULT;
		vertex_buff_descr.BindFlags = D3D11_BIND_VERTEX_BUFFER;
		D3D11_SUBRESOURCE_DATA sr_data = { 0 };
		sr_data.pSysMem = vertex_data_array;
		HRESULT hr = device_ptr->CreateBuffer(&vertex_buff_descr, &sr_data, &vertex_buffer_ptr);
		assert(SUCCEEDED(hr));
	}

	ID3D11SamplerState* sampstate;
	D3D11_SAMPLER_DESC samp;
	samp.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
	samp.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
	samp.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
	samp.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
	samp.MipLODBias = 0;
	samp.MaxAnisotropy = 1;
	samp.ComparisonFunc = D3D11_COMPARISON_NEVER;
	samp.BorderColor[0] = 0.f;
	samp.BorderColor[1] = 0.f;
	samp.BorderColor[2] = 0.f;
	samp.BorderColor[3] = 0.f;
	samp.MinLOD = 0;
	samp.MaxLOD = D3D11_FLOAT32_MAX;

	// Transformation

	struct matstruct
	{
		XMMATRIX rotate;
	};

	ID3D11Buffer* constant_buffer_ptr;
	{
		D3D11_BUFFER_DESC matrixBufferDesc = {};
		matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
		matrixBufferDesc.ByteWidth = sizeof(matstruct);
		matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
		matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
		matrixBufferDesc.MiscFlags = 0;
		matrixBufferDesc.StructureByteStride = 0;
		HRESULT hr = device_ptr->CreateBuffer(&matrixBufferDesc, nullptr, &constant_buffer_ptr);
		assert(SUCCEEDED(hr));
	}
	matstruct* dataPtr;
	D3D11_MAPPED_SUBRESOURCE mappedResource;

	ID3D11ShaderResourceView* view;
	hr = CreateWICTextureFromFile(device_ptr, device_context_ptr, L"..\\Resources\\bild.jpg", nullptr, &view);
	assert(SUCCEEDED(hr));

	// Diffuse Lighting

	struct Light
	{
		XMFLOAT4 diffuseColour;
		XMFLOAT3 pos;
		FLOAT padding;
	};

	ID3D11Buffer* Clightbfr = nullptr;
	D3D11_BUFFER_DESC desc = {};
	desc.ByteWidth = sizeof Light;
	desc.MiscFlags = 0;
	desc.StructureByteStride = 0;
	desc.Usage = D3D11_USAGE_DYNAMIC;
	desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
	desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
	hr = device_ptr->CreateBuffer(&desc, nullptr, &Clightbfr);
	assert(SUCCEEDED(hr));

	Light* light;
	D3D11_MAPPED_SUBRESOURCE lghtresrc;

	hr = device_ptr->CreateSamplerState(&samp, &sampstate);
	assert(SUCCEEDED(hr));

	MSG msg = {};
	BOOL should_close = false;

	FLOAT angle = 0;

	// Run the message loop.
	while (!should_close)
	{
		// Handle user input and other window events
		while (PeekMessageW(&msg, nullptr, 0, 0, PM_REMOVE))
		{
			TranslateMessage(&msg);
			DispatchMessageW(&msg);

			if (msg.message == WM_QUIT)
			{
				device_ptr->Release();
				device_context_ptr->Release();
				swap_chain_ptr->Release();
				render_target_view_ptr->Release();
				Clightbfr->Release();
				constant_buffer_ptr->Release();
				view->Release();
				sampstate->Release();
				input_layout_ptr->Release();
				ps_blob_ptr->Release();
				vs_blob_ptr->Release();
				pixel_shader_ptr->Release();
				vertex_buffer_ptr->Release();
				vertex_shader_ptr->Release();
				framebuffer->Release();
				return 0;
			}
		}

		device_context_ptr->Map(constant_buffer_ptr, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
		dataPtr = (matstruct*)mappedResource.pData;
		dataPtr->rotate = XMMatrixRotationRollPitchYaw(0.0f, angle++ / 100, 0.0f);
		device_context_ptr->Unmap(constant_buffer_ptr, 0);

		device_context_ptr->Map(Clightbfr, 0, D3D11_MAP_WRITE_DISCARD, 0, &lghtresrc);
		light = (Light*)lghtresrc.pData;
		light->diffuseColour = XMFLOAT4(0.2f, 1.0f, 1.0f, 1.0f);
		light->pos = XMFLOAT3(0.0f, 0.0f, -1.0f);
		light->padding = 0.0f;
		device_context_ptr->Unmap(Clightbfr, 0);

		/* RENDER A FRAME */

		/* clear the back buffer to grey for the new frame */
		FLOAT background_colour[4] = { 0.1f, 0.1f, 0.1f, 1.0f };
		device_context_ptr->ClearRenderTargetView(render_target_view_ptr, background_colour);

		/**** Rasteriser state - set viewport area *****/
		RECT winRect;
		GetClientRect(hwnd, &winRect);
		D3D11_VIEWPORT viewport = { 0.0f, 0.0f, (FLOAT)(winRect.right - winRect.left), (FLOAT)(winRect.bottom - winRect.top), 0.0f, 1.0f };
		device_context_ptr->RSSetViewports(1, &viewport);

		/**** Output Merger *****/
		device_context_ptr->OMSetRenderTargets(1, &render_target_view_ptr, nullptr);

		/***** Input Assembler (map how the vertex shader inputs should be read from vertex buffer) ******/
		device_context_ptr->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
		device_context_ptr->IASetInputLayout(input_layout_ptr);
		device_context_ptr->IASetVertexBuffers(0, 1, &vertex_buffer_ptr, &vertex_stride, &vertex_offset);

		/*** set vertex shader to use and pixel shader to use, and constant buffers for each ***/
		device_context_ptr->VSSetShader(vertex_shader_ptr, nullptr, 0);
		device_context_ptr->PSSetShader(pixel_shader_ptr, nullptr, 0);
		device_context_ptr->PSSetShaderResources(0, 1, &view);
		device_context_ptr->PSSetSamplers(0, 1, &sampstate);
		device_context_ptr->VSSetConstantBuffers(0, 1, &constant_buffer_ptr);
		device_context_ptr->PSSetConstantBuffers(1, 1, &Clightbfr);

		/*** draw the vertex buffer with the shaders ***/
		device_context_ptr->Draw(vertex_count, 0);

		/**** swap the back and front buffers (show the frame we just drew) ****/
		swap_chain_ptr->Present(1, 0);
	}
	return 0;
}

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch (uMsg)
	{
	case WM_DESTROY:
		PostQuitMessage(0);
		return 0;

	case WM_PAINT:
	{
		PAINTSTRUCT ps;
		HDC hdc = BeginPaint(hwnd, &ps);
		FillRect(hdc, &ps.rcPaint, (HBRUSH)(COLOR_WINDOW));
		EndPaint(hwnd, &ps);
		break;
	}
	case WM_CLOSE:
	{
		if (MessageBox(hwnd, L"Quit?", L"Exit", MB_YESNO) == IDYES)
			DestroyWindow(hwnd);
		else
			return 0;
	}
	}
	return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

Overloaded function defined twice according to intellisense #6135

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions