bool DemoBase::CompileD3DShader( char* filePath, char* entry, char* shaderModel, ID3DBlob** buffer )
{
DWORD shaderFlags = D3DCOMPILE_ENABLE_STRICTNESS;
#if defined(DEBUG) || defined(_DEBUG)
shaderFlags |= D3DCOMPILE_DEBUG;
#endif
ID3DBlob* errorBuffer = 0;
HRESULT result;
result = D3DX11CompileFromFileA(filePath, 0, 0, entry, shaderModel, shaderFlags, 0, 0, buffer, &errorBuffer, 0);
if (FAILED(result))
{
if (errorBuffer != 0)
{
MessageBoxA(hwnd_, (LPCSTR)errorBuffer->GetBufferPointer(), "", NULL);
OutputDebugStringA((char*)errorBuffer->GetBufferPointer());
errorBuffer->Release();
}
return false;
}
if (errorBuffer != 0)
errorBuffer->Release();
return true;
}
bool Graphics::CompileD3DShader( char* filePath, char* entry, char* shaderModel, ID3DBlob** buffer )
{
DWORD shaderFlags = D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_DEBUG;
ID3DBlob* errorBuffer =0 ;
HRESULT result = 0;
result = D3DX11CompileFromFileA(filePath, 0, 0 , entry, shaderModel, shaderFlags, 0, 0, buffer, &errorBuffer, 0);
if (FAILED(result))
{
if (errorBuffer != 0)
{
NAIA_ERROR("Unnable to compile shader!");
NAIA_ERROR((char*) errorBuffer->GetBufferPointer());
errorBuffer->Release();
}
return false;
}
if (errorBuffer != 0)
errorBuffer->Release();
return true;
}
bool scShader::Compile( ID3DBlob** buffer )
{
DWORD shaderFlags = D3DCOMPILE_ENABLE_STRICTNESS;
ID3DBlob* errorBuffer = 0;
HRESULT result;
result = D3DX11CompileFromFileA(mPath.c_str(), 0, 0, mEntry.c_str(), mShaderModel.c_str(),
shaderFlags, 0, 0, buffer, &errorBuffer, 0 );
if( FAILED( result ) )
{
if( errorBuffer != 0 )
{
scErrMsg( ( char* )errorBuffer->GetBufferPointer( ) );
errorBuffer->Release( );
}
return false;
}
if( errorBuffer != 0 )
{
scErrMsg( ( char* )errorBuffer->GetBufferPointer( ) );
errorBuffer->Release( );
}
return true;
}
bool D3D11Shader::loadHLSLBlob( ID3D10Blob** blob, char* filename, char* fcnName, const char* shaderModel )
{
ID3D10Blob *errorblob;
if( !DX_CHECK( D3DX11CompileFromFileA(
filename,
NULL, NULL,
fcnName,
shaderModel, // usually "ps_5_0" or "vs_5_0"
D3D10_SHADER_ENABLE_STRICTNESS, NULL,
NULL,
blob, &errorblob,
NULL ), "compiling fx" ) )
{
if( !errorblob )
{
error( "%s shader file not found!", filename ) ;
return false ;
}
else
{
int size = errorblob->GetBufferSize() ;
char* errstr = (char*)malloc( size+1 ) ;
strncpy( errstr, (char*)errorblob->GetBufferPointer(), size ) ;
errstr[ size ] = 0 ;
error( errstr );
free( errstr ) ;
}
SAFE_RELEASE( errorblob );
bail( "Couldn't compile your fx file", true ) ; // (exits)
return false ;
}
return true ; // successful load
}
bool ComputeShader::createFromFile(ID3D11Device* currDevice, char* filePath, char* shaderEntryPoint)
{
UINT compileFlags = 0;
#if defined(DEBUG) | defined(_DEBUG)
compileFlags |= D3DCOMPILE_DEBUG;
#else
compileFlags |= D3DCOMPILE_OPTIMIZATION_LEVEL3;
#endif
try
{
D3DX11CompileFromFileA(filePath, 0, NULL, shaderEntryPoint, "cs_5_0", compileFlags, NULL, NULL, &mEffectBlob, &mCompilerErrors, NULL);
if (!mEffectBlob)
throw (char*) mCompilerErrors->GetBufferPointer();
HRESULT error = currDevice->CreateComputeShader(mEffectBlob->GetBufferPointer(), mEffectBlob->GetBufferSize(), NULL, &mComputeShader);
if (!mComputeShader)
throw error;
}
catch (char* e)
{
std::cout << e;
return false;
}
return true;
}
//VERTEX SHADER
HRESULT ACD3D::CompileVS(std::string path, VertexFormat vertexFormat, ACVertexShader** ppOutVertexShaderPtr)
{
*ppOutVertexShaderPtr = new ACVertexShader();
//compila o VS
ID3DBlob* pVSBuf = nullptr;
ID3DBlob* pError = nullptr;
//se estiver em debug ele compila o shader para ser debugado, em release ele é otimizado
DWORD dwShaderFlags = 0;
#if defined( DEBUG ) || defined( _DEBUG )
dwShaderFlags |= D3DCOMPILE_DEBUG;
#endif
HRESULT hr = 0;
hr = D3DX11CompileFromFileA(path.c_str(),
nullptr,
nullptr,
"main",
"vs_4_0",
dwShaderFlags,
0,
nullptr,
&pVSBuf,
&pError,
nullptr );
if( FAILED( hr ) )
{
char* pCompileErrors = static_cast<char*>(pError->GetBufferPointer());
MessageBoxA(nullptr, pCompileErrors, "Error vS", MB_OK | MB_ICONERROR);
Log("[ERROR] Erro ao carregar vertexshader. CompileVS(): %s", pCompileErrors);
hr = AC_FAIL;
}
else
{
//cria o vertexbuffer
ID3D11VertexShader* pVS;
ACD3DGlobals::G_pD3dDevice->CreateVertexShader( ( DWORD* )pVSBuf->GetBufferPointer(),
pVSBuf->GetBufferSize(),
nullptr,
&pVS);
(*ppOutVertexShaderPtr)->pVS = pVS;
(*ppOutVertexShaderPtr)->Format = vertexFormat;
//cria o layout de vertice
hr = ACD3DVertexLayoutProvider::CreateInputLayout(ACD3DGlobals::G_pD3dDevice, pVSBuf, vertexFormat);
}
SAFE_RELEASE(pVSBuf);
SAFE_RELEASE(pError);
return hr;
};
//--------------------------------------------------------------------------------------
// Find and compile the specified shader
//--------------------------------------------------------------------------------------
HRESULT D3D11VShader::CompileShaderFromFile(const CHAR* szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, ID3DBlob** ppBlobOut, std::vector<D3D10_SHADER_MACRO>& makros)
{
HRESULT hr = S_OK;
char dir[260];
GetCurrentDirectoryA(260, dir);
SetCurrentDirectoryA(Engine::GAPI->GetStartDirectory().c_str());
DWORD dwShaderFlags = 0;
#if defined( DEBUG ) || defined( _DEBUG )
// Set the D3DCOMPILE_DEBUG flag to embed debug information in the shaders.
// Setting this flag improves the shader debugging experience, but still allows
// the shaders to be optimized and to run exactly the way they will run in
// the release configuration of this program.
//dwShaderFlags |= D3DCOMPILE_DEBUG;
#endif
// Construct makros
std::vector<D3D10_SHADER_MACRO> m;
D3D11GraphicsEngine::ConstructShaderMakroList(m);
// Push these to the front
m.insert(m.begin(), makros.begin(), makros.end());
ID3DBlob* pErrorBlob;
hr = D3DX11CompileFromFileA(szFileName, &m[0], NULL, szEntryPoint, szShaderModel,
dwShaderFlags, 0, NULL, ppBlobOut, &pErrorBlob, NULL);
if (FAILED(hr))
{
LogInfo() << "Shader compilation failed!";
if (pErrorBlob != NULL)
{
LogErrorBox() << (char*)pErrorBlob->GetBufferPointer() << "\n\n (You can ignore the next error from Gothic about too small video memory!)";
pErrorBlob->Release();
}
SetCurrentDirectoryA(dir);
return hr;
}
if (pErrorBlob)
{
/*if(Engine->SwapchainCreated())
Engine->GetConsole()->PostConsoleMessage((char*)pErrorBlob->GetBufferPointer());
else
LogWarnBox() << (char*)pErrorBlob->GetBufferPointer() << "\n\n (You can ignore the next error from Gothic about too small video memory!)";
*/
pErrorBlob->Release();
}
SetCurrentDirectoryA(dir);
return S_OK;
}
//GEOMETRY SHADER
HRESULT ACD3D::CompileGS(std::string path, ACGeometryShader** ppOutGeometryShaderPtr)
{
*ppOutGeometryShaderPtr = new ACGeometryShader();
//compila o GS
ID3DBlob* pGSBuf = nullptr;
ID3DBlob* pError = nullptr;
//se estiver em debug ele compila o shader para ser debugado, em release ele é otimizado
DWORD dwShaderFlags = 0;
#if defined( DEBUG ) || defined( _DEBUG )
dwShaderFlags |= D3DCOMPILE_DEBUG;
#endif
HRESULT hr = 0;
hr = D3DX11CompileFromFileA(path.c_str(),
nullptr,
nullptr,
"main",
"gs_4_0",
dwShaderFlags,
0,
nullptr,
&pGSBuf,
&pError,
nullptr );
if( FAILED( hr ) )
{
char* pCompileErrors = static_cast<char*>(pError->GetBufferPointer());
MessageBoxA(nullptr, pCompileErrors, "Error GS", MB_OK | MB_ICONERROR);
Log("[ERROR] Erro ao carregar geometryshader. CompileGS(): %s", pCompileErrors);
hr = AC_FAIL;
}
else
{
//cria o geometrybuffer
ID3D11GeometryShader* pGS;
ACD3DGlobals::G_pD3dDevice->CreateGeometryShader( ( DWORD* )pGSBuf->GetBufferPointer(),
pGSBuf->GetBufferSize(),
nullptr,
&pGS);
(*ppOutGeometryShaderPtr)->pGS = pGS;
hr = AC_OK;
}
SAFE_RELEASE(pGSBuf);
SAFE_RELEASE(pError);
return hr;
};
HRESULT CompileShaderFromFile(LPCSTR szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, ID3DBlob** ppBlobOut)
{
HRESULT hr = S_OK;
ID3DBlob* pErrorBlob;
hr = D3DX11CompileFromFileA(szFileName, NULL, NULL, szEntryPoint, szShaderModel, D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, ppBlobOut, &pErrorBlob, NULL);
if(FAILED(hr))
{
OutputDebugStringA((char*)pErrorBlob->GetBufferPointer());
SAFE_RELEASE(pErrorBlob);
return hr;
}
SAFE_RELEASE(pErrorBlob);
return S_OK;
}
ID3D11PixelShader* Shader::InitPixelShader(const std::string& fileName, const std::string& funcName){
ID3D11PixelShader* pPShader;
ID3D10Blob* errBuffer;
//pixel shader
if ( FAILED( D3DX11CompileFromFileA(fileName.c_str(), NULL, NULL, funcName.c_str(), "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &psBuffer, &errBuffer, NULL) ) ){
if (errBuffer){
LOG((LPCSTR)errBuffer->GetBufferPointer());
SAFERELEASE(errBuffer);
}else{
LOG("Shader: Pixel shader file not found");
}
pPShader = NULL;
}else{
if ( FAILED( pDevice->CreatePixelShader(psBuffer->GetBufferPointer(), psBuffer->GetBufferSize(), NULL, &pPShader) ) ){
pPShader = NULL;
SAFERELEASE(psBuffer);
}
}
return pPShader;
}
ID3D11VertexShader* Shader::InitVertexShader(const std::string& fileName, const std::string& funcName){
ID3D11VertexShader* pVShader = NULL;
ID3D10Blob* errBuffer;
//vertex shader
if ( FAILED( D3DX11CompileFromFileA(fileName.c_str(), NULL, NULL, funcName.c_str(), "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &vsBuffer, &errBuffer, NULL) ) ){
if (errBuffer){
LOG((LPCSTR)errBuffer->GetBufferPointer());
SAFERELEASE(errBuffer);
}else{
LOG("Shader: Vertex shader file not found");
}
pVShader = NULL;
}else{
if ( FAILED( pDevice->CreateVertexShader(vsBuffer->GetBufferPointer(), vsBuffer->GetBufferSize(), NULL, &pVShader) ) ){
pVShader = NULL;
SAFERELEASE(vsBuffer);
}
}
return pVShader;
}
void Terrain::init(ID3D11Device* device)
{
ID3D11DeviceContext* deviceContext;
device->GetImmediateContext(&deviceContext);
ID3DBlob* errorBlob;
ID3DBlob* shaderBlob;
HRESULT result = D3DX11CompileFromFileA("Content\\Effects\\SimpleTerrain.fx", 0, 0, 0, "fx_5_0", 0, 0, 0, &shaderBlob, &errorBlob, 0);
char* errorBuffer;
if(errorBlob)
{
errorBuffer = (char*)errorBlob->GetBufferPointer();
}
result = D3DX11CreateEffectFromMemory(shaderBlob->GetBufferPointer(), shaderBlob->GetBufferSize(), 0, device, &effect);
if(shaderBlob)
shaderBlob->Release();
if(errorBlob)
errorBlob->Release();
// vertex buffer
TerrainVertex vertices[] =
{
{Vector3(0.0f, 0, INSTANCE_SIZE), Vector3::up, D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f), Vector2(0, 0)},
{Vector3(INSTANCE_SIZE, 0, INSTANCE_SIZE), Vector3::up, D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f), Vector2(1, 0)},
{Vector3(0.0f, 0, 0.0f), Vector3::up, D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f), Vector2(0, 1)},
{Vector3(INSTANCE_SIZE, 0, 0.0f), Vector3::up, D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f), Vector2(1, 1)}
};
D3D11_BUFFER_DESC vertexBufferDesc;
ZeroMemory(&vertexBufferDesc, sizeof(vertexBufferDesc));
vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
vertexBufferDesc.ByteWidth = sizeof(vertices);
vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
vertexBufferDesc.CPUAccessFlags = 0;
D3D11_SUBRESOURCE_DATA vertexData;
ZeroMemory( &vertexData, sizeof(D3D11_SUBRESOURCE_DATA) );
vertexData.pSysMem = vertices;
device->CreateBuffer(&vertexBufferDesc, &vertexData, &vertexBuffer);
// Instance Buffer
TerrainInstance instances[INSTANCE_COUNT];
for(int i = 0; i < INSTANCE_COUNT_X; ++i)
for(int j = 0; j < INSTANCE_COUNT_Y; ++j)
instances[i * INSTANCE_COUNT_X + j].position = Vector3((float)i*INSTANCE_SIZE, 0, (float)j*INSTANCE_SIZE);
D3D11_BUFFER_DESC instanceBufferDesc;
ZeroMemory(&instanceBufferDesc, sizeof(D3D11_BUFFER_DESC));
instanceBufferDesc.Usage = D3D11_USAGE_DEFAULT;
instanceBufferDesc.ByteWidth = sizeof(instances);
instanceBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
instanceBufferDesc.CPUAccessFlags = 0;
D3D11_SUBRESOURCE_DATA instanceData;
ZeroMemory(&instanceData, sizeof(D3D11_SUBRESOURCE_DATA));
instanceData.pSysMem = instances;
device->CreateBuffer(&instanceBufferDesc, &instanceData, &instanceBuffer);
// index buffer
unsigned indices[] = { 0, 1, 2, 3 };
indexCount = sizeof(indices) / sizeof(unsigned);
D3D11_BUFFER_DESC indexBufferDesc;
ZeroMemory(&indexBufferDesc, sizeof(D3D11_BUFFER_DESC));
indexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
indexBufferDesc.ByteWidth = sizeof(indices);
indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
indexBufferDesc.CPUAccessFlags = 0;
D3D11_SUBRESOURCE_DATA indexData;
ZeroMemory(&indexData, sizeof(D3D11_SUBRESOURCE_DATA));
indexData.pSysMem = indices;
device->CreateBuffer(&indexBufferDesc, &indexData, &indexBuffer);
D3D11_INPUT_ELEMENT_DESC inputElementDesc[] =
{
{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
{"NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0},
{"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0},
{"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 40, D3D11_INPUT_PER_VERTEX_DATA, 0},
{"TEXCOORD", 1, DXGI_FORMAT_R32G32B32_FLOAT, 1, 0, D3D11_INPUT_PER_INSTANCE_DATA, 1}
};
int inputElementCount = sizeof(inputElementDesc) / sizeof(D3D11_INPUT_ELEMENT_DESC);
technique = effect->GetTechniqueByIndex(0);
pass = technique->GetPassByIndex(0);
D3DX11_PASS_DESC passDesc;
pass->GetDesc(&passDesc);
result = device->CreateInputLayout(inputElementDesc, inputElementCount,
passDesc.pIAInputSignature, passDesc.IAInputSignatureSize, &inputLayout);
DXUTGetGlobalResourceCache().CreateTextureFromFile(device, deviceContext, L"Content/Textures/Terrain/Grass.dds", &surfaceTexture);
evSurfaceTexture = effect->GetVariableByName("SurfaceTexture")->AsShaderResource();
evWorld = effect->GetVariableByName("World")->AsMatrix();
evViewProjection = effect->GetVariableByName("ViewProjection")->AsMatrix();
evSurfaceTexture->SetResource(surfaceTexture);
world = Matrix::createTranslation((-INSTANCE_COUNT_X * INSTANCE_SIZE) / 2, 0, (-INSTANCE_COUNT_Y * INSTANCE_SIZE) / 2);
deviceContext->Release();
}
bool D3D11EffectMaterial::LoadFromFile(const char* szFile)
{
ID3D10Blob* pBlob = NULL;
ID3D10Blob* pErrorBlob = NULL;
if( FAILED( D3DX11CompileFromFileA( szFile, NULL, NULL, NULL, "fx_5_0", D3DCOMPILE_ENABLE_STRICTNESS, NULL, NULL, &pBlob, &pErrorBlob, NULL ) ) )
{
OutputDebugInfo(pErrorBlob);
return false;
}
OutputDebugInfo(pErrorBlob);
HRESULT ret = D3DX11CreateEffectFromMemory(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), 0, m_pDevice, &m_pEffect);
if(FAILED(ret))
{
return false;
}
if(m_pEffect->IsValid() == FALSE)
{
m_pEffect->Release();
m_pEffect = NULL;
return false;
}
D3DX11_EFFECT_DESC desc;
if(FAILED(m_pEffect->GetDesc(&desc)))
{
m_pEffect->Release();
m_pEffect = NULL;
return false;
}
for(UINT i = 0; i < desc.Techniques; ++i)
{
ID3DX11EffectTechnique* pTech = m_pEffect->GetTechniqueByIndex(i);
if(TRUE == pTech->IsValid())
{
m_pTech = pTech;
break;
}
}
if(m_pTech == NULL)
{
m_pEffect->Release();
m_pEffect = NULL;
m_pTech = NULL;
return false;
}
D3DX11_TECHNIQUE_DESC tech;
if(FAILED(m_pTech->GetDesc(&tech)))
{
m_pEffect->Release();
m_pEffect = NULL;
m_pTech = NULL;
}
m_nPass = tech.Passes;
m_semantics.m_pViewTM = (ID3DX11EffectMatrixVariable*)m_pEffect->GetVariableBySemantic("MATRIX_VIEW");
m_semantics.m_pWorldTM = (ID3DX11EffectMatrixVariable*)m_pEffect->GetVariableBySemantic("MATRIX_WORLD");
m_semantics.m_pProjTM = (ID3DX11EffectMatrixVariable*)m_pEffect->GetVariableBySemantic("MATRIX_PROJ");
m_semantics.m_pInvViewTM = (ID3DX11EffectMatrixVariable*)m_pEffect->GetVariableBySemantic("MATRIX_I_VIEW");
m_semantics.m_pInvWorldTM = (ID3DX11EffectMatrixVariable*)m_pEffect->GetVariableBySemantic("MATRIX_I_WORLD");
m_semantics.m_pInvProjTM = (ID3DX11EffectMatrixVariable*)m_pEffect->GetVariableBySemantic("MATRIX_I_PROJ");
m_semantics.m_pWVTM = (ID3DX11EffectMatrixVariable*)m_pEffect->GetVariableBySemantic("MATRIX_WV");
m_semantics.m_pWVPTM = (ID3DX11EffectMatrixVariable*)m_pEffect->GetVariableBySemantic("MATRIX_WVP");
m_semantics.m_pInvWVTM = (ID3DX11EffectMatrixVariable*)m_pEffect->GetVariableBySemantic("MATRIX_I_WV");
m_semantics.m_pInvWVPTM = (ID3DX11EffectMatrixVariable*)m_pEffect->GetVariableBySemantic("MATRIX_I_WVP");
m_semantics.m_pInvVPTM = (ID3DX11EffectMatrixVariable*)m_pEffect->GetVariableBySemantic("MATRIX_I_VP");
m_semantics.m_pGBuffer = (ID3DX11EffectShaderResourceVariable*)m_pEffect->GetVariableBySemantic("DR_GBUFFER");
m_semantics.m_pABuffer = (ID3DX11EffectShaderResourceVariable*)m_pEffect->GetVariableBySemantic("DR_ABUFFER");
return true;
}
void TerrainEffect::init(ID3D11Device* graphicsDevice, const char* path)
{
ID3DBlob* errorBlob;
ID3DBlob* effectBlob;
#if defined(DEBUG) | defined(_DEBUG)
unsigned flags = D3DCOMPILE_DEBUG | D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_WARNINGS_ARE_ERRORS;
#else
unsigned flags = D3DCOMPILE_OPTIMIZATION_LEVEL3;
#endif
HRESULT hr = D3DX11CompileFromFileA(path, 0, 0, 0, "fx_5_0", flags, 0, 0, &effectBlob, &errorBlob, 0);
if (hr != S_OK)
{
OutputDebugStringA((char*)errorBlob->GetBufferPointer());
throw std::exception();
}
D3DX11CreateEffectFromMemory(effectBlob->GetBufferPointer(), effectBlob->GetBufferSize(), 0, graphicsDevice, &effect);
effectBlob->Release();
ID3DX11EffectTechnique* technique;
technique = effect->GetTechniqueByIndex(0);
effectPass = technique->GetPassByIndex(0);
D3DX11_PASS_SHADER_DESC vertexShaderDesc;
D3DX11_EFFECT_SHADER_DESC effectShaderDesc;
effectPass->GetVertexShaderDesc(&vertexShaderDesc);
vertexShaderDesc.pShaderVariable->GetShaderDesc(vertexShaderDesc.ShaderIndex, &effectShaderDesc);
graphicsDevice->CreateInputLayout(TerrainPatch::inputElementDesc, TerrainPatch::numElements, effectShaderDesc.pBytecode, effectShaderDesc.BytecodeLength, &inputLayout);
colormap = effect->GetVariableByName("Colormap")->AsShaderResource();
heightmap = effect->GetVariableByName("Heightmap")->AsShaderResource();
normalmap = effect->GetVariableByName("Normalmap")->AsShaderResource();
colormaps = effect->GetVariableByName("Colormaps")->AsShaderResource();
infomap = effect->GetVariableByName("Infomap")->AsShaderResource();
slopemap = effect->GetVariableByName("Slopemap")->AsShaderResource();
roughnessmap = effect->GetVariableByName("Roughnessmap")->AsShaderResource();
fakeView = effect->GetVariableByName("FakeView")->AsMatrix();
world = effect->GetVariableByName("World")->AsMatrix();
view = effect->GetVariableByName("View")->AsMatrix();
projection = effect->GetVariableByName("Projection")->AsMatrix();
worldViewProjection = effect->GetVariableByName("WorldViewProjection")->AsMatrix();
terrainSize = effect->GetVariableByName("TerrainSize")->AsScalar();
terrainScale = effect->GetVariableByName("TerrainScale")->AsScalar();
minPatchSize = effect->GetVariableByName("MinPatchSize")->AsScalar();
minNodeSize = effect->GetVariableByName("MinNodeSize")->AsScalar();
bumpiness = effect->GetVariableByName("Bumpiness")->AsScalar();
roughnessModificator = effect->GetVariableByName("RoughnessModificator")->AsScalar();
minPixelPerTriangle = effect->GetVariableByName("MinPixelPerTriangle")->AsScalar();
colormapRepeat = effect->GetVariableByName("ColormapRepeat")->AsScalar();
screenSize = effect->GetVariableByName("ScreenSize")->AsVector();
slopeRange = effect->GetVariableByName("SlopeRange")->AsVector();
colormapEnabled = effect->GetVariableByName("ColormapEnabled")->AsScalar();
frustumCullingEnabled = effect->GetVariableByName("FrustumCullingEnabled")->AsScalar();
heightTextureEnabled = effect->GetVariableByName("HeightTextureEnabled")->AsScalar();
slopeTextureEnabled = effect->GetVariableByName("SlopeTextureEnabled")->AsScalar();
lightingEnabled = effect->GetVariableByName("LightingEnabled")->AsScalar();
roughnessEnabled = effect->GetVariableByName("RoughnessEnabled")->AsScalar();
antiShimmeringEnabled = effect->GetVariableByName("AntiShimmeringEnabled")->AsScalar();
showNodesEnabled = effect->GetVariableByName("ShowNodesEnabled")->AsScalar();
bruteForceEnabled = effect->GetVariableByName("BruteForceEnabled")->AsScalar();
}
VoxelRenderer::VoxelRenderer(GraphicsDevice& graphicsDevice)
: m_graphicsDevice(graphicsDevice)
{
if (!m_sharedWeakPtr.expired())
{
m_shared = m_sharedWeakPtr.lock();
}
else
{
m_shared = std::make_shared<SharedProperties>();
m_sharedWeakPtr = std::weak_ptr<SharedProperties>(m_shared);
//
// Create the vertex shader and input layout.
//
boost::intrusive_ptr<ID3D10Blob> bytecode, errors;
D3DCHECK(D3DX11CompileFromFileA("assets/shaders/voxel_mesh_vs.hlsl",// pSrcFile
NULL, // pDefines
NULL, // pInclude
"main", // pFunctionName
"vs_4_0", // pProfile
0, // Flags1
0, // Flags2
NULL, // pPump
AttachPtr(bytecode), // ppShader
AttachPtr(errors), // ppErrorMsgs
NULL)); // pHResult
D3DCHECK(m_graphicsDevice.GetD3DDevice().CreateVertexShader(
bytecode->GetBufferPointer(),
bytecode->GetBufferSize(),
NULL,
AttachPtr(m_shared->vertexShader)));
D3D11_INPUT_ELEMENT_DESC inputElements[] =
{
{
"POSITION", // SemanticName
0, // SemanticIndex
DXGI_FORMAT_R32G32B32_FLOAT, // Format
0, // InputSlot
0, // AlignedByteOffset
D3D11_INPUT_PER_VERTEX_DATA, // InputSlotClass
0 // InstanceDataStepRate
},
{
"NORMAL", // SemanticName
0, // SemanticIndex
DXGI_FORMAT_R32_UINT, // Format
0, // InputSlot
12, // AlignedByteOffset
D3D11_INPUT_PER_VERTEX_DATA, // InputSlotClass
0 // InstanceDataStepRate
},
{
"TEXCOORD", // SemanticName
0, // SemanticIndex
DXGI_FORMAT_R32G32_UINT, // Format
0, // InputSlot
16, // AlignedByteOffset
D3D11_INPUT_PER_VERTEX_DATA, // InputSlotClass
0 // InstanceDataStepRate
}
};
D3DCHECK(m_graphicsDevice.GetD3DDevice().CreateInputLayout(
inputElements,
sizeof(inputElements) / sizeof(inputElements[0]),
bytecode->GetBufferPointer(),
bytecode->GetBufferSize(),
AttachPtr(m_shared->inputLayout)));
//
// Create the pixel shader.
//
D3DCHECK(D3DX11CompileFromFileA("assets/shaders/voxel_mesh_ps.hlsl",// pSrcFile
NULL, // pDefines
NULL, // pInclude
"main", // pFunctionName
"ps_4_0", // pProfile
0, // Flags1
0, // Flags2
NULL, // pPump
AttachPtr(bytecode), // ppShader
AttachPtr(errors), // ppErrorMsgs
NULL)); // pHResult
D3DCHECK(m_graphicsDevice.GetD3DDevice().CreatePixelShader(
bytecode->GetBufferPointer(),
bytecode->GetBufferSize(),
NULL,
AttachPtr(m_shared->pixelShader)));
//
// Create the state objects.
//
D3D11_DEPTH_STENCIL_DESC depthStencilDesc =
{
TRUE, // DepthEnable
D3D11_DEPTH_WRITE_MASK_ALL, // DepthWriteMask
D3D11_COMPARISON_LESS, // ComparisonFunc
TRUE, // StencilEnable
0, // StencilReadMask
0xFF, // StencilWriteMask
{ // FrontFace
D3D11_STENCIL_OP_KEEP, // StencilFailOp
D3D11_STENCIL_OP_KEEP, // StencilDepthFailOp
D3D11_STENCIL_OP_INCR_SAT, // StencilPassOp
D3D11_COMPARISON_ALWAYS, // StencilFunc
},
{ // BackFace
D3D11_STENCIL_OP_KEEP, // StencilFailOp
D3D11_STENCIL_OP_KEEP, // StencilDepthFailOp
D3D11_STENCIL_OP_KEEP, // StencilPassOp
D3D11_COMPARISON_NEVER, // StencilFunc
}
};
D3DCHECK(m_graphicsDevice.GetD3DDevice().CreateDepthStencilState(
&depthStencilDesc,
AttachPtr(m_shared->depthStencilState)));
D3D11_DEPTH_STENCIL_DESC transparentDepthStencilDesc =
{
TRUE, // DepthEnable
D3D11_DEPTH_WRITE_MASK_ZERO, // DepthWriteMask
D3D11_COMPARISON_LESS, // ComparisonFunc
FALSE, // StencilEnable
0, // StencilReadMask
0, // StencilWriteMask
{ // FrontFace
D3D11_STENCIL_OP_KEEP, // StencilFailOp
D3D11_STENCIL_OP_KEEP, // StencilDepthFailOp
D3D11_STENCIL_OP_KEEP, // StencilPassOp
D3D11_COMPARISON_ALWAYS, // StencilFunc
},
{ // BackFace
D3D11_STENCIL_OP_KEEP, // StencilFailOp
D3D11_STENCIL_OP_KEEP, // StencilDepthFailOp
D3D11_STENCIL_OP_KEEP, // StencilPassOp
D3D11_COMPARISON_NEVER, // StencilFunc
}
};
D3DCHECK(m_graphicsDevice.GetD3DDevice().CreateDepthStencilState(
&depthStencilDesc,
AttachPtr(m_shared->transparentDepthStencilState)));
D3D11_DEPTH_STENCIL_DESC fillGapsDepthStencilDesc =
{
TRUE, // DepthEnable
D3D11_DEPTH_WRITE_MASK_ALL, // DepthWriteMask
D3D11_COMPARISON_LESS, // ComparisonFunc
TRUE, // StencilEnable
0xFF, // StencilReadMask
0, // StencilWriteMask
{ // FrontFace
D3D11_STENCIL_OP_KEEP, // StencilFailOp
D3D11_STENCIL_OP_KEEP, // StencilDepthFailOp
D3D11_STENCIL_OP_KEEP, // StencilPassOp
D3D11_COMPARISON_EQUAL // StencilFunc
},
{ // BackFace
D3D11_STENCIL_OP_KEEP, // StencilFailOp
D3D11_STENCIL_OP_KEEP, // StencilDepthFailOp
D3D11_STENCIL_OP_KEEP, // StencilPassOp
D3D11_COMPARISON_NEVER // StencilFunc
}
};
D3DCHECK(m_graphicsDevice.GetD3DDevice().CreateDepthStencilState(&fillGapsDepthStencilDesc,
AttachPtr(m_shared->fillGapsDepthStencilState)));
D3D11_BLEND_DESC blendDesc =
{
FALSE, // AlphaToCoverageEnable
FALSE, // IndependentBlendEnable
{{ // RenderTarget[0]
TRUE, // BlendEnable
D3D11_BLEND_SRC_ALPHA, // SrcBlend
D3D11_BLEND_INV_SRC_ALPHA, // DestBlend
D3D11_BLEND_OP_ADD, // BlendOp
D3D11_BLEND_ZERO, // SrcBlendAlpha
D3D11_BLEND_ZERO, // DestBlendAlpha
D3D11_BLEND_OP_ADD, // BlendOpAlpha
D3D11_COLOR_WRITE_ENABLE_ALL // RenderTargetWriteMask
}}
};
D3DCHECK(m_graphicsDevice.GetD3DDevice().CreateBlendState(&blendDesc,
AttachPtr(m_shared->blendState)));
//
// Load the textures.
//
const char* paths[] =
{
"assets/textures/rock.jpg",
"assets/textures/dark_grass.png",
"assets/textures/Grass_1.png",
"assets/textures/dirt.jpg",
"assets/textures/pjrock21.jpg",
"assets/textures/darkrock.png",
"assets/textures/sand.png"
};
for (size_t i = 0; i < sizeof(paths) / sizeof(paths[0]); i++)
{
D3DCHECK(D3DX11CreateShaderResourceViewFromFileA(&m_graphicsDevice.GetD3DDevice(),
paths[i],
NULL,
NULL,
AttachPtr(m_shared->textureViews[i]),
NULL));
}
//
// Create the sampler state.
//
D3D11_SAMPLER_DESC samplerDesc =
{
D3D11_FILTER_MIN_MAG_MIP_LINEAR, // Filter
D3D11_TEXTURE_ADDRESS_WRAP, // AddressU
D3D11_TEXTURE_ADDRESS_WRAP, // AddressV
D3D11_TEXTURE_ADDRESS_WRAP, // AddressW
0.0f, // MaxLODBias
0, // MaxAnisotropy
D3D11_COMPARISON_ALWAYS, // ComparisonFunc
{0, 0, 0, 0}, // BorderColor
-FLT_MAX, // MinLOD
FLT_MAX // MaxLOD
};
D3DCHECK(m_graphicsDevice.GetD3DDevice().CreateSamplerState(&samplerDesc,
AttachPtr(m_shared->samplerState)));
}
//
// Create the constant buffer.
//
D3D11_BUFFER_DESC constantBufferDesc =
{
sizeof(ShaderConstants), // ByteWidth
D3D11_USAGE_DYNAMIC, // Usage
D3D11_BIND_CONSTANT_BUFFER, // BindFlags
D3D11_CPU_ACCESS_WRITE, // CPUAccessFlags
0, // MiscFlags
0 // StructureByteSize
};
D3DCHECK(m_graphicsDevice.GetD3DDevice().CreateBuffer(
&constantBufferDesc,
NULL,
AttachPtr(m_constantBuffer)));
}
SkyRenderer::SkyRenderer(GraphicsDevice& graphicsDevice)
: m_graphicsDevice(graphicsDevice)
{
if (!m_sharedWeakPtr.expired())
{
m_shared = m_sharedWeakPtr.lock();
}
else
{
m_shared = std::make_shared<SharedProperties>();
m_sharedWeakPtr = std::weak_ptr<SharedProperties>(m_shared);
//
// Create the vertex shader and input layout.
//
boost::intrusive_ptr<ID3D10Blob> bytecode, errors;
D3DCHECK(D3DX11CompileFromFileA("assets/shaders/skybox_vs.hlsl", // pSrcFile
NULL, // pDefines
NULL, // pInclude
"main", // pFunctionName
"vs_4_0", // pProfile
0, // Flags1
0, // Flags2
NULL, // pPump
AttachPtr(bytecode), // ppShader
AttachPtr(errors), // ppErrorMsgs
NULL)); // pHResult
D3DCHECK(m_graphicsDevice.GetD3DDevice().CreateVertexShader(
bytecode->GetBufferPointer(),
bytecode->GetBufferSize(),
NULL,
AttachPtr(m_shared->vertexShader)));
D3D11_INPUT_ELEMENT_DESC inputElements[] =
{
{
"POSITION", // SemanticName
0, // SemanticIndex
DXGI_FORMAT_R32G32B32_FLOAT, // Format
0, // InputSlot
0, // AlignedByteOffset
D3D11_INPUT_PER_VERTEX_DATA, // InputSlotClass
0 // InstanceDataStepRate
},
{
"TEXCOORD", // SemanticName
0, // SemanticIndex
DXGI_FORMAT_R32G32_FLOAT, // Format
0, // InputSlot
12, // AlignedByteOffset
D3D11_INPUT_PER_VERTEX_DATA, // InputSlotClass
0 // InstanceDataStepRate
}
};
D3DCHECK(m_graphicsDevice.GetD3DDevice().CreateInputLayout(
inputElements,
sizeof(inputElements) / sizeof(inputElements[0]),
bytecode->GetBufferPointer(),
bytecode->GetBufferSize(),
AttachPtr(m_shared->inputLayout)));
//
// Create the pixel shader.
//
D3DCHECK(D3DX11CompileFromFileA("assets/shaders/skybox_ps.hlsl", // pSrcFile
NULL, // pDefines
NULL, // pInclude
"main", // pFunctionName
"ps_4_0", // pProfile
0, // Flags1
0, // Flags2
NULL, // pPump
AttachPtr(bytecode), // ppShader
AttachPtr(errors), // ppErrorMsgs
NULL)); // pHResult
D3DCHECK(m_graphicsDevice.GetD3DDevice().CreatePixelShader(
bytecode->GetBufferPointer(),
bytecode->GetBufferSize(),
NULL,
AttachPtr(m_shared->pixelShader)));
//
// Create the renderer state objects.
//
D3D11_RASTERIZER_DESC rasterizerDesc =
{
D3D11_FILL_SOLID, // FillMode
D3D11_CULL_NONE, // CullMode
FALSE, // FrontCounterClockwise
0, // DepthBias
0.0f, // DepthBiasClamp
0.0f, // SlopeScaledDepthBias
FALSE, // DepthClipEnable
FALSE, // ScissorEnable
FALSE, // MultisampleEnable
FALSE // AntialiasedLineEnable
};
D3DCHECK(m_graphicsDevice.GetD3DDevice().CreateRasterizerState(
&rasterizerDesc,
AttachPtr(m_shared->rasterizerState)));
D3D11_DEPTH_STENCIL_DESC depthStencilDesc =
{
TRUE, // DepthEnable
D3D11_DEPTH_WRITE_MASK_ZERO, // DepthWriteMask
D3D11_COMPARISON_LESS_EQUAL, // ComparisonFunc
FALSE, // StencilEnable
0, // StencilReadMask
0, // StencilWriteMask
{ // FrontFace
D3D11_STENCIL_OP_KEEP, // StencilFailOp
D3D11_STENCIL_OP_KEEP, // StencilDepthFailOp
D3D11_STENCIL_OP_KEEP, // StencilPassOp
D3D11_COMPARISON_NEVER, // StencilFunc
},
{ // BackFace
D3D11_STENCIL_OP_KEEP, // StencilFailOp
D3D11_STENCIL_OP_KEEP, // StencilDepthFailOp
D3D11_STENCIL_OP_KEEP, // StencilPassOp
D3D11_COMPARISON_NEVER, // StencilFunc
}
};
D3DCHECK(m_graphicsDevice.GetD3DDevice().CreateDepthStencilState(
&depthStencilDesc,
AttachPtr(m_shared->depthStencilState)));
//
// Create the vertex and index buffers.
//
D3D11_SUBRESOURCE_DATA vertexBufferData =
{
SkyboxVertices, // pSysMem
0, // SysMemPitch
0 // SysMemSlicePitch
};
D3D11_BUFFER_DESC vertexBufferDesc =
{
sizeof(SkyboxVertices), // ByteWidth
D3D11_USAGE_IMMUTABLE, // Usage
D3D11_BIND_VERTEX_BUFFER, // BindFlags
0, // CPUAccessFlags
0, // MiscFlags
0 // StructureByteStride
};
D3DCHECK(m_graphicsDevice.GetD3DDevice().CreateBuffer(&vertexBufferDesc,
&vertexBufferData,
AttachPtr(m_shared->vertexBuffer)));
D3D11_SUBRESOURCE_DATA indexBufferData =
{
SkyboxIndices, // pSysMem
0, // SysMemPitch
0 // SysMemSlicePitch
};
D3D11_BUFFER_DESC indexBufferDesc =
{
sizeof(SkyboxIndices), // ByteWidth
D3D11_USAGE_IMMUTABLE, // Usage
D3D11_BIND_INDEX_BUFFER, // BindFlags
0, // CPUAccessFlags
0, // MiscFlags
0 // StructureByteStride
};
D3DCHECK(m_graphicsDevice.GetD3DDevice().CreateBuffer(&indexBufferDesc,
&indexBufferData,
AttachPtr(m_shared->indexBuffer)));
//
// Load the sky texture.
//
D3DCHECK(D3DX11CreateShaderResourceViewFromFileA(&m_graphicsDevice.GetD3DDevice(),
"assets/textures/sky.jpg",
NULL,
NULL,
AttachPtr(m_shared->skyTextureView),
NULL));
//
// Create the sampler state.
//
D3D11_SAMPLER_DESC samplerDesc =
{
D3D11_FILTER_MIN_MAG_MIP_LINEAR, // Filter
D3D11_TEXTURE_ADDRESS_CLAMP, // AddressU
D3D11_TEXTURE_ADDRESS_CLAMP, // AddressV
D3D11_TEXTURE_ADDRESS_CLAMP, // AddressW
0.0f, // MaxLODBias
0, // MaxAnisotropy
D3D11_COMPARISON_ALWAYS, // ComparisonFunc
{0, 0, 0, 0}, // BorderColor
-FLT_MAX, // MinLOD
FLT_MAX // MaxLOD
};
D3DCHECK(m_graphicsDevice.GetD3DDevice().CreateSamplerState(&samplerDesc,
AttachPtr(m_shared->samplerState)));
}
//
// Create the constant buffer.
//
D3D11_BUFFER_DESC constantBufferDesc =
{
sizeof(ShaderConstants), // ByteWidth
D3D11_USAGE_DYNAMIC, // Usage
D3D11_BIND_CONSTANT_BUFFER, // BindFlags
D3D11_CPU_ACCESS_WRITE, // CPUAccessFlags
0, // MiscFlags
0 // StructureByteSize
};
D3DCHECK(m_graphicsDevice.GetD3DDevice().CreateBuffer(
&constantBufferDesc,
NULL,
AttachPtr(m_constantBuffer)));
}
void ComplexTree::init(ID3D11Device* device)
{
ID3D11DeviceContext* deviceContext;
device->GetImmediateContext(&deviceContext);
HRESULT result = trunkMesh.Create(device, trunkPath, true);
boundingBoxCenter = trunkMesh.GetMeshBBoxCenter(0);
boundingBoxExtents = trunkMesh.GetMeshBBoxExtents(0);
ID3DBlob* errorBlob;
ID3DBlob* shaderBlob;
result = D3DX11CompileFromFileA("Content/Effects/Trunk.fx", 0, 0, 0, "fx_5_0", 0, 0, 0, &shaderBlob, &errorBlob, 0);
char* errorBuffer;
if(errorBlob)
{
errorBuffer = (char*)errorBlob->GetBufferPointer();
}
result = D3DX11CreateEffectFromMemory(shaderBlob->GetBufferPointer(), shaderBlob->GetBufferSize(), 0, device, &effect);
if(shaderBlob)
shaderBlob->Release();
if(errorBlob)
errorBlob->Release();
for(int i = 0; i < TREE_INSTANCE_COUNT; ++i)
{
treePositions[i].x = (rand() / (float)RAND_MAX) * TREE_BORDER - TREE_BORDER / 2.0f;
treePositions[i].y = 0;
treePositions[i].z = (rand() / (float)RAND_MAX) * TREE_BORDER - TREE_BORDER / 2.0f;
}
D3D11_BUFFER_DESC instanceBufferDesc;
ZeroMemory(&instanceBufferDesc, sizeof(D3D11_BUFFER_DESC));
instanceBufferDesc.Usage = D3D11_USAGE_DEFAULT;
instanceBufferDesc.ByteWidth = sizeof(treePositions);
instanceBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
instanceBufferDesc.CPUAccessFlags = 0;
D3D11_SUBRESOURCE_DATA instanceData;
ZeroMemory(&instanceData, sizeof(D3D11_SUBRESOURCE_DATA));
instanceData.pSysMem = treePositions;
device->CreateBuffer(&instanceBufferDesc, &instanceData, &instanceBuffer);
technique = effect->GetTechniqueByName("Trunk");
techniqueLOD1 = effect->GetTechniqueByName("TrunkLOD1");
pass = technique->GetPassByIndex(0);
passLOD1 = techniqueLOD1->GetPassByIndex(0);
D3D11_INPUT_ELEMENT_DESC inputElementDescLOD0[] =
{
{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
{"NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0},
{"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0},
{"TEXCOORD", 1, DXGI_FORMAT_R32G32B32_FLOAT, 1, 0, D3D11_INPUT_PER_INSTANCE_DATA, 1}
};
int inputElementCount = sizeof(inputElementDescLOD0) / sizeof(D3D11_INPUT_ELEMENT_DESC);
D3DX11_PASS_DESC passDesc;
pass->GetDesc(&passDesc);
result = device->CreateInputLayout(inputElementDescLOD0, inputElementCount,
passDesc.pIAInputSignature, passDesc.IAInputSignatureSize, &inputLayout);
D3D11_INPUT_ELEMENT_DESC inputElementDescLOD1[] =
{
{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}
};
inputElementCount = sizeof(inputElementDescLOD1) / sizeof(D3D11_INPUT_ELEMENT_DESC);
passLOD1->GetDesc(&passDesc);
device->CreateInputLayout(inputElementDescLOD1, inputElementCount,
passDesc.pIAInputSignature, passDesc.IAInputSignatureSize, &inputLayoutLOD1);
CDXUTResourceCache& resourceCache = DXUTGetGlobalResourceCache();
resourceCache.CreateTextureFromFile(device, deviceContext, L"Content/Textures/Trees/rinde_bumpmap.dds", &bumpMap);
resourceCache.CreateTextureFromFile(device, deviceContext, L"Content/Textures/Trees/rinde.dds", &alternativeTrunkTexture);
resourceCache.CreateTextureFromFile(device, deviceContext, L"Content/Textures/Trees/trunk414_normalmap.dds", &normalMap);
resourceCache.CreateTextureFromFile(device, deviceContext, L"Content/Textures/Trees/trunk414_front.dds", &billboardFront);
resourceCache.CreateTextureFromFile(device, deviceContext, L"Content/Textures/Trees/trunk414_side.dds", &billboardSide);
resourceCache.CreateTextureFromFile(device, deviceContext, L"Content/Textures/Trees/trunk414_top.dds", &billboardTop);
evViewProjection = effect->GetVariableByName("ViewProjection")->AsMatrix();
evWorld = effect->GetVariableByName("World")->AsMatrix();
evTrunkTexture = effect->GetVariableByName("TrunkTexture")->AsShaderResource();
evBumpMap = effect->GetVariableByName("BumpMapTexture")->AsShaderResource();
evNormalMap = effect->GetVariableByName("NormalMapTexture")->AsShaderResource();
evBillboardTop = effect->GetVariableByName("BillboardTop")->AsShaderResource();
evBillboardSide = effect->GetVariableByName("BillboardSide")->AsShaderResource();
evBillboardFront = effect->GetVariableByName("BillboardFront")->AsShaderResource();
evEdgeFactor = effect->GetVariableByName("EdgeFactor")->AsScalar();
evInsideFactor = effect->GetVariableByName("InsideFactor")->AsScalar();
evMinDistance = effect->GetVariableByName("MinDistance")->AsScalar();
evMaxDistance = effect->GetVariableByName("MaxDistance")->AsScalar();
evBoundingBoxCenter = effect->GetVariableByName("BoundingBoxCenter")->AsScalar();
evBoundingBoxExtents = effect->GetVariableByName("BoundingBoxExtents")->AsScalar();
evGSCulling = effect->GetVariableByName("GSCulling")->AsScalar();
evShowSavedCulling = effect->GetVariableByName("ShowSavedCulling")->AsScalar();
evSavedViewProjection = effect->GetVariableByName("SavedViewProjection")->AsMatrix();
evCameraPosition = effect->GetVariableByName("CameraPosition")->AsVector();
evLightVector = effect->GetVariableByName("LightVector")->AsVector();
evAmbientLight = effect->GetVariableByName("AmbientLight")->AsVector();
evDiffuseLight = effect->GetVariableByName("DiffuseLight")->AsVector();
evSpecularLight = effect->GetVariableByName("SpecularLight")->AsVector();
evShininess = effect->GetVariableByName("Shininess")->AsScalar();
evBumpMap->SetResource(bumpMap);
evTrunkTexture->SetResource(alternativeTrunkTexture);
evNormalMap->SetResource(normalMap);
evBillboardTop->SetResource(billboardTop);
evBillboardFront->SetResource(billboardFront);
evBillboardSide->SetResource(billboardSide);
evEdgeFactor->SetFloat(TREE_TESSELLATION_FACTOR_EDGES);
evInsideFactor->SetFloat(TREE_TESSELLATION_FACTOR_INSIDE);
evMinDistance->SetFloat(TREE_MIN_DISTANCE);
evMaxDistance->SetFloat(TREE_MAX_DISTANCE);
evBoundingBoxCenter->SetFloatArray(boundingBoxCenter, 0, 3);
evBoundingBoxExtents->SetFloatArray(boundingBoxExtents, 0, 3);
deviceContext->Release();
}
bool Effect::Compile(char* pFilename, char* pEntryPoint, ShaderTarget target, bool model5)
{
char* model;
switch(target)
{
case Target_VertexShader:
if(model5)
model="vs_5_0";
else
model="vs_4_0";
break;
case Target_PixelShader:
if(model5)
model="ps_5_0";
else
model="ps_4_0";
break;
case Target_GeometryShader:
if(model5)
model="gs_5_0";
else
model="gs_4_0";
break;
case Target_HullShader:
if(model5)
model="hs_5_0";
else
model="hs_4_0";
break;
case Target_DomainShader:
if(model5)
model="ds_5_0";
else
model="ds_4_0";
break;
}
ID3DBlob* code;
ID3DBlob* error;
HR(D3DX11CompileFromFileA( pFilename, NULL, NULL, pEntryPoint, model, 0, 0, NULL, &code, &error,NULL));
switch(target)
{
case Target_VertexShader:
mpVertexByteCode = new byte[code->GetBufferSize()];
mVertexByteSize = code->GetBufferSize();
memcpy_s(mpVertexByteCode, code->GetBufferSize(), code->GetBufferPointer(), code->GetBufferSize());
HR(mpDeviceManager->mpDevice->CreateVertexShader(code->GetBufferPointer(), code->GetBufferSize(), NULL, &mpVertexShader) );
break;
case Target_PixelShader:
HR(mpDeviceManager->mpDevice->CreatePixelShader(code->GetBufferPointer(), code->GetBufferSize(), NULL, &mpPixelShader) );
break;
case Target_GeometryShader:
HR (mpDeviceManager->mpDevice->CreateGeometryShader(code->GetBufferPointer(), code->GetBufferSize(), NULL, &mpGeometryShader) );
break;
case Target_HullShader:
HR (mpDeviceManager->mpDevice->CreateHullShader(code->GetBufferPointer(), code->GetBufferSize(), NULL, &mpHullShader) );
break;
case Target_DomainShader:
HR (mpDeviceManager->mpDevice->CreateDomainShader(code->GetBufferPointer(), code->GetBufferSize(), NULL ,&mpDomainShader) );
break;
}
SAFE_RELEASE(code);
SAFE_RELEASE(error);
return true;
}
