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

create materials

Browse source
This commit is contained in:
lightling 2022-02-27 12:28:58 -05:00
parent d09f63e5fc
commit 34ed169216
Signed by: lightling
GPG key ID: 016F11E0AA296B67
9 changed files with 135 additions and 74 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
BufferStructs.h
View file

@ -1,11 +0,0 @@
#pragma once
#include <DirectXMath.h>
struct VertexShaderExternalData
{
DirectX::XMFLOAT4 colorTint;
DirectX::XMFLOAT4X4 world;
DirectX::XMFLOAT4X4 view;
DirectX::XMFLOAT4X4 projection;
};

3
DX11Starter.vcxproj
View file

@ -129,17 +129,18 @@
<ClCompile Include="Game.cpp" />
<ClCompile Include="Input.cpp" />
<ClCompile Include="Main.cpp" />
<ClCompile Include="Material.cpp" />
<ClCompile Include="Mesh.cpp" />
<ClCompile Include="SimpleShader.cpp" />
<ClCompile Include="Transform.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="BufferStructs.h" />
<ClInclude Include="Camera.h" />
<ClInclude Include="DXCore.h" />
<ClInclude Include="Entity.h" />
<ClInclude Include="Game.h" />
<ClInclude Include="Input.h" />
<ClInclude Include="Material.h" />
<ClInclude Include="Mesh.h" />
<ClInclude Include="SimpleShader.h" />
<ClInclude Include="Transform.h" />

9
DX11Starter.vcxproj.filters
View file

@ -45,6 +45,9 @@
<ClCompile Include="SimpleShader.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="Material.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="Vertex.h">
@ -62,9 +65,6 @@
<ClInclude Include="Mesh.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="BufferStructs.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="Transform.h">
<Filter>Header Files</Filter>
</ClInclude>
@ -77,6 +77,9 @@
<ClInclude Include="SimpleShader.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="Material.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<FxCompile Include="PixelShader.hlsl">

13
Entity.cpp
View file

@ -1,7 +1,8 @@
#include "Entity.h"
Entity::Entity(std::shared_ptr<Mesh> _mesh)
Entity::Entity(std::shared_ptr<Material> _material, std::shared_ptr<Mesh> _mesh)
{
material = _material;
mesh = _mesh;
}
@ -14,3 +15,13 @@ std::shared_ptr<Mesh> Entity::GetMesh()
{
return mesh;
}
std::shared_ptr<Material> Entity::GetMaterial()
{
return material;
}
void Entity::SetMaterial(std::shared_ptr<Material> _material)
{
material = _material;
}

17
Entity.h
View file

@ -2,17 +2,24 @@
#include "Mesh.h"
#include "Transform.h"
#include "Material.h"
#include <memory>
class Entity
{
public:
Entity(std::shared_ptr<Mesh> _mesh);
Entity(
std::shared_ptr<Material> _material,
std::shared_ptr<Mesh> _mesh);
Transform* GetTransform();
std::shared_ptr<Mesh> GetMesh();
Transform* GetTransform();
std::shared_ptr<Mesh> GetMesh();
std::shared_ptr<Material> GetMaterial();
void SetMaterial(std::shared_ptr<Material> _material);
private:
Transform transform;
std::shared_ptr<Mesh> mesh;
Transform transform;
std::shared_ptr<Mesh> mesh;
std::shared_ptr<Material> material;
};

78
Game.cpp
View file

@ -1,7 +1,6 @@
#include "Game.h"
#include "Vertex.h"
#include "Input.h"
#include "BufferStructs.h"
#include "SimpleShader.h"
// Needed for a helper function to read compiled shader files from the hard drive
@ -67,21 +66,6 @@ void Game::Init()
// geometric primitives (points, lines or triangles) we want to draw.
// Essentially: "What kind of shape should the GPU draw with our data?"
context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
// Get size as the next multiple of 16 (instead of hardcoding a size here!)
unsigned int size = sizeof(VertexShaderExternalData);
// This will work even if your struct size changes.
// Adding 15 ensures either go past next multiple of 16, or if size is already a multiple, we almost get to next multiple.
// Integer division tells us how many 16's would fit (w/o remainder). Get back to multiple of 16 with multiplication step.
size = (size + 15) / 16 * 16;
// Describe constant buffer
D3D11_BUFFER_DESC cbDesc = {}; // zero-out
cbDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
cbDesc.ByteWidth = size; // must be multiple of 16
cbDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
cbDesc.Usage = D3D11_USAGE_DYNAMIC;
device->CreateBuffer(&cbDesc, 0, constantBufferVS.GetAddressOf());
}
// --------------------------------------------------------
@ -96,6 +80,17 @@ void Game::LoadShaders()
{
vertexShader = std::make_shared<SimpleVertexShader>(device, context, GetFullPathTo_Wide(L"VertexShader.cso").c_str());
pixelShader = std::make_shared<SimplePixelShader>(device, context, GetFullPathTo_Wide(L"PixelShader.cso").c_str());
// thanks to https://harry7557558.github.io/tools/colorpicker.html for having the only 0f-1f picker i could find
XMFLOAT4 white = XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f);
XMFLOAT4 deeppink = XMFLOAT4(1.0f, 0.08f, 0.4f, 1.0f);
XMFLOAT4 deepcoral = XMFLOAT4(1.0f, 0.39f, 0.22f, 1.0f);
materials = {
std::make_shared<Material>(white, vertexShader, pixelShader),
std::make_shared<Material>(deeppink, vertexShader, pixelShader),
std::make_shared<Material>(deepcoral, vertexShader, pixelShader),
};
}
// --------------------------------------------------------
@ -144,15 +139,15 @@ void Game::CreateBasicGeometry()
};
entities = {
std::make_shared<Entity>(shapes[0]),
std::make_shared<Entity>(shapes[0]),
std::make_shared<Entity>(shapes[0]),
std::make_shared<Entity>(shapes[1]),
std::make_shared<Entity>(shapes[1]),
std::make_shared<Entity>(shapes[1]),
std::make_shared<Entity>(shapes[2]),
std::make_shared<Entity>(shapes[2]),
std::make_shared<Entity>(shapes[2]),
std::make_shared<Entity>(materials[0], shapes[0]),
std::make_shared<Entity>(materials[1], shapes[0]),
std::make_shared<Entity>(materials[2], shapes[0]),
std::make_shared<Entity>(materials[0], shapes[1]),
std::make_shared<Entity>(materials[1], shapes[1]),
std::make_shared<Entity>(materials[2], shapes[1]),
std::make_shared<Entity>(materials[0], shapes[2]),
std::make_shared<Entity>(materials[1], shapes[2]),
std::make_shared<Entity>(materials[2], shapes[2]),
};
}
@ -224,32 +219,15 @@ void Game::Draw(float deltaTime, float totalTime)
for (auto entity : entities)
{
// create constant buffer
VertexShaderExternalData vsData;
vsData.colorTint = XMFLOAT4(1.0f, 0.5f, 0.5f, 1.0f);
vsData.world = entity->GetTransform()->GetWorldMatrix();
vsData.view = camera->GetViewMatrix();
vsData.projection = camera->GetProjectionMatrix();
// copy constant buffer to resource
D3D11_MAPPED_SUBRESOURCE mappedBuffer = {};
context->Map(constantBufferVS.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedBuffer);
memcpy(mappedBuffer.pData, &vsData, sizeof(vsData));
context->Unmap(constantBufferVS.Get(), 0);
// bind constant buffer
context->VSSetConstantBuffers(
0, // which slot (register) to bind buffer to?
1, // how many are we activating? can do multiple at once?
constantBufferVS.GetAddressOf() // Array of buffers (or address of one)
);
// Ensure the pipeline knows how to interpret the data (numbers)
// from the vertex buffer.
// - If all of your 3D models use the exact same vertex layout,
// this could simply be done once in Init()
// - However, this isn't always the case (but might be for this course)
context->IASetInputLayout(inputLayout.Get());
std::shared_ptr<SimpleVertexShader> vs = entity->GetMaterial()->GetVertexShader();
vs->SetFloat4("colorTint", entity->GetMaterial()->GetTint());
vs->SetMatrix4x4("world", entity->GetTransform()->GetWorldMatrix());
vs->SetMatrix4x4("view", camera->GetViewMatrix());
vs->SetMatrix4x4("projection", camera->GetProjectionMatrix());
vs->CopyAllBufferData();
entity->GetMaterial()->GetVertexShader()->SetShader();
entity->GetMaterial()->GetPixelShader()->SetShader();
entity->GetMesh()->Draw();
}

8
Game.h
View file

@ -5,6 +5,7 @@
#include "Mesh.h"
#include "Entity.h"
#include "SimpleShader.h"
#include "Material.h"
#include <DirectXMath.h>
#include <wrl/client.h> // Used for ComPtr - a smart pointer for COM objects
#include <memory>
@ -42,14 +43,15 @@ private:
// Shaders and shader-related constructs
std::shared_ptr<SimplePixelShader> pixelShader;
std::shared_ptr<SimpleVertexShader> vertexShader;
Microsoft::WRL::ComPtr<ID3D11InputLayout> inputLayout;
// Temporary A2 shapes
// A2 shapes
std::vector<std::shared_ptr<Mesh>> shapes;
// Temporary A4 entities;
// A4 entities;
std::vector<std::shared_ptr<Entity>> entities;
// A5 Camera
std::shared_ptr<Camera> camera;
// A6 Materials
std::vector<std::shared_ptr<Material>> materials;
Microsoft::WRL::ComPtr<ID3D11Buffer> constantBufferVS;
};

42
Material.cpp Normal file
View file

@ -0,0 +1,42 @@
#include "Material.h"
Material::Material(DirectX::XMFLOAT4 _tint, std::shared_ptr<SimpleVertexShader> _vertexShader, std::shared_ptr<SimplePixelShader> _pixelShader)
{
tint = _tint;
vertexShader = _vertexShader;
pixelShader = _pixelShader;
}
Material::~Material()
{
}
DirectX::XMFLOAT4 Material::GetTint()
{
return tint;
}
std::shared_ptr<SimpleVertexShader> Material::GetVertexShader()
{
return vertexShader;
}
std::shared_ptr<SimplePixelShader> Material::GetPixelShader()
{
return pixelShader;
}
void Material::SetTint(DirectX::XMFLOAT4 _tint)
{
tint = _tint;
}
void Material::SetVertexShader(std::shared_ptr<SimpleVertexShader> _vertexShader)
{
vertexShader = _vertexShader;
}
void Material::SetPixelShader(std::shared_ptr<SimplePixelShader> _pixelShader)
{
pixelShader = _pixelShader;
}

28
Material.h Normal file
View file

@ -0,0 +1,28 @@
#pragma once
#include <DirectXMath.h>
#include <memory>
#include "SimpleShader.h"
class Material
{
public:
Material(
DirectX::XMFLOAT4 _tint,
std::shared_ptr<SimpleVertexShader> _vertexShader,
std::shared_ptr<SimplePixelShader> _pixelShader);
~Material();
DirectX::XMFLOAT4 GetTint();
std::shared_ptr<SimpleVertexShader> GetVertexShader();
std::shared_ptr<SimplePixelShader> GetPixelShader();
void SetTint(DirectX::XMFLOAT4 _tint);
void SetVertexShader(std::shared_ptr<SimpleVertexShader> _vertexShader);
void SetPixelShader(std::shared_ptr<SimplePixelShader> _pixelShader);
private:
DirectX::XMFLOAT4 tint;
std::shared_ptr<SimpleVertexShader> vertexShader;
std::shared_ptr<SimplePixelShader> pixelShader;
};