utilize simple shader

DX11Starter.vcxproj

@@ -130,6 +130,7 @@
     <ClCompile Include="Input.cpp" />
     <ClCompile Include="Main.cpp" />
     <ClCompile Include="Mesh.cpp" />
+    <ClCompile Include="SimpleShader.cpp" />
     <ClCompile Include="Transform.cpp" />
   </ItemGroup>
   <ItemGroup>
@@ -140,6 +141,7 @@
     <ClInclude Include="Game.h" />
     <ClInclude Include="Input.h" />
     <ClInclude Include="Mesh.h" />
+    <ClInclude Include="SimpleShader.h" />
     <ClInclude Include="Transform.h" />
     <ClInclude Include="Vertex.h" />
   </ItemGroup>

DX11Starter.vcxproj.filters

@@ -42,6 +42,9 @@
     <ClCompile Include="Camera.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="SimpleShader.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Vertex.h">
@@ -71,6 +74,9 @@
     <ClInclude Include="Camera.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="SimpleShader.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <FxCompile Include="PixelShader.hlsl">

Game.cpp

@@ -2,6 +2,7 @@
 #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
 #pragma comment(lib, "d3dcompiler.lib")
@@ -93,69 +94,10 @@ void Game::Init()
 // --------------------------------------------------------
 void Game::LoadShaders()
 {
-	// Blob for reading raw data
+	vertexShader = std::make_shared<SimpleVertexShader>(device, context, GetFullPathTo_Wide(L"VertexShader.cso").c_str());
-	// - This is a simplified way of handling raw data
+	pixelShader = std::make_shared<SimplePixelShader>(device, context, GetFullPathTo_Wide(L"PixelShader.cso").c_str());
-	ID3DBlob* shaderBlob;
-
-	// Read our compiled vertex shader code into a blob
-	// - Essentially just "open the file and plop its contents here"
-	D3DReadFileToBlob(
-		GetFullPathTo_Wide(L"VertexShader.cso").c_str(), // Using a custom helper for file paths
-		&shaderBlob);
-
-	// Create a vertex shader from the information we
-	// have read into the blob above
-	// - A blob can give a pointer to its contents, and knows its own size
-	device->CreateVertexShader(
-		shaderBlob->GetBufferPointer(), // Get a pointer to the blob's contents
-		shaderBlob->GetBufferSize(),	// How big is that data?
-		0,								// No classes in this shader
-		vertexShader.GetAddressOf());	// The address of the ID3D11VertexShader*
-
-
-	// Create an input layout that describes the vertex format
-	// used by the vertex shader we're using
-	//  - This is used by the pipeline to know how to interpret the raw data
-	//     sitting inside a vertex buffer
-	//  - Doing this NOW because it requires a vertex shader's byte code to verify against!
-	//  - Luckily, we already have that loaded (the blob above)
-	D3D11_INPUT_ELEMENT_DESC inputElements[2] = {};
-
-	// Set up the first element - a position, which is 3 float values
-	inputElements[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;				// Most formats are described as color channels; really it just means "Three 32-bit floats"
-	inputElements[0].SemanticName = "POSITION";							// This is "POSITION" - needs to match the semantics in our vertex shader input!
-	inputElements[0].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;	// How far into the vertex is this?  Assume it's after the previous element
-
-	// Set up the second element - a color, which is 4 more float values
-	inputElements[1].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;			// 4x 32-bit floats
-	inputElements[1].SemanticName = "COLOR";							// Match our vertex shader input!
-	inputElements[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;	// After the previous element
-
-	// Create the input layout, verifying our description against actual shader code
-	device->CreateInputLayout(
-		inputElements,					// An array of descriptions
-		2,								// How many elements in that array
-		shaderBlob->GetBufferPointer(),	// Pointer to the code of a shader that uses this layout
-		shaderBlob->GetBufferSize(),	// Size of the shader code that uses this layout
-		inputLayout.GetAddressOf());	// Address of the resulting ID3D11InputLayout*
-
-
-
-	// Read and create the pixel shader
-	//  - Reusing the same blob here, since we're done with the vert shader code
-	D3DReadFileToBlob(
-		GetFullPathTo_Wide(L"PixelShader.cso").c_str(), // Using a custom helper for file paths
-		&shaderBlob);
-
-	device->CreatePixelShader(
-		shaderBlob->GetBufferPointer(),
-		shaderBlob->GetBufferSize(),
-		0,
-		pixelShader.GetAddressOf());
 }
 
-
-
 // --------------------------------------------------------
 // Creates the geometry we're going to draw - a single triangle for now
 // --------------------------------------------------------
@@ -301,13 +243,6 @@ void Game::Draw(float deltaTime, float totalTime)
 			constantBufferVS.GetAddressOf() // Array of buffers (or address of one)
 		);
 
-		// Set the vertex and pixel shaders to use for the next Draw() command
-		//  - These don't technically need to be set every frame
-		//  - Once you start applying different shaders to different objects,
-		//    you'll need to swap the current shaders before each draw
-		context->VSSetShader(vertexShader.Get(), 0, 0);
-		context->PSSetShader(pixelShader.Get(), 0, 0);
-
 		// 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,

Game.h

@@ -4,6 +4,7 @@
 #include "Camera.h"
 #include "Mesh.h"
 #include "Entity.h"
+#include "SimpleShader.h"
 #include <DirectXMath.h>
 #include <wrl/client.h> // Used for ComPtr - a smart pointer for COM objects
 #include <memory>
@@ -39,8 +40,8 @@ private:
 	//  - More info here: https://github.com/Microsoft/DirectXTK/wiki/ComPtr
 	
 	// Shaders and shader-related constructs
-	Microsoft::WRL::ComPtr<ID3D11PixelShader> pixelShader;
+	std::shared_ptr<SimplePixelShader> pixelShader;
-	Microsoft::WRL::ComPtr<ID3D11VertexShader> vertexShader;
+	std::shared_ptr<SimpleVertexShader> vertexShader;
 	Microsoft::WRL::ComPtr<ID3D11InputLayout> inputLayout;
 
 	// Temporary A2 shapes

SimpleShader.h

@@ -0,0 +1,326 @@
+// CREATOR: https://github.com/vixorien/SimpleShader
+// LICENSE: MIT
+
+#pragma once
+#pragma comment(lib, "dxguid.lib")
+#pragma comment(lib, "d3dcompiler.lib")
+
+#include <d3d11.h>
+#include <d3dcompiler.h>
+#include <DirectXMath.h>
+#include <wrl/client.h>
+
+#include <unordered_map>
+#include <vector>
+#include <string>
+
+
+// --------------------------------------------------------
+// Used by simple shaders to store information about
+// specific variables in constant buffers
+// --------------------------------------------------------
+struct SimpleShaderVariable
+{
+	unsigned int ByteOffset;
+	unsigned int Size;
+	unsigned int ConstantBufferIndex;
+};
+
+// --------------------------------------------------------
+// Contains information about a specific
+// constant buffer in a shader, as well as
+// the local data buffer for it
+// --------------------------------------------------------
+struct SimpleConstantBuffer
+{
+	std::string Name;
+	D3D_CBUFFER_TYPE Type = D3D_CBUFFER_TYPE::D3D11_CT_CBUFFER;
+	unsigned int Size = 0;
+	unsigned int BindIndex = 0;
+	Microsoft::WRL::ComPtr<ID3D11Buffer> ConstantBuffer = 0;
+	unsigned char* LocalDataBuffer = 0;
+	std::vector<SimpleShaderVariable> Variables;
+};
+
+// --------------------------------------------------------
+// Contains info about a single SRV in a shader
+// --------------------------------------------------------
+struct SimpleSRV
+{
+	unsigned int Index;		// The raw index of the SRV
+	unsigned int BindIndex; // The register of the SRV
+};
+
+// --------------------------------------------------------
+// Contains info about a single Sampler in a shader
+// --------------------------------------------------------
+struct SimpleSampler
+{
+	unsigned int Index;		// The raw index of the Sampler
+	unsigned int BindIndex; // The register of the Sampler
+};
+
+// --------------------------------------------------------
+// Base abstract class for simplifying shader handling
+// --------------------------------------------------------
+class ISimpleShader
+{
+public:
+	ISimpleShader(Microsoft::WRL::ComPtr<ID3D11Device> device, Microsoft::WRL::ComPtr<ID3D11DeviceContext> context);
+	virtual ~ISimpleShader();
+
+	// Simple helpers
+	bool IsShaderValid() { return shaderValid; }
+
+	// Activating the shader and copying data
+	void SetShader();
+	void CopyAllBufferData();
+	void CopyBufferData(unsigned int index);
+	void CopyBufferData(std::string bufferName);
+
+	// Sets arbitrary shader data
+	bool SetData(std::string name, const void* data, unsigned int size);
+
+	bool SetInt(std::string name, int data);
+	bool SetFloat(std::string name, float data);
+	bool SetFloat2(std::string name, const float data[2]);
+	bool SetFloat2(std::string name, const DirectX::XMFLOAT2 data);
+	bool SetFloat3(std::string name, const float data[3]);
+	bool SetFloat3(std::string name, const DirectX::XMFLOAT3 data);
+	bool SetFloat4(std::string name, const float data[4]);
+	bool SetFloat4(std::string name, const DirectX::XMFLOAT4 data);
+	bool SetMatrix4x4(std::string name, const float data[16]);
+	bool SetMatrix4x4(std::string name, const DirectX::XMFLOAT4X4 data);
+
+	// Setting shader resources
+	virtual bool SetShaderResourceView(std::string name, Microsoft::WRL::ComPtr<ID3D11ShaderResourceView> srv) = 0;
+	virtual bool SetSamplerState(std::string name, Microsoft::WRL::ComPtr<ID3D11SamplerState> samplerState) = 0;
+
+	// Simple resource checking
+	bool HasVariable(std::string name);
+	bool HasShaderResourceView(std::string name);
+	bool HasSamplerState(std::string name);
+
+	// Getting data about variables and resources
+	const SimpleShaderVariable* GetVariableInfo(std::string name);
+
+	const SimpleSRV* GetShaderResourceViewInfo(std::string name);
+	const SimpleSRV* GetShaderResourceViewInfo(unsigned int index);
+	size_t GetShaderResourceViewCount() { return textureTable.size(); }
+
+	const SimpleSampler* GetSamplerInfo(std::string name);
+	const SimpleSampler* GetSamplerInfo(unsigned int index);
+	size_t GetSamplerCount() { return samplerTable.size(); }
+
+	// Get data about constant buffers
+	unsigned int GetBufferCount();
+	unsigned int GetBufferSize(unsigned int index);
+	const SimpleConstantBuffer* GetBufferInfo(std::string name);
+	const SimpleConstantBuffer* GetBufferInfo(unsigned int index);
+
+	// Misc getters
+	Microsoft::WRL::ComPtr<ID3DBlob> GetShaderBlob() { return shaderBlob; }
+
+	// Error reporting
+	static bool ReportErrors;
+	static bool ReportWarnings;
+
+protected:
+
+	bool shaderValid;
+	Microsoft::WRL::ComPtr<ID3DBlob> shaderBlob;
+	Microsoft::WRL::ComPtr<ID3D11Device> device;
+	Microsoft::WRL::ComPtr<ID3D11DeviceContext> deviceContext;
+
+	// Resource counts
+	unsigned int constantBufferCount;
+
+	// Maps for variables and buffers
+	SimpleConstantBuffer* constantBuffers; // For index-based lookup
+	std::vector<SimpleSRV*>		shaderResourceViews;
+	std::vector<SimpleSampler*>	samplerStates;
+	std::unordered_map<std::string, SimpleConstantBuffer*> cbTable;
+	std::unordered_map<std::string, SimpleShaderVariable> varTable;
+	std::unordered_map<std::string, SimpleSRV*> textureTable;
+	std::unordered_map<std::string, SimpleSampler*> samplerTable;
+
+	// Initialization method
+	bool LoadShaderFile(LPCWSTR shaderFile);
+
+	// Pure virtual functions for dealing with shader types
+	virtual bool CreateShader(Microsoft::WRL::ComPtr<ID3DBlob> shaderBlob) = 0;
+	virtual void SetShaderAndCBs() = 0;
+
+	virtual void CleanUp();
+
+	// Helpers for finding data by name
+	SimpleShaderVariable* FindVariable(std::string name, int size);
+	SimpleConstantBuffer* FindConstantBuffer(std::string name);
+
+	// Error logging
+	void Log(std::string message, WORD color);
+	void LogW(std::wstring message, WORD color);
+	void Log(std::string message);
+	void LogW(std::wstring message);
+	void LogError(std::string message);
+	void LogErrorW(std::wstring message);
+	void LogWarning(std::string message);
+	void LogWarningW(std::wstring message);
+};
+
+// --------------------------------------------------------
+// Derived class for VERTEX shaders ///////////////////////
+// --------------------------------------------------------
+class SimpleVertexShader : public ISimpleShader
+{
+public:
+	SimpleVertexShader(Microsoft::WRL::ComPtr<ID3D11Device> device, Microsoft::WRL::ComPtr<ID3D11DeviceContext> context, LPCWSTR shaderFile);
+	SimpleVertexShader(Microsoft::WRL::ComPtr<ID3D11Device> device, Microsoft::WRL::ComPtr<ID3D11DeviceContext> context, LPCWSTR shaderFile, Microsoft::WRL::ComPtr<ID3D11InputLayout> inputLayout, bool perInstanceCompatible);
+	~SimpleVertexShader();
+	Microsoft::WRL::ComPtr<ID3D11VertexShader> GetDirectXShader() { return shader; }
+	Microsoft::WRL::ComPtr<ID3D11InputLayout> GetInputLayout() { return inputLayout; }
+	bool GetPerInstanceCompatible() { return perInstanceCompatible; }
+
+	bool SetShaderResourceView(std::string name, Microsoft::WRL::ComPtr<ID3D11ShaderResourceView> srv);
+	bool SetSamplerState(std::string name, Microsoft::WRL::ComPtr<ID3D11SamplerState> samplerState);
+
+protected:
+	bool perInstanceCompatible;
+	Microsoft::WRL::ComPtr<ID3D11InputLayout> inputLayout;
+	Microsoft::WRL::ComPtr<ID3D11VertexShader> shader;
+	bool CreateShader(Microsoft::WRL::ComPtr<ID3DBlob> shaderBlob);
+	void SetShaderAndCBs();
+	void CleanUp();
+};
+
+
+// --------------------------------------------------------
+// Derived class for PIXEL shaders ////////////////////////
+// --------------------------------------------------------
+class SimplePixelShader : public ISimpleShader
+{
+public:
+	SimplePixelShader(Microsoft::WRL::ComPtr<ID3D11Device> device, Microsoft::WRL::ComPtr<ID3D11DeviceContext> context, LPCWSTR shaderFile);
+	~SimplePixelShader();
+	Microsoft::WRL::ComPtr<ID3D11PixelShader> GetDirectXShader() { return shader; }
+
+	bool SetShaderResourceView(std::string name, Microsoft::WRL::ComPtr<ID3D11ShaderResourceView> srv);
+	bool SetSamplerState(std::string name, Microsoft::WRL::ComPtr<ID3D11SamplerState> samplerState);
+
+protected:
+	Microsoft::WRL::ComPtr<ID3D11PixelShader> shader;
+	bool CreateShader(Microsoft::WRL::ComPtr<ID3DBlob> shaderBlob);
+	void SetShaderAndCBs();
+	void CleanUp();
+};
+
+// --------------------------------------------------------
+// Derived class for DOMAIN shaders ///////////////////////
+// --------------------------------------------------------
+class SimpleDomainShader : public ISimpleShader
+{
+public:
+	SimpleDomainShader(Microsoft::WRL::ComPtr<ID3D11Device> device, Microsoft::WRL::ComPtr<ID3D11DeviceContext> context, LPCWSTR shaderFile);
+	~SimpleDomainShader();
+	Microsoft::WRL::ComPtr<ID3D11DomainShader> GetDirectXShader() { return shader; }
+
+	bool SetShaderResourceView(std::string name, Microsoft::WRL::ComPtr<ID3D11ShaderResourceView> srv);
+	bool SetSamplerState(std::string name, Microsoft::WRL::ComPtr<ID3D11SamplerState> samplerState);
+
+protected:
+	Microsoft::WRL::ComPtr<ID3D11DomainShader> shader;
+	bool CreateShader(Microsoft::WRL::ComPtr<ID3DBlob> shaderBlob);
+	void SetShaderAndCBs();
+	void CleanUp();
+};
+
+// --------------------------------------------------------
+// Derived class for HULL shaders /////////////////////////
+// --------------------------------------------------------
+class SimpleHullShader : public ISimpleShader
+{
+public:
+	SimpleHullShader(Microsoft::WRL::ComPtr<ID3D11Device> device, Microsoft::WRL::ComPtr<ID3D11DeviceContext> context, LPCWSTR shaderFile);
+	~SimpleHullShader();
+	Microsoft::WRL::ComPtr<ID3D11HullShader> GetDirectXShader() { return shader; }
+
+	bool SetShaderResourceView(std::string name, Microsoft::WRL::ComPtr<ID3D11ShaderResourceView> srv);
+	bool SetSamplerState(std::string name, Microsoft::WRL::ComPtr<ID3D11SamplerState> samplerState);
+
+protected:
+	Microsoft::WRL::ComPtr<ID3D11HullShader> shader;
+	bool CreateShader(Microsoft::WRL::ComPtr<ID3DBlob> shaderBlob);
+	void SetShaderAndCBs();
+	void CleanUp();
+};
+
+// --------------------------------------------------------
+// Derived class for GEOMETRY shaders /////////////////////
+// --------------------------------------------------------
+class SimpleGeometryShader : public ISimpleShader
+{
+public:
+	SimpleGeometryShader(Microsoft::WRL::ComPtr<ID3D11Device> device, Microsoft::WRL::ComPtr<ID3D11DeviceContext> context, LPCWSTR shaderFile, bool useStreamOut = 0, bool allowStreamOutRasterization = 0);
+	~SimpleGeometryShader();
+	Microsoft::WRL::ComPtr<ID3D11GeometryShader> GetDirectXShader() { return shader; }
+
+	bool SetShaderResourceView(std::string name, Microsoft::WRL::ComPtr<ID3D11ShaderResourceView> srv);
+	bool SetSamplerState(std::string name, Microsoft::WRL::ComPtr<ID3D11SamplerState> samplerState);
+
+	bool CreateCompatibleStreamOutBuffer(Microsoft::WRL::ComPtr<ID3D11Buffer> buffer, int vertexCount);
+
+	static void UnbindStreamOutStage(Microsoft::WRL::ComPtr<ID3D11DeviceContext> deviceContext);
+
+protected:
+	// Shader itself
+	Microsoft::WRL::ComPtr<ID3D11GeometryShader> shader;
+
+	// Stream out related
+	bool useStreamOut;
+	bool allowStreamOutRasterization;
+	unsigned int streamOutVertexSize;
+
+	bool CreateShader(Microsoft::WRL::ComPtr<ID3DBlob> shaderBlob);
+	bool CreateShaderWithStreamOut(Microsoft::WRL::ComPtr<ID3DBlob> shaderBlob);
+	void SetShaderAndCBs();
+	void CleanUp();
+
+	// Helpers
+	unsigned int CalcComponentCount(unsigned int mask);
+};
+
+
+// --------------------------------------------------------
+// Derived class for COMPUTE shaders //////////////////////
+// --------------------------------------------------------
+class SimpleComputeShader : public ISimpleShader
+{
+public:
+	SimpleComputeShader(Microsoft::WRL::ComPtr<ID3D11Device> device, Microsoft::WRL::ComPtr<ID3D11DeviceContext> context, LPCWSTR shaderFile);
+	~SimpleComputeShader();
+	Microsoft::WRL::ComPtr<ID3D11ComputeShader> GetDirectXShader() { return shader; }
+
+	void DispatchByGroups(unsigned int groupsX, unsigned int groupsY, unsigned int groupsZ);
+	void DispatchByThreads(unsigned int threadsX, unsigned int threadsY, unsigned int threadsZ);
+
+	bool HasUnorderedAccessView(std::string name);
+
+	bool SetShaderResourceView(std::string name, Microsoft::WRL::ComPtr<ID3D11ShaderResourceView> srv);
+	bool SetSamplerState(std::string name, Microsoft::WRL::ComPtr<ID3D11SamplerState> samplerState);
+	bool SetUnorderedAccessView(std::string name, Microsoft::WRL::ComPtr<ID3D11UnorderedAccessView> uav, unsigned int appendConsumeOffset = -1);
+
+	int GetUnorderedAccessViewIndex(std::string name);
+
+protected:
+	Microsoft::WRL::ComPtr<ID3D11ComputeShader> shader;
+	std::unordered_map<std::string, unsigned int> uavTable;
+
+	unsigned int threadsX;
+	unsigned int threadsY;
+	unsigned int threadsZ;
+	unsigned int threadsTotal;
+
+	bool CreateShader(Microsoft::WRL::ComPtr<ID3DBlob> shaderBlob);
+	void SetShaderAndCBs();
+	void CleanUp();
+};