Merge pull request #1 from xLightling/a2_meshes

A2: Meshes

DX11Starter.vcxproj

@@ -127,11 +127,13 @@
     <ClCompile Include="Game.cpp" />
     <ClCompile Include="Input.cpp" />
     <ClCompile Include="Main.cpp" />
+    <ClCompile Include="Mesh.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="DXCore.h" />
     <ClInclude Include="Game.h" />
     <ClInclude Include="Input.h" />
+    <ClInclude Include="Mesh.h" />
     <ClInclude Include="Vertex.h" />
   </ItemGroup>
   <ItemGroup>

DX11Starter.vcxproj.filters

@@ -30,6 +30,9 @@
     <ClCompile Include="Input.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Mesh.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Vertex.h">
@@ -44,6 +47,9 @@
     <ClInclude Include="Input.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Mesh.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <FxCompile Include="PixelShader.hlsl">

Game.cpp

@@ -148,76 +148,39 @@ void Game::CreateBasicGeometry()
 	XMFLOAT4 red = XMFLOAT4(1.0f, 0.0f, 0.0f, 1.0f);
 	XMFLOAT4 green = XMFLOAT4(0.0f, 1.0f, 0.0f, 1.0f);
 	XMFLOAT4 blue = XMFLOAT4(0.0f, 0.0f, 1.0f, 1.0f);
+	XMFLOAT4 black = XMFLOAT4(0.0f, 0.0f, 0.0f, 1.0f);
+	XMFLOAT4 white = XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f);
 
-	// Set up the vertices of the triangle we would like to draw
+	Vertex verts1[] = {
-	// - We're going to copy this array, exactly as it exists in memory
+		{ XMFLOAT3(+0.50f, +0.75f, +0.00f), red },
-	//    over to a DirectX-controlled data structure (the vertex buffer)
+		{ XMFLOAT3(+0.75f, +0.25f, +0.00f), blue },
-	// - Note: Since we don't have a camera or really any concept of
+		{ XMFLOAT3(+0.25f, +0.25f, +0.00f), green },
-	//    a "3d world" yet, we're simply describing positions within the
-	//    bounds of how the rasterizer sees our screen: [-1 to +1] on X and Y
-	// - This means (0,0) is at the very center of the screen.
-	// - These are known as "Normalized Device Coordinates" or "Homogeneous 
-	//    Screen Coords", which are ways to describe a position without
-	//    knowing the exact size (in pixels) of the image/window/etc.  
-	// - Long story short: Resizing the window also resizes the triangle,
-	//    since we're describing the triangle in terms of the window itself
-	Vertex vertices[] =
-	{
-		{ XMFLOAT3(+0.0f, +0.5f, +0.0f), red },
-		{ XMFLOAT3(+0.5f, -0.5f, +0.0f), blue },
-		{ XMFLOAT3(-0.5f, -0.5f, +0.0f), green },
 	};
+	unsigned int ind1[] = { 0, 1, 2 };
 
-	// Set up the indices, which tell us which vertices to use and in which order
+	Vertex verts2[] = {
-	// - This is somewhat redundant for just 3 vertices (it's a simple example)
+		{ XMFLOAT3(-0.75f, +0.50f, +0.00f), red },
-	// - Indices are technically not required if the vertices are in the buffer 
+		{ XMFLOAT3(-0.50f, +0.50f, +0.00f), blue },
-	//    in the correct order and each one will be used exactly once
+		{ XMFLOAT3(-0.50f, +0.20f, +0.00f), red },
-	// - But just to see how it's done...
+		{ XMFLOAT3(-0.75f, +0.20f, +0.00f), blue },
-	unsigned int indices[] = { 0, 1, 2 };
+	};
+	unsigned int ind2[] = { 0, 1, 2, 0, 2, 3 };
 
+	Vertex verts3[] = {
+		{ XMFLOAT3(+0.00f, +0.30f, +0.00f), white },
+		{ XMFLOAT3(+0.15f, +0.15f, +0.00f), black },
+		{ XMFLOAT3(+0.15f, -0.15f, +0.00f), white },
+		{ XMFLOAT3(+0.00f, -0.30f, +0.00f), black },
+		{ XMFLOAT3(-0.15f, -0.15f, +0.00f), white },
+		{ XMFLOAT3(-0.15f, +0.15f, +0.00f), black },
+	};
+	unsigned int ind3[] = { 0,1,5 , 1,2,5 , 2,3,4 , 2,4,5 };
 
-	// Create the VERTEX BUFFER description -----------------------------------
+	shapes = {
-	// - The description is created on the stack because we only need
+		std::make_shared<Mesh>(verts1, 03, ind1, 03, device, context),
-	//    it to create the buffer.  The description is then useless.
+		std::make_shared<Mesh>(verts2, 04, ind2, 06, device, context),
-	D3D11_BUFFER_DESC vbd = {};
+		std::make_shared<Mesh>(verts3, 06, ind3, 12, device, context),
-	vbd.Usage = D3D11_USAGE_IMMUTABLE;
+	};
-	vbd.ByteWidth = sizeof(Vertex) * 3;       // 3 = number of vertices in the buffer
-	vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER; // Tells DirectX this is a vertex buffer
-	vbd.CPUAccessFlags = 0;
-	vbd.MiscFlags = 0;
-	vbd.StructureByteStride = 0;
-
-	// Create the proper struct to hold the initial vertex data
-	// - This is how we put the initial data into the buffer
-	D3D11_SUBRESOURCE_DATA initialVertexData = {};
-	initialVertexData.pSysMem = vertices;
-
-	// Actually create the buffer with the initial data
-	// - Once we do this, we'll NEVER CHANGE THE BUFFER AGAIN
-	device->CreateBuffer(&vbd, &initialVertexData, vertexBuffer.GetAddressOf());
-
-
-
-	// Create the INDEX BUFFER description ------------------------------------
-	// - The description is created on the stack because we only need
-	//    it to create the buffer.  The description is then useless.
-	D3D11_BUFFER_DESC ibd = {};
-	ibd.Usage = D3D11_USAGE_IMMUTABLE;
-	ibd.ByteWidth = sizeof(unsigned int) * 3;	// 3 = number of indices in the buffer
-	ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;	// Tells DirectX this is an index buffer
-	ibd.CPUAccessFlags = 0;
-	ibd.MiscFlags = 0;
-	ibd.StructureByteStride = 0;
-
-	// Create the proper struct to hold the initial index data
-	// - This is how we put the initial data into the buffer
-	D3D11_SUBRESOURCE_DATA initialIndexData = {};
-	initialIndexData.pSysMem = indices;
-
-	// Actually create the buffer with the initial data
-	// - Once we do this, we'll NEVER CHANGE THE BUFFER AGAIN
-	device->CreateBuffer(&ibd, &initialIndexData, indexBuffer.GetAddressOf());
-
 }
 
 
@@ -275,30 +238,10 @@ void Game::Draw(float deltaTime, float totalTime)
 	// - However, this isn't always the case (but might be for this course)
 	context->IASetInputLayout(inputLayout.Get());
 
-
+	for (int i = 0; i < shapes.size(); ++i)
-	// Set buffers in the input assembler
+	{
-	//  - Do this ONCE PER OBJECT you're drawing, since each object might
+		shapes[i]->Draw();
-	//    have different geometry.
+	}
-	//  - for this demo, this step *could* simply be done once during Init(),
-	//    but I'm doing it here because it's often done multiple times per frame
-	//    in a larger application/game
-	UINT stride = sizeof(Vertex);
-	UINT offset = 0;
-	context->IASetVertexBuffers(0, 1, vertexBuffer.GetAddressOf(), &stride, &offset);
-	context->IASetIndexBuffer(indexBuffer.Get(), DXGI_FORMAT_R32_UINT, 0);
-
-
-	// Finally do the actual drawing
-	//  - Do this ONCE PER OBJECT you intend to draw
-	//  - This will use all of the currently set DirectX "stuff" (shaders, buffers, etc)
-	//  - DrawIndexed() uses the currently set INDEX BUFFER to look up corresponding
-	//     vertices in the currently set VERTEX BUFFER
-	context->DrawIndexed(
-		3,     // The number of indices to use (we could draw a subset if we wanted)
-		0,     // Offset to the first index we want to use
-		0);    // Offset to add to each index when looking up vertices
-
-
 
 	// Present the back buffer to the user
 	//  - Puts the final frame we're drawing into the window so the user can see it

Game.h

@@ -1,8 +1,11 @@
 #pragma once
 
 #include "DXCore.h"
+#include "Mesh.h"
 #include <DirectXMath.h>
 #include <wrl/client.h> // Used for ComPtr - a smart pointer for COM objects
+#include <memory>
+#include <vector>
 
 class Game 
 	: public DXCore
@@ -32,15 +35,14 @@ private:
 	//  - This is a smart pointer for objects that abide by the
 	//    Component Object Model, which DirectX objects do
 	//  - More info here: https://github.com/Microsoft/DirectXTK/wiki/ComPtr
-
-	// Buffers to hold actual geometry data
-	Microsoft::WRL::ComPtr<ID3D11Buffer> vertexBuffer;
-	Microsoft::WRL::ComPtr<ID3D11Buffer> indexBuffer;
 	
 	// Shaders and shader-related constructs
 	Microsoft::WRL::ComPtr<ID3D11PixelShader> pixelShader;
 	Microsoft::WRL::ComPtr<ID3D11VertexShader> vertexShader;
 	Microsoft::WRL::ComPtr<ID3D11InputLayout> inputLayout;
 
+	// Temporary A2 shapes
+	std::vector<std::shared_ptr<Mesh>> shapes;
+
 };
 

Mesh.cpp

@@ -0,0 +1,77 @@
+#include "Mesh.h"
+
+using namespace DirectX;
+
+Mesh::Mesh(Vertex* _vertices, int _vertexCount, unsigned int* _indices, int _indexCount, Microsoft::WRL::ComPtr<ID3D11Device> _device, Microsoft::WRL::ComPtr<ID3D11DeviceContext> _context)
+{
+	// Create the VERTEX BUFFER description
+	D3D11_BUFFER_DESC vbd = {};
+	vbd.Usage = D3D11_USAGE_IMMUTABLE;
+	vbd.ByteWidth = sizeof(Vertex) * _vertexCount;
+	vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
+	vbd.CPUAccessFlags = 0;
+	vbd.MiscFlags = 0;
+	vbd.StructureByteStride = 0;
+
+	// Create the proper struct to hold the initial vertex data
+	// - This is how we put the initial data into the buffer
+	D3D11_SUBRESOURCE_DATA initialVertexData = {};
+	initialVertexData.pSysMem = _vertices;
+
+	// Actually create the buffer with the initial data
+	_device->CreateBuffer(&vbd, &initialVertexData, bufferVertex.GetAddressOf());
+
+	// Create the INDEX BUFFER description
+	D3D11_BUFFER_DESC ibd = {};
+	ibd.Usage = D3D11_USAGE_IMMUTABLE;
+	ibd.ByteWidth = sizeof(unsigned int) * _indexCount;
+	ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
+	ibd.CPUAccessFlags = 0;
+	ibd.MiscFlags = 0;
+	ibd.StructureByteStride = 0;
+
+	// Create the proper struct to hold the initial index data
+	D3D11_SUBRESOURCE_DATA initialIndexData = {};
+	initialIndexData.pSysMem = _indices;
+	countIndex = _indexCount;
+
+	// Create the buffer with the initial data
+	_device->CreateBuffer(&ibd, &initialIndexData, bufferIndex.GetAddressOf());
+
+	deviceContext = _context;
+}
+
+Mesh::~Mesh()
+{
+	// Because this is using ComPtr, destructor for now is unnecessary
+}
+
+void Mesh::Draw()
+{
+	// Set buffers in the input assembler
+	UINT stride = sizeof(Vertex);
+	UINT offset = 0;
+	deviceContext->IASetVertexBuffers(0, 1, bufferVertex.GetAddressOf(), &stride, &offset);
+	deviceContext->IASetIndexBuffer(bufferIndex.Get(), DXGI_FORMAT_R32_UINT, 0);
+
+	// Do the actual drawing
+	deviceContext->DrawIndexed(
+		countIndex, // The number of indices to use (we could draw a subset if we wanted)
+		0,          // Offset to the first index we want to use
+		0);         // Offset to add to each index when looking up vertices
+}
+
+Microsoft::WRL::ComPtr<ID3D11Buffer>* Mesh::GetVertexBuffer()
+{
+	return &bufferVertex;
+}
+
+Microsoft::WRL::ComPtr<ID3D11Buffer>* Mesh::GetIndexBuffer()
+{
+	return &bufferIndex;
+}
+
+int Mesh::GetIndexCount()
+{
+	return countIndex;
+}

Mesh.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <d3d11.h>
+#include <wrl/client.h>
+#include "Vertex.h"
+
+class Mesh
+{
+private:
+	Microsoft::WRL::ComPtr<ID3D11Buffer>            bufferVertex;
+	Microsoft::WRL::ComPtr<ID3D11Buffer>            bufferIndex;
+	Microsoft::WRL::ComPtr<ID3D11DeviceContext>     deviceContext;
+	int                                             countIndex;
+public:
+	Mesh(
+		Vertex*                                     _vertices,
+		int                                         _vertexCount,
+		unsigned int*                               _indices,
+		int                                         _indexCount,
+		Microsoft::WRL::ComPtr<ID3D11Device>        _device,
+		Microsoft::WRL::ComPtr<ID3D11DeviceContext> _context);
+	~Mesh();
+
+	void                                            Draw();
+	Microsoft::WRL::ComPtr<ID3D11Buffer>*           GetVertexBuffer();
+	Microsoft::WRL::ComPtr<ID3D11Buffer>*           GetIndexBuffer();
+	int                                             GetIndexCount();
+};