lightling/DX11Starter
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge pull request #1 from xLightling/a2_meshes

Browse source 
A2: Meshes
This commit is contained in:
lightling 2022-01-15 16:46:25 -05:00 • committed by GitHub
commit 3453d2f0f7
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
6 changed files with 151 additions and 93 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
DX11Starter.vcxproj
View file

@ -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>

6
DX11Starter.vcxproj.filters
View file

@ -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">

121
Game.cpp
View file

@ -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
// - We're going to copy this array, exactly as it exists in memory
// over to a DirectX-controlled data structure (the vertex buffer)
// - Note: Since we don't have a camera or really any concept of
// 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 },
Vertex verts1[] = {
{ XMFLOAT3(+0.50f, +0.75f, +0.00f), red },
{ XMFLOAT3(+0.75f, +0.25f, +0.00f), blue },
{ XMFLOAT3(+0.25f, +0.25f, +0.00f), green },
};
unsigned int ind1[] = { 0, 1, 2 };
// Set up the indices, which tell us which vertices to use and in which order
// - This is somewhat redundant for just 3 vertices (it's a simple example)
// - Indices are technically not required if the vertices are in the buffer
// in the correct order and each one will be used exactly once
// - But just to see how it's done...
unsigned int indices[] = { 0, 1, 2 };
Vertex verts2[] = {
{ XMFLOAT3(-0.75f, +0.50f, +0.00f), red },
{ XMFLOAT3(-0.50f, +0.50f, +0.00f), blue },
{ XMFLOAT3(-0.50f, +0.20f, +0.00f), red },
{ XMFLOAT3(-0.75f, +0.20f, +0.00f), blue },
};
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 -----------------------------------
// - The description is created on the stack because we only need
// it to create the buffer. The description is then useless.
D3D11_BUFFER_DESC vbd = {};
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());
shapes = {
std::make_shared<Mesh>(verts1, 03, ind1, 03, device, context),
std::make_shared<Mesh>(verts2, 04, ind2, 06, device, context),
std::make_shared<Mesh>(verts3, 06, ind3, 12, device, context),
};
}
@ -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());
// Set buffers in the input assembler
// - Do this ONCE PER OBJECT you're drawing, since each object might
// 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
for (int i = 0; i < shapes.size(); ++i)
{
shapes[i]->Draw();
}
// Present the back buffer to the user
// - Puts the final frame we're drawing into the window so the user can see it

10
Game.h
View file

@ -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;
};

77
Mesh.cpp Normal file
View file

@ -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;
}

28
Mesh.h Normal file
View file

@ -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();
};