bool LightShaderClass::InitShader(ID3D11Device* pDevice, WCHAR* vFileName, WCHAR* pFileName, WCHAR* gFileName)
{
bool result;
D3D11_INPUT_ELEMENT_DESC vertexDesc[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 20, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "BLENDWEIGHT", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 32, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "BLENDINDICES", 0, DXGI_FORMAT_R32G32B32A32_UINT, 0, 48, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "BLENDINDICES", 1, DXGI_FORMAT_R32_UINT, 0, 64, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
// Get a count of the elements in the layout.
int numElements = sizeof(vertexDesc) / sizeof(vertexDesc[0]);
result = ShaderClass::InitShader(pDevice, vFileName, pFileName, gFileName, vertexDesc, numElements);
if (!result)
{
return false;
}
result = createSamplerState(pDevice, &mSampleState);
if (!result)
{
return false;
}
result = createConstantBuffer(pDevice, sizeof(XMFLOAT4) * 3 + sizeof(PointLight)*MAX_ACTIVE_LIGHTS + sizeof(MatrialDescPadded)*MAX_MATERIAL_COUNT, &mLightBuffer, D3D11_BIND_CONSTANT_BUFFER);
if (!result)
{
return false;
}
result = createConstantBuffer(pDevice, sizeof(XMFLOAT4X4)* 2 + sizeof(XMFLOAT4X4)*MAX_BONE_COUNT, &mBoneTBuffer, D3D11_BIND_CONSTANT_BUFFER);
if (!result)
{
return false;
}
result = createGeometryShader(pDevice, L"data/shaders/AnimatedLightGeometryShader.hlsl", "GSMain", &mAniGS);
if (!result)
{
return false;
}
return true;
}
void WorldObjectEffect::init(WorldObjectStore *oStore, UINT maxThreads, UINT maxNumObjects) {
initialized = true;
objectStore = oStore;
oStore->setWorldObjectEffect(this);
// try to do all expensive operations like shader loading and PSO creation here
// Create the pipeline state, which includes compiling and loading shaders.
{
createRootSigAndPSO(rootSignature, pipelineState);
cbvAlignedSize = calcConstantBufferSize((UINT)sizeof(cbv));
createConstantBuffer((UINT)2 * cbvAlignedSize, L"objecteffect_cbv_resource"); // TODO
setSingleCBVMode(maxThreads, maxNumObjects, sizeof(cbv), L"objecteffect_cbvsingle_resource");
// set cbv data:
XMMATRIX ident = XMMatrixIdentity();
XMStoreFloat4x4(&cbv.wvp, ident);
cbv.world = cbv.wvp;
//memcpy(cbvGPUDest+cbvAlignedSize, &cbv, sizeof(cbv));
}
// Create command allocators and command lists for each frame.
static LPCWSTR fence_names[XApp::FrameCount] = {
L"fence_objecteffect_0", L"fence_objecteffect_1", L"fence_objecteffect_2"
};
for (UINT n = 0; n < XApp::FrameCount; n++)
{
ThrowIfFailed(xapp().device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&commandAllocators[n])));
ThrowIfFailed(xapp().device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, commandAllocators[n].Get(), pipelineState.Get(), IID_PPV_ARGS(&commandLists[n])));
// Command lists are created in the recording state, but there is nothing
// to record yet. The main loop expects it to be closed, so close it now.
ThrowIfFailed(commandLists[n]->Close());
// init fences:
//ThrowIfFailed(xapp().device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(frameData[n].fence.GetAddressOf())));
ThrowIfFailed(xapp().device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&frameData[n].fence)));
frameData[n].fence->SetName(fence_names[n]);
frameData[n].fenceValue = 0;
frameData[n].fenceEvent = CreateEventEx(nullptr, FALSE, FALSE, EVENT_ALL_ACCESS);
if (frameData[n].fenceEvent == nullptr) {
ThrowIfFailed(HRESULT_FROM_WIN32(GetLastError()));
}
}
// init resources for update thread:
ThrowIfFailed(xapp().device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&updateCommandAllocator)));
ThrowIfFailed(xapp().device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, updateCommandAllocator.Get(), pipelineState.Get(), IID_PPV_ARGS(&updateCommandList)));
// Command lists are created in the recording state, but there is nothing
// to record yet. The main loop expects it to be closed, so close it now.
ThrowIfFailed(updateCommandList->Close());
// init fences:
//ThrowIfFailed(xapp().device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(frameData[n].fence.GetAddressOf())));
ThrowIfFailed(xapp().device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&updateFrameData.fence)));
updateFrameData.fence->SetName(L"fence_objecteffect_update");
updateFrameData.fenceValue = 0;
updateFrameData.fenceEvent = CreateEventEx(nullptr, FALSE, FALSE, EVENT_ALL_ACCESS);
if (updateFrameData.fenceEvent == nullptr) {
ThrowIfFailed(HRESULT_FROM_WIN32(GetLastError()));
}
}
bool ShaderClass::InitShader(ID3D11Device* pDevice, WCHAR* vFileName, WCHAR* pFileName, WCHAR* gFileName, D3D11_INPUT_ELEMENT_DESC *vertexDesc, int numElements)
{
bool result;
// Initialize the vertex shader
result = createVertexShaderAndInputLayout(pDevice, vFileName, "VSMain", vertexDesc, numElements);
if (!result)
{
return false;
}
if (gFileName)
{
// Init Geometry Shader
result = createGeometryShader(pDevice, gFileName, "GSMain");
if (!result)
{
return false;
}
}
if (pFileName)
{
// Initialie Pixel shader
result = createPixelShader(pDevice, pFileName, "PSMain");
if (!result)
{
return false;
}
}
result = createConstantBuffer(pDevice, sizeof(MatrixBufferType), &mMatrixBuffer, D3D11_BIND_CONSTANT_BUFFER);
if (!result)
{
return false;
}
return true;
}
bool TerrainShaderClass::InitShader(ID3D11Device* pDevice, WCHAR* vFileName, WCHAR* pFileName, WCHAR* gFileName)
{
bool result;
D3D11_INPUT_ELEMENT_DESC polygonLayout[6];/* =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 1, DXGI_FORMAT_R32G32_FLOAT, 0, 20, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 20, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};*/
// Create the vertex input layout description.
// This setup needs to match the VertexType stucture in the ModelClass and in the shader.
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "TEXCOORD";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
polygonLayout[2].SemanticName = "NORMAL";
polygonLayout[2].SemanticIndex = 0;
polygonLayout[2].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[2].InputSlot = 0;
polygonLayout[2].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[2].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[2].InstanceDataStepRate = 0;
polygonLayout[3].SemanticName = "TEXCOORD";
polygonLayout[3].SemanticIndex = 1;
polygonLayout[3].Format = DXGI_FORMAT_R32G32_FLOAT;
polygonLayout[3].InputSlot = 0;
polygonLayout[3].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[3].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[3].InstanceDataStepRate = 0;
polygonLayout[4].SemanticName = "TANGENT";
polygonLayout[4].SemanticIndex = 0;
polygonLayout[4].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[4].InputSlot = 0;
polygonLayout[4].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[4].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[4].InstanceDataStepRate = 0;
polygonLayout[5].SemanticName = "BINORMAL";
polygonLayout[5].SemanticIndex = 0;
polygonLayout[5].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[5].InputSlot = 0;
polygonLayout[5].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[5].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[5].InstanceDataStepRate = 0;
// Get a count of the elements in the layout.
int numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
result = ShaderClass::InitShader(pDevice, vFileName, pFileName, gFileName, polygonLayout, numElements);
if (!result)
{
return false;
}
result = createSamplerState(pDevice, &mSampleState);
if (!result)
{
return false;
}
// Deferred init
result = createConstantBuffer(pDevice, sizeof(TerrainCBufferType), &mLightBuffer, D3D11_BIND_CONSTANT_BUFFER);
if (!result)
{
return false;
}
result = createPixelShader(pDevice, L"data/shaders/DeferredTerrainPixelShader.hlsl", "PSMain", &mDeferredPS);
if (!result)
{
return false;
}
// Shadow Init
result = createConstantBuffer(pDevice, sizeof(ShadowBuffer), &mShadowBuffer, D3D11_BIND_CONSTANT_BUFFER);
if (!result)
{
return false;
}
result = createVertexShader(pDevice, L"data/shaders/ShadowDeferredVS.hlsl", "VSMain", &mShadowDeferredVS);
if (!result)
{
return false;
}
result = createGeometryShader(pDevice, L"data/shaders/ShadowDeferredGS.hlsl", "GSMain", &mShadowDeferredGS);
if (!result)
return false;
result = createPixelShader(pDevice, L"data/shaders/ShadowDeferredPS.hlsl", "PSMain", &mShadowDeferredPS);
if (!result)
{
return false;
}
D3D11_SAMPLER_DESC samplerDesc;
// Create a texture sampler state description.
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;//D3D11_FILTER_ANISOTROPIC;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_BORDER;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_BORDER;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_BORDER;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samplerDesc.BorderColor[0] = 0;
samplerDesc.BorderColor[1] = 0;
samplerDesc.BorderColor[2] = 0;
samplerDesc.BorderColor[3] = 0;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
result = createSamplerState(pDevice, &mPointSampleState, &samplerDesc);
if (!result)
{
return false;
}
return true;
}
// Init
HRESULT CFW1GlyphRenderStates::initRenderResources(
IFW1Factory *pFW1Factory,
ID3D11Device *pDevice,
bool wantGeometryShader,
bool anisotropicFiltering
) {
HRESULT hResult = initBaseObject(pFW1Factory);
if(FAILED(hResult))
return hResult;
if(pDevice == NULL)
return E_INVALIDARG;
pDevice->AddRef();
m_pDevice = pDevice;
m_featureLevel = m_pDevice->GetFeatureLevel();
// D3DCompiler
#ifdef FW1_DELAYLOAD_D3DCOMPILER_XX_DLL
HMODULE hD3DCompiler = LoadLibrary(D3DCOMPILER_DLL);
if(hD3DCompiler == NULL) {
DWORD dwErr = GetLastError();
dwErr;
m_lastError = std::wstring(L"Failed to load ") + D3DCOMPILER_DLL_W;
hResult = E_FAIL;
}
else {
m_pfnD3DCompile = reinterpret_cast<pD3DCompile>(GetProcAddress(hD3DCompiler, "D3DCompile"));
if(m_pfnD3DCompile == NULL) {
DWORD dwErr = GetLastError();
dwErr;
m_lastError = std::wstring(L"Failed to load D3DCompile from ") + D3DCOMPILER_DLL_W;
hResult = E_FAIL;
}
else {
hResult = S_OK;
}
}
#else
m_pfnD3DCompile = D3DCompile;
hResult = S_OK;
#endif
// Create all needed resources
if(SUCCEEDED(hResult))
hResult = createQuadShaders();
if(SUCCEEDED(hResult))
hResult = createPixelShaders();
if(SUCCEEDED(hResult))
hResult = createConstantBuffer();
if(SUCCEEDED(hResult))
hResult = createRenderStates(anisotropicFiltering);
if(SUCCEEDED(hResult) && wantGeometryShader) {
hResult = createGlyphShaders();
if(FAILED(hResult))
hResult = S_OK;
}
if(SUCCEEDED(hResult))
hResult = S_OK;
#ifdef FW1_DELAYLOAD_D3DCOMPILER_XX_DLL
FreeLibrary(hD3DCompiler);
#endif
return hResult;
}
//-----------------------------------------------------------------------
void D3D10HLSLProgram::loadFromSource(void)
{
class HLSLIncludeHandler : public ID3D10Include
{
public:
HLSLIncludeHandler(Resource* sourceProgram)
: mProgram(sourceProgram) {}
~HLSLIncludeHandler() {}
STDMETHOD(Open)(D3D10_INCLUDE_TYPE IncludeType,
LPCSTR pFileName,
LPCVOID pParentData,
LPCVOID *ppData,
UINT *pByteLen
)
{
// find & load source code
DataStreamPtr stream =
ResourceGroupManager::getSingleton().openResource(
String(pFileName), mProgram->getGroup(), true, mProgram);
String source = stream->getAsString();
// copy into separate c-string
// Note - must NOT copy the null terminator, otherwise this will terminate
// the entire program string!
*pByteLen = static_cast<UINT>(source.length());
char* pChar = new char[*pByteLen];
memcpy(pChar, source.c_str(), *pByteLen);
*ppData = pChar;
return S_OK;
}
STDMETHOD(Close)(LPCVOID pData)
{
char* pChar = (char*)pData;
delete [] pChar;
return S_OK;
}
protected:
Resource* mProgram;
};
// include handler
HLSLIncludeHandler includeHandler(this);
ID3D10Blob * errors = 0;
/*String profile; // Instruction set to be used when generating code. Possible values: "vs_4_0", "ps_4_0", or "gs_4_0".
switch(mType)
{
case GPT_VERTEX_PROGRAM:
profile = "vs_4_0";
break;
case GPT_FRAGMENT_PROGRAM:
profile = "ps_4_0";
break;
}*/
HRESULT hr = D3DX10CompileFromMemory(
mSource.c_str(), // [in] Pointer to the shader in memory.
mSource.size(), // [in] Size of the shader in memory.
NULL, // [in] The name of the file that contains the shader code.
NULL, // [in] Optional. Pointer to a NULL-terminated array of macro definitions. See D3D10_SHADER_MACRO. If not used, set this to NULL.
&includeHandler, // [in] Optional. Pointer to an ID3D10Include Interface interface for handling include files. Setting this to NULL will cause a compile error if a shader contains a #include.
mEntryPoint.c_str(), // [in] Name of the shader-entrypoint function where shader execution begins.
mTarget.c_str(), // [in] A string that specifies the shader model; can be any profile in shader model 2, shader model 3, or shader model 4.
0, // [in] Effect compile flags - no D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY at the first try...
NULL, // [in] Effect compile flags
NULL, // [in] A pointer to a thread pump interface (see ID3DX10ThreadPump Interface). Use NULL to specify that this function should not return until it is completed.
&mpMicroCode, // [out] A pointer to an ID3D10Blob Interface which contains the compiled shader, as well as any embedded debug and symbol-table information.
&errors, // [out] A pointer to an ID3D10Blob Interface which contains a listing of errors and warnings that occured during compilation. These errors and warnings are identical to the the debug output from a debugger.
NULL // [out] A pointer to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes.
);
if (FAILED(hr)) // if fails - try with backwards compatibility flag
{
hr = D3DX10CompileFromMemory(
mSource.c_str(), // [in] Pointer to the shader in memory.
mSource.size(), // [in] Size of the shader in memory.
NULL, // [in] The name of the file that contains the shader code.
NULL, // [in] Optional. Pointer to a NULL-terminated array of macro definitions. See D3D10_SHADER_MACRO. If not used, set this to NULL.
&includeHandler, // [in] Optional. Pointer to an ID3D10Include Interface interface for handling include files. Setting this to NULL will cause a compile error if a shader contains a #include.
mEntryPoint.c_str(), // [in] Name of the shader-entrypoint function where shader execution begins.
mTarget.c_str(), // [in] A string that specifies the shader model; can be any profile in shader model 2, shader model 3, or shader model 4.
D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY, // [in] Effect compile flags - D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY enables older shaders to compile to 4_0 targets
NULL, // [in] Effect compile flags
NULL, // [in] A pointer to a thread pump interface (see ID3DX10ThreadPump Interface). Use NULL to specify that this function should not return until it is completed.
&mpMicroCode, // [out] A pointer to an ID3D10Blob Interface which contains the compiled shader, as well as any embedded debug and symbol-table information.
&errors, // [out] A pointer to an ID3D10Blob Interface which contains a listing of errors and warnings that occured during compilation. These errors and warnings are identical to the the debug output from a debugger.
NULL // [out] A pointer to the return value. May be NULL. If pPump is not NULL, then pHResult must be a valid memory location until the asynchronous execution completes.
);
}
#if 0 // this is how you disassemble
LPCSTR commentString = NULL;
ID3D10Blob* pIDisassembly = NULL;
char* pDisassembly = NULL;
if( mpMicroCode )
{
D3D10DisassembleShader( (UINT*) mpMicroCode->GetBufferPointer(),
mpMicroCode->GetBufferSize(), TRUE, commentString, &pIDisassembly );
}
const char* assemblyCode = static_cast<const char*>(pIDisassembly->GetBufferPointer());
#endif
if (FAILED(hr))
{
mErrorsInCompile = true;
String message = "Cannot assemble D3D10 high-level shader " + mName + " Errors:\n" +
static_cast<const char*>(errors->GetBufferPointer());
errors->Release();
OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, message,
"D3D10HLSLProgram::loadFromSource");
}
SIZE_T BytecodeLength = mpMicroCode->GetBufferSize();
// this is a temp patch for the nov 08 DX SDK
#ifdef D3DX10ReflectShader
hr = D3DX10ReflectShader( (void*) mpMicroCode->GetBufferPointer(), BytecodeLength,
&mpIShaderReflection );
#else
hr = D3D10ReflectShader( (void*) mpMicroCode->GetBufferPointer(), BytecodeLength,
&mpIShaderReflection );
#endif
if (!FAILED(hr))
{
hr = mpIShaderReflection->GetDesc( &mShaderDesc );
if (!FAILED(hr))
{
if (mShaderDesc.ConstantBuffers == 1)
{
mShaderReflectionConstantBuffer = mpIShaderReflection->GetConstantBufferByIndex(0);
hr = mShaderReflectionConstantBuffer->GetDesc(&mConstantBufferDesc);
createConstantBuffer(mConstantBufferDesc.Size);
for(unsigned int i = 0; i < mConstantBufferDesc.Variables ; i++)
{
ID3D10ShaderReflectionVariable* varRef;
varRef = mShaderReflectionConstantBuffer->GetVariableByIndex(i);
D3D10_SHADER_VARIABLE_DESC shaderVerDesc;
HRESULT hr = varRef->GetDesc(&shaderVerDesc);
ShaderVarWithPosInBuf newVar;
newVar.var = shaderVerDesc;
newVar.wasInit = false;
mShaderVars.push_back(newVar);
}
}
}
}
switch(mType)
{
case GPT_VERTEX_PROGRAM:
CreateVertexShader();
break;
case GPT_FRAGMENT_PROGRAM:
CreatePixelShader();
break;
}
}
