bindable/drawable system

hw3d/App.cpp

 #include "App.h"
+#include "Box.h"
+#include <memory>
 
 App::App()
 	:
 	wnd( 800,600,"The Donkey Fart Box" )
-{}
+{
+	std::mt19937 rng( std::random_device{}() );
+	std::uniform_real_distribution<float> adist( 0.0f,3.1415f * 2.0f );
+	std::uniform_real_distribution<float> ddist( 0.0f,3.1415f * 2.0f );
+	std::uniform_real_distribution<float> odist( 0.0f,3.1415f * 0.3f );
+	std::uniform_real_distribution<float> rdist( 6.0f,20.0f );
+	for( auto i = 0; i < 80; i++ )
+	{
+		boxes.push_back( std::make_unique<Box>(
+			wnd.Gfx(),rng,adist,
+			ddist,odist,rdist
+		) );
+	}
+	wnd.Gfx().SetProjection( DirectX::XMMatrixPerspectiveLH( 1.0f,3.0f / 4.0f,0.5f,40.0f ) );
+}
 
 int App::Go()
 {
@@ -19,14 +35,17 @@ int App::Go()
 	}
 }
 
+App::~App()
+{}
+
 void App::DoFrame()
 {
-	const float c = sin( timer.Peek() ) / 2.0f + 0.5f;
-	wnd.Gfx().ClearBuffer( c,c,1.0f );
-	wnd.Gfx().DrawTestTriangle(
-		timer.Peek(),
-		wnd.mouse.GetPosX() / 400.0f - 1.0f,
-		-wnd.mouse.GetPosY() / 300.0f + 1.0f
-	);
+	auto dt = timer.Mark();
+	wnd.Gfx().ClearBuffer( 0.07f,0.0f,0.12f );
+	for( auto& b : boxes )
+	{
+		b->Update( dt );
+		b->Draw( wnd.Gfx() );
+	}
 	wnd.Gfx().EndFrame();
 }
\ No newline at end of file

hw3d/App.h

@@ -8,9 +8,11 @@ public:
 	App();
 	// master frame / message loop
 	int Go();
+	~App();
 private:
 	void DoFrame();
 private:
 	Window wnd;
 	ChiliTimer timer;
+	std::vector<std::unique_ptr<class Box>> boxes;
 };
\ No newline at end of file

hw3d/Bindable.cpp

+#include "Bindable.h"
+
+ID3D11DeviceContext* Bindable::GetContext( Graphics& gfx ) noexcept
+{
+	return gfx.pContext.Get();
+}
+
+ID3D11Device* Bindable::GetDevice( Graphics& gfx ) noexcept
+{
+	return gfx.pDevice.Get();
+}
+
+DxgiInfoManager& Bindable::GetInfoManager( Graphics& gfx ) noexcept(!IS_DEBUG)
+{
+#ifndef NDEBUG
+	return gfx.infoManager;
+#else
+	throw std::logic_error( "YouFuckedUp! (tried to access gfx.infoManager in Release config)" );
+#endif
+}

hw3d/Bindable.h

+#pragma once
+#include "Graphics.h"
+
+class Bindable
+{
+public:
+	virtual void Bind( Graphics& gfx ) noexcept = 0;
+	virtual ~Bindable() = default;
+protected:
+	static ID3D11DeviceContext* GetContext( Graphics& gfx ) noexcept;
+	static ID3D11Device* GetDevice( Graphics& gfx ) noexcept;
+	static DxgiInfoManager& GetInfoManager( Graphics& gfx ) noexcept(!IS_DEBUG);
+};
\ No newline at end of file

hw3d/BindableBase.h

+#pragma once
+
+#include "ConstantBuffers.h"
+#include "IndexBuffer.h"
+#include "InputLayout.h"
+#include "PixelShader.h"
+#include "Topology.h"
+#include "TransformCbuf.h"
+#include "VertexBuffer.h"
+#include "VertexShader.h"
\ No newline at end of file

hw3d/Box.cpp

+#include "Box.h"
+#include "BindableBase.h"
+#include "GraphicsThrowMacros.h"
+
+Box::Box( Graphics& gfx,
+	std::mt19937& rng,
+	std::uniform_real_distribution<float>& adist,
+	std::uniform_real_distribution<float>& ddist,
+	std::uniform_real_distribution<float>& odist,
+	std::uniform_real_distribution<float>& rdist )
+	:
+	r( rdist( rng ) ),
+	droll( ddist( rng ) ),
+	dpitch( ddist( rng ) ),
+	dyaw( ddist( rng ) ),
+	dphi( odist( rng ) ),
+	dtheta( odist( rng ) ),
+	dchi( odist( rng ) ),
+	chi( adist( rng ) ),
+	theta( adist( rng ) ),
+	phi( adist( rng ) )
+{
+	struct Vertex
+	{
+		struct
+		{
+			float x;
+			float y;
+			float z;
+		} pos;
+	};
+	const std::vector<Vertex> vertices =
+	{
+		{ -1.0f,-1.0f,-1.0f },
+		{ 1.0f,-1.0f,-1.0f },
+		{ -1.0f,1.0f,-1.0f },
+		{ 1.0f,1.0f,-1.0f },
+		{ -1.0f,-1.0f,1.0f },
+		{ 1.0f,-1.0f,1.0f },
+		{ -1.0f,1.0f,1.0f },
+		{ 1.0f,1.0f,1.0f },
+	};
+	AddBind( std::make_unique<VertexBuffer>( gfx,vertices )	);
+
+	auto pvs = std::make_unique<VertexShader>( gfx,L"VertexShader.cso" );
+	auto pvsbc = pvs->GetBytecode();
+	AddBind( std::move( pvs ) );
+
+	AddBind( std::make_unique<PixelShader>( gfx,L"PixelShader.cso" ) );
+
+	const std::vector<unsigned short> indices =
+	{
+		0,2,1, 2,3,1,
+		1,3,5, 3,7,5,
+		2,6,3, 3,6,7,
+		4,5,7, 4,7,6,
+		0,4,2, 2,4,6,
+		0,1,4, 1,5,4
+	};
+	AddIndexBuffer( std::make_unique<IndexBuffer>( gfx,indices ) );
+
+	struct ConstantBuffer2
+	{
+		struct
+		{
+			float r;
+			float g;
+			float b;
+			float a;
+		} face_colors[6];
+	};
+	const ConstantBuffer2 cb2 =
+	{
+		{
+			{ 1.0f,0.0f,1.0f },
+			{ 1.0f,0.0f,0.0f },
+			{ 0.0f,1.0f,0.0f },
+			{ 0.0f,0.0f,1.0f },
+			{ 1.0f,1.0f,0.0f },
+			{ 0.0f,1.0f,1.0f },
+		}
+	};
+	AddBind( std::make_unique<PixelConstantBuffer<ConstantBuffer2>>( gfx,cb2 ) );
+
+	const std::vector<D3D11_INPUT_ELEMENT_DESC> ied =
+	{
+		{ "Position",0,DXGI_FORMAT_R32G32B32_FLOAT,0,0,D3D11_INPUT_PER_VERTEX_DATA,0 },
+	};
+	AddBind( std::make_unique<InputLayout>( gfx,ied,pvsbc ) );
+
+	AddBind( std::make_unique<Topology>( gfx,D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST ) );
+
+	AddBind( std::make_unique<TransformCbuf>( gfx,*this ) );
+}
+
+void Box::Update( float dt ) noexcept
+{
+	roll += droll * dt;
+	pitch += dpitch * dt;
+	yaw += dyaw * dt;
+	theta += dtheta * dt;
+	phi += dphi * dt;
+	chi += dchi * dt;
+}
+
+DirectX::XMMATRIX Box::GetTransformXM() const noexcept
+{
+	return DirectX::XMMatrixRotationRollPitchYaw( pitch,yaw,roll ) *
+		DirectX::XMMatrixTranslation( r,0.0f,0.0f ) *
+		DirectX::XMMatrixRotationRollPitchYaw( theta,phi,chi ) *
+		DirectX::XMMatrixTranslation( 0.0f,0.0f,20.0f );
+}

hw3d/Box.h

+#pragma once
+#include "Drawable.h"
+
+class Box : public Drawable
+{
+public:
+	Box( Graphics& gfx,std::mt19937& rng,
+		std::uniform_real_distribution<float>& adist,
+		std::uniform_real_distribution<float>& ddist,
+		std::uniform_real_distribution<float>& odist,
+		std::uniform_real_distribution<float>& rdist );
+	void Update( float dt ) noexcept override;
+	DirectX::XMMATRIX GetTransformXM() const noexcept override;
+private:
+	// positional
+	float r;
+	float roll = 0.0f;
+	float pitch = 0.0f;
+	float yaw = 0.0f;
+	float theta;
+	float phi;
+	float chi;
+	// speed (delta/s)
+	float droll;
+	float dpitch;
+	float dyaw;
+	float dtheta;
+	float dphi;
+	float dchi;
+};
\ No newline at end of file

hw3d/ConstantBuffers.h

+#pragma once
+#include "Bindable.h"
+#include "GraphicsThrowMacros.h"
+
+template<typename C>
+class ConstantBuffer : public Bindable
+{
+public:
+	void Update( Graphics& gfx,const C& consts )
+	{
+		INFOMAN( gfx );
+
+		D3D11_MAPPED_SUBRESOURCE msr;
+		GFX_THROW_INFO( GetContext( gfx )->Map(
+			pConstantBuffer.Get(),0u,
+			D3D11_MAP_WRITE_DISCARD,0u,
+			&msr
+		) );
+		memcpy( msr.pData,&consts,sizeof( consts ) );
+		GetContext( gfx )->Unmap( pConstantBuffer.Get(),0u );
+	}
+	ConstantBuffer( Graphics& gfx,const C& consts )
+	{
+		INFOMAN( gfx );
+
+		D3D11_BUFFER_DESC cbd;
+		cbd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
+		cbd.Usage = D3D11_USAGE_DYNAMIC;
+		cbd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+		cbd.MiscFlags = 0u;
+		cbd.ByteWidth = sizeof( consts );
+		cbd.StructureByteStride = 0u;
+
+		D3D11_SUBRESOURCE_DATA csd = {};
+		csd.pSysMem = &consts;
+		GFX_THROW_INFO( GetDevice( gfx )->CreateBuffer( &cbd,&csd,&pConstantBuffer ) );
+	}
+	ConstantBuffer( Graphics& gfx )
+	{
+		INFOMAN( gfx );
+
+		D3D11_BUFFER_DESC cbd;
+		cbd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
+		cbd.Usage = D3D11_USAGE_DYNAMIC;
+		cbd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+		cbd.MiscFlags = 0u;
+		cbd.ByteWidth = sizeof( C );
+		cbd.StructureByteStride = 0u;
+		GFX_THROW_INFO( GetDevice( gfx )->CreateBuffer( &cbd,nullptr,&pConstantBuffer ) );
+	}
+protected:
+	Microsoft::WRL::ComPtr<ID3D11Buffer> pConstantBuffer;
+};
+
+template<typename C>
+class VertexConstantBuffer : public ConstantBuffer<C>
+{
+	using ConstantBuffer<C>::pConstantBuffer;
+	using Bindable::GetContext;
+public:
+	using ConstantBuffer<C>::ConstantBuffer;
+	void Bind( Graphics& gfx ) noexcept override
+	{
+		GetContext( gfx )->VSSetConstantBuffers( 0u,1u,pConstantBuffer.GetAddressOf() );
+	}
+};
+
+template<typename C>
+class PixelConstantBuffer : public ConstantBuffer<C>
+{
+	using ConstantBuffer<C>::pConstantBuffer;
+	using Bindable::GetContext;
+public:
+	using ConstantBuffer<C>::ConstantBuffer;
+	void Bind( Graphics& gfx ) noexcept override
+	{
+		GetContext( gfx )->PSSetConstantBuffers( 0u,1u,pConstantBuffer.GetAddressOf() );
+	}
+};
\ No newline at end of file

hw3d/Drawable.cpp

+#include "Drawable.h"
+#include "GraphicsThrowMacros.h"
+#include "IndexBuffer.h"
+#include <cassert>
+#include <typeinfo>
+
+void Drawable::Draw( Graphics& gfx ) const noexcept(!IS_DEBUG)
+{
+	for( auto& b : binds )
+	{
+		b->Bind( gfx );
+	}
+	gfx.DrawIndexed( pIndexBuffer->GetCount() );
+}
+
+void Drawable::AddBind( std::unique_ptr<Bindable> bind ) noexcept(!IS_DEBUG)
+{
+	assert( "*Must* use AddIndexBuffer to bind index buffer" && typeid(*bind) != typeid(IndexBuffer) );
+	binds.push_back( std::move( bind ) );
+}
+
+void Drawable::AddIndexBuffer( std::unique_ptr<IndexBuffer> ibuf ) noexcept
+{
+	assert( "Attempting to add index buffer a second time" && pIndexBuffer == nullptr );
+	pIndexBuffer = ibuf.get();
+	binds.push_back( std::move( ibuf ) );
+}

hw3d/Drawable.h

+#pragma once
+#include "Graphics.h"
+#include <DirectXMath.h>
+
+class Bindable;
+
+class Drawable
+{
+public:
+	Drawable() = default;
+	Drawable( const Drawable& ) = delete;
+	virtual DirectX::XMMATRIX GetTransformXM() const noexcept = 0;
+	void Draw( Graphics& gfx ) const noexcept(!IS_DEBUG);
+	virtual void Update( float dt ) noexcept = 0;
+	void AddBind( std::unique_ptr<Bindable> bind ) noexcept(!IS_DEBUG);
+	void AddIndexBuffer( std::unique_ptr<class IndexBuffer> ibuf ) noexcept;
+	virtual ~Drawable() = default;
+private:
+	const IndexBuffer* pIndexBuffer = nullptr;
+	std::vector<std::unique_ptr<Bindable>> binds;
+};
\ No newline at end of file

hw3d/Graphics.cpp

@@ -55,6 +55,7 @@ Graphics::Graphics( HWND hWnd )
 		nullptr,
 		&pContext
 	) );
+
 	// gain access to texture subresource in swap chain (back buffer)
 	wrl::ComPtr<ID3D11Resource> pBackBuffer;
 	GFX_THROW_INFO( pSwap->GetBuffer( 0,__uuidof(ID3D11Resource),&pBackBuffer ) );
@@ -96,6 +97,16 @@ Graphics::Graphics( HWND hWnd )
 
 	// bind depth stensil view to OM
 	pContext->OMSetRenderTargets( 1u,pTarget.GetAddressOf(),pDSV.Get() );
+	   
+	// configure viewport
+	D3D11_VIEWPORT vp;
+	vp.Width = 800.0f;
+	vp.Height = 600.0f;
+	vp.MinDepth = 0.0f;
+	vp.MaxDepth = 1.0f;
+	vp.TopLeftX = 0.0f;
+	vp.TopLeftY = 0.0f;
+	pContext->RSSetViewports( 1u,&vp );
 }
 
 void Graphics::EndFrame()
@@ -124,199 +135,19 @@ void Graphics::ClearBuffer( float red,float green,float blue ) noexcept
 	pContext->ClearDepthStencilView( pDSV.Get(),D3D11_CLEAR_DEPTH,1.0f,0u );
 }
 
-void Graphics::DrawTestTriangle( float angle,float x,float z )
+void Graphics::DrawIndexed( UINT count ) noexcept(!IS_DEBUG)
 {
-	HRESULT hr;
-
-	struct Vertex
-	{
-		struct
-		{
-			float x;
-			float y;
-			float z;
-		} pos;
-	};
-
-	// create vertex buffer (1 2d triangle at center of screen)
-	Vertex vertices[] =
-	{
-		{ -1.0f,-1.0f,-1.0f	 },
-		{ 1.0f,-1.0f,-1.0f	 },
-		{ -1.0f,1.0f,-1.0f	 },
-		{ 1.0f,1.0f,-1.0f	  },
-		{ -1.0f,-1.0f,1.0f	 },
-		{ 1.0f,-1.0f,1.0f	  },
-		{ -1.0f,1.0f,1.0f	 },
-		{ 1.0f,1.0f,1.0f	 },
-	};
-	wrl::ComPtr<ID3D11Buffer> pVertexBuffer;
-	D3D11_BUFFER_DESC bd = {};
-	bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
-	bd.Usage = D3D11_USAGE_DEFAULT;
-	bd.CPUAccessFlags = 0u;
-	bd.MiscFlags = 0u;
-	bd.ByteWidth = sizeof( vertices );
-	bd.StructureByteStride = sizeof( Vertex );
-	D3D11_SUBRESOURCE_DATA sd = {};
-	sd.pSysMem = vertices;
-	GFX_THROW_INFO( pDevice->CreateBuffer( &bd,&sd,&pVertexBuffer ) );
-	
-	// Bind vertex buffer to pipeline
-	const UINT stride = sizeof( Vertex );
-	const UINT offset = 0u;
-	pContext->IASetVertexBuffers( 0u,1u,pVertexBuffer.GetAddressOf(),&stride,&offset );
-
-
-	// create index buffer
-	const unsigned short indices[] =
-	{
-		0,2,1, 2,3,1,
-		1,3,5, 3,7,5,
-		2,6,3, 3,6,7,
-		4,5,7, 4,7,6,
-		0,4,2, 2,4,6,
-		0,1,4, 1,5,4
-	};
-	wrl::ComPtr<ID3D11Buffer> pIndexBuffer;
-	D3D11_BUFFER_DESC ibd = {};
-	ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
-	ibd.Usage = D3D11_USAGE_DEFAULT;
-	ibd.CPUAccessFlags = 0u;
-	ibd.MiscFlags = 0u;
-	ibd.ByteWidth = sizeof( indices );
-	ibd.StructureByteStride = sizeof( unsigned short );
-	D3D11_SUBRESOURCE_DATA isd = {};
-	isd.pSysMem = indices;
-	GFX_THROW_INFO( pDevice->CreateBuffer( &ibd,&isd,&pIndexBuffer ) );
-
-	// bind index buffer
-	pContext->IASetIndexBuffer( pIndexBuffer.Get(),DXGI_FORMAT_R16_UINT,0u );
-	
-
-	// create constant buffer for transformation matrix
-	struct ConstantBuffer
-	{
-		dx::XMMATRIX transform;
-	};
-	const ConstantBuffer cb =
-	{
-		{
-			dx::XMMatrixTranspose(
-				dx::XMMatrixRotationZ( angle ) *
-				dx::XMMatrixRotationX( angle ) *
-				dx::XMMatrixTranslation( x,0.0f,z + 4.0f ) *
-				dx::XMMatrixPerspectiveLH( 1.0f,3.0f / 4.0f,0.5f,10.0f )
-			)
-		}
-	};
-	wrl::ComPtr<ID3D11Buffer> pConstantBuffer;
-	D3D11_BUFFER_DESC cbd;
-	cbd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
-	cbd.Usage = D3D11_USAGE_DYNAMIC;
-	cbd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
-	cbd.MiscFlags = 0u;
-	cbd.ByteWidth = sizeof( cb );
-	cbd.StructureByteStride = 0u;
-	D3D11_SUBRESOURCE_DATA csd = {};
-	csd.pSysMem = &cb;
-	GFX_THROW_INFO( pDevice->CreateBuffer( &cbd,&csd,&pConstantBuffer ) );
-
-	// bind constant buffer to vertex shader
-	pContext->VSSetConstantBuffers( 0u,1u,pConstantBuffer.GetAddressOf() );
-
-
-	// lookup table for cube face colors
-	struct ConstantBuffer2
-	{
-		struct
-		{
-			float r;
-			float g;
-			float b;
-			float a;
-		} face_colors[6];
-	};
-	const ConstantBuffer2 cb2 =
-	{
-		{
-			{1.0f,0.0f,1.0f},
-			{1.0f,0.0f,0.0f},
-			{0.0f,1.0f,0.0f},
-			{0.0f,0.0f,1.0f},
-			{1.0f,1.0f,0.0f},
-			{0.0f,1.0f,1.0f},
-		}
-	};
-	wrl::ComPtr<ID3D11Buffer> pConstantBuffer2;
-	D3D11_BUFFER_DESC cbd2;
-	cbd2.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
-	cbd2.Usage = D3D11_USAGE_DEFAULT;
-	cbd2.CPUAccessFlags = 0u;
-	cbd2.MiscFlags = 0u;
-	cbd2.ByteWidth = sizeof( cb2 );
-	cbd2.StructureByteStride = 0u;
-	D3D11_SUBRESOURCE_DATA csd2 = {};
-	csd2.pSysMem = &cb2;
-	GFX_THROW_INFO( pDevice->CreateBuffer( &cbd2,&csd2,&pConstantBuffer2 ) );
-
-	// bind constant buffer to pixel shader
-	pContext->PSSetConstantBuffers( 0u,1u,pConstantBuffer2.GetAddressOf() );
-
-
-
-	// create pixel shader
-	wrl::ComPtr<ID3D11PixelShader> pPixelShader;
-	wrl::ComPtr<ID3DBlob> pBlob;
-	GFX_THROW_INFO( D3DReadFileToBlob( L"PixelShader.cso",&pBlob ) );
-	GFX_THROW_INFO( pDevice->CreatePixelShader( pBlob->GetBufferPointer(),pBlob->GetBufferSize(),nullptr,&pPixelShader ) );
-
-	// bind pixel shader
-	pContext->PSSetShader( pPixelShader.Get(),nullptr,0u );
-
-
-	// create vertex shader
-	wrl::ComPtr<ID3D11VertexShader> pVertexShader;
-	GFX_THROW_INFO( D3DReadFileToBlob( L"VertexShader.cso",&pBlob ) );
-	GFX_THROW_INFO( pDevice->CreateVertexShader( pBlob->GetBufferPointer(),pBlob->GetBufferSize(),nullptr,&pVertexShader ) );
-
-	// bind vertex shader
-	pContext->VSSetShader( pVertexShader.Get(),nullptr,0u );
-		
-
-	// input (vertex) layout (2d position only)
-	wrl::ComPtr<ID3D11InputLayout> pInputLayout;
-	const D3D11_INPUT_ELEMENT_DESC ied[] =
-	{
-		{ "Position",0,DXGI_FORMAT_R32G32B32_FLOAT,0,0,D3D11_INPUT_PER_VERTEX_DATA,0 },
-	};
-	GFX_THROW_INFO( pDevice->CreateInputLayout(
-		ied,(UINT)std::size( ied ),
-		pBlob->GetBufferPointer(),
-		pBlob->GetBufferSize(),
-		&pInputLayout
-	) );
-
-	// bind vertex layout
-	pContext->IASetInputLayout( pInputLayout.Get() );
-
-
-	// Set primitive topology to triangle list (groups of 3 vertices)
-	pContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
-
-
-	// configure viewport
-	D3D11_VIEWPORT vp;
-	vp.Width = 800;
-	vp.Height = 600;
-	vp.MinDepth = 0;
-	vp.MaxDepth = 1;
-	vp.TopLeftX = 0;
-	vp.TopLeftY = 0;
-	pContext->RSSetViewports( 1u,&vp );
+	GFX_THROW_INFO_ONLY( pContext->DrawIndexed( count,0u,0u ) );
+}
 
+void Graphics::SetProjection( DirectX::FXMMATRIX proj ) noexcept
+{
+	projection = proj;
+}
 
-	GFX_THROW_INFO_ONLY( pContext->DrawIndexed( (UINT)std::size( indices ),0u,0u ) );
+DirectX::XMMATRIX Graphics::GetProjection() const noexcept
+{
+	return projection;
 }
 
 

hw3d/Graphics.h

@@ -5,9 +5,14 @@
 #include <wrl.h>
 #include <vector>
 #include "DxgiInfoManager.h"
+#include <d3dcompiler.h>
+#include <DirectXMath.h>
+#include <memory>
+#include <random>
 
 class Graphics
 {
+	friend class Bindable;
 public:
 	class Exception : public ChiliException
 	{
@@ -52,8 +57,11 @@ public:
 	~Graphics() = default;
 	void EndFrame();
 	void ClearBuffer( float red,float green,float blue ) noexcept;
-	void DrawTestTriangle( float angle,float x,float y );
+	void DrawIndexed( UINT count ) noexcept(!IS_DEBUG);
+	void SetProjection( DirectX::FXMMATRIX proj ) noexcept;
+	DirectX::XMMATRIX GetProjection() const noexcept;
 private:
+	DirectX::XMMATRIX projection;
 #ifndef NDEBUG
 	DxgiInfoManager infoManager;
 #endif

hw3d/GraphicsThrowMacros.h

@@ -2,7 +2,6 @@
 
 // HRESULT hr should exist in the local scope for these macros to work
 
-
 #define GFX_EXCEPT_NOINFO(hr) Graphics::HrException( __LINE__,__FILE__,(hr) )
 #define GFX_THROW_NOINFO(hrcall) if( FAILED( hr = (hrcall) ) ) throw Graphics::HrException( __LINE__,__FILE__,hr )
 
@@ -19,9 +18,9 @@
 #endif
 
 // macro for importing infomanager into local scope
-// this.GetInfoManager() must exist
+// this.GetInfoManager(Graphics& gfx) must exist
 #ifdef NDEBUG
-#define INFOMAN() HRESULT hr
+#define INFOMAN(gfx) HRESULT hr
 #else
-#define INFOMAN() HRESULT hr; DxgiInfoManager& infoManager = GetInfoManager()
+#define INFOMAN(gfx) HRESULT hr; DxgiInfoManager& infoManager = GetInfoManager((gfx))
 #endif

hw3d/IndexBuffer.cpp

+#include "IndexBuffer.h"
+#include "GraphicsThrowMacros.h"
+
+IndexBuffer::IndexBuffer( Graphics& gfx,const std::vector<unsigned short>& indices )
+	:
+	count( (UINT)indices.size() )
+{
+	INFOMAN( gfx );
+
+	D3D11_BUFFER_DESC ibd = {};
+	ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
+	ibd.Usage = D3D11_USAGE_DEFAULT;
+	ibd.CPUAccessFlags = 0u;
+	ibd.MiscFlags = 0u;
+	ibd.ByteWidth = UINT( count * sizeof( unsigned short ) );
+	ibd.StructureByteStride = sizeof( unsigned short );
+	D3D11_SUBRESOURCE_DATA isd = {};
+	isd.pSysMem = indices.data();
+	GFX_THROW_INFO( GetDevice( gfx )->CreateBuffer( &ibd,&isd,&pIndexBuffer ) );
+}
+
+void IndexBuffer::Bind( Graphics& gfx ) noexcept
+{
+	GetContext( gfx )->IASetIndexBuffer( pIndexBuffer.Get(),DXGI_FORMAT_R16_UINT,0u );
+}
+
+UINT IndexBuffer::GetCount() const noexcept
+{
+	return count;
+}

hw3d/IndexBuffer.h

+#pragma once
+#include "Bindable.h"
+
+class IndexBuffer : public Bindable
+{
+public:
+	IndexBuffer( Graphics& gfx,const std::vector<unsigned short>& indices );
+	void Bind( Graphics& gfx ) noexcept override;
+	UINT GetCount() const noexcept;
+protected:
+	UINT count;
+	Microsoft::WRL::ComPtr<ID3D11Buffer> pIndexBuffer;
+};
\ No newline at end of file

hw3d/InputLayout.cpp

+#include "InputLayout.h"
+#include "GraphicsThrowMacros.h"
+
+InputLayout::InputLayout( Graphics& gfx,
+	const std::vector<D3D11_INPUT_ELEMENT_DESC>& layout,
+	ID3DBlob* pVertexShaderBytecode )
+{
+	INFOMAN( gfx );
+
+	GFX_THROW_INFO( GetDevice( gfx )->CreateInputLayout(
+		layout.data(),(UINT)layout.size(),
+		pVertexShaderBytecode->GetBufferPointer(),
+		pVertexShaderBytecode->GetBufferSize(),
+		&pInputLayout
+	) );
+}
+
+void InputLayout::Bind( Graphics& gfx ) noexcept
+{
+	GetContext( gfx )->IASetInputLayout( pInputLayout.Get() );
+}

hw3d/InputLayout.h

+#pragma once
+#include "Bindable.h"
+
+class InputLayout : public Bindable
+{
+public:
+	InputLayout( Graphics& gfx,
+		const std::vector<D3D11_INPUT_ELEMENT_DESC>& layout,
+		ID3DBlob* pVertexShaderBytecode );
+	void Bind( Graphics& gfx ) noexcept override;
+protected:
+	Microsoft::WRL::ComPtr<ID3D11InputLayout> pInputLayout;
+};
\ No newline at end of file

hw3d/PixelShader.cpp

+#include "PixelShader.h"
+#include "GraphicsThrowMacros.h"
+
+PixelShader::PixelShader( Graphics& gfx,const std::wstring& path )
+{
+	INFOMAN( gfx );
+
+	Microsoft::WRL::ComPtr<ID3DBlob> pBlob;
+	GFX_THROW_INFO( D3DReadFileToBlob( path.c_str(),&pBlob ) );
+	GFX_THROW_INFO( GetDevice( gfx )->CreatePixelShader( pBlob->GetBufferPointer(),pBlob->GetBufferSize(),nullptr,&pPixelShader ) );
+}
+
+void PixelShader::Bind( Graphics& gfx ) noexcept
+{
+	GetContext( gfx )->PSSetShader( pPixelShader.Get(),nullptr,0u );
+}

hw3d/PixelShader.h

+#pragma once
+#include "Bindable.h"
+
+class PixelShader : public Bindable
+{
+public:
+	PixelShader( Graphics& gfx,const std::wstring& path );
+	void Bind( Graphics& gfx ) noexcept override;
+protected:
+	Microsoft::WRL::ComPtr<ID3D11PixelShader> pPixelShader;
+};
\ No newline at end of file

hw3d/PixelShader.hlsl

@@ -5,5 +5,5 @@ cbuffer CBuf
 
 float4 main( uint tid : SV_PrimitiveID ) : SV_Target
 {
-	return face_colors[tid / 2];
+	return face_colors[tid/2];
 }
\ No newline at end of file