bool CD3D8ShaderMaterialRenderer::createPixelShader(const c8* pxsh)
{
if (!pxsh)
return true;
#if defined( _IRR_XBOX_PLATFORM_)
return false;
#else
// compile shader
LPD3DXBUFFER code = 0;
LPD3DXBUFFER errors = 0;
#ifdef _IRR_D3D_NO_SHADER_DEBUGGING
// compile shader without debug info
D3DXAssembleShader(pxsh, (UINT)strlen(pxsh), 0, 0, &code, &errors);
#else
// compile shader and emitt some debug informations to
// make it possible to debug the shader in visual studio
static int irr_dbg_file_nr = 0;
++irr_dbg_file_nr;
char tmp[32];
sprintf(tmp, "irr_d3d8_dbg_shader_%d.psh", irr_dbg_file_nr);
FILE* f = fopen(tmp, "wb");
fwrite(pxsh, strlen(pxsh), 1, f);
fflush(f);
fclose(f);
D3DXAssembleShaderFromFile(tmp, D3DXASM_DEBUG, 0, &code, &errors);
#endif
if (errors)
{
// print out compilation errors.
os::Printer::log("Pixel shader compilation failed:", ELL_ERROR);
os::Printer::log((c8*)errors->GetBufferPointer(), ELL_ERROR);
if (code)
code->Release();
errors->Release();
return false;
}
if (FAILED(pID3DDevice->CreatePixelShader((DWORD*)code->GetBufferPointer(), &PixelShader)))
{
os::Printer::log("Could not create pixel shader.", ELL_ERROR);
code->Release();
return false;
}
code->Release();
return true;
#endif
}
HRESULT U2Dx9ShaderMgr::CreateShader( LPD3DXBUFFER pbufShader,
U2Dx9ShaderDesc::ShaderType ShaderType,
U2Dx9ShaderDesc * pDesc )
{
HRESULT hr = S_OK;
FAIL_IF_NULL( pbufShader );
FAIL_IF_NULL( pDesc );
FAIL_IF_NULL( ms_pD3DDev );
pDesc->m_type = ShaderType;
if( ShaderType == U2Dx9ShaderDesc::SHADERTYPE_VERTEX )
{
hr = ms_pD3DDev->CreateVertexShader( (DWORD*) pbufShader->GetBufferPointer(),
(IDirect3DVertexShader9**) & pDesc->m_pShader );
SAFE_RELEASE( pbufShader );
BREAK_AND_RET_VAL_IF_FAILED(hr);
}
else
{
hr = ms_pD3DDev->CreatePixelShader( (DWORD*) pbufShader->GetBufferPointer(),
(IDirect3DPixelShader9**) & pDesc->m_pShader );
SAFE_RELEASE( pbufShader );
BREAK_AND_RET_VAL_IF_FAILED(hr);
}
return( hr );
}
CShaderPtr Graphics::LoadShader( const std::string& strFileName, const std::string& strFuncName, const std::string& profile )
{
CShaderPtr pShader = new CShader;
if (FAILED(pShader->Load(strFileName, strFuncName, profile)))
return NULL;
LPD3DXBUFFER pShaderBuff = pShader->GetCompileBuffer();
if (pShader->IsPS())
{
// создаЄм пиксельный шейдер
LPDIRECT3DPIXELSHADER9 pPixelShader;
m_pd3dDevice->CreatePixelShader(( DWORD* )pShaderBuff->GetBufferPointer(), &pPixelShader);
pShader->SetHardwareShader(m_pd3dDevice, pPixelShader);
}
else
{
// создаЄм вертексный шейдер
LPDIRECT3DVERTEXSHADER9 pVertexShader;
m_pd3dDevice->CreateVertexShader(( DWORD* )pShaderBuff->GetBufferPointer(), &pVertexShader);
pShader->SetHardwareShader(m_pd3dDevice, pVertexShader);
}
m_vecShaders.push_back(pShader);
return pShader;
}
bool Viewer::loadVertexShader()
{
g_pD3DDevice->CreateVertexDeclaration( decl, &m_pVertexDeclaration );
// Load bumpmapping vertex shader
LPD3DXBUFFER pCode;
LPD3DXBUFFER pError;
if(FAILED(D3DXAssembleShader(vertexShaderStr,sizeof(vertexShaderStr),NULL, NULL, 0,
&pCode, &pError)))
{
std::cout << "Error while assembling default vertex shader:\n " << (char *)pError->GetBufferPointer();
pError->Release();
return false;
}
if(FAILED(g_pD3DDevice->CreateVertexShader((DWORD*)pCode->GetBufferPointer(),
&m_pVS)))
{
pCode->Release();
return false;
}
pCode->Release();
return true;
}
GXHRESULT GShaderImpl::CompileShader(clBuffer* pIntermediateCode, GXLPCSTR szSourceCode, size_t nSourceLen, LPD3DXINCLUDE pInclude, GXDEFINITION* pMacros, CompiledType eCompiled)
{
LPD3DXBUFFER pShader = NULL;
LPD3DXBUFFER pErrorBuf = NULL;
GXHRESULT hval = GX_OK;
LPCSTR szFunctionName = NULL;
LPCSTR szProfile = NULL;
switch(eCompiled)
{
case CompiledComponentPixelShder:
szFunctionName = "compose_ps_main";
szProfile = "ps_3_0";
break;
case CompiledPixelShder:
szFunctionName = "ps_main";
szProfile = "ps_3_0";
break;
case CompiledComponentVertexShder:
szFunctionName = "compose_vs_main";
szProfile = "vs_3_0";
break;
case CompiledVertexShder:
szFunctionName = "vs_main";
szProfile = "vs_3_0";
break;
default:
return GX_FAIL;
}
if(FAILED(D3DXCompileShader((LPCSTR)szSourceCode, (UINT)nSourceLen,
(D3DXMACRO*)pMacros, pInclude, szFunctionName, szProfile, NULL, &pShader, &pErrorBuf, NULL)))
{
LPCSTR szErrorString = (LPCSTR)pErrorBuf->GetBufferPointer();
CLOG_ERROR("Shader compiled error:\n>%s\n", szErrorString);
hval = GX_FAIL;
}
#if 0
// Test D3DXDisassembleShader
LPD3DXBUFFER pAsmBuffer = NULL;
GXHRESULT hval2 = D3DXDisassembleShader((DWORD*)pShader->GetBufferPointer(),
FALSE, NULL, &pAsmBuffer);
if(GXSUCCEEDED(hval2) && pAsmBuffer)
{
LPCSTR szAsmString = (LPCSTR)pAsmBuffer->GetBufferPointer();
TRACE(szAsmString);
}
SAFE_RELEASE(pAsmBuffer);
#endif // #if
pIntermediateCode->Resize(0, FALSE);
if(pShader) {
pIntermediateCode->Append(pShader->GetBufferPointer(), pShader->GetBufferSize());
}
SAFE_RELEASE(pErrorBuf);
SAFE_RELEASE(pShader);
return hval;
}
void* LcD3D_BuildShader(PDEV pDev, char* sStrAssem, int iLen, char* sShader)
{
HRESULT hr;
DWORD dFlag = 0;
#if defined( _DEBUG ) || defined( DEBUG )
dFlag |= D3DXSHADER_DEBUG;
#endif
LPD3DXBUFFER pAsm = NULL;
LPD3DXBUFFER pErr = NULL;
void* pShd = NULL;
hr = D3DXAssembleShader(
sStrAssem
, iLen
, NULL
, NULL
, dFlag
, &pAsm
, &pErr);
if( FAILED(hr) )
{
if(pErr)
{
char* sErr = (char*)pErr->GetBufferPointer();
LcD3D_GetDxError(hr, sErr);
pErr->Release();
}
else
LcD3D_GetDxError(hr);
return NULL;
}
if( 0 == _strnicmp(sShader, "vs", 2))
{
PDVS pVS = NULL;
hr = pDev->CreateVertexShader( (DWORD*)pAsm->GetBufferPointer() , &pVS);
pShd = pVS;
}
else if( 0 == _strnicmp(sShader, "ps", 2))
{
PDPS pPS = NULL;
hr = pDev->CreatePixelShader( (DWORD*)pAsm->GetBufferPointer() , &pPS);
pShd = pPS;
}
pAsm->Release();
if( FAILED(hr) )
{
LcD3D_GetDxError(hr);
return NULL;
}
return pShd;
}
GPUContextDX9::VertexShaderHandle GPUContextDX9::createVertexShader( const char* inSource )
{
IDirect3DVertexShader9* shader;
HRESULT result;
LPD3DXBUFFER codeBuffer;
LPD3DXBUFFER errorBuffer;
result = D3DXAssembleShader( inSource, strlen(inSource), NULL, NULL, 0, &codeBuffer, &errorBuffer );
if( errorBuffer != NULL )
{
const char* errorMessage = (const char*)errorBuffer->GetBufferPointer();
GPUWARN << "Vertex shader failed to compile:\n" << errorMessage;
return NULL;
}
else if( FAILED(result) )
{
GPUWARN << "Vertex shader failed to compile.";
return NULL;
}
result = _device->CreateVertexShader( (DWORD*)codeBuffer->GetBufferPointer(), &shader );
codeBuffer->Release();
if( FAILED(result) )
{
DX9WARN << "Failed to allocate vertex shader.";
return NULL;
}
return (VertexShaderHandle)shader;
}
bool CDx9FragmentProgram::load(const char* buf,size_t fsize)
{
if (m_isLoad)
release();
LPD3DXBUFFER errors;
LPD3DXBUFFER pBuffer;
HRESULT hr;
hr = D3DXPreprocessShader(
buf,
static_cast<uint>(fsize),
((DX9_ShaderMacroMgr*)ShaderMacroMgr::GetInst())->GET_MACRO(m_ID),
DX9_ShaderInclude::GetInst(),
&pBuffer,
&errors);
if (FAILED(hr))
{
string message = "D3D9 Pixel Shader拼接不成功 Errors:\n";
message.append(static_cast<const char*>(errors->GetBufferPointer()));
errors->Release();
OutputDebugString(message.c_str());
GenErr(GraphicErr::GetErrTypeStr(ShaderInit_Err),message);
return false;
}
m_cCode = static_cast<const char*>(pBuffer->GetBufferPointer());
SafeRelease(pBuffer);
return true;
}
bool CD3D9ShaderMaterialRenderer::createVertexShader(const char* vtxsh)
{
if (!vtxsh)
return true;
// compile shader
LPD3DXBUFFER code = 0;
LPD3DXBUFFER errors = 0;
#ifdef _IRR_D3D_NO_SHADER_DEBUGGING
// compile shader without debug info
stubD3DXAssembleShader(vtxsh, strlen(vtxsh), 0, 0, 0, &code, &errors);
#else
// compile shader and emitt some debug informations to
// make it possible to debug the shader in visual studio
static int irr_dbg_file_nr = 0;
++irr_dbg_file_nr;
char tmp[32];
sprintf(tmp, "irr_d3d9_dbg_shader_%d.vsh", irr_dbg_file_nr);
FILE* f = fopen(tmp, "wb");
fwrite(vtxsh, strlen(vtxsh), 1, f);
fflush(f);
fclose(f);
stubD3DXAssembleShaderFromFile(tmp, 0, 0, D3DXSHADER_DEBUG, &code, &errors);
#endif
if (errors)
{
// print out compilation errors.
os::Printer::log("Vertex shader compilation failed:");
os::Printer::log((c8*)errors->GetBufferPointer());
if (code)
code->Release();
errors->Release();
return false;
}
if (!code || FAILED(pID3DDevice->CreateVertexShader((DWORD*)code->GetBufferPointer(), &VertexShader)))
{
os::Printer::log("Could not create vertex shader.");
if (code)
code->Release();
return false;
}
code->Release();
return true;
}
HRESULT plDXVertexShader::ICreate(plDXPipeline* pipe)
{
fHandle = nil; // in case something goes wrong.
fPipe = nil;
ISetError(nil);
#ifdef HS_DEBUGGING
DWORD flags = D3DXSHADER_DEBUG | D3DXSHADER_SKIPOPTIMIZATION;
#else // HS_DEBUGGING
DWORD flags = 0;
#endif // HS_DEBUGGING
// We could store the compiled buffer and skip the assembly step
// if we need to recreate the shader (e.g. on device lost).
// But whatever.
DWORD* shaderCodes = nil;
HRESULT hr = S_OK;
if( plShaderTable::LoadFromFile() || !fOwner->GetDecl()->GetCodes() )
{
if( fOwner->GetDecl()->GetFileName() )
{
LPD3DXBUFFER compiledShader = nil;
LPD3DXBUFFER compilationErrors = nil;
hr = D3DXAssembleShaderFromFile(
fOwner->GetDecl()->GetFileName(),
NULL, NULL, flags,
&compiledShader,
&compilationErrors);
if( FAILED(hr) )
{
return IOnError(hr, compilationErrors
? reinterpret_cast<const char *>(compilationErrors->GetBufferPointer())
: "File not found");
}
shaderCodes = (DWORD*)(compiledShader->GetBufferPointer());
}
}
if( !shaderCodes )
{
shaderCodes = (DWORD*)(fOwner->GetDecl()->GetCodes());
}
if( !shaderCodes )
return IOnError(-1, "No file and no compiled codes");
hr = pipe->GetD3DDevice()->CreateVertexShader(shaderCodes, &fHandle);
if( FAILED(hr) )
return IOnError(hr, "Error on CreateVertexShader");
hsAssert(fHandle, "No error, but no vertex shader handle. Grrrr.");
fPipe = pipe;
return S_OK;
}
//----------------------------------------------------------------------------
PdrPixelShader::PdrPixelShader (Renderer* renderer,
const PixelShader* pshader)
{
IDirect3DDevice9* device = renderer->mData->mDevice;
// 编译汇编着色器代码
const char* programText =
pshader->GetProgram(PixelShader::GetProfile())->c_str();
int shaderKey = pshader->GetShaderKey();
assertion(0!=shaderKey, "shaderKey must not be 0.\n");
std::map<int, Renderer::SharePdrData>::iterator it = renderer->mSharePdrPixelShaders.find(shaderKey);
if (it != renderer->mSharePdrPixelShaders.end())
{
mShader = (IDirect3DPixelShader9*)(it->second.DataPtr);
mShader->AddRef();
}
else
{
int programLength = (int)strlen(programText);
LPD3DXBUFFER compiledShader = 0;
LPD3DXBUFFER errors = 0;
HRESULT hr = D3DXAssembleShader(programText, programLength, 0, 0, 0,
&compiledShader, &errors);
#ifdef _DEBUG
if (errors)
{
DWORD size = errors->GetBufferSize();
PX2_UNUSED(size);
char* data = (char*)errors->GetBufferPointer();
PX2_UNUSED(data);
assertion(false, "Failed to assemble pixel shader.\n");
}
#endif
PX2_UNUSED(hr);
assertion(hr == D3D_OK && compiledShader,
"Failed to assemble pixel shader: %s\n", DXGetErrorString(hr));
// 创建像素着色器
hr = device->CreatePixelShader(
(DWORD*)(compiledShader->GetBufferPointer()), &mShader);
assertion(hr == D3D_OK, "Failed to create pixel shader\n");
// 释放需要释放的数据
if (compiledShader)
{
compiledShader->Release();
}
if (errors)
{
errors->Release();
}
renderer->mSharePdrPixelShaders[shaderKey].DataPtr = mShader;
((IDirect3DPixelShader9*)renderer->mSharePdrPixelShaders[shaderKey].DataPtr)
->AddRef();
}
}
ErrorCode Shader::compileasm(std::string vert, std::string pixel) {
LPD3DXBUFFER code;
LPD3DXBUFFER err;
HRESULT result;
/**
* Assemble Vertex Shader
*/
result = D3DXAssembleShader(vert.c_str(), vert.length(), NULL, NULL, 0, &code, &err);
if (FAILED(result))
{
ErrorHandleCritical(mamain->err, mamain->errCrit, ErrorCompileVertexShader, result, (char*) err->GetBufferPointer());
err->Release();
return ErrorCompileVertexShader;
}
result = mamain->d3ddev->CreateVertexShader((DWORD*) code->GetBufferPointer(), &VShader);
code->Release();
if (FAILED(result))
return ErrorHandleCritical(mamain->err, mamain->errCrit, ErrorCreateVertexShader, result);
/**
* Assemble Pixel Shader
*/
result = D3DXAssembleShader(pixel.c_str(), pixel.length(), NULL, NULL, 0, &code, &err);
if (FAILED(result))
{
ErrorHandleCritical(mamain->err, mamain->errCrit, ErrorCompilePixelShader, result, (char*) err->GetBufferPointer());
err->Release();
VShader->Release();
VShader = 0;
return ErrorCompilePixelShader;
}
result = mamain->d3ddev->CreatePixelShader((DWORD*)code->GetBufferPointer(), &PShader);
code->Release();
if (FAILED(result))
{
ErrorHandleCritical(mamain->err, mamain->errCrit, ErrorCreatePixelShader, result);
VShader->Release();
VShader = 0;
return ErrorCreatePixelShader;
}
return ErrorOk;
}
HRESULT CMyD3DApplication::OptimizeMeshData
(
LPD3DXMESH pMeshSysMem,
LPD3DXBUFFER pAdjacencyBuffer,
DWORD dwOptFlags,
SMeshData *pMeshData
)
{
HRESULT hr = S_OK;
LPD3DXBUFFER pbufTemp = NULL;
DWORD iMaterial;
// attribute sort - the un-optimized mesh option
// remember the adjacency for the vertex cache optimization
hr = pMeshSysMem->Optimize( dwOptFlags|D3DXMESH_SYSTEMMEM,
(DWORD*)pAdjacencyBuffer->GetBufferPointer(),
NULL, NULL, NULL, &pMeshData->m_pMeshSysMem);
if( FAILED(hr) )
goto End;
pMeshData->m_cStripDatas = m_dwNumMaterials;
pMeshData->m_rgStripData = new SStripData[pMeshData->m_cStripDatas];
if (pMeshData->m_rgStripData == NULL)
{
hr = E_OUTOFMEMORY;
goto End;
}
for (iMaterial = 0; iMaterial < m_dwNumMaterials; iMaterial++)
{
hr = D3DXConvertMeshSubsetToSingleStrip(pMeshData->m_pMeshSysMem, iMaterial,
D3DXMESH_IB_MANAGED, &pMeshData->m_rgStripData[iMaterial].m_pStrips,
&pMeshData->m_rgStripData[iMaterial].m_cStripIndices);
if (FAILED(hr))
goto End;
hr = D3DXConvertMeshSubsetToStrips(pMeshData->m_pMeshSysMem, iMaterial,
D3DXMESH_IB_MANAGED, &pMeshData->m_rgStripData[iMaterial].m_pStripsMany,
NULL, &pbufTemp, &pMeshData->m_rgStripData[iMaterial].m_cStrips);
if (FAILED(hr))
goto End;
pMeshData->m_rgStripData[iMaterial].m_rgcStripLengths = new DWORD[pMeshData->m_rgStripData[iMaterial].m_cStrips];
if (pMeshData->m_rgStripData[iMaterial].m_rgcStripLengths == NULL)
{
hr = E_OUTOFMEMORY;
goto End;
}
memcpy(pMeshData->m_rgStripData[iMaterial].m_rgcStripLengths, pbufTemp->GetBufferPointer(), sizeof(DWORD)*pMeshData->m_rgStripData[iMaterial].m_cStrips);
}
End:
SAFE_RELEASE(pbufTemp);
return hr;
}
int compileHLSLToD3D9(const char* from, const char* to, const std::map<std::string, int>& attributes) {
LPD3DXBUFFER errors;
LPD3DXBUFFER shader;
LPD3DXCONSTANTTABLE table;
HRESULT hr = D3DXCompileShaderFromFileA(from, nullptr, nullptr, "main", isVertexShader(from) ? "vs_2_0" : "ps_2_0", 0, &shader, &errors, &table);
if (FAILED(hr)) hr = D3DXCompileShaderFromFileA(from, nullptr, nullptr, "main", isVertexShader(from) ? "vs_3_0" : "ps_3_0", 0, &shader, &errors, &table);
if (errors != nullptr) std::cerr << (char*)errors->GetBufferPointer();
if (!FAILED(hr)) {
std::ofstream file(to, std::ios_base::binary);
file.put(attributes.size());
for (std::map<std::string, int>::const_iterator attribute = attributes.begin(); attribute != attributes.end(); ++attribute) {
file << attribute->first.c_str();
file.put(0);
file.put(attribute->second);
}
D3DXCONSTANTTABLE_DESC desc;
table->GetDesc(&desc);
file.put(desc.Constants);
for (UINT i = 0; i < desc.Constants; ++i) {
D3DXHANDLE handle = table->GetConstant(nullptr, i);
D3DXCONSTANT_DESC descriptions[10];
UINT count = 10;
table->GetConstantDesc(handle, descriptions, &count);
if (count > 1) std::cerr << "Error: Number of descriptors for one constant is greater than one." << std::endl;
for (UINT i2 = 0; i2 < count; ++i2) {
char regtype;
switch (descriptions[i2].RegisterSet) {
case D3DXRS_BOOL:
regtype = 'b';
break;
case D3DXRS_INT4:
regtype = 'i';
break;
case D3DXRS_FLOAT4:
regtype = 'f';
break;
case D3DXRS_SAMPLER:
regtype = 's';
break;
}
//std::cout << descriptions[i2].Name << " " << regtype << descriptions[i2].RegisterIndex << " " << descriptions[i2].RegisterCount << std::endl;
file << descriptions[i2].Name;
file.put(0);
file.put(regtype);
file.put(descriptions[i2].RegisterIndex);
file.put(descriptions[i2].RegisterCount);
}
}
DWORD* data = (DWORD*)shader->GetBufferPointer();
for (unsigned i = 0; i < shader->GetBufferSize() / 4; ++i) {
if ((data[i] & 0xffff) == 0xfffe) { //comment token
unsigned size = (data[i] >> 16) & 0xffff;
i += size;
}
else file.write((char*)&data[i], 4);
//-----------------------------------------------------------------------------
HRESULT CDXUTMesh::Create( LPDIRECT3DDEVICE9 pd3dDevice, LPCWSTR strFilename )
{
WCHAR strPath[MAX_PATH];
LPD3DXBUFFER pAdjacencyBuffer = NULL;
LPD3DXBUFFER pMtrlBuffer = NULL;
HRESULT hr;
// Cleanup previous mesh if any
Destroy();
// Find the path for the file, and convert it to ANSI (for the D3DX API)
DXUTFindDXSDKMediaFileCch( strPath, sizeof(strPath) / sizeof(WCHAR), strFilename );
// Load the mesh
if( FAILED( hr = D3DXLoadMeshFromX( strPath, D3DXMESH_MANAGED, pd3dDevice,
&pAdjacencyBuffer, &pMtrlBuffer, NULL,
&m_dwNumMaterials, &m_pMesh ) ) )
{
return hr;
}
// Optimize the mesh for performance
if( FAILED( hr = m_pMesh->OptimizeInplace(
D3DXMESHOPT_COMPACT | D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_VERTEXCACHE,
(DWORD*)pAdjacencyBuffer->GetBufferPointer(), NULL, NULL, NULL ) ) )
{
SAFE_RELEASE( pAdjacencyBuffer );
SAFE_RELEASE( pMtrlBuffer );
return hr;
}
// Set strPath to the path of the mesh file
WCHAR *pLastBSlash = wcsrchr( strPath, L'\\' );
if( pLastBSlash )
*(pLastBSlash + 1) = L'\0';
else
*strPath = L'\0';
D3DXMATERIAL* d3dxMtrls = (D3DXMATERIAL*)pMtrlBuffer->GetBufferPointer();
hr = CreateMaterials( strPath, pd3dDevice, d3dxMtrls, m_dwNumMaterials );
SAFE_RELEASE( pAdjacencyBuffer );
SAFE_RELEASE( pMtrlBuffer );
// Extract data from m_pMesh for easy access
D3DVERTEXELEMENT9 decl[MAX_FVF_DECL_SIZE];
m_dwNumVertices = m_pMesh->GetNumVertices();
m_dwNumFaces = m_pMesh->GetNumFaces();
m_dwBytesPerVertex = m_pMesh->GetNumBytesPerVertex();
m_pMesh->GetIndexBuffer( &m_pIB );
m_pMesh->GetVertexBuffer( &m_pVB );
m_pMesh->GetDeclaration( decl );
pd3dDevice->CreateVertexDeclaration( decl, &m_pDecl );
return hr;
}
void CompileShader()
{
DWORD dwShaderFlags = 0;
#if defined( DEBUG ) || defined( _DEBUG )
// Set the D3DXSHADER_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 |= D3DXSHADER_DEBUG;
#endif
#ifdef DEBUG_VS
dwShaderFlags |= D3DXSHADER_SKIPOPTIMIZATION|D3DXSHADER_DEBUG;
#endif
#ifdef DEBUG_PS
dwShaderFlags |= D3DXSHADER_SKIPOPTIMIZATION|D3DXSHADER_DEBUG;
#endif
WCHAR* shader_file = L"torus_shader.hlsl";
// Compile Vertex Shader
LPD3DXBUFFER pVertexShaderCode;
HRESULT hr = D3DXCompileShaderFromFile(shader_file, NULL, NULL, "VS", "vs_3_0", dwShaderFlags, &pVertexShaderCode, NULL, NULL);
if(FAILED(hr))
{
MessageBox(NULL, L"Error", L"Compile Vertex Shader Failed!", 0);
}
// Create Vertex Shader
hr = g_pd3dDevice->CreateVertexShader((DWORD*)pVertexShaderCode->GetBufferPointer(), &g_pVertexShader);
if(FAILED(hr))
{
MessageBox(NULL, L"Error", L"Create Vertex Shader Failed!", 0);
}
// Compile Pixel Shader
LPD3DXBUFFER pPixelShaderCode;
hr = D3DXCompileShaderFromFile(shader_file, NULL, NULL, "PS", "ps_3_0", dwShaderFlags, &pPixelShaderCode, NULL, NULL);
if(FAILED(hr))
{
MessageBox(NULL, L"Error", L"Compile Pixel Shader Failed!", 0);
}
// Create Pixel Shader
hr = g_pd3dDevice->CreatePixelShader((DWORD*)pPixelShaderCode->GetBufferPointer(), &g_pPixelShader);
if(FAILED(hr))
{
MessageBox(NULL, L"Error", L"Create Pixel Shader Failed!", 0);
}
// cleanup
pVertexShaderCode->Release();
pPixelShaderCode->Release();
}
bool CD3D9HLSLMaterialRenderer::createHLSLPixelShader(const char* pixelShaderProgram,
const char* shaderEntryPointName,
const char* shaderTargetName)
{
if (!pixelShaderProgram)
return true;
LPD3DXBUFFER buffer = 0;
LPD3DXBUFFER errors = 0;
HRESULT h = stubD3DXCompileShader(
pixelShaderProgram,
strlen(pixelShaderProgram),
0, // macros
0, // no includes
shaderEntryPointName,
shaderTargetName,
0, // no flags (D3DXSHADER_DEBUG)
&buffer,
&errors,
&PSConstantsTable);
if (FAILED(h))
{
os::Printer::log("HLSL pixel shader compilation failed:");
if (errors)
{
os::Printer::log((c8*)errors->GetBufferPointer());
errors->Release();
if (buffer)
buffer->Release();
}
return false;
}
if (errors)
errors->Release();
if (buffer)
{
if (FAILED(pID3DDevice->CreatePixelShader((DWORD*)buffer->GetBufferPointer(),
&PixelShader)))
{
os::Printer::log("Could not create hlsl pixel shader.");
buffer->Release();
return false;
}
buffer->Release();
return true;
}
return false;
}
void D3D9PixelShader::Reset(GraphicsDevice &graphics)
{
FreeMemory();
HRESULT hr;
_device = graphics.CastD3D9().GetDevice();
Assert(_device != NULL, "_device == NULL");
DWORD dwShaderFlags = 0;
#ifdef DEBUG_PS
dwShaderFlags |= D3DXSHADER_SKIPOPTIMIZATION | D3DXSHADER_DEBUG;
#endif
LPD3DXBUFFER pCode = NULL;
LPD3DXBUFFER pErrors = NULL;
PersistentAssert(Utility::FileExists(_shaderFile), String("Shader file not found: ") + _shaderFile);
// Assemble the vertex shader from the file
hr = D3DXCompileShaderFromFile( _shaderFile.CString(), NULL, NULL, "PShaderEntry",
"ps_3_0", dwShaderFlags, &pCode,
&pErrors, &_constantTable );
String ErrorString;
if(pErrors)
{
char *ErrorMessage = (char *)pErrors->GetBufferPointer();
DWORD ErrorLength = pErrors->GetBufferSize();
ofstream file("ShaderDebug.txt");
for(UINT i = 0; i < ErrorLength; i++)
{
file << ErrorMessage[i];
ErrorString += String(ErrorMessage[i]);
}
file.close();
}
PersistentAssert(!FAILED(hr), String("D3DXCompileShaderFromFile failed: ") + ErrorString);
hr = _device->CreatePixelShader( (DWORD*)pCode->GetBufferPointer(),
&_shader );
if(pErrors)
{
pErrors->Release();
}
if(pCode)
{
pCode->Release();
}
PersistentAssert(!FAILED(hr), "CreatePixelShader failed");
}
//-------------------------------------------------------------
// Name: InitDeviceObjects()
// Desc: ����̽��� ���������� �ʱ�ȭ
// �����ӹ��� ���˰� ����̽� ������ ���ѵڿ� ȣ��
// ���⼭ Ȯ���� �� DeleteDeviceObjects()���� ����
//-------------------------------------------------------------
HRESULT CMyD3DApplication::InitDeviceObjects()
{
HRESULT hr;
LPD3DXBUFFER pCode;
// ---------------------------------------------------------
// �� �ȼ����̴� ����
// ---------------------------------------------------------
if( FAILED( hr = D3DXAssembleShaderFromFile(
_T("PixelShader.psh"),
NULL, NULL, 0, &pCode, NULL ) ) ){
return hr;
}
SAFE_RELEASE( m_pPixelShader );
if (FAILED( hr = m_pd3dDevice->CreatePixelShader(
(DWORD*)pCode->GetBufferPointer(),
&m_pPixelShader ) ) )
return hr;
SAFE_RELEASE( pCode );
// ---------------------------------------------------------
// �������̴� ����
// ---------------------------------------------------------
// ���_�錾�I�u�W�F�N�g�̐���
D3DVERTEXELEMENT9 decl[] = {
{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT,
D3DDECLUSAGE_POSITION, 0 },
D3DDECL_END()
};
if( FAILED( hr = m_pd3dDevice->CreateVertexDeclaration( decl, &m_pVertexDeclaration ) ) ) {
return hr;
}
// ���̴� �б�
if( FAILED( hr = D3DXAssembleShaderFromFile(
_T("VertexShader.vsh"), NULL, NULL, 0, &pCode, NULL ))) {
return hr;
}
// �������̴� ����
hr = m_pd3dDevice->CreateVertexShader(
(DWORD*)pCode->GetBufferPointer(),
&m_pVertexShader );
pCode->Release();
if( FAILED(hr) ) return hr;
// ��Ʈ
m_pFont->InitDeviceObjects( m_pd3dDevice );
return S_OK;
}
void D3D9PixelShader::Reset(LPDIRECT3DDEVICE9 _Device)
{
FreeMemory();
HRESULT hr;
Device = _Device;
Assert(Device != NULL, "Device == NULL");
DWORD dwShaderFlags = 0;
#ifdef DEBUG_PS
dwShaderFlags |= D3DXSHADER_SKIPOPTIMIZATION | D3DXSHADER_DEBUG;
#endif
LPD3DXBUFFER pCode = NULL;
LPD3DXBUFFER pErrors = NULL;
// Assemble the vertex shader from the file
hr = D3DXCompileShaderFromFile( ShaderFile.CString(), NULL, NULL, "PShaderEntry",
"ps_3_0", dwShaderFlags, &pCode,
&pErrors, &ConstantTable );
String ErrorString;
if(pErrors)
{
char *ErrorMessage = (char *)pErrors->GetBufferPointer();
DWORD ErrorLength = pErrors->GetBufferSize();
ofstream file("ShaderDebug.txt");
for(UINT i = 0; i < ErrorLength; i++)
{
file << ErrorMessage[i];
ErrorString += String(ErrorMessage[i]);
}
file.close();
}
PersistentAssert(!FAILED(hr), String("D3DXCompileShaderFromFile failed: ") + ErrorString);
// Create the vertex shader
hr = Device->CreatePixelShader( (DWORD*)pCode->GetBufferPointer(),
&Shader );
if(pErrors)
{
pErrors->Release();
}
if(pCode)
{
pCode->Release();
}
PersistentAssert(!FAILED(hr), "CreatePixelShader failed");
}
Plane* Plane::init(LPDIRECT3DDEVICE9 device) {
CUSTOMVERTEX vtx[] = {
CUSTOMVERTEX(D3DXVECTOR3(-1, 0, 1), D3DXVECTOR3(0, 1, 0), 0x00ffffff, D3DXVECTOR2(0, 0)),
CUSTOMVERTEX(D3DXVECTOR3( 1, 0, 1), D3DXVECTOR3(0, 1, 0), 0x00ffffff, D3DXVECTOR2(1, 0)),
CUSTOMVERTEX(D3DXVECTOR3(-1, 0, -1), D3DXVECTOR3(0, 1, 0), 0xffffffff, D3DXVECTOR2(0, 1)),
CUSTOMVERTEX(D3DXVECTOR3( 1, 0, -1), D3DXVECTOR3(0, 1, 0), 0xffffffff, D3DXVECTOR2(1, 1)),
};
setVertices(vtx, 4);
LPD3DXBUFFER code;
LPD3DXBUFFER error;
D3DXCompileShaderFromFile("shader.hlsl", NULL, NULL,
"vertexShaderTexture", "vs_2_0", 0,
&code, &error, &_vs_constant_table);
if(error) {
OutputDebugString((LPCSTR)error->GetBufferPointer());
vbuf->Release();
error->Release();
return 0;
}
device->CreateVertexShader((DWORD*)code->GetBufferPointer(), &_vs);
code->Release();
D3DXCompileShaderFromFile("shader.hlsl", NULL, NULL,
"pixelShaderTexture", "ps_2_0", 0,
&code, &error, &_ps_constant_table);
if(error) {
OutputDebugString((LPCSTR)error->GetBufferPointer());
vbuf->Release();
_vs_constant_table->Release();
_vs->Release();
error->Release();
return 0;
}
device->CreatePixelShader((DWORD*)code->GetBufferPointer(), &_ps);
code->Release();
D3DXCreateTextureFromFile(device, "textures/ground.png", &texture);
angle = (D3DX_PI / 180.0f * 2);
//D3DXMATRIX rot;
//D3DXMatrixRotationAxis(&rot, &D3DXVECTOR3(1, 0, 0), (D3DX_PI / 180.0f * -90));
//world *= rot;
return this;
}
void GUIBasicEffect::Initialize()
{
LPD3DXBUFFER pErrors = NULL;
HRESULT hr = D3DXCreateEffectFromFile(MyApp::GetSingleton()->GetD3DDevice(), L"Content\\Effects\\GUI\\BasicEffect.fx",
NULL, NULL, NULL, NULL, &pEffect, &pErrors);
#if defined( _DEBUG )
if ( FAILED( hr ) && pErrors != NULL && pErrors->GetBufferPointer() != NULL )
MyApp::GetSingleton()->Error(strcat("Effect Compilation Error: ", (char *)pErrors->GetBufferPointer()));
#endif
if( pErrors != NULL )
pErrors->Release();
return;
}
int uPixelShader::LoadPS(char *filename, char *pixelprog)
{
int er=0;
// Create the pixel shader.
LPD3DXBUFFER pCode; // assembled shader code
LPD3DXBUFFER pError;
if(hPixelShader!=NULL) pd->DeletePixelShader( hPixelShader);
if(filename==NULL)
D3DXAssembleShader( pixelprog, strlen(pixelprog), 0, NULL, &pCode, &pError ); // assemble shader code
else
{
if( D3DXAssembleShaderFromFile( filename, 0, NULL, &pCode, &pError) != D3D_OK)er=1; // assemble shader code
}
if(pError!=NULL)
{
char text[150];
char* error_text = new char[pError->GetBufferSize()+1];
memcpy(error_text,pError->GetBufferPointer(),pError->GetBufferSize());
error_text[pError->GetBufferSize()]=NULL;
pError->Release();
if(filename!=NULL)
sprintf( text, "ERROR in pixel shader: %s", filename);
else
sprintf( text, "ERROR in pixel shader: %s");
MessageBox(hWnd, error_text, text, MB_OK);
delete [] error_text;
hPixelShader = NULL;
return 0;
}
else if(er==1)
{
MessageBox(hWnd, filename, english ? "Couldn't find file for pixel shader":"Nenajdeny subor pre pixel shader", MB_OK);
return 0;
}
if( pd->CreatePixelShader( (DWORD*)pCode->GetBufferPointer(), &hPixelShader )
== D3D_OK )
{
pCode->Release();
return 1;
}
pCode->Release();
MessageBox(hWnd, filename, english ? "ERROR in pixel shader":"Chyba pri nacitavani pixel shader", MB_OK);
return 0;
}
// 쉐이더 로딩
LPD3DXEFFECT LoadShader(const char * filename)
{
LPD3DXEFFECT ret = NULL;
LPD3DXBUFFER pError = NULL;
DWORD dwShaderFlags = 0;
#if _DEBUG
dwShaderFlags |= D3DXSHADER_DEBUG;
#endif
D3DXCreateEffectFromFile(gpD3DDevice, filename,
NULL, NULL, dwShaderFlags, NULL, &ret, &pError);
// 쉐이더 로딩에 실패한 경우 output창에 쉐이더
// 컴파일 에러를 출력한다.
if (!ret && pError)
{
int size = pError->GetBufferSize();
void *ack = pError->GetBufferPointer();
if (ack)
{
char* str = new char[size];
sprintf(str, (const char*)ack, size);
OutputDebugString(str);
delete[] str;
}
}
return ret;
}
Mesh::Mesh(char *catalog, char *filename)
{
char filepath[222];
LPD3DXBUFFER pMtrlBuffer = NULL;
pAdjBuffer = 0;
strcpy(filepath, catalog);
strcat(filepath, filename);
if (FAILED(D3DXLoadMeshFromX(filepath, D3DXMESH_MANAGED, gdevice,
&pAdjBuffer, &pMtrlBuffer, NULL, &Mtnum, &m_pmesh))) {
MessageBox(0, "load mesh fail ", 0, 0);
return;
}
//二，读取材质和纹理数据
D3DXMATERIAL*pMtrls = (D3DXMATERIAL*)pMtrlBuffer->GetBufferPointer(); //创建一个D3DXMATERIAL结构体用于读取材质和纹理信息
pMaterial = new D3DMATERIAL9[Mtnum];
pTexture = new LPDIRECT3DTEXTURE9[Mtnum];
for (DWORD i = 0; i<Mtnum; i++) {
//获取材质，并设置环境光的颜色值
pMaterial[i] = pMtrls[i].MatD3D;
pMaterial[i].Ambient = pMaterial[i].Diffuse;
strcpy(filepath, catalog);
strcat(filepath, pMtrls[i].pTextureFilename);
if(FAILED(D3DXCreateTextureFromFileA(gdevice, filepath, &pTexture[i])))
MessageBox(0, "load mesh texture fail ", 0, 0);
}
LoadData(); // load vertex and face
RELEASE(pMtrlBuffer);
}
//==============================================================
// エフェクトのロード
ID3DXEffect* CGraphics::LoadEffect(string file) {
ID3DXEffect* effect=NULL;
LPD3DXBUFFER error;
// エフェクトファイルの存在を確認する
WIN32_FIND_DATA fd;
if (FindFirstFile(file.c_str(), &fd)==INVALID_HANDLE_VALUE) {
MessageBox(NULL, file.c_str(), "Shader File Not Found", MB_OK);
PostQuitMessage(1);
return NULL;
}
// エフェクトファイルのロード
D3DXCreateEffectFromFile(
m_pDevice, file.c_str(),
NULL, NULL, 0, NULL, &effect, &error);
// コンパイルエラーの場合はエラーを表示して終了
if (!effect) {
MessageBox(
NULL,
error?(LPCTSTR)error->GetBufferPointer():NULL,
"Shader Compile Error", MB_OK);
PostQuitMessage(1);
return NULL;
}
return effect;
}
bool ObjectInit(HWND hwnd)
{
srand(unsigned(time(nullptr)));
PlaySound(_T("コミネリサ - Resuscitated Hope.wav"), nullptr, SND_ASYNC | SND_FILENAME | SND_LOOP);
D3DXCreateFont(gPD3DDevice, 30, 0, 0, 0, 0, 0, 0, 0, 0, _T("微软雅黑"), &gPTextAdapterFont);
D3DXCreateFont(gPD3DDevice, 20, 0, 0, 0, 0, 0, 0, 0, 0, _T("华文中宋"), &gPTextHelperFont);
D3DXCreateFont(gPD3DDevice, 30, 0, 0, 0, 0, 0, 0, 0, 0, _T("黑体"), &gPTextInfoFont);
D3DXCreateFont(gPD3DDevice, 36, 0, 0, 0, 0, 0, 0, 0, 0, _T("楷体"), &gPTextFPSFont);
//////////////////////////////////////////////////////////////////////////
// Load mesh and materials here
//////////////////////////////////////////////////////////////////////////
LPD3DXBUFFER pAdjBuffer;
LPD3DXBUFFER pMtrlBuffer;
D3DXLoadMeshFromX(_T("loli.X"), D3DXMESH_MANAGED, gPD3DDevice, &pAdjBuffer, &pMtrlBuffer, nullptr, &gDwNumMtrl, &gPCharacter);
D3DXMATERIAL* pMaterial = (D3DXMATERIAL*)(pMtrlBuffer->GetBufferPointer());
gPMaterial = new D3DMATERIAL9[gDwNumMtrl];
gPTexture = new LPDIRECT3DTEXTURE9[gDwNumMtrl];
for (DWORD i = 0; i < gDwNumMtrl; i++)
{
gPMaterial[i] = pMaterial->MatD3D;
gPMaterial[i].Ambient = gPMaterial[i].Diffuse;
gPTexture[i] = nullptr;
D3DXCreateTextureFromFileA(gPD3DDevice, pMaterial[i].pTextureFilename, &gPTexture[i]);
}
pAdjBuffer->Release();
SAFE_RELEASE(pMtrlBuffer);
// 设置渲染状态
gPD3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); //开启背面消隐
gPD3DDevice->SetRenderState(D3DRS_AMBIENT, D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f)); //设置环境光
return true;
}
//-------------------------------------------------------------
// Name: InitDeviceObjects()
// Desc: 디바이스가 생성된후의 초기화
// 프레임버퍼 포맷과 디바이스 종류가 변한뒤에 호출
// 여기서 확보한 메모리는 DeleteDeviceObjects()에서 해제
//-------------------------------------------------------------
HRESULT CMyD3DApplication::InitDeviceObjects()
{
HRESULT hr;
// 모델읽기
if(FAILED(hr=m_pMesh ->Create( m_pd3dDevice, _T("ufo.x"))))
return DXTRACE_ERR( "LoadCar", hr );
// 지형읽기
if(FAILED(hr=m_pMeshBg->Create( m_pd3dDevice, _T("map.x"))))
return DXTRACE_ERR( "Load BG", hr );
// 셰이더 읽기
LPD3DXBUFFER pErr;
if( FAILED( hr = D3DXCreateEffectFromFile(
m_pd3dDevice, "hlsl.fx", NULL, NULL,
D3DXSHADER_DEBUG , NULL, &m_pEffect, &pErr ))){
MessageBox( NULL, (LPCTSTR)pErr->GetBufferPointer()
, "ERROR", MB_OK);
return DXTRACE_ERR( "CreateEffectFromFile", hr );
}
m_hTechnique = m_pEffect->GetTechniqueByName( "TShader" );
m_hmWV = m_pEffect->GetParameterByName( NULL, "mWV" );
m_hmVP = m_pEffect->GetParameterByName( NULL, "mVP" );
m_hmLastWV = m_pEffect->GetParameterByName( NULL, "mLastWV" );
m_hvLightDir = m_pEffect->GetParameterByName( NULL, "vLightDir" );
m_hvEyePos = m_pEffect->GetParameterByName( NULL, "vEyePos" );
m_hvCol = m_pEffect->GetParameterByName( NULL, "vCol" );
// 폰트
m_pFont->InitDeviceObjects( m_pd3dDevice );
return S_OK;
}
bool CD3DEffect::CreateEffect()
{
HRESULT hr;
LPD3DXBUFFER pError = NULL;
std::vector<D3DXMACRO> definemacros;
for( DefinesMap::const_iterator it = m_defines.begin(); it != m_defines.end(); ++it )
{
D3DXMACRO m;
m.Name = it->first.c_str();
if (it->second.IsEmpty())
m.Definition = NULL;
else
m.Definition = it->second.c_str();
definemacros.push_back( m );
}
definemacros.push_back(D3DXMACRO());
definemacros.back().Name = 0;
definemacros.back().Definition = 0;
hr = D3DXCreateEffect(g_Windowing.Get3DDevice(), m_effectString, m_effectString.length(), &definemacros[0], NULL, 0, NULL, &m_effect, &pError );
if(hr == S_OK)
return true;
else if(pError)
{
CStdString error;
error.assign((const char*)pError->GetBufferPointer(), pError->GetBufferSize());
CLog::Log(LOGERROR, "CD3DEffect::CreateEffect(): %s", error.c_str());
}
else
CLog::Log(LOGERROR, "CD3DEffect::CreateEffect(): call to D3DXCreateEffect() failed with %" PRId32, hr);
return false;
}
FxGrass::FxGrass()
{
if( _grassEffect == NULL )
{
LPD3DXBUFFER compilationErrors = NULL;
if( S_OK != D3DXCreateEffectFromFile(
iDirect3DDevice,
_T( "./res/effects/grass.fx" ),
NULL,
NULL,
D3DXSHADER_DEBUG,
NULL,
&_grassEffect,
&compilationErrors
) )
{
const char* text = (const char*)( compilationErrors->GetBufferPointer() );
MessageBox( 0, text, "Effect compilation error", MB_OK );
compilationErrors->Release();
}
_grassLostable = new StaticLostable( onLostDevice, onResetDevice );
}
_arguments.numLayers = 10;
_arguments.height = 100.0f;
}
