Merge pull request #2 from xLightling/a3_shaders

A3: Shaders

BufferStructs.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <DirectXMath.h>
+
+struct VertexShaderExternalData
+{
+	DirectX::XMFLOAT4 colorTint;
+	DirectX::XMFLOAT3 offset;
+};

DX11Starter.vcxproj

@@ -130,6 +130,7 @@
     <ClCompile Include="Mesh.cpp" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="BufferStructs.h" />
     <ClInclude Include="DXCore.h" />
     <ClInclude Include="Game.h" />
     <ClInclude Include="Input.h" />

DX11Starter.vcxproj.filters

@@ -50,6 +50,9 @@
     <ClInclude Include="Mesh.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="BufferStructs.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <FxCompile Include="PixelShader.hlsl">

Game.cpp

@@ -1,6 +1,7 @@
 #include "Game.h"
 #include "Vertex.h"
 #include "Input.h"
+#include "BufferStructs.h"
 
 // Needed for a helper function to read compiled shader files from the hard drive
 #pragma comment(lib, "d3dcompiler.lib")
@@ -63,6 +64,21 @@ 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());
 }
 
 // --------------------------------------------------------
@@ -209,6 +225,24 @@ void Game::Update(float deltaTime, float totalTime)
 // --------------------------------------------------------
 void Game::Draw(float deltaTime, float totalTime)
 {
+	// create constant buffer
+	VertexShaderExternalData vsData;
+	vsData.colorTint = XMFLOAT4(1.0f, 0.5f, 0.5f, 1.0f);
+	vsData.offset = XMFLOAT3(0.25f, 0.0f, 0.0f);
+
+	// 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)
+	);
+
 	// Background color (Cornflower Blue in this case) for clearing
 	const float color[4] = { 0.4f, 0.6f, 0.75f, 0.0f };
 

Game.h

@@ -44,5 +44,6 @@ private:
 	// Temporary A2 shapes
 	std::vector<std::shared_ptr<Mesh>> shapes;
 
+	Microsoft::WRL::ComPtr<ID3D11Buffer> constantBufferVS;
 };
 

VertexShader.hlsl

@@ -1,3 +1,8 @@
+cbuffer ExternalData : register(b0)
+{
+	float4 colorTint;
+	float3 offset;
+}
 
 // Struct representing a single vertex worth of data
 // - This should match the vertex definition in our C++ code
@@ -51,12 +56,12 @@ VertexToPixel main( VertexShaderInput input )
 	// - Each of these components is then automatically divided by the W component, 
 	//   which we're leaving at 1.0 for now (this is more useful when dealing with 
 	//   a perspective projection matrix, which we'll get to in the future).
-	output.screenPosition = float4(input.localPosition, 1.0f);
+	output.screenPosition = float4(input.localPosition + offset, 1.0f);
 
 	// Pass the color through 
 	// - The values will be interpolated per-pixel by the rasterizer
 	// - We don't need to alter it here, but we do need to send it to the pixel shader
-	output.color = input.color;
+	output.color = input.color * colorTint;
 
 	// Whatever we return will make its way through the pipeline to the
 	// next programmable stage we're using (the pixel shader for now)