595 lines
21 KiB
C++
595 lines
21 KiB
C++
#pragma once
|
|
|
|
//#include <DXUT.h>
|
|
//#include <SDKMisc.h>
|
|
#include <d3d11.h>
|
|
#include <wrl.h>
|
|
#include <vector>
|
|
#include <iostream>
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
#include <string>
|
|
#include <map>
|
|
#include <set>
|
|
|
|
|
|
#define COMPILED_SHADER_DIR "compiled/"
|
|
|
|
#ifndef V
|
|
#define V(x) { hr = (x); }
|
|
#endif
|
|
#ifndef V_RETURN
|
|
#define V_RETURN(x) { hr = (x); if( FAILED(hr) ) { return hr; } }
|
|
#endif
|
|
|
|
|
|
#ifndef SAFE_DELETE
|
|
#define SAFE_DELETE(p) { if (p) { delete (p); (p)=NULL; } }
|
|
#endif
|
|
#ifndef SAFE_DELETE_ARRAY
|
|
#define SAFE_DELETE_ARRAY(p) { if (p) { delete[] (p); (p)=NULL; } }
|
|
#endif
|
|
#ifndef SAFE_RELEASE
|
|
#define SAFE_RELEASE(p) { if (p) { (p)->Release(); (p)=NULL; } }
|
|
#endif
|
|
|
|
enum SHADERTYPE {
|
|
VERTEX_SHADER = 1,
|
|
HULL_SHADER = 2,
|
|
DOMAIN_SHADER = 4,
|
|
GEOMETRY_SHADER = 8,
|
|
PIXEL_SHADER = 16,
|
|
COMPUTE_SHADER = 32,
|
|
};
|
|
|
|
|
|
|
|
static ULARGE_INTEGER GetFileChangeTime(char* name) {
|
|
HANDLE hFile = CreateFile(
|
|
name,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL
|
|
);
|
|
|
|
ULARGE_INTEGER create, access, write;
|
|
GetFileTime(
|
|
hFile,
|
|
LPFILETIME(&create),
|
|
LPFILETIME(&access),
|
|
LPFILETIME(&write)
|
|
);
|
|
|
|
CloseHandle(hFile);
|
|
return write;
|
|
}
|
|
|
|
static bool GetAndSetFileChange(char* name, ULARGE_INTEGER& lastWrite) {
|
|
ULARGE_INTEGER write = GetFileChangeTime(name);
|
|
if ( write.QuadPart > lastWrite.QuadPart ) {
|
|
lastWrite = write;
|
|
return true;
|
|
}
|
|
lastWrite = write;
|
|
return false;
|
|
}
|
|
|
|
static bool GetFileChange(char* name, ULARGE_INTEGER lastWrite) {
|
|
return GetFileChangeTime(name).QuadPart > lastWrite.QuadPart;
|
|
}
|
|
|
|
__forceinline std::string GetFileExt(const std::string& file)
|
|
{
|
|
size_t found = file.find_last_of(".");
|
|
return file.substr(found+1);
|
|
}
|
|
|
|
__forceinline std::string ReplaceFileExtension(const std::string& file, const std::string& ext)
|
|
{
|
|
size_t found = file.find_last_of(".");
|
|
return file.substr(0,found) + ext;
|
|
}
|
|
|
|
__forceinline std::string ExtractPath(const std::string& fname)
|
|
{
|
|
size_t pos = fname.find_last_of("\\/");
|
|
return (std::string::npos == pos) ? "" : fname.substr(0, pos);
|
|
}
|
|
|
|
// custom include handle
|
|
class CShaderInclude : public ID3DInclude {
|
|
public:
|
|
CShaderInclude(const char* shaderDir, const char* systemDir = "");
|
|
|
|
HRESULT __stdcall Open(D3D_INCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes);
|
|
HRESULT __stdcall Close(LPCVOID pData);
|
|
const std::set<std::string>& GetIncludes() const {return m_includeFiles;}
|
|
private:
|
|
std::string m_ShaderDir;
|
|
std::string m_SystemDir;
|
|
std::set<std::string> m_includeFiles;
|
|
};
|
|
|
|
|
|
//template <typename T> HRESULT createShader(T* tmpShader, ID3DBlob* pBlob, T** shader )
|
|
template <typename T> HRESULT CreateShader(ID3D11Device* pd3dDevice, T** shader, ID3DBlob* pBlob)
|
|
{
|
|
return S_FALSE;
|
|
};
|
|
|
|
template <typename T> HRESULT CreateShaderStreamOutput(ID3D11Device* pd3dDevice, T** shader, ID3DBlob* pBlob, D3D11_SO_DECLARATION_ENTRY *pSODeclaration = NULL, UINT numSOEntries = 0, UINT* pSOStrides = NULL, UINT numSOStrides = 0, UINT rasterizerStream = D3D11_SO_NO_RASTERIZED_STREAM)
|
|
{
|
|
return S_FALSE;
|
|
};
|
|
|
|
|
|
template <typename T>
|
|
class Shader
|
|
{
|
|
public:
|
|
// TODO checkme: copy macros and stream output array data as data pointed to may be deleted
|
|
Shader(ID3D11Device* pd3dDevice, const char* szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, SHADERTYPE shaderType, ID3DBlob** ppBlobOut, std::string& compiledFileName, D3D_SHADER_MACRO* pDefines = NULL, DWORD compilerFlags = 0, ID3D11ClassLinkage* pClassLinkage = NULL)
|
|
{
|
|
//HRESULT hr;
|
|
/* V( DXUTFindDXSDKMediaFileCch( m_fileNameSrc, MAX_PATH, szFileName ) );
|
|
if(FAILED(hr))
|
|
{
|
|
std::wcout << "cannot find file " << szFileName << std::endl;
|
|
return;
|
|
}*/
|
|
m_fileNameSrcString = szFileName;
|
|
wcscpy_s( m_fileNameSrc, std::wstring(m_fileNameSrcString.begin(), m_fileNameSrcString.end()).c_str());
|
|
|
|
|
|
init(szEntryPoint, szShaderModel, shaderType,
|
|
compiledFileName, pDefines, compilerFlags,
|
|
NULL, 0, NULL, 0, D3D11_SO_NO_RASTERIZED_STREAM,
|
|
pClassLinkage);
|
|
|
|
//m_lastChange.QuadPart = 0;
|
|
//GetAndSetFileChange(m_fileNameSrc, m_lastChange);
|
|
//m_fileNameSrc;
|
|
|
|
|
|
g_shaderManager.AddIncludeFile(m_fileNameSrcString);
|
|
|
|
m_compiledInvalid = false;
|
|
HANDLE hFindCompiled = FindFirstFile(m_fileNameCompiled.c_str(), &m_lastChangeCompiled);
|
|
if(hFindCompiled == INVALID_HANDLE_VALUE) m_compiledInvalid = true;
|
|
|
|
|
|
CompileShader(pd3dDevice, ppBlobOut);
|
|
}
|
|
|
|
// with stream out support
|
|
Shader( ID3D11Device* pd3dDevice, const char* szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, SHADERTYPE shaderType, ID3DBlob** ppBlobOut,
|
|
std::string& compiledFileName, D3D_SHADER_MACRO* pDefines = NULL, DWORD compilerFlags = 0,
|
|
D3D11_SO_DECLARATION_ENTRY *pSODeclaration = NULL, UINT numSOEntries = 0, UINT* pSOStrides = NULL, UINT numSOStrides = 0, UINT rasterizerStream = D3D11_SO_NO_RASTERIZED_STREAM,
|
|
ID3D11ClassLinkage* pClassLinkage = NULL)
|
|
{
|
|
//HRESULT hr;
|
|
//V( DXUTFindDXSDKMediaFileCch( m_fileNameSrc, MAX_PATH, szFileName ) );
|
|
//if(FAILED(hr))
|
|
//{
|
|
// std::wcout << "cannot find file " << szFileName << std::endl;
|
|
// return;
|
|
//}
|
|
|
|
m_fileNameSrcString = szFileName;
|
|
wcscpy_s( m_fileNameSrc, std::wstring(m_fileNameSrcString.begin(), m_fileNameSrcString.end()).c_str());
|
|
//g_shaderManager->AddIncludeFile(szFileName);
|
|
|
|
init(szEntryPoint, szShaderModel, shaderType,
|
|
compiledFileName, pDefines, compilerFlags,
|
|
pSODeclaration, numSOEntries, pSOStrides, numSOStrides, rasterizerStream,
|
|
pClassLinkage);
|
|
|
|
|
|
//m_lastChange.QuadPart = 0;
|
|
//GetAndSetFileChange(m_fileNameSrc, m_lastChange);
|
|
|
|
|
|
g_shaderManager.AddIncludeFile(m_fileNameSrcString);
|
|
|
|
m_compiledInvalid = false;
|
|
HANDLE hFindCompiled = FindFirstFile(m_fileNameCompiled.c_str(), &m_lastChangeCompiled);
|
|
if(hFindCompiled == INVALID_HANDLE_VALUE) m_compiledInvalid = true;
|
|
|
|
CompileShader(pd3dDevice, ppBlobOut);
|
|
}
|
|
|
|
void init( LPCSTR szEntryPoint, LPCSTR szShaderModel, SHADERTYPE shaderType,
|
|
std::string& compiledFileName, D3D_SHADER_MACRO* pDefines = NULL, DWORD compilerFlags = 0,
|
|
D3D11_SO_DECLARATION_ENTRY *pSODeclaration = NULL, UINT numSOEntries = 0, UINT* pSOStrides = NULL, UINT numSOStrides = 0, UINT rasterizerStream = D3D11_SO_NO_RASTERIZED_STREAM,
|
|
ID3D11ClassLinkage* pClassLinkage = NULL)
|
|
{
|
|
m_shader = NULL;
|
|
m_entryPoint = szEntryPoint;
|
|
m_shaderModel = szShaderModel;
|
|
m_type = shaderType;
|
|
m_fileNameCompiled = compiledFileName;
|
|
m_pDefines = NULL;
|
|
m_classLinkage = pClassLinkage;
|
|
m_compilerFlags = compilerFlags;
|
|
|
|
m_SODeclarationArray = pSODeclaration;
|
|
m_SONumEntries = numSOEntries;
|
|
m_SOStridesArray = pSOStrides;
|
|
m_SONumStrides = numSOStrides;
|
|
m_rasterizerStream = rasterizerStream;
|
|
m_firstLoad = true;
|
|
|
|
|
|
// copy macros to local for shader reloading
|
|
if(pDefines)
|
|
{
|
|
// count macros
|
|
int numDefs = 0;
|
|
for(numDefs = 0; pDefines[numDefs].Name != NULL; ++numDefs);
|
|
|
|
|
|
m_pDefines = new D3D_SHADER_MACRO[numDefs+1];
|
|
for(int i=0; i < numDefs; ++i)
|
|
{
|
|
size_t sizeName = strlen(pDefines[i].Name)+1;
|
|
size_t sizeDef = strlen(pDefines[i].Definition)+1;
|
|
|
|
m_pDefines[i].Name = new char[sizeName];
|
|
m_pDefines[i].Definition = new char[sizeDef];
|
|
|
|
memcpy((void*)&(m_pDefines[i].Name[0]), (void*)&(pDefines[i].Name[0]), sizeName);
|
|
memcpy((void*)&(m_pDefines[i].Definition[0]), (void*)&(pDefines[i].Definition[0]), sizeDef);
|
|
|
|
}
|
|
|
|
m_pDefines[numDefs].Name = NULL;
|
|
m_pDefines[numDefs].Definition = NULL;
|
|
|
|
//for(int i = 0; m_pDefines[i].Name != NULL; ++i)
|
|
//{
|
|
// std::cout << i << ": " << m_pDefines[i].Name << " " << m_pDefines[i].Definition << std::endl;
|
|
//}
|
|
|
|
}
|
|
|
|
// TODO copy SO Declaration Array and SOStride Array to local
|
|
|
|
}
|
|
|
|
Shader()
|
|
{
|
|
m_shader = NULL;
|
|
}
|
|
|
|
T* Get() const { return m_shader; }
|
|
operator T*() const { return Get(); }
|
|
|
|
~Shader()
|
|
{
|
|
Destroy();
|
|
}
|
|
|
|
void Destroy();
|
|
|
|
|
|
HRESULT CheckAndReload(ID3D11Device* pd3dDevice);
|
|
|
|
|
|
private:
|
|
HRESULT CompileShader(ID3D11Device* pd3dDevice, ID3DBlob** ppBlobOut);
|
|
|
|
|
|
|
|
SHADERTYPE m_type;
|
|
wchar_t m_fileNameSrc[MAX_PATH];
|
|
std::string m_fileNameSrcString;
|
|
|
|
std::string m_fileNameCompiled;
|
|
|
|
LPCSTR m_entryPoint;
|
|
LPCSTR m_shaderModel;
|
|
D3D_SHADER_MACRO* m_pDefines;
|
|
ID3D11ClassLinkage* m_classLinkage;
|
|
DWORD m_compilerFlags;
|
|
|
|
//bool m_isChanged;
|
|
//ULARGE_INTEGER m_lastChange;
|
|
WIN32_FIND_DATA m_lastChangeCompiled;
|
|
|
|
// Stream Output Support
|
|
D3D11_SO_DECLARATION_ENTRY* m_SODeclarationArray;
|
|
UINT m_SONumEntries;
|
|
UINT* m_SOStridesArray;
|
|
UINT m_SONumStrides;
|
|
UINT m_rasterizerStream;
|
|
std::unordered_set<std::string> m_includes;
|
|
bool m_firstLoad;
|
|
|
|
bool m_compiledInvalid;
|
|
|
|
T* m_shader;
|
|
};
|
|
|
|
template <typename T>
|
|
class ShaderWrapper {
|
|
public:
|
|
ShaderWrapper(Shader<T>* shader) : m_shader(shader) {}
|
|
operator T*() const { return m_shader->Get(); }
|
|
private:
|
|
Shader<T>* m_shader;
|
|
};
|
|
|
|
template <typename T>
|
|
HRESULT Shader<T>::CheckAndReload(ID3D11Device* pd3dDevice)
|
|
{
|
|
|
|
HRESULT hr;
|
|
// return if not changed
|
|
//if (!GetAndSetFileChange(m_fileNameSrc, m_lastChange))
|
|
// return S_OK;
|
|
|
|
// is changed, reload
|
|
ID3DBlob* pBlob = NULL;
|
|
hr = CompileShader(pd3dDevice, &pBlob);
|
|
SAFE_RELEASE(pBlob);
|
|
|
|
if(FAILED(hr))
|
|
{
|
|
if(m_type == VERTEX_SHADER)
|
|
std::cerr << "vertex shader failed" << std::endl;
|
|
else if(m_type == DOMAIN_SHADER)
|
|
std::cerr << "domain shader failed" << std::endl;
|
|
else if(m_type == HULL_SHADER)
|
|
std::cerr << "hull shader failed" << std::endl;
|
|
else if(m_type == GEOMETRY_SHADER)
|
|
std::cerr << "geometry shader failed" << std::endl;
|
|
else if(m_type == PIXEL_SHADER)
|
|
std::cerr << "pixel shader failed" << std::endl;
|
|
else if(m_type == COMPUTE_SHADER)
|
|
std::cerr << "compute shader failed" << std::endl;
|
|
}
|
|
return hr;
|
|
|
|
}
|
|
|
|
template <typename T>
|
|
void Shader<T>::Destroy()
|
|
{
|
|
SAFE_RELEASE(m_shader);
|
|
if(m_pDefines)
|
|
{
|
|
for(int i = 0; m_pDefines[i].Name != NULL; ++i)
|
|
{
|
|
SAFE_DELETE_ARRAY(m_pDefines[i].Name);
|
|
SAFE_DELETE_ARRAY(m_pDefines[i].Definition);
|
|
}
|
|
}
|
|
SAFE_DELETE_ARRAY(m_pDefines);
|
|
}
|
|
|
|
struct EffectCommonConfig{
|
|
int common_render_hash;
|
|
EffectCommonConfig()
|
|
{
|
|
common_render_hash = 0;
|
|
}
|
|
};
|
|
|
|
typedef std::pair< std::string, std::string > ShaderDefine;
|
|
typedef std::vector< ShaderDefine > ShaderDefineVector;
|
|
|
|
|
|
struct DrawShaderSource {
|
|
//typedef std::pair< std::string, std::string > Define;
|
|
//typedef std::vector< Define > DefineVector;
|
|
|
|
void AddDefine(std::string const & name, std::string const & value = "1")
|
|
{
|
|
defines.push_back( ShaderDefine(name, value) );
|
|
}
|
|
|
|
std::string sourceFile;
|
|
std::string version;
|
|
std::string target;
|
|
std::string entry;
|
|
|
|
ShaderDefineVector defines;
|
|
};
|
|
|
|
struct DrawSourceConfig {
|
|
int value;
|
|
DrawSourceConfig()
|
|
{
|
|
value = 0;
|
|
}
|
|
DrawShaderSource commonShader;
|
|
DrawShaderSource vertexShader;
|
|
DrawShaderSource hullShader;
|
|
DrawShaderSource domainShader;
|
|
DrawShaderSource geometryShader;
|
|
DrawShaderSource pixelShader;
|
|
DrawShaderSource computeShader;
|
|
|
|
// config hashes for shader precompile names
|
|
EffectCommonConfig commonConfig;
|
|
virtual ~DrawSourceConfig();
|
|
|
|
};
|
|
|
|
struct DrawConfig {
|
|
DrawConfig() :
|
|
vertexShader(0), hullShader(0), domainShader(0),
|
|
geometryShader(0), pixelShader(0), computeShader(0), srcConfig(0) {}
|
|
virtual ~DrawConfig() {
|
|
if (srcConfig)
|
|
delete srcConfig;
|
|
srcConfig = NULL;
|
|
}
|
|
|
|
|
|
Shader<ID3D11VertexShader>* vertexShader;
|
|
Shader<ID3D11HullShader>* hullShader;
|
|
Shader<ID3D11DomainShader>* domainShader;
|
|
Shader<ID3D11GeometryShader>* geometryShader;
|
|
Shader<ID3D11PixelShader>* pixelShader;
|
|
Shader<ID3D11ComputeShader>* computeShader;
|
|
DrawSourceConfig* srcConfig;
|
|
};
|
|
|
|
class DrawRegistryBase {
|
|
public:
|
|
typedef int DescType;
|
|
typedef DrawConfig ConfigType;
|
|
typedef DrawSourceConfig SourceConfigType;
|
|
|
|
virtual ~DrawRegistryBase(){};
|
|
|
|
protected:
|
|
virtual ConfigType * _NewDrawConfig() const { return new ConfigType(); }
|
|
virtual ConfigType * _CreateDrawConfig( DescType const & desc,
|
|
SourceConfigType const * sconfig,
|
|
ID3D11Device * pd3dDevice,
|
|
ID3D11InputLayout ** ppInputLayout,
|
|
D3D11_INPUT_ELEMENT_DESC const * pInputElementDescs,
|
|
int numInputElements) const;
|
|
|
|
virtual SourceConfigType * _NewDrawSourceConfig() const { return new SourceConfigType(); }
|
|
virtual SourceConfigType *_CreateDrawSourceConfig(DescType const & desc, ID3D11Device * pd3dDevice) const;
|
|
};
|
|
|
|
template < class DESC_TYPE = Effect,
|
|
class CONFIG_TYPE = DrawConfig,
|
|
class SOURCE_CONFIG_TYPE = DrawSourceConfig >
|
|
class TEffectDrawRegistry : public DrawRegistryBase {
|
|
public:
|
|
typedef DESC_TYPE DescType;
|
|
typedef CONFIG_TYPE ConfigType;
|
|
typedef SOURCE_CONFIG_TYPE SourceConfigType;
|
|
|
|
typedef std::map<DescType, ConfigType *> ConfigMap;
|
|
|
|
public:
|
|
virtual ~TEffectDrawRegistry()
|
|
{
|
|
Reset();
|
|
}
|
|
|
|
void Reset()
|
|
{
|
|
//for (typename ConfigMap::iterator i = _configMap.begin(); i != _configMap.end(); ++i)
|
|
//{
|
|
// delete i->second;
|
|
//}
|
|
if(_configMap.size() > 0)
|
|
{
|
|
for(auto i : _configMap)
|
|
{
|
|
if(i.second) delete i.second;
|
|
}
|
|
_configMap.clear();
|
|
}
|
|
|
|
}
|
|
|
|
// fetch shader config
|
|
ConfigType * GetDrawConfig(DescType const & desc, ID3D11Device * pd3dDevice, ID3D11InputLayout ** ppInputLayout = NULL, D3D11_INPUT_ELEMENT_DESC const * pInputElementDescs = NULL, int numInputElements = 0)
|
|
{
|
|
typename ConfigMap::iterator it = _configMap.find(desc);
|
|
if (it != _configMap.end())
|
|
{
|
|
return it->second;
|
|
}
|
|
else
|
|
{
|
|
auto* srcConfig = _CreateDrawSourceConfig(desc, pd3dDevice);
|
|
ConfigType * config = _CreateDrawConfig(desc, srcConfig, pd3dDevice, ppInputLayout, pInputElementDescs, numInputElements);
|
|
_configMap[desc] = config;
|
|
return config;
|
|
}
|
|
}
|
|
|
|
protected:
|
|
virtual ConfigType * _NewDrawConfig() const { return new ConfigType(); }
|
|
virtual ConfigType * _CreateDrawConfig( DescType const & desc,
|
|
SourceConfigType const * sconfig,
|
|
ID3D11Device * pd3dDevice,
|
|
ID3D11InputLayout ** ppInputLayout,
|
|
D3D11_INPUT_ELEMENT_DESC const * pInputElementDescs,
|
|
int numInputElements) const { return NULL; }
|
|
|
|
virtual SourceConfigType * _NewDrawSourceConfig() const { return new SourceConfigType(); }
|
|
virtual SourceConfigType * _CreateDrawSourceConfig(DescType const & desc, ID3D11Device * pd3dDevice) const { return NULL; }
|
|
|
|
private:
|
|
ConfigMap _configMap;
|
|
};
|
|
|
|
class WatchedFile
|
|
{
|
|
public:
|
|
WatchedFile(const std::string& includeFileName);
|
|
~WatchedFile();
|
|
|
|
bool CheckIsModified();
|
|
WIN32_FIND_DATA& getLastWrite() { return m_lastWrite;}
|
|
private:
|
|
WIN32_FIND_DATA m_lastWrite;
|
|
std::string m_fileName;
|
|
};
|
|
|
|
class ShaderManager{
|
|
public:
|
|
ShaderManager();
|
|
~ShaderManager();
|
|
|
|
Shader<ID3D11VertexShader>* AddVertexShader( ID3D11Device* pd3dDevice, const char* szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, ID3DBlob** ppBlobOut, D3D_SHADER_MACRO* pDefines = NULL, DWORD compilerFlags = 0,const std::vector<int>& configHashes = std::vector<int>(), ID3D11ClassLinkage* pClassLinkage = NULL);
|
|
Shader<ID3D11HullShader>* AddHullShader( ID3D11Device* pd3dDevice, const char* szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, ID3DBlob** ppBlobOut, D3D_SHADER_MACRO* pDefines = NULL, DWORD compilerFlags = 0,const std::vector<int>& configHashes = std::vector<int>(), ID3D11ClassLinkage* pClassLinkage = NULL);
|
|
Shader<ID3D11DomainShader>* AddDomainShader( ID3D11Device* pd3dDevice, const char* szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, ID3DBlob** ppBlobOut, D3D_SHADER_MACRO* pDefines = NULL, DWORD compilerFlags = 0,const std::vector<int>& configHashes = std::vector<int>(), ID3D11ClassLinkage* pClassLinkage = NULL);
|
|
Shader<ID3D11GeometryShader>* AddGeometryShader( ID3D11Device* pd3dDevice, const char* szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, ID3DBlob** ppBlobOut, D3D_SHADER_MACRO* pDefines = NULL, DWORD compilerFlags = 0,const std::vector<int>& configHashes = std::vector<int>(), ID3D11ClassLinkage* pClassLinkage = NULL);
|
|
Shader<ID3D11GeometryShader>* AddGeometryShaderSO(ID3D11Device* pd3dDevice, const char* szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, ID3DBlob** ppBlobOut, D3D_SHADER_MACRO* pDefines = NULL, DWORD compilerFlags = 0,
|
|
D3D11_SO_DECLARATION_ENTRY *pSODeclaration = NULL, UINT numSOEntries = 0, UINT* pSOStrides = NULL, UINT numSOStrides = 0, UINT rasterizerStream = D3D11_SO_NO_RASTERIZED_STREAM,
|
|
ID3D11ClassLinkage* pClassLinkage = NULL);
|
|
Shader<ID3D11PixelShader>* AddPixelShader( ID3D11Device* pd3dDevice, const char* szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, ID3DBlob** ppBlobOut, D3D_SHADER_MACRO* pDefines = NULL, DWORD compilerFlags = 0, const std::vector<int>& configHashes = std::vector<int>(), ID3D11ClassLinkage* pClassLinkage = NULL);
|
|
Shader<ID3D11ComputeShader>* AddComputeShader( ID3D11Device* pd3dDevice, const char* szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, ID3DBlob** ppBlobOut, D3D_SHADER_MACRO* pDefines = NULL, DWORD compilerFlags = 0, const std::vector<int>& configHashes = std::vector<int>(), ID3D11ClassLinkage* pClassLinkage = NULL);
|
|
|
|
// with support for compiled names from config hashes
|
|
//Shader<ID3D11VertexShader>* AddVertexShader( const char* szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, ID3DBlob** ppBlobOut, const std::vector<int>& configHashes, D3D_SHADER_MACRO* pDefines = NULL, DWORD compilerFlags = 0, ID3D11ClassLinkage* pClassLinkage = NULL);
|
|
//Shader<ID3D11HullShader>* AddHullShader( const char* szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, ID3DBlob** ppBlobOut, const std::vector<int>& configHashes = std::vector<int>(), D3D_SHADER_MACRO* pDefines = NULL, DWORD compilerFlags = 0, ID3D11ClassLinkage* pClassLinkage = NULL);
|
|
//Shader<ID3D11DomainShader>* AddDomainShader( const char* szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, ID3DBlob** ppBlobOut, const std::vector<int>& configHashes = std::vector<int>(), D3D_SHADER_MACRO* pDefines = NULL, DWORD compilerFlags = 0, ID3D11ClassLinkage* pClassLinkage = NULL);
|
|
//Shader<ID3D11GeometryShader>* AddGeometryShader( const char* szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, ID3DBlob** ppBlobOut, const std::vector<int>& configHashes = std::vector<int>(), D3D_SHADER_MACRO* pDefines = NULL, DWORD compilerFlags = 0, ID3D11ClassLinkage* pClassLinkage = NULL);
|
|
// Shader<ID3D11GeometryShader>* AddGeometryShaderSO(const char* szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, ID3DBlob** ppBlobOut, const std::vector<int>& configHashes = std::vector<int>(), D3D_SHADER_MACRO* pDefines = NULL, DWORD compilerFlags = 0,
|
|
// D3D11_SO_DECLARATION_ENTRY *pSODeclaration = NULL, UINT numSOEntries = 0, UINT* pSOStrides = NULL, UINT numSOStrides = 0, UINT rasterizerStream = D3D11_SO_NO_RASTERIZED_STREAM,
|
|
// ID3D11ClassLinkage* pClassLinkage = NULL);
|
|
// Shader<ID3D11PixelShader>* AddPixelShader( const char* szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, ID3DBlob** ppBlobOut, const std::vector<int>& configHashes = std::vector<int>(),D3D_SHADER_MACRO* pDefines = NULL, DWORD compilerFlags = 0, ID3D11ClassLinkage* pClassLinkage = NULL);
|
|
// Shader<ID3D11ComputeShader>* AddComputeShader( const char* szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, ID3DBlob** ppBlobOut, const std::vector<int>& configHashes = std::vector<int>(),D3D_SHADER_MACRO* pDefines = NULL, DWORD compilerFlags = 0, ID3D11ClassLinkage* pClassLinkage = NULL);
|
|
|
|
|
|
HRESULT CheckAndReload(ID3D11Device* pd3dDevice);
|
|
void Destroy();
|
|
WatchedFile* AddIncludeFile(std::string includeFileName);
|
|
const std::unordered_map<std::string, WatchedFile*>& GetIncludes() const { return m_includeFiles; }
|
|
bool UsePrecompiledShaders() const { return m_precompiledShadersEnabled; }
|
|
void SetPrecompiledShaders(bool enabled) { m_precompiledShadersEnabled = enabled; }
|
|
private:
|
|
void CheckIncludes();
|
|
std::string CreateCompiledFileName(const char* szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, D3D_SHADER_MACRO* pDefines = NULL, DWORD compilerFlags = 0, const std::vector<int>& config_hashes = std::vector<int>());
|
|
std::unordered_map<std::string, Shader<ID3D11VertexShader>* > m_vertexShaders;
|
|
std::unordered_map<std::string, Shader<ID3D11HullShader>* > m_hullShaders;
|
|
std::unordered_map<std::string, Shader<ID3D11DomainShader>* > m_domainShaders;
|
|
std::unordered_map<std::string, Shader<ID3D11GeometryShader>* > m_geometryShaders;
|
|
std::unordered_map<std::string, Shader<ID3D11PixelShader>* > m_pixelShaders;
|
|
std::unordered_map<std::string, Shader<ID3D11ComputeShader>* > m_computeShaders;
|
|
std::string m_compiledShaderDirectory;
|
|
|
|
std::vector<WatchedFile> m_includes;
|
|
std::unordered_map<std::string, WatchedFile*> m_includeFiles;
|
|
std::unordered_map<std::string, bool> m_changedIncludeFiles;
|
|
bool m_precompiledShadersEnabled; // for nsight debugging
|
|
};
|
|
|
|
|
|
|
|
extern ShaderManager g_shaderManager; |