TRESULT D3DWrapper::CompilePixelShader( OCShader*& shader )
{
if( NULL == shader )
return RE_FAILED;
if( NULL == shader->GetPixelShaderCode() )
return RE_FAILED;
UINT codeSize = static_cast<UINT>( strlen(shader->GetPixelShaderCode()) );
if( 0 == codeSize )
return RE_FAILED;
LPD3DXBUFFER pCode;
LPD3DXBUFFER pErrorMsgs;
HRESULT hr = D3DXCompileShader( shader->GetPixelShaderCode(), codeSize, NULL, NULL, "main", "ps_3_0", 0, &pCode, &pErrorMsgs, shader->GetConstantTablePtr() );
if(FAILED(hr))return RE_FAILED;
hr = m_pD3dDevice->CreatePixelShader( (DWORD*)pCode->GetBufferPointer(), shader->GetPixelShaderPtr() );
if(FAILED(hr))return RE_FAILED;
if(pCode)
pCode->Release();
if(pErrorMsgs)
pErrorMsgs->Release();
return RE_SUCCEED;
}
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
}
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;
}
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;
}
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;
}
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;
}
bool CD3DEffectMgr::Load(const char* szFilename, bool bSoftware)
{
// make sure we're term'd first
Term();
Init();
if(szFilename == NULL)
{
return false;
}
LPD3DXBUFFER pErrorBuffer = NULL;
DWORD dwShaderFlags = 0;
if(bSoftware)
{
dwShaderFlags |= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT;
dwShaderFlags |= D3DXSHADER_NO_PRESHADER;
dwShaderFlags |= D3DXSHADER_DEBUG;
}
LTEffectInclude includeSolver;
//includeSolver.SetParentFilename(szFilename);
HRESULT hr = D3DXCreateEffectFromFile(PD3DDEVICE,
szFilename,
NULL,
&includeSolver,
dwShaderFlags,
NULL,
&m_pEffect,
&pErrorBuffer);
if(FAILED(hr))
{
if(pErrorBuffer)
{
const char* pszError = (pErrorBuffer != NULL) ? (const char*)pErrorBuffer->GetBufferPointer() : "<Unknown Error>";
// Save the error to our last error buffer.
int nLen = strlen(pszError);
strncpy(m_pszLastError, pszError, (nLen < 1023) ? nLen : 1023);
pErrorBuffer->Release();
}
m_pEffect = NULL;
return false;
}
if(pErrorBuffer)
{
pErrorBuffer->Release();
}
return true;
}
//----------------------------------------------------------------------------
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();
}
}
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();
}
TRESULT D3DWrapper::CompileVertexShader( OCShader*& shader )
{
if( NULL == shader )
return RE_FAILED;
if( NULL == shader->GetVertexShaderCode() )
return RE_FAILED;
UINT codeSize = static_cast<UINT>( strlen(shader->GetVertexShaderCode()) );
if( 0 == codeSize )
return RE_FAILED;
LPD3DXCONSTANTTABLE pConstantTable;
LPD3DXBUFFER pCode;
LPD3DXBUFFER pErrorMsgs;
HRESULT hr = D3DXCompileShader( shader->GetVertexShaderCode(), codeSize, NULL, NULL, "main", "vs_3_0", 0, &pCode, &pErrorMsgs, &pConstantTable );
if(FAILED(hr))return RE_FAILED;
hr = m_pD3dDevice->CreateVertexShader( (DWORD*)pCode->GetBufferPointer(), shader->GetVertexShaderPtr() );
if(FAILED(hr))return RE_FAILED;
//vector<string> constantNameList;
//if( pConstantTable )
//{
// D3DXCONSTANTTABLE_DESC constant_desc;
// pConstantTable->GetDesc( &constant_desc );
// // Get Constant list
// D3DXCONSTANT_DESC Desc;
// UINT Count;
// for( UINT i = 0; i<constant_desc.Constants; i++ )
// {
// D3DXHANDLE handle = pConstantTable->GetConstant(NULL, i);
// pConstantTable->GetConstantDesc( handle, &Desc, &Count );
// constantNameList.push_back( Desc.Name );
// }
//}
if(pCode)
pCode->Release();
if(pErrorMsgs)
pErrorMsgs->Release();
if(pConstantTable)
pConstantTable->Release();
return RE_SUCCEED;
}
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");
}
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;
}
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;
}
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;
}
FxWater::FxWater()
{
if( _effect == NULL )
{
LPD3DXBUFFER compilationErrors = NULL;
if( S_OK != D3DXCreateEffectFromFile(
iDirect3DDevice,
"./res/effects/water.fx",
NULL,
NULL,
D3DXSHADER_DEBUG,
NULL,
&_effect,
&compilationErrors
) )
{
const char* text = (const char*)( compilationErrors->GetBufferPointer() );
MessageBox( 0, text, "Effect compilation error", MB_OK );
compilationErrors->Release();
}
_effectLostable = new StaticLostable( onLostDevice, onResetDevice );
}
_arguments.reflectivity = 0.5f;
_arguments.uvOffset1.x = 0, _arguments.uvOffset1.y = 0;
_arguments.uvOffset2.x = 0, _arguments.uvOffset2.y = 0;
_arguments.uvVelocity1.x = 0.7f, _arguments.uvVelocity1.y = -0.7f;
_arguments.uvVelocity2.x = -0.7f, _arguments.uvVelocity2.y = 0.7f;
_animatedEffects.push_back( this );
}
bool Shader::CreateFromFile( const tstring& filePath )
{
if( m_pEffect )
{
m_pEffect.Release();
Graphics::GetInstance()->DelResource( this );
}
LPD3DXBUFFER pBuffer = NULL;
HRESULT hr = D3DXCreateEffectFromFile(
Graphics::GetInstance()->GetDirect3DDevice(),
filePath.c_str(),
NULL,NULL,0,NULL,&m_pEffect,&pBuffer );
if( pBuffer )
{
tstring error = to_tstring( (char*)pBuffer->GetBufferPointer() );
OutputDebugStringFormat( _T("effect compiled\n%s"),error.c_str() );
pBuffer->Release();
}
if( hr!=D3D_OK )
{
return false;
}
Graphics::GetInstance()->AddResource( this );
return true;
}
bool Shader::CreateFromMemory( LPCVOID buffer,size_t size )
{
Graphics* graphics = Graphics::GetInstance();
if( m_pEffect )
{
m_pEffect.Release();
graphics->DelResource( this );
}
LPD3DXBUFFER pBuffer = NULL;
HRESULT hr = D3DXCreateEffect(
graphics->GetDirect3DDevice(),
buffer,
size,
NULL,NULL,0,NULL,&m_pEffect,&pBuffer );
if( pBuffer )
{
tstring error = to_tstring( (char*)pBuffer->GetBufferPointer() );
OutputDebugStringFormat( _T("effect compiled\n%s"),error.c_str() );
pBuffer->Release();
}
if( hr!=D3D_OK )
{
return false;
}
graphics->AddResource( this );
return true;
}
//-------------------------------------------------------------
//! @brief : コンストラクタ
//-------------------------------------------------------------
ScreenEffect::ScreenEffect()
: m_FadeValue (0.f)
, m_hFadeValue (NULL)
, m_hFadeColor (NULL)
{
ZeroMemory(m_FadeColor.m, sizeof(float) * 3);
m_DrawStep = 100000;
LPD3DXBUFFER wError = NULL;
HRESULT hr = D3DXCreateEffectFromFile(
GraphicsManager::GetInstance()->GetD3DDevice(),
L"Source/ScreenEffect.fx",
NULL,
NULL,
D3DXSHADER_DEBUG,
NULL,
&m_Effect,
&wError);
if (FAILED(hr))
{
::MessageBoxA( NULL, (LPCSTR)wError->GetBufferPointer(), "Error", MB_OK ); // 失敗の原因を表示
wError->Release();
}
m_Effect->SetTechnique(m_Effect->GetTechniqueByName("Fade"));
m_hFadeValue = m_Effect->GetParameterByName(m_hFadeValue, "g_FadeValue");
m_hFadeColor = m_Effect->GetParameterByName(m_hFadeColor, "g_FadeColor");
}
Gui::Gui(IDirect3DDevice9* d3ddev)
{
HRESULT ret;
int vertSize = sizeof(GuiVertex);
mNumVerts = 0;
mNumCommands = 0;
mCurrentOffset = 0;
mMaxVerts = 1024;
// load FX
LPD3DXBUFFER errors = NULL;
HRESULT result = D3DXCreateEffectFromFileW( d3ddev, L"fx/gui.fx", NULL, NULL,
0, NULL, &mFX, &errors );
if( FAILED( result ) )
{
char* szErrors = (char*)errors->GetBufferPointer();
errors->Release();
}
// create vertex buffer
ret = d3ddev->CreateVertexBuffer(mMaxVerts * vertSize, D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY, 0,
D3DPOOL_DEFAULT, &mVertexBuffer, NULL);
D3DVERTEXELEMENT9 decl[] = {
{0, 0, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITIONT, 0},
{0, 16, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
{0, 20, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
D3DDECL_END() };
ret = d3ddev->CreateVertexDeclaration(decl, &mVertexDecl);
}
void D3D9Mesh::QueryHits(const Vec3f &Pos, const Vec3f &Dir, Vector<float> &Hits, DWORD &FirstHitFaceIndex, float &u, float &v) const
{
D3DXVECTOR3 D3DPos = Pos;
D3DXVECTOR3 D3DDir = Dir;
BOOL Hit;
DWORD HitCount;
FLOAT Dist;
LPD3DXBUFFER AllHits = NULL;
D3DXIntersect(_Mesh, &D3DPos, &D3DDir, &Hit, &FirstHitFaceIndex, &u, &v, &Dist, &AllHits, &HitCount);
Hits.Allocate(HitCount);
if(HitCount)
{
LPD3DXINTERSECTINFO HitInfo = (LPD3DXINTERSECTINFO)AllHits->GetBufferPointer();
for(UINT HitIndex = 0; HitIndex < HitCount; HitIndex++)
{
Hits[HitIndex] = HitInfo[HitIndex].Dist;
}
Hits.Sort();
}
if(AllHits != NULL)
{
AllHits->Release();
}
}
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;
}
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 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;
}
HRESULT CShimmer::Init(void)
{
Window* window = Window::Instance();
LPDIRECT3DDEVICE9 Device = window->Device();
//シェーダーを作成
LPD3DXBUFFER pError = NULL;
if (FAILED(D3DXCreateEffectFromFile(Device,"data/shaders/ShimmerShader.fx",NULL,NULL,D3DXSHADER_SKIPVALIDATION,NULL,&Effect,&pError)))
{
MessageBox(nullptr,"陽炎シェーダーの生成に失敗しました","ERROR",MB_OK | MB_ICONERROR);
OutputDebugStringA((LPCSTR)pError->GetBufferPointer());
pError->Release();
pError = nullptr;
return E_FAIL;
}
//陽炎マップ用テクスチャを作成、サーフェイスにセット
D3DXCreateTexture(Device,(UINT)window->WindowSize().x,(UINT)window->WindowSize().y,1,D3DUSAGE_RENDERTARGET,D3DFMT_A8R8G8B8,D3DPOOL_DEFAULT,&Texture);
Texture->GetSurfaceLevel(0,&Surface);
for (int cnt = 0;cnt < 2;cnt++)
{
D3DXCreateTexture(Device,(UINT)window->WindowSize().x,(UINT)window->WindowSize().y,1,D3DUSAGE_RENDERTARGET,D3DFMT_A8R8G8B8,D3DPOOL_DEFAULT,&BlurTex[cnt]);
BlurTex[cnt]->GetSurfaceLevel(0,&Blur[cnt]);
}
//結果用テクスチャを作成、サーフェイスにセット
D3DXCreateTexture(Device,(UINT)window->WindowSize().x,(UINT)window->WindowSize().y,1,D3DUSAGE_RENDERTARGET,D3DFMT_A8R8G8B8,D3DPOOL_DEFAULT,&Result);
Result->GetSurfaceLevel(0,&ResultSurface);
D3DXMATRIX Projection = D3DXMATRIX(
2.0f,0,0,0,
0,-2.0f,0,0,
0,0,1.0f,0,
0,0,0,1.0f);
Effect->SetMatrix("Projection",&Projection);
D3DXVECTOR2 texel = D3DXVECTOR2(1.0f / window->WindowSize().x,1.0f / window->WindowSize().y);
float U[5];
float V[5];
for (int cnt = 0;cnt < 5;cnt++)
{
U[cnt] = texel.x * (cnt + 1);
V[cnt] = texel.y * (cnt + 1);
}
Effect->SetFloatArray("TexelU",U,5);
Effect->SetFloatArray("TexelV",V,5);
for (int cnt = 0;cnt < PARAM_MAX;cnt++)
{
Param[cnt] = Effect->GetParameterByName(NULL,ParamName[cnt]);
}
Effect->SetTechnique("Shimmer");
return S_OK;
}
INT TShd::CreatePixelShader(PDEV pDev)
{
HRESULT hr= -1;
DWORD dFlag = 0;
#if defined( _DEBUG ) || defined( DEBUG )
dFlag |= D3DXSHADER_DEBUG;
#endif
LPD3DXBUFFER pAsm = NULL;
LPD3DXBUFFER pErr = NULL;
if(0==strlen(sPxl))
return -1;
hr = D3DXAssembleShaderFromFile(sPxl, 0, 0, dFlag, &pAsm, &pErr );
if(FAILED(hr))
{
if(pErr)
{
char* sErr = (char*)pErr->GetBufferPointer();
LcD3D_GetDxError(hr, sErr);
pErr->Release();
}
else
LcD3D_GetDxError(hr);
return hr;
}
hr = pDev->CreatePixelShader( (DWORD*)pAsm->GetBufferPointer(), &pPxl);
pAsm->Release();
if( FAILED(hr) )
{
LcD3D_GetDxError(hr);
return hr;
}
return hr;
}
//----------------------------------------------------------------------------
PdrVertexShader::PdrVertexShader (Renderer* renderer,
const VertexShader* vshader)
{
IDirect3DDevice9* device = renderer->mData->mDevice;
// Compile the shader to assembly code.
const char* programText =
vshader->GetProgram(VertexShader::GetProfile())->c_str();
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();
WM5_UNUSED(size);
char* data = (char*)errors->GetBufferPointer();
WM5_UNUSED(data);
assertion(false, "Failed to assemble vertex shader.\n");
}
#endif
WM5_UNUSED(hr);
assertion(hr == D3D_OK && compiledShader,
"Failed to assemble vertex shader: %s\n", DXGetErrorString(hr));
// Create the vertex shader.
hr = device->CreateVertexShader(
(DWORD*)(compiledShader->GetBufferPointer()), &mShader);
assertion(hr == D3D_OK, "Failed to create vertex shader\n");
// Release buffers, if necessary.
if (compiledShader)
{
compiledShader->Release();
}
if (errors)
{
errors->Release();
}
}
PixelShader::PixelShader(LPDIRECT3DDEVICE9 pDevice, LPCWSTR fileName)
{
m_pDevice = pDevice;
m_pDevice->CreateVertexDeclaration(Declaration, &m_pVD);
LPD3DXBUFFER code = NULL;
D3DXAssembleShaderFromFile(fileName, 0, 0, 0, &code, 0);
m_pDevice->CreatePixelShader((DWORD*) code->GetBufferPointer(), &m_pPShader);
code->Release();
}
//-----------------------------------【Object_Init( )函数】--------------------------------------
// 描述：渲染资源初始化函数，在此函数中进行要被渲染的物体的资源的初始化
//--------------------------------------------------------------------------------------------------
HRESULT Objects_Init()
{
//创建字体
D3DXCreateFont(g_pd3dDevice, 36, 0, 0, 1000, false, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, 0, _T("Calibri"), &g_pTextFPS);
D3DXCreateFont(g_pd3dDevice, 20, 0, 1000, 0, false, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, 0, L"华文中宋", &g_pTextAdaperName);
D3DXCreateFont(g_pd3dDevice, 23, 0, 1000, 0, false, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, 0, L"微软雅黑", &g_pTextHelper);
D3DXCreateFont(g_pd3dDevice, 26, 0, 1000, 0, false, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, 0, L"黑体", &g_pTextInfor);
// 从X文件中加载网格数据
LPD3DXBUFFER pAdjBuffer = NULL;
LPD3DXBUFFER pMtrlBuffer = NULL;
D3DXLoadMeshFromX(L"Optimus.x", D3DXMESH_MANAGED, g_pd3dDevice,
&pAdjBuffer, &pMtrlBuffer, NULL, &g_dwNumMtrls, &g_pMesh);
// 读取材质和纹理数据
D3DXMATERIAL *pMtrls = (D3DXMATERIAL*)pMtrlBuffer->GetBufferPointer();
g_pMaterials = new D3DMATERIAL9[g_dwNumMtrls];
g_pTextures = new LPDIRECT3DTEXTURE9[g_dwNumMtrls];
for (DWORD i=0; i<g_dwNumMtrls; i++)
{
g_pMaterials[i] = pMtrls[i].MatD3D;
g_pMaterials[i].Ambient = g_pMaterials[i].Diffuse;
g_pTextures[i] = NULL;
D3DXCreateTextureFromFileA(g_pd3dDevice, pMtrls[i].pTextureFilename, &g_pTextures[i]);
}
pAdjBuffer->Release();
pMtrlBuffer->Release();
// 设置渲染状态
g_pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); //开启背面消隐
g_pd3dDevice->SetRenderState(D3DRS_AMBIENT, D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f)); //设置环境光
Matrix_Set();//设置四大变换
return S_OK;
}
