utilize simple shader
This commit is contained in:
parent
c16053eb6d
commit
d09f63e5fc
GPG key ID:
016F11E0AA296B67
6 changed files with 2313 additions and 70 deletions
|
|
@ -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>
|
||||
|
|
|
|||
|
|
@ -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">
|
||||
|
|
|
|||
71
Game.cpp
71
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
|
||||
// - This is a simplified way of handling raw data
|
||||
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());
|
||||
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());
|
||||
}
|
||||
|
||||
|
||||
|
||||
// --------------------------------------------------------
|
||||
// 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,
|
||||
|
|
|
|||
5
Game.h
5
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;
|
||||
Microsoft::WRL::ComPtr<ID3D11VertexShader> vertexShader;
|
||||
std::shared_ptr<SimplePixelShader> pixelShader;
|
||||
std::shared_ptr<SimpleVertexShader> vertexShader;
|
||||
Microsoft::WRL::ComPtr<ID3D11InputLayout> inputLayout;
|
||||
|
||||
// Temporary A2 shapes
|
||||
|
|
|
|||
1973
SimpleShader.cpp
Normal file
1973
SimpleShader.cpp
Normal file
File diff suppressed because it is too large
Load diff
326
SimpleShader.h
Normal file
326
SimpleShader.h
Normal file
|
|
@ -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();
|
||||
};
|
||||
Reference in a new issue