void ColoredCubeApp::buildFX()
{
DWORD shaderFlags = D3D10_SHADER_ENABLE_STRICTNESS;
#if defined( DEBUG ) || defined( _DEBUG )
shaderFlags |= D3D10_SHADER_DEBUG;
shaderFlags |= D3D10_SHADER_SKIP_OPTIMIZATION;
#endif
ID3D10Blob* compilationErrors = 0;
HRESULT hr = 0;
hr = D3DX10CreateEffectFromFile(L"color.fx", 0, 0,
"fx_4_0", shaderFlags, 0, md3dDevice, 0, 0, &mFX, &compilationErrors, 0);
if(FAILED(hr))
{
if( compilationErrors )
{
MessageBoxA(0, (char*)compilationErrors->GetBufferPointer(), 0, 0);
ReleaseCOM(compilationErrors);
}
DXTrace(__FILE__, (DWORD)__LINE__, hr, L"D3DX10CreateEffectFromFile", true);
}
mTech = mFX->GetTechniqueByName("ColorTech");
mfxWVPVar = mFX->GetVariableByName("gWVP")->AsMatrix();
mfxFLIPVar = mFX->GetVariableByName("flip");
}
void ColoredCubeApp::buildFX()
{
DWORD shaderFlags = D3D10_SHADER_ENABLE_STRICTNESS;
#if defined( DEBUG ) || defined( _DEBUG )
//shaderFlags |= D3D10_SHADER_DEBUG;
//shaderFlags |= D3D10_SHADER_SKIP_OPTIMIZATION;
#endif
ID3D10Blob* compilationErrors = 0;
HRESULT hr = 0;
hr = D3DX10CreateEffectFromFile(L"tex.fx", 0, 0,
"fx_4_0", shaderFlags, 0, md3dDevice, 0, 0, &mFX, &compilationErrors, 0);
if(FAILED(hr))
{
if( compilationErrors )
{
MessageBoxA(0, (char*)compilationErrors->GetBufferPointer(), 0, 0);
ReleaseCOM(compilationErrors);
}
DXTrace(__FILE__, (DWORD)__LINE__, hr, L"D3DX10CreateEffectFromFile", true);
}
mTech = mFX->GetTechniqueByName("TexTech");
mTechColor2 = mFX->GetTechniqueByName("ColorTech");
//mTechStatic = mFX->GetTechniqueByName("StaticTech");
mfxWVPVar = mFX->GetVariableByName("gWVP")->AsMatrix();
mfxWorldVar = mFX->GetVariableByName("gWorld")->AsMatrix();
mfxEyePosVar = mFX->GetVariableByName("gEyePosW");
mfxLightVar = mFX->GetVariableByName("gLight");
mfxDiffuseMapVar = mFX->GetVariableByName("gDiffuseMap")->AsShaderResource();
mfxSpecMapVar = mFX->GetVariableByName("gSpecMap")->AsShaderResource();
mfxTexMtxVar = mFX->GetVariableByName("gTexMtx")->AsMatrix();
mfxNumLights = mFX->GetVariableByName("gNumLights")->AsScalar();
}
bool D10State::init() {
static HMODREF(GetModuleHandleW(L"D3D10.DLL"), D3D10CreateEffectFromMemory);
static HMODREF(GetModuleHandleW(L"D3D10.DLL"), D3D10CreateStateBlock);
static HMODREF(GetModuleHandleW(L"D3D10.DLL"), D3D10StateBlockMaskEnableAll);
if (pD3D10CreateEffectFromMemory == NULL
|| pD3D10CreateStateBlock == NULL
|| pD3D10StateBlockMaskEnableAll == NULL) {
ods("D3D10: Could not get handles for all required D3D10 state initialization functions");
return false;
}
HRESULT hr;
D3D10_STATE_BLOCK_MASK StateBlockMask;
ZeroMemory(&StateBlockMask, sizeof(StateBlockMask));
hr = pD3D10StateBlockMaskEnableAll(&StateBlockMask);
if (FAILED(hr)) {
ods("D3D10: D3D10StateBlockMaskEnableAll failed");
return false;
}
hr = pD3D10CreateStateBlock(pDevice, &StateBlockMask, &pOrigStateBlock);
if (FAILED(hr)) {
ods("D3D10: D3D10CreateStateBlock for pOrigStateBlock failed");
return false;
}
hr = pD3D10CreateStateBlock(pDevice, &StateBlockMask, &pMyStateBlock);
if (FAILED(hr)) {
ods("D3D10: D3D10CreateStateBlock for pMyStateBlock failed");
return false;
}
hr = pOrigStateBlock->Capture();
if (FAILED(hr)) {
ods("D3D10: Failed to store original state block during init");
return false;
}
ID3D10Texture2D *pBackBuffer = NULL;
hr = pSwapChain->GetBuffer(0, __uuidof(*pBackBuffer), (LPVOID*)&pBackBuffer);
if (FAILED(hr)) {
ods("D3D10: pSwapChain->GetBuffer failure!");
return false;
}
pDevice->ClearState();
D3D10_TEXTURE2D_DESC backBufferSurfaceDesc;
pBackBuffer->GetDesc(&backBufferSurfaceDesc);
ZeroMemory(&vp, sizeof(vp));
vp.Width = backBufferSurfaceDesc.Width;
vp.Height = backBufferSurfaceDesc.Height;
vp.MinDepth = 0;
vp.MaxDepth = 1;
vp.TopLeftX = 0;
vp.TopLeftY = 0;
pDevice->RSSetViewports(1, &vp);
hr = pDevice->CreateRenderTargetView(pBackBuffer, NULL, &pRTV);
if (FAILED(hr)) {
ods("D3D10: pDevice->CreateRenderTargetView failed!");
return false;
}
pDevice->OMSetRenderTargets(1, &pRTV, NULL);
// Settings for an "over" operation.
// https://en.wikipedia.org/w/index.php?title=Alpha_compositing&oldid=580659153#Description
D3D10_BLEND_DESC blend;
ZeroMemory(&blend, sizeof(blend));
blend.BlendEnable[0] = TRUE;
blend.SrcBlend = D3D10_BLEND_ONE;
blend.DestBlend = D3D10_BLEND_INV_SRC_ALPHA;
blend.BlendOp = D3D10_BLEND_OP_ADD;
blend.SrcBlendAlpha = D3D10_BLEND_ONE;
blend.DestBlendAlpha = D3D10_BLEND_INV_SRC_ALPHA;
blend.BlendOpAlpha = D3D10_BLEND_OP_ADD;
blend.RenderTargetWriteMask[0] = D3D10_COLOR_WRITE_ENABLE_ALL;
hr = pDevice->CreateBlendState(&blend, &pBlendState);
if (FAILED(hr)) {
ods("D3D10: pDevice->CreateBlendState failed!");
return false;
}
pDevice->OMSetBlendState(pBlendState, NULL, 0xffffffff);
hr = pD3D10CreateEffectFromMemory((void *) g_main, sizeof(g_main), 0, pDevice, NULL, &pEffect);
if (FAILED(hr)) {
ods("D3D10: D3D10CreateEffectFromMemory failed!");
return false;
}
pTechnique = pEffect->GetTechniqueByName("Render");
if (pTechnique == NULL) {
ods("D3D10: Could not get technique for name 'Render'");
return false;
}
pDiffuseTexture = pEffect->GetVariableByName("txDiffuse")->AsShaderResource();
if (pDiffuseTexture == NULL) {
ods("D3D10: Could not get variable by name 'txDiffuse'");
return false;
}
pTexture = NULL;
pSRView = NULL;
// Define the input layout
D3D10_INPUT_ELEMENT_DESC layout[] = {
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D10_INPUT_PER_VERTEX_DATA, 0 },
};
UINT numElements = sizeof(layout) / sizeof(layout[0]);
// Create the input layout
D3D10_PASS_DESC PassDesc;
hr = pTechnique->GetPassByIndex(0)->GetDesc(&PassDesc);
if (FAILED(hr)) {
ods("D3D10: Couldn't get pass description for technique");
return false;
}
hr = pDevice->CreateInputLayout(layout, numElements, PassDesc.pIAInputSignature, PassDesc.IAInputSignatureSize, &pVertexLayout);
if (FAILED(hr)) {
ods("D3D10: pDevice->CreateInputLayout failure!");
return false;
}
pDevice->IASetInputLayout(pVertexLayout);
D3D10_BUFFER_DESC bd;
ZeroMemory(&bd, sizeof(bd));
bd.Usage = D3D10_USAGE_DYNAMIC;
bd.ByteWidth = sizeof(SimpleVertex) * 4;
bd.BindFlags = D3D10_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
bd.MiscFlags = 0;
hr = pDevice->CreateBuffer(&bd, NULL, &pVertexBuffer);
if (FAILED(hr)) {
ods("D3D10: pDevice->CreateBuffer failure!");
return false;
}
DWORD indices[] = {
0,1,3,
1,2,3,
};
bd.Usage = D3D10_USAGE_DEFAULT;
bd.ByteWidth = sizeof(DWORD) * 6;
bd.BindFlags = D3D10_BIND_INDEX_BUFFER;
bd.CPUAccessFlags = 0;
bd.MiscFlags = 0;
D3D10_SUBRESOURCE_DATA InitData;
ZeroMemory(&InitData, sizeof(InitData));
InitData.pSysMem = indices;
hr = pDevice->CreateBuffer(&bd, &InitData, &pIndexBuffer);
if (FAILED(hr)) {
ods("D3D10: pDevice->CreateBuffer failure!");
return false;
}
// Set index buffer
pDevice->IASetIndexBuffer(pIndexBuffer, DXGI_FORMAT_R32_UINT, 0);
// Set primitive topology
pDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
hr = pMyStateBlock->Capture();
if (FAILED(hr)) {
ods("D3D10: Failed to capture newly created state block");
return false;
}
hr = pOrigStateBlock->Apply();
if (FAILED(hr)) {
ods("D3D10: Failed to restore original state block during init");
return false;
}
pBackBuffer->Release();
return true;
}
bool DX10_Renderer::BuildFX(std::string _fxFileName, std::string _techniqueName, ID3D10Effect*& _prFX, ID3D10EffectTechnique*& _prTech)
{
ID3D10Effect* pFX = 0;
ID3D10EffectTechnique* pTech = 0;
// Checking if the Effects file is already loaded
std::map<std::string, ID3D10Effect*>::iterator fxCheck;
fxCheck = m_fxFiles.find(_fxFileName);
// Check if the FX file has already been created
if (fxCheck != m_fxFiles.end())
{
// FX file already exists, save the Pointer
pFX = fxCheck->second;
}
else
{
// Set the shader flags to enforce strictness
DWORD shaderFlags = D3D10_SHADER_ENABLE_STRICTNESS;
#if defined( DEBUG ) || defined( _DEBUG )
// Addition shader flags for information in DEBUG mode only
shaderFlags |= D3D10_SHADER_DEBUG;
shaderFlags |= D3D10_SHADER_SKIP_OPTIMIZATION;
#endif
ID3D10Blob* compilationErrors;
// Add the directory path from the DX10Render file to the stored FX files
std::string fxfilePath = "Resources/FX/" + _fxFileName;
// Create the FX file from the input file string
VALIDATEHR(D3DX10CreateEffectFromFileA(fxfilePath.c_str(), 0, 0,
"fx_4_0", shaderFlags, 0, m_pDX10Device, 0, 0, &pFX, &compilationErrors, 0));
ReleaseCOM(compilationErrors);
// Create the pairs to be inserted into the appropriate FX Maps
std::pair<std::string, ID3D10Effect*> fxPair(_fxFileName, pFX);
// Insert the pairs into their respective Maps
VALIDATE(m_fxFiles.insert(fxPair).second);
}
// Adding the Technique to the Map
// Retrieve the Technique IDs map using the FX ID to get a Map of all techniques for that particular FX file
std::map<std::string, std::map<std::string, ID3D10EffectTechnique*>>::iterator fxNameCheck;
fxNameCheck = m_techniques.find(_fxFileName);
// Check if the FX file already has techniques stored for it
if (fxNameCheck != m_techniques.end())
{
// Search the Inner Map (of Techs by FX ID) to check if the Technique has already been created
std::map<std::string, ID3D10EffectTechnique*>::iterator techNameCheck;
techNameCheck = fxNameCheck->second.find(_techniqueName);
if (techNameCheck != fxNameCheck->second.end())
{
// Technique already exists, save the ID
pTech = techNameCheck->second;
}
else
{
// Technique has not been created so Retrieve the Tech from the FX file
pTech = pFX->GetTechniqueByName(_techniqueName.c_str());
if (pTech == NULL)
{
// technique was not found
return false;
}
// Create pairs to store in the Technique Maps
std::pair<std::string, ID3D10EffectTechnique*> techPair(_techniqueName, pTech);
// Insert the pairs into their respective Maps
VALIDATE((&fxNameCheck->second)->insert(techPair).second);
}
}
else
{
// Technique has not been created so Retrieve the Tech from the FX file
pTech = pFX->GetTechniqueByName(_techniqueName.c_str());
if (pTech == NULL)
{
// technique was not found
return false;
}
// Create pairs to store in the Technique Maps
std::map<std::string, ID3D10EffectTechnique*> innerTechMap;
std::pair<std::string, ID3D10EffectTechnique*> innerTechPair(_techniqueName, pTech);
VALIDATE(innerTechMap.insert(innerTechPair).second);
std::pair<std::string, std::map<std::string, ID3D10EffectTechnique*>> outerTechMap(_fxFileName, innerTechMap);
VALIDATE(m_techniques.insert(outerTechMap).second);
}
// Save the FX and Technique IDs in the memory passed by the Object.
_prFX = pFX;
_prTech = pTech;
return true;
}
void D10State::init() {
static HMODREF(GetModuleHandleW(L"D3D10.DLL"), D3D10CreateEffectFromMemory);
static HMODREF(GetModuleHandleW(L"D3D10.DLL"), D3D10CreateStateBlock);
static HMODREF(GetModuleHandleW(L"D3D10.DLL"), D3D10StateBlockMaskEnableAll);
HRESULT hr;
dwMyThread = GetCurrentThreadId();
D3D10_STATE_BLOCK_MASK StateBlockMask;
ZeroMemory(&StateBlockMask, sizeof(StateBlockMask));
pD3D10StateBlockMaskEnableAll(&StateBlockMask);
pD3D10CreateStateBlock(pDevice, &StateBlockMask, &pOrigStateBlock);
pD3D10CreateStateBlock(pDevice, &StateBlockMask, &pMyStateBlock);
pOrigStateBlock->Capture();
ID3D10Texture2D* pBackBuffer = NULL;
hr = pSwapChain->GetBuffer(0, __uuidof(*pBackBuffer), (LPVOID*)&pBackBuffer);
pDevice->ClearState();
D3D10_TEXTURE2D_DESC backBufferSurfaceDesc;
pBackBuffer->GetDesc(&backBufferSurfaceDesc);
ZeroMemory(&vp, sizeof(vp));
vp.Width = backBufferSurfaceDesc.Width;
vp.Height = backBufferSurfaceDesc.Height;
vp.MinDepth = 0;
vp.MaxDepth = 1;
vp.TopLeftX = 0;
vp.TopLeftY = 0;
pDevice->RSSetViewports(1, &vp);
hr = pDevice->CreateRenderTargetView(pBackBuffer, NULL, &pRTV);
pDevice->OMSetRenderTargets(1, &pRTV, NULL);
D3D10_BLEND_DESC blend;
ZeroMemory(&blend, sizeof(blend));
blend.BlendEnable[0] = TRUE;
blend.SrcBlend = D3D10_BLEND_ONE;
blend.DestBlend = D3D10_BLEND_INV_SRC_ALPHA;
blend.BlendOp = D3D10_BLEND_OP_ADD;
blend.SrcBlendAlpha = D3D10_BLEND_ONE;
blend.DestBlendAlpha = D3D10_BLEND_INV_SRC_ALPHA;
blend.BlendOpAlpha = D3D10_BLEND_OP_ADD;
blend.RenderTargetWriteMask[0] = D3D10_COLOR_WRITE_ENABLE_ALL;
pDevice->CreateBlendState(&blend, &pBlendState);
float bf[4];
pDevice->OMSetBlendState(pBlendState, bf, 0xffffffff);
pD3D10CreateEffectFromMemory((void *) g_main, sizeof(g_main), 0, pDevice, NULL, &pEffect);
pTechnique = pEffect->GetTechniqueByName("Render");
pDiffuseTexture = pEffect->GetVariableByName("txDiffuse")->AsShaderResource();
pTexture = NULL;
pSRView = NULL;
// Define the input layout
D3D10_INPUT_ELEMENT_DESC layout[] = {
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D10_INPUT_PER_VERTEX_DATA, 0 },
};
UINT numElements = sizeof(layout) / sizeof(layout[0]);
// Create the input layout
D3D10_PASS_DESC PassDesc;
pTechnique->GetPassByIndex(0)->GetDesc(&PassDesc);
hr = pDevice->CreateInputLayout(layout, numElements, PassDesc.pIAInputSignature, PassDesc.IAInputSignatureSize, &pVertexLayout);
pDevice->IASetInputLayout(pVertexLayout);
D3D10_BUFFER_DESC bd;
ZeroMemory(&bd, sizeof(bd));
bd.Usage = D3D10_USAGE_DYNAMIC;
bd.ByteWidth = sizeof(SimpleVertex) * 4;
bd.BindFlags = D3D10_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
bd.MiscFlags = 0;
hr = pDevice->CreateBuffer(&bd, NULL, &pVertexBuffer);
DWORD indices[] = {
0,1,3,
1,2,3,
};
bd.Usage = D3D10_USAGE_DEFAULT;
bd.ByteWidth = sizeof(DWORD) * 6;
bd.BindFlags = D3D10_BIND_INDEX_BUFFER;
bd.CPUAccessFlags = 0;
bd.MiscFlags = 0;
D3D10_SUBRESOURCE_DATA InitData;
ZeroMemory(&InitData, sizeof(InitData));
InitData.pSysMem = indices;
hr = pDevice->CreateBuffer(&bd, &InitData, &pIndexBuffer);
// Set index buffer
pDevice->IASetIndexBuffer(pIndexBuffer, DXGI_FORMAT_R32_UINT, 0);
// Set primitive topology
pDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
pMyStateBlock->Capture();
pOrigStateBlock->Apply();
pBackBuffer->Release();
dwMyThread = 0;
}
