//---------------------------------------------//
//HLSL読み込み
//---------------------------------------------//
HRESULT HLSLShader::InitHLSL(LPCTSTR filename,LPDIRECT3DDEVICE9 pD3DDev)
{
m_pD3DDevice = pD3DDev;
//シェーダの読み込み
LPD3DXBUFFER pErr = NULL;
HRESULT hr = S_OK;
if( FAILED( hr = D3DXCreateEffectFromFile(
pD3DDev,
filename,
NULL,
NULL,
0,
NULL,
&m_pEffect,
&pErr ) ) )
{
HRESULTCheck(hr);
LPSTR s = (LPSTR)pErr->GetBufferPointer();
LPTCH t[MAX_PATH*10];
//アスキーからユニコード
MultiByteToWideChar(
CP_ACP,
MB_PRECOMPOSED,
s,
MAX_PATH*2,
(LPTSTR)t,
MAX_PATH*2);
MessageBox(NULL,(LPCTSTR)t,TEXT("失敗"),MB_OK);
}else{
m_hTechnique = m_pEffect->GetTechniqueByName("TShader");
m_hmWorld = m_pEffect->GetParameterByName(NULL,"g_mWorld");
m_hmVP = m_pEffect->GetParameterByName(NULL,"g_mVP");
m_hmWVP = m_pEffect->GetParameterByName(NULL,"g_mWVP");
m_hmWVPB = m_pEffect->GetParameterByName(NULL,"g_mWVPB");
m_hmWLP = m_pEffect->GetParameterByName(NULL,"g_mWLP");
m_hmLP = m_pEffect->GetParameterByName(NULL,"g_mLP");
m_hmWLPB = m_pEffect->GetParameterByName(NULL,"g_mWLPB");
m_hmB = m_pEffect->GetParameterByName(NULL,"g_mB");
m_hmWorldMatrixArray = m_pEffect->GetParameterByName(NULL,"g_mWorldMatrixArray");
m_hiNumBones = m_pEffect->GetParameterByName(NULL,"g_NumBones");
m_hTex = m_pEffect->GetParameterByName(NULL,"g_Tex");
m_hShadowTex = m_pEffect->GetParameterByName(NULL,"g_ShadowTex");
m_hRenderTex = m_pEffect->GetParameterByName(NULL,"g_RenderTex");
m_hvLight = m_pEffect->GetParameterByName(NULL,"g_vLight");
m_hvRealLightPos = m_pEffect->GetParameterByName(NULL,"g_vRealLightPos");
m_hvRealLightVec = m_pEffect->GetParameterByName(NULL,"g_vRealLightVec");
m_hvRealCameraPos = m_pEffect->GetParameterByName(NULL,"g_vRealCameraPos");
m_hvRealCameraVec = m_pEffect->GetParameterByName(NULL,"g_vRealCameraVec");
m_hvLightAmb = m_pEffect->GetParameterByName(NULL,"g_vLightAmb");
m_hvLightDif = m_pEffect->GetParameterByName(NULL,"g_vLightDif");
m_hvEyePos = m_pEffect->GetParameterByName(NULL,"g_vEyePos");
m_hDecay_c0 = m_pEffect->GetParameterByName(NULL,"decay_c0");
m_hDecay_c1 = m_pEffect->GetParameterByName(NULL,"decay_c1");
m_hDecay_c2 = m_pEffect->GetParameterByName(NULL,"decay_c2");
m_hsBaias = m_pEffect->GetParameterByName(NULL,"g_sBaias");
m_hShadowLange = m_pEffect->GetParameterByName(NULL,"g_ShadowLange");
}
if(pErr!=NULL)pErr->Release();
return hr;
}
HRESULT SampleShaderPluginVertexShader::InitValid(Mesh *mesh, INode *node)
{
HRESULT hr = S_OK;
m_pINode = node;
// Create a vertex shader for doing the effect
LPD3DXBUFFER *ppCode = &pCode;
LPD3DXBUFFER pBuffer = NULL;
//! VertexShader Declarations
//! VertexShader Constants
Constants.SetCount(20);
//! set up the material vertex color ...
D3DMATERIAL8 mtrl;
ZeroMemory( &mtrl, sizeof(D3DMATERIAL8) );
mtrl.Diffuse.r = mtrl.Ambient.r = m_MtlColor.r;
mtrl.Diffuse.g = mtrl.Ambient.g = m_MtlColor.g;
mtrl.Diffuse.b = mtrl.Ambient.b = m_MtlColor.b;
mtrl.Diffuse.a = mtrl.Ambient.a = 1.0f;
pd3dDevice->SetMaterial( &mtrl );
pd3dDevice->SetRenderState( D3DRS_LIGHTING, TRUE );
pd3dDevice->SetRenderState( D3DRS_AMBIENT, 0xffffffff );
/*!
* D3DXAssembleShader
* Assembles an ASCII description of a shader into binary form, where the shader source is in memory.
*
* @param pSrcData : [in] Pointer to the source code.
* @param SrcDataLen : [in] Size of the source code, in bytes.
* @param Flags : [in] A combination of the following flags, specifying assembly options.
* D3DXASM_DEBUG Inserts debugging information as comments in the assembled shader.
* D3DXASM_SKIPVALIDATION Do not validate the generated code against known capabilities and constraints. This option is recommended only when assembling a shader you know will function (that is, the shader has been assembled before without this option.)
* @param ppConstants : [out] Returns a pointer to an ID3DXBuffer interface, representing the returned constant declarations. These constants are returned as a vertex shader declaration fragment. It is up to the application to insert the contents of this buffer into their declaration. For pixel shaders this parameter is meaningless because constant declarations are included in the assembled shader. This parameter is ignored if it is NULL.
* @param ppCompiledShader : [out] Returns a pointer to an ID3DXBuffer interface, representing the returned compiled object code. This parameter is ignored if it is NULL.
* @param ppCompilationErrors : [out] Returns a pointer to an ID3DXBuffer interface, representing the returned ASCII error messages. This parameter is ignored if it is NULL.
*
* @return HRESULT :
HRESULT D3DXAssembleShader(
LPCVOID pSrcData,
UINT SrcDataLen,
DWORD Flags,
LPD3DXBUFFER* ppConstants,
LPD3DXBUFFER* ppCompiledShader,
LPD3DXBUFFER* ppCompilationErrors
);
*/
//! Specify the vertex format that the vertex shader will be using for doing the effect
DWORD dwVertexFormatDefinition[] =
{
D3DVSD_STREAM( 0 ), D3DVSD_REG( 0, D3DVSDT_FLOAT3 ), // v0 = Position
D3DVSD_REG( 1, D3DVSDT_FLOAT3 ), // v1 = Normal
D3DVSD_END()
};
#if 0
TCHAR *vertexShaderPath = FindMapFile("ambient.njv");
hr = D3DXAssembleShaderFromFile(vertexShaderPath , 0, NULL, &pCode, NULL);
#else
hr = D3DXAssembleShader( SurfaceShader , sizeof(SurfaceShader)-1 , 0 , NULL , &pCode , NULL );
#endif
hr = pd3dDevice->CreateVertexShader(dwVertexFormatDefinition,(LPDWORD)pCode->GetBufferPointer(), &dwVertexShader, 0);
initDone = true;
return hr;
}
void D3D9VertexShader::Reset(LPDIRECT3DDEVICE9 Device)
{
FreeMemory();
HRESULT hr;
_Device = Device;
Assert(Device != NULL, "Device == NULL");
_Decl.Init(Device);
// Define DEBUG_VS and/or DEBUG_PS to debug vertex and/or pixel shaders with the
// shader debugger. Debugging vertex shaders requires either REF or software vertex
// processing, and debugging pixel shaders requires REF. The
// D3DXSHADER_FORCE_*_SOFTWARE_NOOPT flag improves the debug experience in the
// shader debugger. It enables source level debugging, prevents instruction
// reordering, prevents dead code elimination, and forces the compiler to compile
// against the next higher available software target, which ensures that the
// unoptimized shaders do not exceed the shader model limitations. Setting these
// flags will cause slower rendering since the shaders will be unoptimized and
// forced into software. See the DirectX documentation for more information about
// using the shader debugger.
DWORD dwShaderFlags = 0;
#ifdef DEBUG_VS
dwShaderFlags |= D3DXSHADER_SKIPOPTIMIZATION|D3DXSHADER_DEBUG;
#endif
LPD3DXBUFFER pCode = NULL;
LPD3DXBUFFER pErrors = NULL;
PersistentAssert(Utility::FileExists(_ShaderFile), String(_ShaderFile) + String(" not found."));
// Assemble the vertex shader from the file
hr = D3DXCompileShaderFromFile( _ShaderFile.CString(), NULL, NULL, "VShaderEntry",
"vs_3_0", dwShaderFlags, &pCode,
&pErrors, &_ConstantTable );
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];
}
file.close();
}
Assert(!FAILED(hr), "D3DXCompileShaderFromFile failed. See ShaderDebug.txt for details.");
// Create the vertex shader
hr = Device->CreateVertexShader( (DWORD*)pCode->GetBufferPointer(),
&_Shader );
if(pErrors)
{
pErrors->Release();
}
if(pCode)
{
pCode->Release();
}
Assert(!FAILED(hr), "CreateVertexShader failed");
}
//--------------------------------------------------------------------------------------------------------------
SVS* CResourceManager::_CreateVS (LPCSTR _name)
{
string_path name;
strcpy_s (name,_name);
if (0 == ::Render->m_skinning) strcat(name,"_0");
if (1 == ::Render->m_skinning) strcat(name,"_1");
if (2 == ::Render->m_skinning) strcat(name,"_2");
LPSTR N = LPSTR (name);
map_VS::iterator I = m_vs.find (N);
if (I!=m_vs.end()) return I->second;
else
{
SVS* _vs = xr_new<SVS> ();
_vs->dwFlags |= xr_resource_flagged::RF_REGISTERED;
m_vs.insert (mk_pair(_vs->set_name(name),_vs));
if (0==stricmp(_name,"null")) {
_vs->vs = NULL;
return _vs;
}
includer Includer;
LPD3DXBUFFER pShaderBuf = NULL;
LPD3DXBUFFER pErrorBuf = NULL;
LPD3DXSHADER_CONSTANTTABLE pConstants = NULL;
HRESULT _hr = S_OK;
string_path cname;
strconcat (sizeof(cname),cname,::Render->getShaderPath(),_name,".vs");
FS.update_path (cname, "$game_shaders$", cname);
// LPCSTR target = NULL;
IReader* fs = FS.r_open(cname);
R_ASSERT3 (fs, "shader file doesnt exist", cname);
// Select target
LPCSTR c_target = "vs_2_0";
LPCSTR c_entry = "main";
/*if (HW.Caps.geometry.dwVersion>=CAP_VERSION(3,0)) target="vs_3_0";
else*/ if (HW.Caps.geometry_major>=2) c_target="vs_2_0";
else c_target="vs_1_1";
LPSTR pfs = xr_alloc<char>(fs->length() + 1);
strncpy (pfs, (LPCSTR)fs->pointer(), fs->length());
pfs [fs->length()] = 0;
if (strstr(pfs, "main_vs_1_1")) { c_target = "vs_1_1"; c_entry = "main_vs_1_1"; }
if (strstr(pfs, "main_vs_2_0")) { c_target = "vs_2_0"; c_entry = "main_vs_2_0"; }
xr_free(pfs);
// vertex
R_ASSERT2 (fs,cname);
_hr = ::Render->shader_compile(name,LPCSTR(fs->pointer()),fs->length(), NULL, &Includer, c_entry, c_target, D3DXSHADER_DEBUG | D3DXSHADER_PACKMATRIX_ROWMAJOR /*| D3DXSHADER_PREFER_FLOW_CONTROL*/, &pShaderBuf, &pErrorBuf, NULL);
// _hr = D3DXCompileShader (LPCSTR(fs->pointer()),fs->length(), NULL, &Includer, "main", target, D3DXSHADER_DEBUG | D3DXSHADER_PACKMATRIX_ROWMAJOR, &pShaderBuf, &pErrorBuf, NULL);
FS.r_close (fs);
if (SUCCEEDED(_hr))
{
if (pShaderBuf)
{
_hr = HW.pDevice->CreateVertexShader ((DWORD*)pShaderBuf->GetBufferPointer(), &_vs->vs);
if (SUCCEEDED(_hr)) {
LPCVOID data = NULL;
_hr = D3DXFindShaderComment ((DWORD*)pShaderBuf->GetBufferPointer(),MAKEFOURCC('C','T','A','B'),&data,NULL);
if (SUCCEEDED(_hr) && data)
{
pConstants = LPD3DXSHADER_CONSTANTTABLE(data);
_vs->constants.parse (pConstants,0x2);
} else _hr = E_FAIL;
}
}
else _hr = E_FAIL;
} else {
VERIFY (pErrorBuf);
Log ("! error: ",(LPCSTR)pErrorBuf->GetBufferPointer());
}
_RELEASE (pShaderBuf);
_RELEASE (pErrorBuf);
pConstants = NULL;
R_CHK (_hr);
return _vs;
}
}
void Shader::Internal::reload()
{
if (opengl) {
GLint status;
const GLchar *p = (const GLchar *)vertex_source.c_str();
opengl_vertex_shader = glCreateShader(GL_VERTEX_SHADER);
printGLerror("glCreateShader");
glShaderSource(opengl_vertex_shader, 1, &p, 0);
printGLerror("glShaderSource");
glCompileShader(opengl_vertex_shader);
printGLerror("glCompileShader");
glGetShaderiv(opengl_vertex_shader, GL_COMPILE_STATUS, &status);
printGLerror("glGetShaderiv");
if (status != GL_TRUE) {
char buffer[512];
glGetShaderInfoLog(opengl_vertex_shader, 512, 0, buffer);
errormsg("Vertex shader error: %s\n", buffer);
}
p = (const GLchar *)fragment_source.c_str();
opengl_fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
printGLerror("glCreateShader");
glShaderSource(opengl_fragment_shader, 1, &p, 0);
printGLerror("glShaderSource");
glCompileShader(opengl_fragment_shader);
printGLerror("glCompileShader");
glGetShaderiv(opengl_fragment_shader, GL_COMPILE_STATUS, &status);
printGLerror("glGetShaderiv");
if (status != GL_TRUE) {
char buffer[512];
glGetShaderInfoLog(opengl_fragment_shader, 512, 0, buffer);
errormsg("Fragment shader error: %s\n", buffer);
}
opengl_shader = glCreateProgram();
glAttachShader(opengl_shader, opengl_vertex_shader);
printGLerror("glAttachShader");
glAttachShader(opengl_shader, opengl_fragment_shader);
printGLerror("glAttachShader");
glLinkProgram(opengl_shader);
printGLerror("glLinkProgram");
}
#ifdef NOOSKEWL_ENGINE_WINDOWS
else {
LPD3DXBUFFER errors;
std::string shader_source = vertex_source + fragment_source;
shader_source +=
"technique TECH"
"{"
" pass p1"
" {"
" VertexShader = compile vs_2_0 vs_main();"
" PixelShader = compile ps_2_0 ps_main();"
" }"
"}";
DWORD result = D3DXCreateEffect(noo.d3d_device, shader_source.c_str(), shader_source.length(), 0, 0, D3DXSHADER_PACKMATRIX_ROWMAJOR, 0, &d3d_effect, &errors);
if (result != D3D_OK) {
char *msg = (char *)errors->GetBufferPointer();
throw Error("Shader error: " + std::string(msg));
}
d3d_technique = d3d_effect->GetTechniqueByName("TECH");
d3d_effect->ValidateTechnique(d3d_technique);
d3d_effect->SetTechnique(d3d_technique);
}
#endif
}
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
HRESULT CD3DMesh::Create( LPDIRECT3DDEVICE8 pd3dDevice, TCHAR* strFilename )
{
TCHAR strPath[MAX_PATH];
CHAR strPathANSI[MAX_PATH];
LPD3DXBUFFER pAdjacencyBuffer = NULL;
LPD3DXBUFFER pMtrlBuffer = NULL;
HRESULT hr;
// Find the path for the file, and convert it to ANSI (for the D3DX API)
DXUtil_FindMediaFile( strPath, strFilename );
DXUtil_ConvertGenericStringToAnsi( strPathANSI, strPath );
// Load the mesh
if( FAILED( hr = D3DXLoadMeshFromX( strPathANSI, D3DXMESH_SYSTEMMEM, pd3dDevice,
&pAdjacencyBuffer, &pMtrlBuffer,
&m_dwNumMaterials, &m_pSysMemMesh ) ) )
{
return hr;
}
// Optimize the mesh for performance
if( FAILED( hr = m_pSysMemMesh->OptimizeInplace(
D3DXMESHOPT_COMPACT | D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_VERTEXCACHE,
(DWORD*)pAdjacencyBuffer->GetBufferPointer(), NULL, NULL, NULL ) ) )
{
SAFE_RELEASE( pAdjacencyBuffer );
SAFE_RELEASE( pMtrlBuffer );
return hr;
}
// Get material info for the mesh
// Get the array of materials out of the buffer
if( pMtrlBuffer && m_dwNumMaterials > 0 )
{
// Allocate memory for the materials and textures
D3DXMATERIAL* d3dxMtrls = (D3DXMATERIAL*)pMtrlBuffer->GetBufferPointer();
m_pMaterials = new D3DMATERIAL8[m_dwNumMaterials];
m_pTextures = new LPDIRECT3DTEXTURE8[m_dwNumMaterials];
// Copy each material and create its texture
for( DWORD i=0; i<m_dwNumMaterials; i++ )
{
// Copy the material
m_pMaterials[i] = d3dxMtrls[i].MatD3D;
m_pMaterials[i].Ambient = m_pMaterials[i].Diffuse;
m_pTextures[i] = NULL;
// Create a texture
if( d3dxMtrls[i].pTextureFilename )
{
TCHAR strTexture[MAX_PATH];
TCHAR strTextureTemp[MAX_PATH];
DXUtil_ConvertAnsiStringToGeneric( strTextureTemp, d3dxMtrls[i].pTextureFilename );
DXUtil_FindMediaFile( strTexture, strTextureTemp );
if( FAILED( D3DXCreateTextureFromFile( pd3dDevice, strTexture,
&m_pTextures[i] ) ) )
m_pTextures[i] = NULL;
}
}
}
SAFE_RELEASE( pAdjacencyBuffer );
SAFE_RELEASE( pMtrlBuffer );
return S_OK;
}
bool CDirect3D::SetShaderHLSL(const TCHAR *file)
{
//MUDLORD: the guts
//Compiles a shader from files on disc
//Sets LUT textures to texture files in PNG format.
TCHAR folder[MAX_PATH];
TCHAR rubyLUTfileName[MAX_PATH];
TCHAR *slash;
TCHAR errorMsg[MAX_PATH + 50];
shaderTimer = 1.0f;
shaderTimeStart = 0;
shaderTimeElapsed = 0;
if(effect) {
effect->Release();
effect = NULL;
}
for(int i = 0; i < MAX_SHADER_TEXTURES; i++) {
if (rubyLUT[i] != NULL) {
rubyLUT[i]->Release();
rubyLUT[i] = NULL;
}
}
if (file == NULL || *file==TEXT('\0'))
return true;
CXML xml;
if(!xml.loadXmlFile(file))
return false;
TCHAR *lang = xml.getAttribute(TEXT("/shader"),TEXT("language"));
if(lstrcmpi(lang,TEXT("hlsl"))) {
_stprintf(errorMsg,TEXT("Shader language is <%s>, expected <HLSL> in file:\n%s"),lang,file);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
return false;
}
TCHAR *shaderText = xml.getNodeContent(TEXT("/shader/source"));
if(!shaderText) {
_stprintf(errorMsg,TEXT("No HLSL shader program in file:\n%s"),file);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"),
MB_OK|MB_ICONEXCLAMATION);
return false;
}
LPD3DXBUFFER pBufferErrors = NULL;
#ifdef UNICODE
HRESULT hr = D3DXCreateEffect( pDevice,WideToCP(shaderText,CP_ACP),strlen(WideToCP(shaderText,CP_ACP)),NULL, NULL,
D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY, NULL, &effect,
&pBufferErrors );
#else
HRESULT hr = D3DXCreateEffect( pDevice,shaderText,strlen(shaderText),NULL, NULL,
D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY, NULL, &effect,
&pBufferErrors );
#endif
if( FAILED(hr) ) {
_stprintf(errorMsg,TEXT("Error parsing HLSL shader file:\n%s"),file);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
if(pBufferErrors) {
LPVOID pCompilErrors = pBufferErrors->GetBufferPointer();
MessageBox(NULL, (const TCHAR*)pCompilErrors, TEXT("FX Compile Error"),
MB_OK|MB_ICONEXCLAMATION);
}
return false;
}
lstrcpy(folder,file);
slash = _tcsrchr(folder,TEXT('\\'));
if(slash)
*(slash+1)=TEXT('\0');
else
*folder=TEXT('\0');
SetCurrentDirectory(S9xGetDirectoryT(DEFAULT_DIR));
for(int i = 0; i < MAX_SHADER_TEXTURES; i++) {
_stprintf(rubyLUTfileName, TEXT("%srubyLUT%d.png"), folder, i);
hr = D3DXCreateTextureFromFile(pDevice,rubyLUTfileName,&rubyLUT[i]);
if FAILED(hr){
rubyLUT[i] = NULL;
}
}
D3DXHANDLE hTech;
effect->FindNextValidTechnique(NULL,&hTech);
effect->SetTechnique( hTech );
shader_type = D3D_SHADER_HLSL;
return true;
}
HRESULT CRender::shader_compile (
LPCSTR name,
DWORD const* pSrcData,
UINT SrcDataLen,
LPCSTR pFunctionName,
LPCSTR pTarget,
DWORD Flags,
void*& result
)
{
D3DXMACRO defines [128];
int def_it = 0;
char sh_name[MAX_PATH] = "";
u32 len = 0;
// options
if (o.forceskinw) {
defines[def_it].Name = "SKIN_COLOR";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(o.forceskinw); ++len;
if (m_skinning<0) {
defines[def_it].Name = "SKIN_NONE";
defines[def_it].Definition = "1";
def_it ++;
sh_name[len]='1'; ++len;
}
else {
sh_name[len]='0'; ++len;
}
if (0==m_skinning) {
defines[def_it].Name = "SKIN_0";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(0==m_skinning); ++len;
if (1==m_skinning) {
defines[def_it].Name = "SKIN_1";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(1==m_skinning); ++len;
if (2==m_skinning) {
defines[def_it].Name = "SKIN_2";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(2==m_skinning); ++len;
if (3==m_skinning) {
defines[def_it].Name = "SKIN_3";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(3==m_skinning); ++len;
if (4==m_skinning) {
defines[def_it].Name = "SKIN_4";
defines[def_it].Definition = "1";
def_it ++;
}
sh_name[len]='0'+char(4==m_skinning); ++len;
// finish
defines[def_it].Name = 0;
defines[def_it].Definition = 0;
def_it ++;
R_ASSERT (def_it<128);
HRESULT _result = E_FAIL;
string_path folder_name, folder;
xr_strcpy ( folder, "r1\\objects\\r1\\" );
xr_strcat ( folder, name );
xr_strcat ( folder, "." );
char extension[3];
strncpy_s ( extension, pTarget, 2 );
xr_strcat ( folder, extension );
FS.update_path ( folder_name, "$game_shaders$", folder );
xr_strcat ( folder_name, "\\" );
m_file_set.clear( );
FS.file_list ( m_file_set, folder_name, FS_ListFiles | FS_RootOnly, "*");
string_path temp_file_name, file_name;
if ( !match_shader_id(name, sh_name, m_file_set, temp_file_name) ) {
string_path file;
xr_strcpy ( file, "shaders_cache\\r1\\" );
xr_strcat ( file, name );
xr_strcat ( file, "." );
xr_strcat ( file, extension );
xr_strcat ( file, "\\" );
xr_strcat ( file, sh_name );
FS.update_path ( file_name, "$app_data_root$", file);
}
else {
xr_strcpy ( file_name, folder_name );
xr_strcat ( file_name, temp_file_name );
}
if (FS.exist(file_name))
{
IReader* file = FS.r_open(file_name);
if (file->length()>4)
{
u32 crc = 0;
crc = file->r_u32();
boost::crc_32_type processor;
processor.process_block ( file->pointer(), ((char*)file->pointer()) + file->elapsed() );
u32 const real_crc = processor.checksum( );
if ( real_crc == crc ) {
_result = create_shader(pTarget, (DWORD*)file->pointer(), file->elapsed(), file_name, result, o.disasm);
}
}
file->close();
}
if (FAILED(_result))
{
includer Includer;
LPD3DXBUFFER pShaderBuf = NULL;
LPD3DXBUFFER pErrorBuf = NULL;
LPD3DXCONSTANTTABLE pConstants = NULL;
LPD3DXINCLUDE pInclude = (LPD3DXINCLUDE)&Includer;
_result = D3DXCompileShader((LPCSTR)pSrcData,SrcDataLen,defines,pInclude,pFunctionName,pTarget,Flags|D3DXSHADER_USE_LEGACY_D3DX9_31_DLL,&pShaderBuf,&pErrorBuf,&pConstants);
if (SUCCEEDED(_result)) {
IWriter* file = FS.w_open(file_name);
boost::crc_32_type processor;
processor.process_block ( pShaderBuf->GetBufferPointer(), ((char*)pShaderBuf->GetBufferPointer()) + pShaderBuf->GetBufferSize() );
u32 const crc = processor.checksum( );
file->w_u32 (crc);
file->w ( pShaderBuf->GetBufferPointer(), (u32)pShaderBuf->GetBufferSize());
FS.w_close (file);
_result = create_shader(pTarget, (DWORD*)pShaderBuf->GetBufferPointer(), pShaderBuf->GetBufferSize(), file_name, result, o.disasm);
}
else {
Log ("! ", file_name);
if ( pErrorBuf )
Log ("! error: ",(LPCSTR)pErrorBuf->GetBufferPointer());
else
Msg ("Can't compile shader hr=0x%08x", _result);
}
}
return _result;
}
bool CD3D8ShaderMaterialRenderer::createVertexShader(const char* vtxsh, E_VERTEX_TYPE type)
{
if (!vtxsh)
return true;
// compile shader
#if defined( _IRR_XBOX_PLATFORM_)
return false;
#else
LPD3DXBUFFER code = 0;
LPD3DXBUFFER errors = 0;
#ifdef _IRR_D3D_NO_SHADER_DEBUGGING
// compile shader without debug info
D3DXAssembleShader(vtxsh, (UINT)strlen(vtxsh), 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.vsh", irr_dbg_file_nr);
FILE* f = fopen(tmp, "wb");
fwrite(vtxsh, strlen(vtxsh), 1, f);
fflush(f);
fclose(f);
D3DXAssembleShaderFromFile(tmp, D3DXASM_DEBUG, 0, &code, &errors);
#endif
if (errors)
{
// print out compilation errors.
os::Printer::log("Vertex shader compilation failed:", ELL_ERROR);
os::Printer::log((c8*)errors->GetBufferPointer(), ELL_ERROR);
if (code)
code->Release();
errors->Release();
return false;
}
DWORD* decl = 0;
DWORD dwStdDecl[] =
{
D3DVSD_STREAM(0),
D3DVSD_REG(0, D3DVSDT_FLOAT3), // position 0
D3DVSD_REG(1, D3DVSDT_FLOAT3), // normal 1
D3DVSD_REG(2, D3DVSDT_D3DCOLOR ),// color 2
D3DVSD_REG(3, D3DVSDT_FLOAT2 ), // tex1 3
D3DVSD_REG(4, D3DVSDT_FLOAT2 ), // tex2 4
D3DVSD_END()
};
DWORD dwTngtDecl[] =
{
D3DVSD_STREAM(0),
D3DVSD_REG(0 , D3DVSDT_FLOAT3), // position 0
D3DVSD_REG(1 , D3DVSDT_FLOAT3), // normal 1
D3DVSD_REG(2 , D3DVSDT_D3DCOLOR ),// color 2
D3DVSD_REG(3 , D3DVSDT_FLOAT2 ), // tex1 3
D3DVSD_REG(4, D3DVSDT_FLOAT3 ), // tangent 4
D3DVSD_REG(5, D3DVSDT_FLOAT3 ), // binormal 5
D3DVSD_END()
};
if (type == EVT_TANGENTS)
decl = dwTngtDecl;
else
decl = dwStdDecl;
if (FAILED(pID3DDevice->CreateVertexShader(decl,
(DWORD*)code->GetBufferPointer(), &VertexShader, 0)))
{
os::Printer::log("Could not create vertex shader.", ELL_ERROR);
code->Release();
return false;
}
code->Release();
return true;
#endif
}
bool Box::Init(IDirect3DDevice9* pDevice, float width, float height, float x, float y, D3DCOLOR color)
{
/*VertexData vertex [] =
{
//X Y Z RHW Color
{ D3DXVECTOR3(x, y, 0), 1.0, color },
{ D3DXVECTOR3(x + width, y, 0), 1.0, color },
{ D3DXVECTOR3(x, y + height, 0), 1.0, color },
{ D3DXVECTOR3(x + width, y + height, 0), 1.0, color }
};*/
VertexData vertex[] =
{
//X Y Z RHW Color
{ D3DXVECTOR3(x, y, 0), 1.0, color, D3DXVECTOR2(0.0, 0.0) },
{ D3DXVECTOR3(x + width, y, 0), 1.0, color, D3DXVECTOR2(1.0, 0.0) },
{ D3DXVECTOR3(x, y + height, 0), 1.0, color, D3DXVECTOR2(0.0, 1.0) },
{ D3DXVECTOR3(x + width, y + height, 0), 1.0, color, D3DXVECTOR2(1.0, 1.0) }
};
/*VertexData vertex[] =
{
//X Y Z RHW Color
{ D3DXVECTOR3(x, y, 1), color },
{ D3DXVECTOR3(x + width, y, 1), color },
{ D3DXVECTOR3(x, y + height, 1), color },
{ D3DXVECTOR3(x + width, y + height, 1), color }
};*/
VOID* pVoid = nullptr;
//Set up the vertex buffer
unsigned long vertexSize = 4 * sizeof(VertexData);
if (FAILED(pDevice->CreateVertexBuffer(vertexSize, 0, CUSTOMFVF, D3DPOOL_MANAGED, &v_buffer, NULL)))
{
CLog::Write("Box::Init - Couldn't create the vertex buffer");
return false;
}
v_buffer->Lock(0, 0, (void**) &pVoid, 0);
{
memcpy(pVoid, vertex, sizeof(vertex));
}
v_buffer->Unlock();
//Set up the index buffer
short indices [] =
{
0, 1, 2, 3
};
if (FAILED(pDevice->CreateIndexBuffer(4 * sizeof(short), 0, D3DFMT_INDEX16, D3DPOOL_MANAGED, &m_pIndexBuffer, 0)))
{
CLog::Write("Box::Init - Couldn't create the index buffer");
return false;
}
m_pIndexBuffer->Lock(0, 0, (void**) &pVoid, 0);
{
memcpy(pVoid, indices, sizeof(indices));
}
m_pIndexBuffer->Unlock();
//Create the index declaration
D3DVERTEXELEMENT9 decl [] =
{
{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
{ 0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0 },
D3DDECL_END()
};
if (FAILED(pDevice->CreateVertexDeclaration(decl, &m_pDeclaration)))
return false;
//Create the shader
LPD3DXBUFFER pErr = nullptr;
if (FAILED(D3DXCreateEffectFromResource(pDevice, GetModuleHandle("sampp_client.asi"), MAKEINTRESOURCE(IDR_RCDATA1), 0, 0, 0, 0, &m_pShader, &pErr)))
{
CLog::Write("D3DXCreateEffectFromResource failed: %s", (char*) pErr->GetBufferPointer());
pErr->Release();
pErr = nullptr;
return false;
}
//Create the texture
if (FAILED(D3DXCreateTextureFromFile(pDevice, "rocks.jpg", &m_pTexture)))
{
CLog::Write("D3DXCreateTextureFromFile failed");
return false;
}
//Initialize the variables
m_fX = x;
m_fY = y;
m_fWidth = width;
m_fHeight = height;
m_pDevice = pDevice;
m_bDraw = true;
m_cColor = color;
m_BarRect = { m_fX, m_fY, m_fX + m_fWidth, m_fY + m_fHeight };
initialized = true;
D3DXMatrixTranslation(&m_View, 0, 0, 2);
D3DXMatrixPerspectiveFovLH(&m_Proj, D3DXToRadian(75), 1366 / 768, 0.01f, 100.0f);
return true;
}
//=============================================================================
// 初期化
//=============================================================================
HRESULT CMeshField::Init(LPDIRECT3DDEVICE9 pDevice,int nType, D3DXVECTOR3 pos, D3DXVECTOR3 rot,
int nNumBlockX, int nNumBlockZ, float fSizeBlockX, float fSizeBlockZ)
{
m_pDevice=pDevice;
// ブロック数の設定
m_nNumBlockX = nNumBlockX;
m_nNumBlockZ = nNumBlockZ;
// 頂点数の設定
m_nNumVertex = (nNumBlockX + 1) * (nNumBlockZ + 1);
// インデックス数の設定
m_nNumVertexIndex = (nNumBlockX + 1) * 2 * nNumBlockZ + (nNumBlockZ - 1) * 2;
// ポリゴン数の設定
m_nNumPolygon = nNumBlockX * nNumBlockZ * 2 + (nNumBlockZ - 1) * 4;
// ブロックサイズの設定
m_fSizeBlockX = fSizeBlockX;
m_fSizeBlockZ = fSizeBlockZ;
// テクスチャの読み込み
m_texid = m_apTexture[nType];
//D3DXCreateTextureFromFile(m_pDevice,m_apTextureName[nType],&m_pD3DTex);
//フィールドの初期化
m_Pos = pos;
m_Rot = rot;
m_Scl = D3DXVECTOR3(1.0f,1.0f,1.0f);
// オブジェクトの頂点バッファを生成
if(FAILED(m_pDevice->CreateVertexBuffer(sizeof(VERTEX_3D)*m_nNumVertex,
D3DUSAGE_WRITEONLY,
FVF_VERTEX_3D,
D3DPOOL_MANAGED,
&m_pD3DVtxBuff,
NULL)))
{
return E_FAIL;
}
// オブジェクトのインデックスバッファを生成
if(FAILED(m_pDevice->CreateIndexBuffer(sizeof(WORD)*m_nNumVertexIndex,
D3DUSAGE_WRITEONLY,
D3DFMT_INDEX16,
D3DPOOL_MANAGED,
&m_pD3DIndexBuff,
NULL)))
{
return E_FAIL;
}
// 法線算出用バッファ確保
m_pBuffNormal = new D3DXVECTOR3 [(m_nNumBlockX * 2) * m_nNumBlockZ];
{//頂点バッファの中身を埋める
VERTEX_3D *pVtx;
const float texSizeX = 1.0f;
const float texSizeZ = 1.0f;
// 頂点データの範囲をロックし、頂点バッファへのポインタを取得
m_pD3DVtxBuff->Lock(0, 0, (void**)&pVtx, 0);
for(int nCntVtxZ = 0; nCntVtxZ < (m_nNumBlockZ + 1); nCntVtxZ++)
{
for(int nCntVtxX = 0; nCntVtxX < (m_nNumBlockX + 1); nCntVtxX++)
{
// 頂点座標の設定
pVtx[nCntVtxZ * (m_nNumBlockX + 1) + nCntVtxX].vtx.x = -(m_nNumBlockX / 2.0f) * m_fSizeBlockX + nCntVtxX * m_fSizeBlockX;
pVtx[nCntVtxZ * (m_nNumBlockX + 1) + nCntVtxX].vtx.z = (m_nNumBlockZ / 2.0f) * m_fSizeBlockZ - nCntVtxZ * m_fSizeBlockZ;
pVtx[nCntVtxZ * (m_nNumBlockX + 1) + nCntVtxX].vtx.y = HIGHT_MAP[nCntVtxZ * (m_nNumBlockX + 1) + nCntVtxX];
// 反射光の設定
pVtx[nCntVtxZ * (m_nNumBlockX + 1) + nCntVtxX].diffuse = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
// テクスチャ座標の設定
pVtx[nCntVtxZ * (m_nNumBlockX + 1) + nCntVtxX].tex.x = texSizeX * nCntVtxX;
pVtx[nCntVtxZ * (m_nNumBlockX + 1) + nCntVtxX].tex.y = texSizeZ * nCntVtxZ;
}
}
// 頂点データをアンロックする
m_pD3DVtxBuff->Unlock();
}
{// 法線の算出
VERTEX_3D *pVtx;
// 頂点データの範囲をロックし、頂点バッファへのポインタを取得
m_pD3DVtxBuff->Lock(0, 0, (void**)&pVtx, 0);
D3DXVECTOR3 *pNor = m_pBuffNormal;
for(int nCntVtxZ = 0; nCntVtxZ < m_nNumBlockZ; nCntVtxZ++)
{
for(int nCntVtxX = 0; nCntVtxX < m_nNumBlockX; nCntVtxX++)
{
// 法線の設定
D3DXVECTOR3 v0,v1,v2;
D3DXVECTOR3 normal;
D3DXVECTOR3 *pVtx0,*pVtx1,*pVtx2;
pVtx0 = &pVtx[nCntVtxZ * (m_nNumBlockX + 1) + nCntVtxX].vtx;
pVtx1 = &pVtx[(nCntVtxZ + 1) * (m_nNumBlockX + 1) + nCntVtxX].vtx;
pVtx2 = &pVtx[(nCntVtxZ + 1) * (m_nNumBlockX + 1) + nCntVtxX + 1].vtx;
v0.x = pVtx1->x - pVtx2->x;
v0.y = pVtx1->y - pVtx2->y;
v0.z = pVtx1->z - pVtx2->z;
v1.x = pVtx0->x - pVtx2->x;
v1.y = pVtx0->y - pVtx2->y;
v1.z = pVtx0->z - pVtx2->z;
D3DXVec3Cross(&v2, &v0, &v1);
D3DXVec3Normalize(&normal, &v2);
*pNor = normal;
pNor++;
pVtx0 = &pVtx[nCntVtxZ * (m_nNumBlockX + 1) + nCntVtxX].vtx;
pVtx1 = &pVtx[(nCntVtxZ + 1) * (m_nNumBlockX + 1) + nCntVtxX + 1].vtx;
pVtx2 = &pVtx[nCntVtxZ * (m_nNumBlockX + 1) + nCntVtxX + 1].vtx;
v0.x = pVtx1->x - pVtx2->x;
v0.y = pVtx1->y - pVtx2->y;
v0.z = pVtx1->z - pVtx2->z;
v1.x = pVtx0->x - pVtx2->x;
v1.y = pVtx0->y - pVtx2->y;
v1.z = pVtx0->z - pVtx2->z;
D3DXVec3Cross(&v2, &v0, &v1);
D3DXVec3Normalize(&normal, &v2);
*pNor = normal;
pNor++;
}
}
// 頂点データをアンロックする
m_pD3DVtxBuff->Unlock();
}
{//頂点バッファの中身を埋める
VERTEX_3D *pVtx;
// 頂点データの範囲をロックし、頂点バッファへのポインタを取得
m_pD3DVtxBuff->Lock(0, 0, (void**)&pVtx, 0);
D3DXVECTOR3 *pNor = m_pBuffNormal;
for(int nCntVtxZ = 0; nCntVtxZ < (m_nNumBlockZ + 1); nCntVtxZ++)
{
for(int nCntVtxX = 0; nCntVtxX < (m_nNumBlockX + 1); nCntVtxX++)
{
// 法線の設定
D3DXVECTOR3 normal;
D3DXVECTOR3 norAvg0, norAvg1;
if(nCntVtxZ == 0)
{
if(nCntVtxX == 0)
{
normal = (pNor[0] + pNor[1]) / 2;
}
else if(nCntVtxX == m_nNumBlockX)
{
normal = pNor[m_nNumBlockX * 2 - 1];
}
else
{
norAvg0 = (pNor[nCntVtxX * 2] + pNor[nCntVtxX * 2 + 1]) / 2;
normal = (pNor[nCntVtxX * 2 - 1] + norAvg0) / 2;
}
}
else if(nCntVtxZ == m_nNumBlockZ)
{
if(nCntVtxX == 0)
{
normal = pNor[(m_nNumBlockZ - 1) * m_nNumBlockX * 2];
}
else if(nCntVtxX == m_nNumBlockX)
{
normal = (pNor[m_nNumBlockZ * m_nNumBlockX * 2 - 2] + pNor[m_nNumBlockZ * m_nNumBlockX * 2 - 1]) / 2;
}
else
{
norAvg0 = (pNor[(m_nNumBlockZ - 1) * m_nNumBlockX * 2 + nCntVtxX * 2 - 2] + pNor[(m_nNumBlockZ - 1) * m_nNumBlockX * 2 + nCntVtxX * 2 - 1]) / 2;
normal = (norAvg0 + pNor[(m_nNumBlockZ - 1) * m_nNumBlockX * 2 + nCntVtxX * 2]) / 2;
}
}
else
{
if(nCntVtxX == 0)
{
norAvg0 = (pNor[nCntVtxZ * m_nNumBlockX * 2] + pNor[nCntVtxZ * m_nNumBlockX * 2 + 1]) / 2;
normal = (pNor[(nCntVtxZ - 1) * m_nNumBlockX * 2] + norAvg0) / 2;
}
else if(nCntVtxX == m_nNumBlockX)
{
norAvg0 = (pNor[(nCntVtxZ - 1) * m_nNumBlockX * 2 + nCntVtxX * 2 - 1] + pNor[(nCntVtxZ - 1) * m_nNumBlockX * 2 + nCntVtxX * 2 - 2]) / 2;
normal = (norAvg0 + pNor[nCntVtxZ * m_nNumBlockX * 2 + nCntVtxX * 2 - 1]) / 2;
}
else
{
int nIdx0 = (nCntVtxZ - 1) * m_nNumBlockX * 2 + nCntVtxX * 2 - 2;
int nIdx1 = (nCntVtxZ - 1) * m_nNumBlockX * 2 + nCntVtxX * 2 - 1;
int nIdx2 = (nCntVtxZ - 1) * m_nNumBlockX * 2 + nCntVtxX * 2;
int nIdx3 = nCntVtxZ * m_nNumBlockX * 2 + nCntVtxX * 2 - 1;
int nIdx4 = nCntVtxZ * m_nNumBlockX * 2 + nCntVtxX * 2;
int nIdx5 = nCntVtxZ * m_nNumBlockX * 2 + nCntVtxX * 2 + 1;
norAvg0 = (pNor[nIdx0] + pNor[nIdx1]) / 2;
norAvg1 = (pNor[nIdx4] + pNor[nIdx5]) / 2;
normal = (norAvg0 + pNor[nIdx2] + pNor[nIdx3] + norAvg1) / 4;
}
}
D3DXVec3Normalize(&normal, &normal);
pVtx[nCntVtxZ * (m_nNumBlockX + 1) + nCntVtxX].nor = normal;
}
}
// 頂点データをアンロックする
m_pD3DVtxBuff->Unlock();
}
{//インデックスバッファの中身を埋める
WORD *pIdx;
// インデックスデータの範囲をロックし、頂点バッファへのポインタを取得
m_pD3DIndexBuff->Lock(0, 0, (void**)&pIdx, 0);
int nCntIdx = 0;
for(int nCntVtxZ = 0; nCntVtxZ < m_nNumBlockZ; nCntVtxZ++)
{
if(nCntVtxZ > 0)
{// 縮退ポリゴンのためのダブりの設定
pIdx[nCntIdx] = (nCntVtxZ + 1) * (m_nNumBlockX + 1) + 0;
nCntIdx++;
}
for(int nCntVtxX = 0; nCntVtxX < (m_nNumBlockX + 1); nCntVtxX++)
{
pIdx[nCntIdx] = (nCntVtxZ + 1) * (m_nNumBlockX + 1) + nCntVtxX;
nCntIdx++;
pIdx[nCntIdx] = nCntVtxZ * (m_nNumBlockX + 1) + nCntVtxX;
nCntIdx++;
}
if(nCntVtxZ < (m_nNumBlockZ - 1))
{// 縮退ポリゴンのためのダブりの設定
pIdx[nCntIdx] = nCntVtxZ * (m_nNumBlockX + 1) + m_nNumBlockX;
nCntIdx++;
}
}
// インデックスデータをアンロックする
m_pD3DIndexBuff->Unlock();
}
HRESULT hr;
LPD3DXBUFFER err;
LPD3DXBUFFER code;
//ピクセルシェーダー用に変換
hr = D3DXCompileShaderFromFile("source/shader/basicPS.hlsl", NULL, NULL, "PS_SHADOW", "ps_2_0", 0, &code, &err, &_psc);
if (FAILED(hr))
{
MessageBox(NULL, (LPCSTR)err->GetBufferPointer(), "D3DXCompileShaderFromFile", MB_OK);
err->Release();
return false;
}
//シェーダーの登録
hr = pDevice->CreatePixelShader((DWORD*)code->GetBufferPointer(), &_ps);
if (FAILED(hr))
{
MessageBox(NULL, "FAILED", "CreatePixelShader", MB_OK);
return false;
}
//バーテックスシェーダー用に変換1
hr = D3DXCompileShaderFromFile("source/shader/basicVS.hlsl", NULL, NULL, "VS_SHADOW", "vs_2_0", 0, &code, &err, &_vsc[0]);
if (FAILED(hr))
{
MessageBox(NULL, (LPCSTR)err->GetBufferPointer(), "D3DXCompileShaderFromFile", MB_OK);
err->Release();
return false;
}
//シェーダーの登録
hr = pDevice->CreateVertexShader((DWORD*)code->GetBufferPointer(), &_vs[0]);
if (FAILED(hr))
{
MessageBox(NULL, "FAILED", "CreateVertexShader", MB_OK);
return false;
}
//バーテックスシェーダー用に変換1
hr = D3DXCompileShaderFromFile("source/shader/basicVS.hlsl", NULL, NULL, "VS", "vs_2_0", 0, &code, &err, &_vsc[1]);
if (FAILED(hr))
{
MessageBox(NULL, (LPCSTR)err->GetBufferPointer(), "D3DXCompileShaderFromFile", MB_OK);
err->Release();
return false;
}
//シェーダーの登録
hr = pDevice->CreateVertexShader((DWORD*)code->GetBufferPointer(), &_vs[1]);
if (FAILED(hr))
{
MessageBox(NULL, "FAILED", "CreateVertexShader", MB_OK);
return false;
}
// マテリアルの設定
m_material.Ambient = D3DXCOLOR(0.25f, 0.25f, 0.25f, 1.0f);
m_material.Diffuse = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
m_material.Emissive = D3DXCOLOR(0, 0, 0, 0);
m_material.Specular = D3DXCOLOR(0, 0, 0, 0);
m_material.Power = 2.0f;
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: InitDeviceObjects()
// Desc: Initialize scene objects.
//-----------------------------------------------------------------------------
HRESULT CMeshRender::InitDeviceObjects()
{
DWORD cVerticesPerMesh;
// Load mesh
LPD3DXBUFFER pAdjacencyBuffer = NULL;
LPDIRECT3DVERTEXBUFFER9 pVertexBuffer = NULL;
LPD3DXMESH pMesh = NULL;
LPD3DXPMESH pPMesh = NULL;
LPD3DXMESH pTempMesh;
LPD3DXBUFFER pD3DXMtrlBuffer = NULL;
void* pVertices;
TCHAR strMediaPath[512];
HRESULT hr;
DWORD dw32BitFlag;
DWORD cVerticesMin;
DWORD cVerticesMax;
DWORD iPMesh;
D3DXWELDEPSILONS Epsilons;
DWORD i;
D3DXMATERIAL* d3dxMaterials;
// Find the path to the mesh
if( FAILED( DXUtil_FindMediaFileCb( strMediaPath, sizeof(strMediaPath), m_strMeshFilename ) ) )
return E_FAIL;//D3DAPPERR_MEDIANOTFOUND;
// Load the mesh from the specified file
if( FAILED( hr = D3DXLoadMeshFromX( strMediaPath, D3DXMESH_MANAGED, m_pd3dDevice,
&pAdjacencyBuffer, &pD3DXMtrlBuffer, NULL,
&m_dwNumMaterials, &pMesh ) ) )
{
// hide error so that device changes will not cause exit, shows blank screen instead
goto End;
}
dw32BitFlag = (pMesh->GetOptions() & D3DXMESH_32BIT);
// perform simple cleansing operations on mesh
if( FAILED( hr = D3DXCleanMesh( pMesh, (DWORD*)pAdjacencyBuffer->GetBufferPointer(), &pTempMesh,
(DWORD*)pAdjacencyBuffer->GetBufferPointer(), NULL ) ) )
{
m_dwNumMaterials = 0;
goto End;
}
SAFE_RELEASE(pMesh);
pMesh = pTempMesh;
// Perform a weld to try and remove excess vertices like the model bigship1.x in the DX9.0 SDK (current model is fixed)
// Weld the mesh using all epsilons of 0.0f. A small epsilon like 1e-6 works well too
memset(&Epsilons, 0, sizeof(D3DXWELDEPSILONS));
if( FAILED( hr = D3DXWeldVertices( pMesh, 0, &Epsilons,
(DWORD*)pAdjacencyBuffer->GetBufferPointer(),
(DWORD*)pAdjacencyBuffer->GetBufferPointer(), NULL, NULL ) ) )
{
m_dwNumMaterials = 0;
goto End;
}
// verify validity of mesh for simplification
if( FAILED( hr = D3DXValidMesh( pMesh, (DWORD*)pAdjacencyBuffer->GetBufferPointer(), NULL ) ) )
{
m_dwNumMaterials = 0;
goto End;
}
// Allocate a material/texture arrays
d3dxMaterials = (D3DXMATERIAL*)pD3DXMtrlBuffer->GetBufferPointer();
m_mtrlMeshMaterials = new D3DMATERIAL9[m_dwNumMaterials];
m_pMeshTextures = new LPDIRECT3DTEXTURE9[m_dwNumMaterials];
// Copy the materials and load the textures
for( i=0; i<m_dwNumMaterials; i++ )
{
m_mtrlMeshMaterials[i] = d3dxMaterials[i].MatD3D;
m_mtrlMeshMaterials[i].Ambient = m_mtrlMeshMaterials[i].Diffuse;
// Find the path to the texture and create that texture
DXUtil_FindMediaFileCb( strMediaPath, sizeof(strMediaPath), d3dxMaterials[i].pTextureFilename );
if( FAILED( D3DXCreateTextureFromFile( m_pd3dDevice, strMediaPath,
&m_pMeshTextures[i] ) ) )
m_pMeshTextures[i] = NULL;
}
pD3DXMtrlBuffer->Release();
pD3DXMtrlBuffer = NULL;
// Lock the vertex buffer, to generate a simple bounding sphere
hr = pMesh->GetVertexBuffer( &pVertexBuffer );
if( FAILED(hr) )
goto End;
hr = pVertexBuffer->Lock( 0, 0, &pVertices, D3DLOCK_NOSYSLOCK );
if( FAILED(hr) )
goto End;
hr = D3DXComputeBoundingSphere( (D3DXVECTOR3*)pVertices, pMesh->GetNumVertices(),
D3DXGetFVFVertexSize(pMesh->GetFVF()),
&m_vObjectCenter, &m_fObjectRadius );
pVertexBuffer->Unlock();
pVertexBuffer->Release();
if( FAILED(hr) || m_dwNumMaterials == 0 )
goto End;
if ( !(pMesh->GetFVF() & D3DFVF_NORMAL) )
{
hr = pMesh->CloneMeshFVF( dw32BitFlag|D3DXMESH_MANAGED, pMesh->GetFVF() | D3DFVF_NORMAL,
m_pd3dDevice, &pTempMesh );
if (FAILED(hr))
goto End;
D3DXComputeNormals( pTempMesh, NULL );
pMesh->Release();
pMesh = pTempMesh;
}
hr = D3DXGeneratePMesh( pMesh, (DWORD*)pAdjacencyBuffer->GetBufferPointer(),
NULL, NULL, 1, D3DXMESHSIMP_VERTEX, &pPMesh);
if( FAILED(hr) )
goto End;
cVerticesMin = pPMesh->GetMinVertices();
cVerticesMax = pPMesh->GetMaxVertices();
cVerticesPerMesh = (cVerticesMax - cVerticesMin) / 10;
m_cPMeshes = max(1, (DWORD)ceil((cVerticesMax - cVerticesMin) / (float)cVerticesPerMesh));
m_pPMeshes = new LPD3DXPMESH[m_cPMeshes];
if (m_pPMeshes == NULL)
{
hr = E_OUTOFMEMORY;
goto End;
}
memset(m_pPMeshes, 0, sizeof(LPD3DXPMESH) * m_cPMeshes);
// clone full size pmesh
hr = pPMesh->ClonePMeshFVF( D3DXMESH_MANAGED | D3DXMESH_VB_SHARE, pPMesh->GetFVF(), m_pd3dDevice, &m_pPMeshFull );
if (FAILED(hr))
goto End;
// clone all the separate pmeshes
for (iPMesh = 0; iPMesh < m_cPMeshes; iPMesh++)
{
hr = pPMesh->ClonePMeshFVF( D3DXMESH_MANAGED | D3DXMESH_VB_SHARE, pPMesh->GetFVF(), m_pd3dDevice, &m_pPMeshes[iPMesh] );
if (FAILED(hr))
goto End;
// trim to appropriate space
hr = m_pPMeshes[iPMesh]->TrimByVertices(cVerticesMin + cVerticesPerMesh * iPMesh, cVerticesMin + cVerticesPerMesh * (iPMesh+1), NULL, NULL);
if (FAILED(hr))
goto End;
hr = m_pPMeshes[iPMesh]->OptimizeBaseLOD(D3DXMESHOPT_VERTEXCACHE, NULL);
if (FAILED(hr))
goto End;
}
// set current to be maximum number of vertices
m_iPMeshCur = m_cPMeshes - 1;
hr = m_pPMeshes[m_iPMeshCur]->SetNumVertices(cVerticesMax);
if (FAILED(hr))
goto End;
hr = m_pPMeshFull->SetNumVertices(cVerticesMax);
if (FAILED(hr))
goto End;
End:
SAFE_RELEASE( pAdjacencyBuffer );
SAFE_RELEASE( pD3DXMtrlBuffer );
SAFE_RELEASE( pMesh );
SAFE_RELEASE( pPMesh );
if (FAILED(hr))
{
for (iPMesh = 0; iPMesh < m_cPMeshes; iPMesh++)
{
SAFE_RELEASE( m_pPMeshes[iPMesh] );
}
delete []m_pPMeshes;
m_cPMeshes = 0;
m_pPMeshes = NULL;
SAFE_RELEASE( m_pPMeshFull )
}
return hr;
}
BOOL initD3dStuff(HWND hWnd) {
void *tempVoid;
LPD3DXBUFFER shipMB;
D3DXMATERIAL *tempMaterials;
int transparency = 127;
CUSTOMVERTEX customVertex1[] = {
// triangle
{0.8f, -0.8f, 0.0f, 0, 0, 1, D3DCOLOR_ARGB(255, 255, 255, 255), 0, 0},
{0.0f, 0.8f, 0.0f, 0, 0, 1, D3DCOLOR_ARGB(255, 255, 255, 255), 1, 0},
{-0.8f, -0.8f, 0.0f, 0, 0, 1, D3DCOLOR_ARGB(255, 255, 255, 255), 1, 1}
};
CUSTOMVERTEX customVertex2[] = {
// side 1
{-3.0f, 3.0f, -3.0f, 0, 0, -1, D3DCOLOR_ARGB(transparency, 255, 255, 255), 0, 0},
{3.0f, 3.0f, -3.0f, 0, 0, -1, D3DCOLOR_ARGB(transparency, 255, 255, 255), 0, 1},
{-3.0f, -3.0f, -3.0f, 0, 0, -1, D3DCOLOR_ARGB(transparency, 255, 255, 255), 1, 0},
{3.0f, -3.0f, -3.0f, 0, 0, -1, D3DCOLOR_ARGB(transparency, 255, 255, 255), 1, 1},
// side 2
{-3.0f, 3.0f, 3.0f, 0, 0, 1, D3DCOLOR_ARGB(transparency, 255, 255, 255), 0, 0},
{-3.0f, -3.0f, 3.0f, 0, 0, 1, D3DCOLOR_ARGB(transparency, 255, 255, 255), 0, 1},
{3.0f, 3.0f, 3.0f, 0, 0, 1, D3DCOLOR_ARGB(transparency, 255, 255, 255), 1, 0},
{3.0f, -3.0f, 3.0f, 0, 0, 1, D3DCOLOR_ARGB(transparency, 255, 255, 255), 1, 1},
// side 3
{-3.0f, 3.0f, 3.0f, 0, 1, 0, D3DCOLOR_ARGB(transparency, 255, 255, 255), 0, 0},
{3.0f, 3.0f, 3.0f, 0, 1, 0, D3DCOLOR_ARGB(transparency, 255, 255, 255), 0, 1},
{-3.0f, 3.0f, -3.0f, 0, 1, 0, D3DCOLOR_ARGB(transparency, 255, 255, 255), 1, 0},
{3.0f, 3.0f, -3.0f, 0, 1, 0, D3DCOLOR_ARGB(transparency, 255, 255, 255), 1, 1},
// side 4
{-3.0f, -3.0f, 3.0f, 0, -1, 0, D3DCOLOR_ARGB(transparency, 255, 255, 255), 0, 0},
{-3.0f, -3.0f, -3.0f, 0, -1, 0, D3DCOLOR_ARGB(transparency, 255, 255, 255), 0, 1},
{3.0f, -3.0f, 3.0f, 0, -1, 0, D3DCOLOR_ARGB(transparency, 255, 255, 255), 1, 0},
{3.0f, -3.0f, -3.0f, 0, -1, 0, D3DCOLOR_ARGB(transparency, 255, 255, 255), 1, 1},
// side 5
{3.0f, 3.0f, -3.0f, 1, 0, 0, D3DCOLOR_ARGB(transparency, 255, 255, 255), 0, 0},
{3.0f, 3.0f, 3.0f, 1, 0, 0, D3DCOLOR_ARGB(transparency, 255, 255, 255), 0, 1},
{3.0f, -3.0f, -3.0f, 1, 0, 0, D3DCOLOR_ARGB(transparency, 255, 255, 255), 1, 0},
{3.0f, -3.0f, 3.0f, 1, 0, 0, D3DCOLOR_ARGB(transparency, 255, 255, 255), 1, 1},
// side 6
// I inverted the texture coords to get my image right
{-3.0f, 3.0f, -3.0f, -1, 0, 0, D3DCOLOR_ARGB(transparency, 255, 255, 255), 0, 0},
{-3.0f, -3.0f, -3.0f, -1, 0, 0, D3DCOLOR_ARGB(transparency, 255, 255, 255), 0, 1},
{-3.0f, 3.0f, 3.0f, -1, 0, 0, D3DCOLOR_ARGB(transparency, 255, 255, 255), 1, 0},
{-3.0f, -3.0f, 3.0f, -1, 0, 0, D3DCOLOR_ARGB(transparency, 255, 255, 255), 1, 1}
};
// predefined simple D3DX mesh objects
D3DXCreateBox(d3d9dev, 7.0f, 3.0f, 3.0f, &mesh1, NULL);
D3DXCreateSphere(d3d9dev, 0.3f, 20, 10, &mesh2, NULL);
// one complete mesh loading (vertices, materials and textures)
if (D3DXLoadMeshFromXResource(NULL, (LPCSTR)MAKEINTRESOURCE(IDR_MESHX1), "meshx", D3DXMESH_MANAGED, d3d9dev, NULL, &shipMB, NULL, &numMaterials, &mesh3) != D3D_OK) {
MessageBox(hWnd, "craft.x could not be loaded", "Error", MB_ICONERROR);
PostQuitMessage(0);
return FALSE;
}
/* load from file
if (D3DXLoadMeshFromX("craft.x", D3DXMESH_MANAGED, d3d9dev, NULL, &shipMB, NULL, &numMaterials, &mesh3) != D3D_OK) {
MessageBox(hWnd, "craft.x file not found", "Error", MB_ICONERROR);
PostQuitMessage(0);
}
*/
tempMaterials = (D3DXMATERIAL *)shipMB->GetBufferPointer();
materialX = new D3DMATERIAL9[numMaterials];
planeTexture = new LPDIRECT3DTEXTURE9[numMaterials];
for (DWORD i = 0; i < numMaterials; i++) {
materialX[i] = tempMaterials[i].MatD3D;
materialX[i].Ambient = materialX[i].Diffuse;
/* dont need the following cause I use resources
USES_CONVERSION; // allows certain string conversions
// if there is a texture to load, load it
if(FAILED(D3DXCreateTextureFromFile(d3d9dev, CA2W(tempMaterials[i].pTextureFilename), &planeTexture[i])))
*/ planeTexture[i] = NULL; // if there is no texture, set the texture to NULL
}
// load the textures (embedded in the executable) we will use
if (D3DXCreateTextureFromResource(d3d9dev, NULL, (LPCSTR)MAKEINTRESOURCE(IDB_BITMAP1), &planeTexture[2]) != D3D_OK) {
MessageBox(hWnd, "wings.bmp could not be loaded", "Error", MB_ICONERROR);
PostQuitMessage(0);
return FALSE;
}
if (D3DXCreateTextureFromResource(d3d9dev, NULL, (LPCSTR)MAKEINTRESOURCE(IDB_BITMAP2), &planeTexture[6]) != D3D_OK) {
MessageBox(hWnd, "bihull.bmp could not be loaded", "Error", MB_ICONERROR);
PostQuitMessage(0);
return FALSE;
}
planeTexture[0] = planeTexture[1] = planeTexture[3] = planeTexture[4] = planeTexture[6];
if (D3DXCreateTextureFromResourceEx(d3d9dev, // the device pointer
NULL, // module (executable containing the resource)
(LPCSTR)MAKEINTRESOURCE(IDB_BITMAP3), // resource
//"logo1.bmp", // the file name
D3DX_DEFAULT, // default width
D3DX_DEFAULT, // default height
D3DX_DEFAULT, // no mip mapping
NULL, // regular usage
D3DFMT_A8R8G8B8, // 32-bit pixels with alpha
D3DPOOL_MANAGED, // typical memory handling
D3DX_DEFAULT, // no filtering
D3DX_DEFAULT, // no mip filtering
D3DCOLOR_ARGB(127, 255, 0, 255), // the hot-pink color key
NULL, // no image info struct
NULL, // not using 256 colors
&texture1) != D3D_OK) {
MessageBox(hWnd, "logo1.bmp could not be loaded", "Error", MB_ICONERROR);
PostQuitMessage(0);
return FALSE;
}
/* if (D3DXCreateTextureFromResource(d3d9dev, NULL, (LPCSTR)MAKEINTRESOURCE(IDB_BITMAP3), &texture1) != D3D_OK) {
MessageBox(hWnd, "logo1.bmp could not be loaded", "Error", MB_ICONERROR);
PostQuitMessage(0);
return FALSE;
}
*/
if (D3DXCreateTextureFromResourceEx(d3d9dev, // the device pointer
NULL, // module (executable containing the resource)
(LPCSTR)MAKEINTRESOURCE(IDR_LOGO2PNG), // resource
//"logo2.png", // the file name
D3DX_DEFAULT, // default width
D3DX_DEFAULT, // default height
D3DX_DEFAULT, // no mip mapping
NULL, // regular usage
D3DFMT_A8R8G8B8, // 32-bit pixels with alpha
D3DPOOL_MANAGED, // typical memory handling
D3DX_DEFAULT, // no filtering
D3DX_DEFAULT, // no mip filtering
D3DCOLOR_ARGB(127, 255, 0, 255), // the hot-pink color key
NULL, // no image info struct
NULL, // not using 256 colors
&texture2) != D3D_OK) {
MessageBox(hWnd, "logo2.png could not be loaded", "Error", MB_ICONERROR);
PostQuitMessage(0);
return FALSE;
}
/*
if (D3DXCreateTextureFromResource(d3d9dev, NULL, (LPCSTR)MAKEINTRESOURCE(IDR_LOGO2PNG), &texture2) != D3D_OK) {
MessageBox(hWnd, "logo2.png could not be loaded", "Error", MB_ICONERROR);
PostQuitMessage(0);
return FALSE;
}
*/
if (D3DXCreateTextureFromResourceEx(d3d9dev, // the device pointer
NULL, // module (executable containing the resource)
(LPCSTR)MAKEINTRESOURCE(IDR_LOGO3PNG), // resource
//"logo3.png", // the file name
D3DX_DEFAULT, // default width
D3DX_DEFAULT, // default height
D3DX_DEFAULT, // no mip mapping
NULL, // regular usage
D3DFMT_A8R8G8B8, // 32-bit pixels with alpha
D3DPOOL_MANAGED, // typical memory handling
D3DX_DEFAULT, // no filtering
D3DX_DEFAULT, // no mip filtering
D3DCOLOR_ARGB(127, 255, 0, 255), // the hot-pink color key
NULL, // no image info struct
NULL, // not using 256 colors
&texture3) != D3D_OK) {
MessageBox(hWnd, "logo3.png could not be loaded", "Error", MB_ICONERROR);
PostQuitMessage(0);
return FALSE;
}
/* if (D3DXCreateTextureFromResource(d3d9dev, NULL, (LPCSTR)MAKEINTRESOURCE(IDR_LOGO3PNG), &texture3) != D3D_OK) {
MessageBox(hWnd, "logo3.png could not be loaded", "Error", MB_ICONERROR);
PostQuitMessage(0);
return FALSE;
}
*/
// sprite
D3DXCreateSprite(d3d9dev, &sprite);
// sprite texture
if (D3DXCreateTextureFromResourceEx(d3d9dev, // the device pointer
NULL, // module (executable containing the resource)
(LPCSTR)MAKEINTRESOURCE(IDR_LEGENDPNG), // resource
//"legend.png", // the file name
D3DX_DEFAULT, // default width
D3DX_DEFAULT, // default height
D3DX_DEFAULT, // no mip mapping
NULL, // regular usage
D3DFMT_A8R8G8B8, // 32-bit pixels with alpha
D3DPOOL_MANAGED, // typical memory handling
D3DX_DEFAULT, // no filtering
D3DX_DEFAULT, // no mip filtering
D3DCOLOR_XRGB(255, 0, 255), // the hot-pink color key
NULL, // no image info struct
NULL, // not using 256 colors
&legendTexture) != D3D_OK) {
MessageBox(hWnd, "legend.png could not be loaded", "Error", MB_ICONERROR);
PostQuitMessage(0);
return FALSE;
}
// sprite legend
D3DXCreateSprite(d3d9dev, &legendSprite);
// its texture
if (D3DXCreateTextureFromResourceEx(d3d9dev, // the device pointer
NULL,
(LPCSTR)MAKEINTRESOURCE(IDR_SPRITEPNG),
//"sprite.png", // the file name
D3DX_DEFAULT, // default width
D3DX_DEFAULT, // default height
D3DX_DEFAULT, // no mip mapping
NULL, // regular usage
D3DFMT_A8R8G8B8, // 32-bit pixels with alpha
D3DPOOL_MANAGED, // typical memory handling
D3DX_DEFAULT, // no filtering
D3DX_DEFAULT, // no mip filtering
D3DCOLOR_XRGB(255, 0, 255), // the hot-pink color key
NULL, // no image info struct
NULL, // not using 256 colors
&spriteTexture) != D3D_OK) {
MessageBox(hWnd, "panel.png could not be loaded", "Error", MB_ICONERROR);
PostQuitMessage(0);
return FALSE;
}
// triangle
d3d9dev->CreateVertexBuffer(3*sizeof(CUSTOMVERTEX), 0, CUSTOMFVF, D3DPOOL_MANAGED, &d3d9VertexBuffer1, NULL);
d3d9VertexBuffer1->Lock(0, 0, &tempVoid, 0);
if (memcpy(tempVoid, customVertex1, sizeof(customVertex1)) == NULL) MessageBox(NULL, "Error", "error", MB_OK);
d3d9VertexBuffer1->Unlock();
// cube
d3d9dev->CreateVertexBuffer(24*sizeof(CUSTOMVERTEX), 0, CUSTOMFVF, D3DPOOL_MANAGED, &d3d9VertexBuffer2, NULL);
d3d9VertexBuffer2->Lock(0, 0, &tempVoid, 0);
memcpy(tempVoid, customVertex2, sizeof(customVertex2));
d3d9VertexBuffer2->Unlock();
return TRUE;
}
//-----------------------------------【Object_Init( )函数】--------------------------------------
// 描述：渲染资源初始化函数，在此函数中进行要被渲染的物体的资源的初始化
//--------------------------------------------------------------------------------------------------
HRESULT Objects_Init(HWND hwnd)
{
//创建字体
if(FAILED(D3DXCreateFont(g_pd3dDevice, 36, 0, 0, 1000, false, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, 0, _T("Calibri"), &g_pTextFPS)))
return E_FAIL;
if (FAILED(D3DXCreateFont(g_pd3dDevice, 20, 0, 1000, 0, false, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, 0, _T("华文中宋"), &g_pTextAdaperName)))
return E_FAIL;
if (FAILED(D3DXCreateFont(g_pd3dDevice, 23, 0, 1000, 0, false, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, 0, _T("微软雅黑"), &g_pTextHelper)))
return E_FAIL;
if (FAILED(D3DXCreateFont(g_pd3dDevice, 26, 0, 1000, 0, false, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, 0, _T("黑体"), &g_pTextInfo)))
return E_FAIL;
LPD3DXBUFFER pAdjBuffer = NULL;
LPD3DXBUFFER pMtrlBuffer = NULL;
if (FAILED(D3DXLoadMeshFromX(L"Warden.X", D3DXMESH_MANAGED, g_pd3dDevice, &pAdjBuffer, &pMtrlBuffer, NULL, &g_dwNumMtrls, &g_pMesh)))
//if (FAILED(D3DXLoadMeshFromX(L"miki.X", D3DXMESH_MANAGED, g_pd3dDevice, &pAdjBuffer, &pMtrlBuffer, NULL, &g_dwNumMtrls, &g_pMesh)))
//if (FAILED(D3DXLoadMeshFromX(L"65.X", D3DXMESH_MANAGED, g_pd3dDevice, &pAdjBuffer, &pMtrlBuffer, NULL, &g_dwNumMtrls, &g_pMesh)))
return E_FAIL;
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_pMaterials[i].Diffuse.a = 0.3f;
g_pTextures[i] = NULL;
//D3DXCreateTextureFromFileA(g_pd3dDevice, pMtrls[i].pTextureFilename, &g_pTextures[i]);
}
SAFE_RELEASE(pAdjBuffer);
SAFE_RELEASE(pMtrlBuffer);
D3DLIGHT9 light;
ZeroMemory(&light, sizeof(light));
light.Type = D3DLIGHT_DIRECTIONAL;
light.Ambient = D3DXCOLOR(0.5f, 0.5f, 0.5f, 1.0f);
light.Diffuse = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
light.Specular = D3DXCOLOR(0.0f, 0.0f, 0.0f, 1.0f);
light.Direction = D3DXVECTOR3(1.0f, 0.0f, 1.0f);
g_pd3dDevice->SetLight(0, &light);
g_pd3dDevice->LightEnable(0, true);
g_pd3dDevice->SetRenderState(D3DRS_NORMALIZENORMALS, true);
g_pd3dDevice->SetRenderState(D3DRS_SPECULARENABLE, true);
g_pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
g_pd3dDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESS);
g_pd3dDevice->SetRenderState(D3DRS_ZWRITEENABLE, true);
g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
g_pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
g_pd3dDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
g_pd3dDevice->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
Matrix_Set();
return S_OK;
}
bool CD3D9HLSLMaterialRenderer::createHLSLPixelShader(const char* pixelShaderProgram,
const char* shaderEntryPointName,
const char* shaderTargetName)
{
if (!pixelShaderProgram)
return true;
LPD3DXBUFFER buffer = 0;
LPD3DXBUFFER errors = 0;
DWORD flags = 0;
#ifdef D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY
if (Driver->queryFeature(video::EVDF_VERTEX_SHADER_2_0) || Driver->queryFeature(video::EVDF_VERTEX_SHADER_3_0))
// this one's for newer DX SDKs which don't support ps_1_x anymore
// instead they'll silently compile 1_x as 2_x when using this flag
flags |= D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY;
#endif
#if defined(_IRR_D3D_USE_LEGACY_HLSL_COMPILER) && defined(D3DXSHADER_USE_LEGACY_D3DX9_31_DLL)
#ifdef D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY
else
#endif
flags |= D3DXSHADER_USE_LEGACY_D3DX9_31_DLL;
#endif
#ifdef _IRR_D3D_NO_SHADER_DEBUGGING
// compile without debug info
HRESULT h = stubD3DXCompileShader(
pixelShaderProgram,
strlen(pixelShaderProgram),
0, // macros
0, // no includes
shaderEntryPointName,
shaderTargetName,
flags,
&buffer,
&errors,
&PSConstantsTable);
#else
// compile shader and emitt some debug informations to
// make it possible to debug the shader in visual studio
static int irr_dbg_hlsl_file_nr = 0;
++irr_dbg_hlsl_file_nr;
char tmp[32];
sprintf(tmp, "irr_d3d9_dbg_hlsl_%d.psh", irr_dbg_hlsl_file_nr);
FILE* f = fopen(tmp, "wb");
fwrite(pixelShaderProgram, strlen(pixelShaderProgram), 1, f);
fflush(f);
fclose(f);
HRESULT h = stubD3DXCompileShaderFromFile(
tmp,
0, // macros
0, // no includes
shaderEntryPointName,
shaderTargetName,
flags | D3DXSHADER_DEBUG | D3DXSHADER_SKIPOPTIMIZATION,
&buffer,
&errors,
&PSConstantsTable);
#endif
if (FAILED(h))
{
os::Printer::log("HLSL pixel shader compilation failed:", ELL_ERROR);
if (errors)
{
os::Printer::log((c8*)errors->GetBufferPointer(), ELL_ERROR);
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.", ELL_ERROR);
buffer->Release();
return false;
}
buffer->Release();
return true;
}
return false;
}
bool InitVertexShader()
{
#if DIRECTX_VERSION == 8
// shader decl
DWORD decl[] =
{
D3DVSD_STREAM(0),
D3DVSD_REG(0, D3DVSDT_FLOAT3 ), // D3DVSDE_POSITION
D3DVSD_REG(1, D3DVSDT_FLOAT3 ), // D3DVSDE_NORMAL
D3DVSD_REG(2, D3DVSDT_D3DCOLOR ), // D3DVSDE_DIFFUSE
D3DVSD_REG(3, D3DVSDT_FLOAT2 ), // D3DVSDE_TEXCOORD0
D3DVSD_END()
};
#else
D3DVERTEXELEMENT9 decl[] =
{
{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
{ 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0 },
{ 0, 24, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0 },
{ 0, 28, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
D3DDECL_END()
};
#endif
LPD3DXBUFFER pCode;
LPD3DXBUFFER ppCompilationErrors;
HRESULT res;
#ifdef _DEBUG
#if DIRECTX_VERSION == 8
LPD3DXBUFFER ppConstants;
res = D3DXAssembleShaderFromFile("shader.vsh", D3DXASM_DEBUG, &ppConstants, &pCode, &ppCompilationErrors);
#else
res = D3DXAssembleShaderFromFileA("D:\\n64developing\\RiceVideo\\shaderdx9.vsh", NULL, NULL, D3DXSHADER_DEBUG, &pCode, &ppCompilationErrors);
//res = D3DXAssembleShaderFromFileA("D:\\n64developing\\RiceVideo\\shaderdx9-2.vsh", NULL, NULL, D3DXSHADER_DEBUG, &pCode, &ppCompilationErrors);
#endif
#else
#if DIRECTX_VERSION == 8
LPD3DXBUFFER ppConstants;
res = D3DXAssembleShader(shaderstr, strlen(shaderstr), 0, &ppConstants, &pCode, &ppCompilationErrors);
#else
res = D3DXAssembleShader(shaderstr2, strlen(shaderstr2), NULL, NULL, D3DXSHADER_DEBUG, &pCode, &ppCompilationErrors);
#endif
#endif
if( CDXGraphicsContext::IsResultGood(res,true) )
{
#if DIRECTX_VERSION == 8
res = g_pD3DDev->CreateVertexShader( decl, (DWORD*)pCode->GetBufferPointer(), &gVertexShader, 0 );
#else
res = g_pD3DDev->CreateVertexShader( (DWORD*)pCode->GetBufferPointer(), &gVertexShader );
//FILE *fp = fopen("D:\\n64developing\\RiceVideo\\shaderdx9.vso","rb");
//BYTE buf[4000];
//int num = fread(buf, 1, 4000, fp);
//res = g_pD3DDev->CreateVertexShader( (DWORD*)buf, &gVertexShader );
//fclose(fp);
#endif
pCode->Release();
if( !CDXGraphicsContext::IsResultGood(res,true) )
return false;
res = g_pD3DDev->SetVertexShader( gVertexShader );
InitVertexShaderConstants();
return true;
}
else
{
if( ppCompilationErrors )
{
char* str = (char*)(ppCompilationErrors->GetBufferPointer());
TRACE0(str);
}
return false;
}
}
bool CD3D9HLSLMaterialRenderer::createHLSLVertexShader(const char* vertexShaderProgram,
const char* shaderEntryPointName,
const char* shaderTargetName)
{
if (!vertexShaderProgram)
return true;
LPD3DXBUFFER buffer = 0;
LPD3DXBUFFER errors = 0;
#ifdef _IRR_D3D_NO_SHADER_DEBUGGING
// compile without debug info
HRESULT h = stubD3DXCompileShader(
vertexShaderProgram,
strlen(vertexShaderProgram),
0, // macros
0, // no includes
shaderEntryPointName,
shaderTargetName,
0, // no flags
&buffer,
&errors,
&VSConstantsTable);
#else
// compile shader and emitt some debug informations to
// make it possible to debug the shader in visual studio
static int irr_dbg_hlsl_file_nr = 0;
++irr_dbg_hlsl_file_nr;
char tmp[32];
sprintf(tmp, "irr_d3d9_dbg_hlsl_%d.vsh", irr_dbg_hlsl_file_nr);
FILE* f = fopen(tmp, "wb");
fwrite(vertexShaderProgram, strlen(vertexShaderProgram), 1, f);
fflush(f);
fclose(f);
HRESULT h = stubD3DXCompileShaderFromFile(
tmp,
0, // macros
0, // no includes
shaderEntryPointName,
shaderTargetName,
D3DXSHADER_DEBUG | D3DXSHADER_SKIPOPTIMIZATION,
&buffer,
&errors,
&VSConstantsTable);
#endif
if (FAILED(h))
{
os::Printer::log("HLSL vertex shader compilation failed:", ELL_ERROR);
if (errors)
{
os::Printer::log((c8*)errors->GetBufferPointer(), ELL_ERROR);
errors->Release();
if (buffer)
buffer->Release();
}
return false;
}
if (errors)
errors->Release();
if (buffer)
{
if (FAILED(pID3DDevice->CreateVertexShader((DWORD*)buffer->GetBufferPointer(),
&VertexShader)))
{
os::Printer::log("Could not create hlsl vertex shader.", ELL_ERROR);
buffer->Release();
return false;
}
buffer->Release();
return true;
}
return false;
}
bool CDx9FragmentProgram::bind(void)
{
if(!m_isLoad)
{
LPD3DXBUFFER errors;
LPD3DXBUFFER pBuffer;
DWORD dwShaderFlags = D3DXSHADER_PACKMATRIX_ROWMAJOR | D3DXSHADER_PREFER_FLOW_CONTROL;
#if defined( DEBUG ) || defined( _DEBUG )
dwShaderFlags |= D3DXSHADER_DEBUG;
#endif
HRESULT hr = D3DXCompileShader(
m_cCode.c_str(),
static_cast<uint>(m_cCode.size()),
NULL,
DX9_ShaderInclude::GetInst(),
m_sMain.c_str(),
"ps_2_0",
dwShaderFlags,
&pBuffer,
&errors,
&m_pConstTable);
if (FAILED(hr))
{
hr = D3DXCompileShader(
m_cCode.c_str(),
static_cast<uint>(m_cCode.size()),
NULL,
DX9_ShaderInclude::GetInst(),
m_sMain.c_str(),
"ps_3_0",
dwShaderFlags,
&pBuffer,
&errors,
&m_pConstTable);
if (FAILED(hr))
{
string message = "D3D9 Pixel Shader创建不成功 Errors:\n";
message.append(static_cast<const char*>(errors->GetBufferPointer()));
errors->Release();
OutputDebugString(message.c_str());
LogErr(GraphicErr::GetErrTypeStr(ShaderInit_Err),message);
return false;
}
}
SafeRelease(errors);
hr = m_pD3DDevice->CreatePixelShader((DWORD*)pBuffer->GetBufferPointer(),&m_pPixelShader);
SafeRelease(pBuffer);
if ( SUCCEEDED(hr))
{
m_Params.Create(m_pConstTable);
m_isLoad = true;
m_isNeedUpdateParameters = true;
}
else
{
stringstream ss;
ss << "CreatePixelShader失败: " << DXGetErrorDescription(hr);
LogErr(GraphicErr::GetErrTypeStr(ShaderInit_Err), ss.str());
return false;
}
}
if(!m_isActive)
{
m_isActive = true;
return SUCCEEDED(m_pD3DDevice->SetPixelShader(m_pPixelShader));
}
return true;
}
//--------------------------------------------------------------------------------------
// This callback function will be called immediately after the Direct3D device has been
// created, which will happen during application initialization and windowed/full screen
// toggles. This is the best location to create D3DPOOL_MANAGED resources since these
// resources need to be reloaded whenever the device is destroyed. Resources created
// here should be released in the OnDestroyDevice callback.
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnCreateDevice(IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext)
{
#ifdef _PERFORMANCE
::SetThreadAffinityMask(::GetCurrentThread(), 1);
PerfManager::createTheOne();
grp::setProfiler(PerfManager::getTheOne());
#endif
HRESULT hr;
V_RETURN(g_DialogResourceManager.OnD3D9CreateDevice(pd3dDevice));
// Initialize the font
V_RETURN(D3DXCreateFont(pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE,
L"Arial", &g_pFont));
// Define DEBUG_VS and/or DEBUG_PS to debug vertex and/or pixel shaders with the
// shader debugger. Debugging vertex shaders requires either REF or software vertex
// processing, and debugging pixel shaders requires REF. The
// D3DXSHADER_FORCE_*_SOFTWARE_NOOPT flag improves the debug experience in the
// shader debugger. It enables source level debugging, prevents instruction
// reordering, prevents dead code elimination, and forces the compiler to compile
// against the next higher available software target, which ensures that the
// unoptimized shaders do not exceed the shader model limitations. Setting these
// flags will cause slower rendering since the shaders will be unoptimized and
// forced into software. See the DirectX documentation for more information about
// using the shader debugger.
DWORD dwShaderFlags = D3DXFX_NOT_CLONEABLE;
#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_FORCE_VS_SOFTWARE_NOOPT;
#endif
#ifdef DEBUG_PS
dwShaderFlags |= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT;
#endif
// Read the D3DX effect file
WCHAR str[MAX_PATH];
V_RETURN(DXUTFindDXSDKMediaFileCch(str, MAX_PATH, L"Test/Demo.fx"));
// If this fails, there should be debug output as to
// why the .fx file failed to compile
LPD3DXBUFFER pError = NULL;
D3DXCreateEffectFromFile(pd3dDevice, str, NULL, NULL, dwShaderFlags, NULL, &g_pEffect, &pError);
if (NULL != pError)
{
char* szErr = (char*)(pError->GetBufferPointer());
assert(false);
}
V(g_pEffect->SetFloat("g_fAmbient", g_fAmbient));
V(g_pEffect->SetFloat("g_fDiffuse", g_fDiffuse));
// Setup the camera's view parameters
g_camera.setControlMode(DemoCamera::THIRD_PERSON);
g_camera.setViewDistance(3.0f);
g_camera.setYaw(3.1415926f);
//g_camera.setRoll(3.14159f/4);
#if (DEMO_RIGHT_HAND_COORD)
g_camera.setViewParams(grp::Vector3(-2.0f, -2.0f, 1.0f),
grp::Vector3(0.0f, 0.0f, 1.0f),
grp::Vector3(0.0f, 0.0f, 1.0f));
g_camera.setCoordinateSystem(DemoCamera::RIGHT_HAND);
g_camera.setUpAxis(DemoCamera::Z_UP);
#else
g_camera.setViewParams(grp::Vector3(-2.0f, 1.0f, -2.0f),
grp::Vector3(0.0f, 1.0f, 0.0f),
grp::Vector3(0.0f, 1.0f, 0.0f));
#endif
// Setup the camera's projection parameters
float fAspectRatio = pBackBufferSurfaceDesc->Width / (FLOAT)pBackBufferSurfaceDesc->Height;
g_camera.setPerspectiveParams(D3DX_PI/4, fAspectRatio, 0.001f, 200.0f);
g_fileLoader = new MultithreadFileLoader(pd3dDevice);
g_fileLoader->enableMultithread(false);
g_resourceManager = new MultithreadResManager(g_fileLoader);
grp::initialize(NULL, g_fileLoader, NULL, g_resourceManager);
g_character = new DemoCharacter(L"Test/warrior.gmd", pd3dDevice);
//g_character->setGpuSkinning(true);
g_model = g_character->getModel();
if (g_model == NULL)
{
return E_FAIL;
}
//g_model->enableMeshLod(true);
//g_model->enableWeightLod(true);
//g_model->enableSkeletonLod(true);
//g_model->setLodTolerance(0.1f);
#if (DEMO_RIGHT_HAND_COORD)
grp::Matrix coordTransform(grp::Matrix::IDENTITY);
#else
grp::Matrix coordTransform(grp::Matrix::ZERO);
coordTransform._11 = 1.0f;
coordTransform._23 = 1.0f;
coordTransform._32 = 1.0f;
coordTransform._44 = 1.0f;
#endif
g_model->setTransform(coordTransform);// * translateMatrix);
g_model->playAnimation(L"fight", grp::ANIMATION_LOOP, 0, 0);
g_model->playAnimation(L"walk", grp::ANIMATION_LOOP, 0, 0);
g_model->playAnimation(L"run", grp::ANIMATION_LOOP, 0, 0);
setAnimationWeight();
return S_OK;
}
bool ObjectInit(HINSTANCE hInstance)
{
/**
* No need to be so annoying, just make a CObserver class, and that's all.
* */
//if (!CameraInit())
//{
// return false;
//}
//AddToUpdate(OnCameraUpdate);
//if (!MouseInit())
//{
// return false;
//}
//AddToUpdate(OnMouseUpdate);
//if (!KeyBoardInit())
//{
// return false;
//}
//AddToUpdate(OnKeyBoardUpdate);
//if (!AudioInit())
//{
// return false;
//}
//AddToUpdate(OnAudioUpdate);
gEnv.m_pObserver = new CObserver();
gEnv.m_pCamera = new GD::CCamera<float>();
gEnv.m_pCamera->LookAtLH(GD::CVector3<float>(0.0f, 0.0f, -50.0f), GD::CVector3<float>(0.0f, 0.0f, 0.0f), GD::CVector3<float>(0.0f, 1.0f, 0.0f));
gEnv.m_pDInput = new GD::CDXInput(gEnv.m_pWindow->GetHwnd());
gEnv.m_pDInput->Init(hInstance);
gEnv.m_pMouse = new GD::CMouse();
gEnv.m_pKeyBoard = new GD::CKeyBoard();
gEnv.m_pObserver->m_pCamera = gEnv.m_pCamera;
gEnv.m_pObserver->m_pKeyBoard = gEnv.m_pKeyBoard;
gEnv.m_pObserver->m_pMouse = gEnv.m_pMouse;
if (FAILED(D3DXCreateFont(gEnv.m_pDXDevice->GetD3DDevice(), 20, 0, 0, 0, 0, 0, 0, 0, 0, _T("楷体"), &gPFont)))
{
return false;
}
PlaySound(_T("日笠陽子 - 美しき残酷な世界.wav"), nullptr, SND_LOOP | SND_FILENAME | SND_ASYNC);
D3DXCreateTeapot(gEnv.m_pDXDevice->GetD3DDevice(), &gPTeapot, 0);
gTeapotMtrl.Diffuse = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
gTeapotMtrl.Ambient = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
gTeapotMtrl.Emissive = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
gTeapotMtrl.Specular = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
gTeapotMtrl.Power = 2.0f;
/**
* Load mesh from X file
* */
LPD3DXBUFFER pAdjaBuffer = nullptr;
LPD3DXBUFFER pMtrlBuffer = nullptr;
DWORD numMtrl = 0;
D3DXLoadMeshFromX(L"bigship1.x",
D3DXMESH_MANAGED,
gEnv.m_pDXDevice->GetD3DDevice(),
&pAdjaBuffer,
&pMtrlBuffer,
0,
&numMtrl,
&gPAirplane);
D3DXMATERIAL* pMtrl = (D3DXMATERIAL*)pMtrlBuffer->GetBufferPointer();
for (DWORD i = 0; i < numMtrl; i++)
{
pMtrl[i].MatD3D.Ambient = pMtrl[i].MatD3D.Diffuse;
gAirplaneMtrl.push_back(pMtrl[i].MatD3D);
LPDIRECT3DTEXTURE9 pTex = nullptr;
D3DXCreateTextureFromFileA(gEnv.m_pDXDevice->GetD3DDevice(),
pMtrl[i].pTextureFilename,
&pTex
);
gPAirplaneTex.push_back(pTex);
}
/**
* Then create PMesh from mesh.
* */
D3DXGeneratePMesh(gPAirplane,
(DWORD*)pAdjaBuffer->GetBufferPointer(),
0,
0,
1,
D3DXMESHSIMP_FACE,
&gPPAirplane);
DWORD maxFaces = gPPAirplane->GetMaxFaces();
gPPAirplane->SetNumFaces(maxFaces);
D3DLIGHT9 dir;
::ZeroMemory(&dir, sizeof(dir));
dir.Type = D3DLIGHT_DIRECTIONAL;
dir.Diffuse = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
dir.Specular = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f)* 0.2f;
dir.Ambient = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f) * 0.6f;
dir.Direction = D3DXVECTOR3(0.707f, 0.0f, 0.707f);
gEnv.m_pDXDevice->GetD3DDevice()->SetLight(0, &dir);
gEnv.m_pDXDevice->GetD3DDevice()->LightEnable(0, true);
gEnv.m_pDXDevice->GetD3DDevice()->SetRenderState(D3DRS_NORMALIZENORMALS, true);
gEnv.m_pDXDevice->GetD3DDevice()->SetRenderState(D3DRS_SPECULARENABLE, true);
/**
* Set filter mode
* */
gEnv.m_pDXDevice->GetD3DDevice()->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
gEnv.m_pDXDevice->GetD3DDevice()->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
/**
* Set mipmap mode
* */
gEnv.m_pDXDevice->GetD3DDevice()->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);
//
// Set alpha blending states.
//
// use alpha in material's diffuse component for alpha
//gEnv.m_pDXDevice->GetD3DDevice()->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
//gEnv.m_pDXDevice->GetD3DDevice()->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
//// set blending factors so that alpha component determines transparency
gEnv.m_pDXDevice->GetD3DDevice()->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_DESTCOLOR);
gEnv.m_pDXDevice->GetD3DDevice()->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVDESTCOLOR);
return true;
}
bool CDirect3D::SetShaderHLSL(const TCHAR *file)
{
//MUDLORD: the guts
//Compiles a shader from files on disc
//Sets LUT textures to texture files in PNG format.
TCHAR folder[MAX_PATH];
TCHAR rubyLUTfileName[MAX_PATH];
TCHAR *slash;
char *shaderText = NULL;
TCHAR errorMsg[MAX_PATH + 50];
IXMLDOMDocument * pXMLDoc = NULL;
IXMLDOMElement * pXDE = NULL;
IXMLDOMNode * pXDN = NULL;
BSTR queryString, nodeContent;
HRESULT hr;
shaderTimer = 1.0f;
shaderTimeStart = 0;
shaderTimeElapsed = 0;
if(effect) {
effect->Release();
effect = NULL;
}
for(int i = 0; i < MAX_SHADER_TEXTURES; i++) {
if (rubyLUT[i] != NULL) {
rubyLUT[i]->Release();
rubyLUT[i] = NULL;
}
}
if (file == NULL || *file==TEXT('\0'))
return true;
hr = CoCreateInstance(CLSID_DOMDocument,NULL,CLSCTX_INPROC_SERVER,IID_PPV_ARGS(&pXMLDoc));
if(FAILED(hr)) {
MessageBox(NULL, TEXT("Error creating XML Parser"), TEXT("Shader Loading Error"),
MB_OK|MB_ICONEXCLAMATION);
return false;
}
VARIANT fileName;
VARIANT_BOOL ret;
fileName.vt = VT_BSTR;
#ifdef UNICODE
fileName.bstrVal = SysAllocString(file);
#else
wchar_t tempfilename[MAX_PATH];
MultiByteToWideChar(CP_UTF8,0,file,-1,tempfilename,MAX_PATH);
fileName.bstrVal = SysAllocString(tempfilename);
#endif
hr = pXMLDoc->load(fileName,&ret);
SysFreeString(fileName.bstrVal);
if(FAILED(hr) || hr==S_FALSE) {
_stprintf(errorMsg,TEXT("Error loading HLSL shader file:\n%s"),file);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
pXMLDoc->Release();
return false;
}
VARIANT attributeValue;
BSTR attributeName;
hr = pXMLDoc->get_documentElement(&pXDE);
if(FAILED(hr) || hr==S_FALSE) {
_stprintf(errorMsg,TEXT("Error loading root element from file:\n%s"),file);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
pXMLDoc->Release();
return false;
}
attributeName=SysAllocString(L"language");
pXDE->getAttribute(attributeName,&attributeValue);
SysFreeString(attributeName);
pXDE->Release();
if(attributeValue.vt!=VT_BSTR || lstrcmpiW(attributeValue.bstrVal,L"hlsl")) {
_stprintf(errorMsg,TEXT("Shader language is <%s>, expected <HLSL> in file:\n%s"),attributeValue.bstrVal,file);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
if(attributeValue.vt==VT_BSTR) SysFreeString(attributeValue.bstrVal);
pXMLDoc->Release();
return false;
}
if(attributeValue.vt==VT_BSTR) SysFreeString(attributeValue.bstrVal);
queryString=SysAllocString(L"/shader/source");
hr = pXMLDoc->selectSingleNode(queryString,&pXDN);
SysFreeString(queryString);
if(hr == S_OK) {
hr = pXDN->get_text(&nodeContent);
if(hr == S_OK) {
int requiredChars = WideCharToMultiByte(CP_ACP,0,nodeContent,-1,shaderText,0,NULL,NULL);
shaderText = new char[requiredChars];
WideCharToMultiByte(CP_UTF8,0,nodeContent,-1,shaderText,requiredChars,NULL,NULL);
}
SysFreeString(nodeContent);
pXDN->Release();
pXDN = NULL;
}
pXMLDoc->Release();
if(!shaderText) {
_stprintf(errorMsg,TEXT("No HLSL shader program in file:\n%s"),file);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"),
MB_OK|MB_ICONEXCLAMATION);
return false;
}
LPD3DXBUFFER pBufferErrors = NULL;
hr = D3DXCreateEffect( pDevice,shaderText,strlen(shaderText),NULL, NULL,
D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY, NULL, &effect,
&pBufferErrors );
delete[] shaderText;
if( FAILED(hr) ) {
_stprintf(errorMsg,TEXT("Error parsing HLSL shader file:\n%s"),file);
MessageBox(NULL, errorMsg, TEXT("Shader Loading Error"), MB_OK|MB_ICONEXCLAMATION);
if(pBufferErrors) {
LPVOID pCompilErrors = pBufferErrors->GetBufferPointer();
MessageBox(NULL, (const TCHAR*)pCompilErrors, TEXT("FX Compile Error"),
MB_OK|MB_ICONEXCLAMATION);
}
return false;
}
lstrcpy(folder,file);
slash = _tcsrchr(folder,TEXT('\\'));
if(slash)
*(slash+1)=TEXT('\0');
else
*folder=TEXT('\0');
SetCurrentDirectory(S9xGetDirectoryT(DEFAULT_DIR));
for(int i = 0; i < MAX_SHADER_TEXTURES; i++) {
_stprintf(rubyLUTfileName, TEXT("%srubyLUT%d.png"), folder, i);
hr = D3DXCreateTextureFromFile(pDevice,rubyLUTfileName,&rubyLUT[i]);
if FAILED(hr){
rubyLUT[i] = NULL;
}
}
D3DXHANDLE hTech;
effect->FindNextValidTechnique(NULL,&hTech);
effect->SetTechnique( hTech );
shader_type = D3D_SHADER_HLSL;
return true;
}
bool CAXModel::Load(const char* strFileName)
{
this->Unload();
m_strFile = strFileName;
LPD3DXBUFFER pAdjacencyBuffer = NULL;
LPD3DXBUFFER pMtrlBuffer = NULL;
if (FAILED(D3DXLoadMeshFromXA(m_strFile.c_str(), D3DXMESH_MANAGED, APROJECT_WINDOW->GetD3DDevice(), &pAdjacencyBuffer, &pMtrlBuffer, NULL, &m_dwNumMaterials, &m_pMeshObject)))
return false;
// Optimize the mesh for performance
if (FAILED(m_pMeshObject->OptimizeInplace(D3DXMESHOPT_COMPACT | D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_VERTEXCACHE, (DWORD*)pAdjacencyBuffer->GetBufferPointer(), NULL, NULL, NULL)))
{
SAFE_RELEASE(pAdjacencyBuffer);
SAFE_RELEASE(pMtrlBuffer);
return false;
}
D3DXMATERIAL* d3dxMtrls = (D3DXMATERIAL*)pMtrlBuffer->GetBufferPointer();
do
{
if (d3dxMtrls && m_dwNumMaterials > 0)
{
// Allocate memory for the materials and textures
m_pMaterials = new D3DMATERIAL9[m_dwNumMaterials];
if (m_pMaterials == NULL)
break;
m_pTextures = new LPDIRECT3DBASETEXTURE9[m_dwNumMaterials];
if (m_pTextures == NULL)
break;
m_strMaterials = new CHAR[m_dwNumMaterials][MAX_PATH];
if (m_strMaterials == NULL)
break;
// Copy each material and create its texture
for (DWORD i = 0; i < m_dwNumMaterials; i++)
{
// Copy the material
m_pMaterials[i] = d3dxMtrls[i].MatD3D;
m_pTextures[i] = NULL;
// Create a texture
if (d3dxMtrls[i].pTextureFilename)
{
strcpy_s(m_strMaterials[i], MAX_PATH, d3dxMtrls[i].pTextureFilename);
CHAR strTexture[MAX_PATH];
D3DXIMAGE_INFO ImgInfo;
// First attempt to look for texture in the same folder as the input folder.
int p = 0;
strcpy_s(strTexture, MAX_PATH, m_strFile.c_str());
for (DWORD j = 0; j < strlen(strTexture); j++)
{
if (strTexture[j] == '/')
p = j;
}
strTexture[p + 1] = 0;
strcat_s(strTexture, MAX_PATH, d3dxMtrls[i].pTextureFilename);
// Inspect the texture file to determine the texture type.
if (FAILED(D3DXGetImageInfoFromFileA(strTexture, &ImgInfo)))
continue;
// Call the appropriate loader according to the texture type.
switch (ImgInfo.ResourceType)
{
case D3DRTYPE_TEXTURE:
{
IDirect3DTexture9* pTex;
if (SUCCEEDED(D3DXCreateTextureFromFileA(APROJECT_WINDOW->GetD3DDevice(), strTexture, &pTex)))
{
pTex->QueryInterface(IID_IDirect3DBaseTexture9, (LPVOID*)&m_pTextures[i]);
pTex->Release();
}
break;
}
case D3DRTYPE_CUBETEXTURE:
{
IDirect3DCubeTexture9* pTex;
if (SUCCEEDED(D3DXCreateCubeTextureFromFileA(APROJECT_WINDOW->GetD3DDevice(), strTexture, &pTex)))
{
pTex->QueryInterface(IID_IDirect3DBaseTexture9, (LPVOID*)&m_pTextures[i]);
pTex->Release();
}
break;
}
case D3DRTYPE_VOLUMETEXTURE:
{
IDirect3DVolumeTexture9* pTex;
if (SUCCEEDED(D3DXCreateVolumeTextureFromFileA(APROJECT_WINDOW->GetD3DDevice(), strTexture, &pTex)))
{
pTex->QueryInterface(IID_IDirect3DBaseTexture9, (LPVOID*)&m_pTextures[i]);
pTex->Release();
}
break;
}
}
}
}
}
} while (0);
// Extract data from m_pMesh for easy access
D3DVERTEXELEMENT9 decl[MAX_FVF_DECL_SIZE];
m_dwNumVertices = m_pMeshObject->GetNumVertices();
m_dwNumFaces = m_pMeshObject->GetNumFaces();
m_dwBytesPerVertex = m_pMeshObject->GetNumBytesPerVertex();
m_pMeshObject->GetIndexBuffer(&m_pIB);
m_pMeshObject->GetVertexBuffer(&m_pVB);
m_pMeshObject->GetDeclaration(decl);
APROJECT_WINDOW->GetD3DDevice()->CreateVertexDeclaration(decl, &m_pDecl);
SAFE_RELEASE(pAdjacencyBuffer);
SAFE_RELEASE(pMtrlBuffer);
return true;
}
//--------------------------------------------------------------------------------------------------------------
SPS* CResourceManager::_CreatePS (LPCSTR name)
{
LPSTR N = LPSTR(name);
map_PS::iterator I = m_ps.find (N);
if (I!=m_ps.end()) return I->second;
else
{
SPS* _ps = xr_new<SPS> ();
_ps->dwFlags |= xr_resource_flagged::RF_REGISTERED;
m_ps.insert (mk_pair(_ps->set_name(name),_ps));
if (0==stricmp(name,"null")) {
_ps->ps = NULL;
return _ps;
}
// Open file
includer Includer;
string_path cname;
strconcat (sizeof(cname), cname,::Render->getShaderPath(),name,".ps");
FS.update_path (cname, "$game_shaders$", cname);
// duplicate and zero-terminate
IReader* R = FS.r_open(cname);
R_ASSERT2 (R,cname);
u32 size = R->length();
char* data = xr_alloc<char>(size + 1);
CopyMemory (data,R->pointer(),size);
data[size] = 0;
FS.r_close (R);
// Select target
LPCSTR c_target = "ps_2_0";
LPCSTR c_entry = "main";
if (strstr(data,"main_ps_1_1")) { c_target = "ps_1_1"; c_entry = "main_ps_1_1"; }
if (strstr(data,"main_ps_1_2")) { c_target = "ps_1_2"; c_entry = "main_ps_1_2"; }
if (strstr(data,"main_ps_1_3")) { c_target = "ps_1_3"; c_entry = "main_ps_1_3"; }
if (strstr(data,"main_ps_1_4")) { c_target = "ps_1_4"; c_entry = "main_ps_1_4"; }
if (strstr(data,"main_ps_2_0")) { c_target = "ps_2_0"; c_entry = "main_ps_2_0"; }
// Compile
LPD3DXBUFFER pShaderBuf = NULL;
LPD3DXBUFFER pErrorBuf = NULL;
LPD3DXSHADER_CONSTANTTABLE pConstants = NULL;
HRESULT _hr = S_OK;
_hr = ::Render->shader_compile (name,data,size, NULL, &Includer, c_entry, c_target, D3DXSHADER_DEBUG | D3DXSHADER_PACKMATRIX_ROWMAJOR /*| D3DXSHADER_PREFER_FLOW_CONTROL*/, &pShaderBuf, &pErrorBuf, NULL);
//_hr = D3DXCompileShader (text,text_size, NULL, &Includer, c_entry, c_target, D3DXSHADER_DEBUG | D3DXSHADER_PACKMATRIX_ROWMAJOR, &pShaderBuf, &pErrorBuf, NULL);
xr_free (data);
LPCSTR last_error = "";
if (SUCCEEDED(_hr))
{
if (pShaderBuf)
{
_hr = HW.pDevice->CreatePixelShader ((DWORD*)pShaderBuf->GetBufferPointer(), &_ps->ps);
if (SUCCEEDED(_hr)) {
LPCVOID data = NULL;
_hr = D3DXFindShaderComment ((DWORD*)pShaderBuf->GetBufferPointer(),MAKEFOURCC('C','T','A','B'),&data,NULL);
if (SUCCEEDED(_hr) && data)
{
pConstants = LPD3DXSHADER_CONSTANTTABLE(data);
_ps->constants.parse (pConstants,0x1);
}
else
_hr = E_FAIL;
}
}
else
_hr = E_FAIL;
}else
{
if (pErrorBuf)
last_error = (LPCSTR)pErrorBuf->GetBufferPointer();
}
// Real Wolf.10.12.2014
string1024 buff;
if (FAILED(_hr))
{
if (xr_strlen(last_error))
sprintf_s(buff, 1023, "ќшибка компил¤ции шейдера %s: %s ", name, last_error);
else
sprintf_s(buff, 1023, "ќшибка компил¤ции шейдера %s. ¬озможна ошибка в скрипте, или\n видеокарта не поддерживает пиксельные шейдеры 1.1", name);
Msg(buff);
}
pConstants = NULL;
_RELEASE(pShaderBuf);
_RELEASE(pErrorBuf);
CHECK_OR_EXIT (
!FAILED(_hr),
make_string(buff)
);
return _ps;
}
}
void SkeletalModel::AcquireResources( RenderContext* context )
{
for( unsigned int m=0; m<mMeshes.size(); ++m )
{
Mesh& mesh = mMeshes[m];
context->Device()->CreateVertexDeclaration( &mesh.Data.mVertexElements[0], &mesh.mVertexDeclaration );
// now create vertex buffer
{
DX_CHECK( context->Device()->CreateVertexBuffer( mesh.Data.mVertexData.size(), D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, &mesh.mVertexBuffer, NULL ) );
BYTE* vertexData;
DX_CHECK( mesh.mVertexBuffer->Lock( 0, 0, reinterpret_cast<void**>( &vertexData ), 0 ) );
memcpy( vertexData, &mesh.Data.mVertexData[0], mesh.Data.mVertexData.size() );
DX_CHECK( mesh.mVertexBuffer->Unlock() );
}
// build index buffer
{
DX_CHECK( context->Device()->CreateIndexBuffer( mesh.Data.mIndexData.size(), D3DUSAGE_WRITEONLY, mesh.Data.mIndexFormat, D3DPOOL_DEFAULT, &mesh.mIndexBuffer, NULL ) );
BYTE* indexData;
DX_CHECK( mesh.mIndexBuffer->Lock( 0, 0, reinterpret_cast<void**>( &indexData ), 0 ) );
memcpy( indexData, &mesh.Data.mIndexData[0], mesh.Data.mIndexData.size() );
DX_CHECK( mesh.mIndexBuffer->Unlock() );
}
// load textures
{
DWORD albedoMapFilter = D3DX_FILTER_TRIANGLE | D3DX_FILTER_DITHER | D3DX_FILTER_SRGB_IN | D3DX_FILTER_SRGB_OUT;
DWORD normalMapFilter = D3DX_FILTER_LINEAR;
DX_CHECK( D3DXCreateTextureFromFileInMemoryEx( context->Device(), &mesh.Data.mAlbedoMap[0], mesh.Data.mAlbedoMap.size(),
D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0, D3DFMT_FROM_FILE, D3DPOOL_DEFAULT, albedoMapFilter,
D3DX_DEFAULT, 0, NULL, NULL, &mesh.mDiffuseMap ) );
DX_CHECK( D3DXCreateTextureFromFileInMemoryEx( context->Device(), &mesh.Data.mNormalMap[0], mesh.Data.mNormalMap.size(),
D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0, D3DFMT_FROM_FILE, D3DPOOL_DEFAULT, normalMapFilter,
D3DX_DEFAULT, 0, NULL, NULL, &mesh.mNormalMap ) );
}
// load shaders
{
unsigned int maxFloats = 0;
for( unsigned int m=0; m<SAM_COUNT; ++m )
maxFloats = max( maxFloats, mPoseBuffers[m]->Size() / sizeof(float) );
char maxFloats4s[8];
sprintf_s( maxFloats4s, sizeof(maxFloats4s), "%d", maxFloats / 4 );
D3DXMACRO macros[] =
{
{ "MAX_SKINNING_VECTORS", maxFloats4s },
#ifdef DEBUG
{ "DEBUG", "1" },
#endif
NULL
};
LPD3DXBUFFER buf;
const char* shaderName = "../Shaders/Model.fx";
HRESULT hr = D3DXCreateEffectFromFile( context->Device(), shaderName, macros, NULL, NULL, NULL, &mesh.mEffect, &buf );
if( FAILED(hr) && buf)
{
const char* errorText = reinterpret_cast<char*>( buf->GetBufferPointer() );
char errorTitle[1024];
sprintf_s( errorTitle, "Error compiling shader '%s'", shaderName );
#ifdef DEBUG
// TODO: replace DXTRACE_ERR with vs console print so double clicking on file/line of error opens correct file
DXTRACE_ERR(errorText, hr );
__debugbreak();
#else
MessageBox( NULL, errorText, errorTitle, MB_OK );
#endif
buf->Release();
}
else
{
// set static shader parameters
D3DXHANDLE hDiffuseMap = mesh.mEffect->GetParameterBySemantic( NULL, "DIFFUSE_MAP" );
DX_CHECK( mesh.mEffect->SetTexture( hDiffuseMap, mesh.mDiffuseMap ) );
D3DXHANDLE hNormalMap = mesh.mEffect->GetParameterBySemantic( NULL, "NORMAL_MAP" );
DX_CHECK( mesh.mEffect->SetTexture( hNormalMap, mesh.mNormalMap ) );
D3DXHANDLE hLightDirection = mesh.mEffect->GetParameterBySemantic( NULL, "LIGHTDIRECTION" );
D3DXVECTOR4 lightDirection = Math::Vector( 0.5, 1, 0 ).Normal();
DX_CHECK( mesh.mEffect->SetVector( hLightDirection, &lightDirection ) );
// store handles for dynamic shader parameters
mesh.EffectParameters.mViewProjection = mesh.mEffect->GetParameterBySemantic( NULL, "VIEWPROJECTION" );
mesh.EffectParameters.mBoneTransforms = mesh.mEffect->GetParameterBySemantic( NULL, "BONE_TRANSFORMS" );
mesh.EffectParameters.mShaderTest = mesh.mEffect->GetParameterBySemantic( NULL, "SHADER_TEST" );
for( int t=0; t<SAM_COUNT; ++t )
{
mesh.EffectParameters.mTechniques[t] = mesh.mEffect->GetTechniqueByName( mSkeletons[t]->GetShaderTechnique() );
}
}
}
}
}
/**
* Render the Oculus Rift View.
***/
void* OculusRenderer::Provoke(void* pThis, int eD3D, int eD3DInterface, int eD3DMethod, DWORD dwNumberConnected, int& nProvokerIndex)
{
// return if wrong call
if ((eD3D >= (int)AQU_DirectXVersion::DirectX_9_0) &&
(eD3D <= (int)AQU_DirectXVersion::DirectX_9_29))
{
if (((eD3DInterface == INTERFACE_IDIRECT3DDEVICE9) &&
(eD3DMethod == METHOD_IDIRECT3DDEVICE9_PRESENT)) ||
((eD3DInterface == INTERFACE_IDIRECT3DDEVICE9) &&
(eD3DMethod == METHOD_IDIRECT3DDEVICE9_ENDSCENE)) ||
((eD3DInterface == INTERFACE_IDIRECT3DSWAPCHAIN9) &&
(eD3DMethod == METHOD_IDIRECT3DSWAPCHAIN9_PRESENT)))
{
(pThis);
}
else return nullptr;
}
else
return nullptr;
// get input data
if (m_paInput[(int)ORN_Decommanders::LeftTexture])
m_pcTextureLeft = *(LPDIRECT3DTEXTURE9*)m_paInput[(int)ORN_Decommanders::LeftTexture];
else
m_pcTextureLeft = nullptr;
if (m_paInput[(int)ORN_Decommanders::RightTexture])
m_pcTextureRight = *(LPDIRECT3DTEXTURE9*)m_paInput[(int)ORN_Decommanders::RightTexture];
else m_pcTextureRight = nullptr;
if (m_paInput[(int)ORN_Decommanders::DistortionVertexBufferLeft])
if (*(LPDIRECT3DVERTEXBUFFER9**)m_paInput[(int)ORN_Decommanders::DistortionVertexBufferLeft])
m_pcDistortionVertexBufferLeft = **(LPDIRECT3DVERTEXBUFFER9**)m_paInput[(int)ORN_Decommanders::DistortionVertexBufferLeft];
else m_pcDistortionVertexBufferLeft = nullptr;
else m_pcDistortionVertexBufferLeft = nullptr;
if (m_paInput[(int)ORN_Decommanders::DistortionVertexBufferRight])
if (*(LPDIRECT3DVERTEXBUFFER9**)m_paInput[(int)ORN_Decommanders::DistortionVertexBufferRight])
m_pcDistortionVertexBufferRight = **(LPDIRECT3DVERTEXBUFFER9**)m_paInput[(int)ORN_Decommanders::DistortionVertexBufferRight];
else m_pcDistortionVertexBufferRight = nullptr;
else m_pcDistortionVertexBufferRight = nullptr;
if (m_paInput[(int)ORN_Decommanders::DistortionIndexBufferLeft])
if (*(LPDIRECT3DINDEXBUFFER9**)m_paInput[(int)ORN_Decommanders::DistortionIndexBufferLeft])
m_pcDistortionIndexBufferLeft = **(LPDIRECT3DINDEXBUFFER9**)m_paInput[(int)ORN_Decommanders::DistortionIndexBufferLeft];
else m_pcDistortionIndexBufferLeft = nullptr;
else m_pcDistortionIndexBufferLeft = nullptr;
if (m_paInput[(int)ORN_Decommanders::DistortionIndexBufferRight])
if (*(LPDIRECT3DINDEXBUFFER9**)m_paInput[(int)ORN_Decommanders::DistortionIndexBufferRight])
m_pcDistortionIndexBufferRight = **(LPDIRECT3DINDEXBUFFER9**)m_paInput[(int)ORN_Decommanders::DistortionIndexBufferRight];
else m_pcDistortionIndexBufferRight = nullptr;
else m_pcDistortionIndexBufferRight = nullptr;
if (m_paInput[(int)ORN_Decommanders::OculusVertexDeclaration])
if (*(LPDIRECT3DVERTEXDECLARATION9**)m_paInput[(int)ORN_Decommanders::OculusVertexDeclaration])
m_pcVertexDecl = **(LPDIRECT3DVERTEXDECLARATION9**)m_paInput[(int)ORN_Decommanders::OculusVertexDeclaration];
else m_pcVertexDecl = nullptr;
else m_pcVertexDecl = nullptr;
if (m_paInput[(int)ORN_Decommanders::DefaultEyeFovLeft])
if (*(ovrFovPort**)m_paInput[(int)ORN_Decommanders::DefaultEyeFovLeft])
m_psFOVPortLeft = *(ovrFovPort**)m_paInput[(int)ORN_Decommanders::DefaultEyeFovLeft];
else m_psFOVPortLeft = nullptr;
else m_psFOVPortLeft = nullptr;
if (m_paInput[(int)ORN_Decommanders::DefaultEyeFovRight])
if (*(ovrFovPort**)m_paInput[(int)ORN_Decommanders::DefaultEyeFovRight])
m_psFOVPortRight = *(ovrFovPort**)m_paInput[(int)ORN_Decommanders::DefaultEyeFovRight];
else m_psFOVPortRight = nullptr;
else m_psFOVPortRight = nullptr;
// get device
LPDIRECT3DDEVICE9 pcDevice = nullptr;
bool bReleaseDevice = false;
if (eD3DInterface == INTERFACE_IDIRECT3DDEVICE9)
{
pcDevice = (LPDIRECT3DDEVICE9)pThis;
}
else if (eD3DInterface == INTERFACE_IDIRECT3DSWAPCHAIN9)
{
LPDIRECT3DSWAPCHAIN9 pSwapChain = (LPDIRECT3DSWAPCHAIN9)pThis;
if (!pSwapChain)
{
OutputDebugString(L"Oculus Renderer Node : No swapchain !");
return nullptr;
}
pSwapChain->GetDevice(&pcDevice);
bReleaseDevice = true;
}
if (!pcDevice)
{
OutputDebugString(L"Oculus Renderer Node : No device !");
return nullptr;
}
// Original code (LibOVR) :
// pShaderCode = ShaderCompile("precompiledVertexShaderSrc",VertexShaderSrc,"vs_2_0");
// pShaderCode = ShaderCompile("precompiledVertexShaderTimewarpSrc",VertexShaderTimewarpSrc,"vs_3_0");
// pShaderCode = ShaderCompile("precompiledPixelShaderSrc",PixelShaderSrc,"ps_3_0");
// pixel shader created ?
if (!m_pcOculusPixelShader)
{
LPD3DXBUFFER pShader;
// compile and create shader
if (SUCCEEDED(D3DXCompileShader(PixelShaderSrc,strlen(PixelShaderSrc),NULL,NULL,"main","ps_3_0",NULL,&pShader,NULL,&m_pcOculusPixelShaderCT)))
{
OutputDebugString(L"Pixel shader compiled!");
pcDevice->CreatePixelShader((DWORD*)pShader->GetBufferPointer(), &m_pcOculusPixelShader);
}
}
// vertex shader created ?
if (!m_pcOculusVertexShader)
{
LPD3DXBUFFER pShader;
// compile and create shader
if (SUCCEEDED(D3DXCompileShader(VertexShaderSrc,strlen(VertexShaderSrc),NULL,NULL,"main","vs_2_0",NULL,&pShader,NULL,&m_pcOculusVertexShaderCT)))
{
OutputDebugString(L"Vertex shader compiled!");
pcDevice->CreateVertexShader((DWORD*)pShader->GetBufferPointer(), &m_pcOculusVertexShader);
}
}
// side by side pixel shader ?
if (!m_pcSideBySidePixelShader)
{
LPD3DXBUFFER pShader;
// compile and create shader
if (SUCCEEDED(D3DXCompileShader(PixelShaderSrcSideBySide,strlen(PixelShaderSrcSideBySide),NULL,NULL,"SBS","ps_2_0",NULL,&pShader,NULL,&m_pcSideBySidePixelShaderCT)))
{
OutputDebugString(L"Pixel shader compiled!");
pcDevice->CreatePixelShader((DWORD*)pShader->GetBufferPointer(), &m_pcSideBySidePixelShader);
}
}
// test textures created ?
if ((!m_pcTextureRightTest) || (!m_pcTextureLeftTest))
{
HMODULE hModule = GetModuleHandle(L"OculusRenderer.dll");
if (!m_pcTextureLeftTest)
{
// create a test texture
if (SUCCEEDED(D3DXCreateTextureFromResource(pcDevice, hModule, MAKEINTRESOURCE(IMG_BACKGROUND01), &m_pcTextureLeftTest)))
OutputDebugString(L"Texture created !");
else m_pcTextureLeftTest = nullptr;
}
if (!m_pcTextureRightTest)
{
// create a test texture
if (SUCCEEDED(D3DXCreateTextureFromResource(pcDevice, hModule, MAKEINTRESOURCE(IMG_BACKGROUND02), &m_pcTextureRightTest)))
OutputDebugString(L"Texture created !");
else m_pcTextureRightTest = nullptr;
}
}
// default vertex buffer ?
if (!m_pcVertexBufferDefault)
{
InitDefaultVertexBuffer(pcDevice);
if (!m_pcVertexBufferDefault) return nullptr;
}
// vertex buffers ? index buffers ? not all present ?
if ((!m_pcDistortionVertexBufferLeft) || (!m_pcDistortionVertexBufferRight) ||
(!m_pcDistortionIndexBufferLeft) || (!m_pcDistortionIndexBufferRight) ||
(!m_pcVertexDecl))
{
if (m_bBuffersConnected)
{
// clear all descriptions for safety
ZeroMemory(&m_sVertexBufferDescLeft, sizeof(D3DVERTEXBUFFER_DESC));
ZeroMemory(&m_sVertexBufferDescRight, sizeof(D3DVERTEXBUFFER_DESC));
ZeroMemory(&m_sIndexBufferDescLeft, sizeof(D3DINDEXBUFFER_DESC));
ZeroMemory(&m_sIndexBufferDescRight, sizeof(D3DINDEXBUFFER_DESC));
m_bBuffersConnected = false;
}
}
else
{
m_bBuffersConnected = true;
// vertex buffer description ? left
if (!m_sVertexBufferDescLeft.Size)
m_pcDistortionVertexBufferLeft->GetDesc(&m_sVertexBufferDescLeft);
// vertex buffer length matches oculus vertex type ?
if ((m_sVertexBufferDescLeft.Size % sizeof(ovrDistortionVertex)) != 0)
{
OutputDebugString(L"OculusRenderer Node : Connected vertex buffer size mismatch !");
return nullptr;
}
// and right
if (!m_sVertexBufferDescRight.Size)
m_pcDistortionVertexBufferRight->GetDesc(&m_sVertexBufferDescRight);
// vertex buffer length matches oculus vertex type ?
if ((m_sVertexBufferDescRight.Size % sizeof(ovrDistortionVertex)) != 0)
{
OutputDebugString(L"OculusRenderer Node : Connected vertex buffer size mismatch !");
return nullptr;
}
// index buffer ?
if ((!m_pcDistortionIndexBufferLeft) || (!m_pcDistortionIndexBufferRight))
return nullptr;
// index buffer description ?
if (!m_sIndexBufferDescLeft.Size)
{
m_pcDistortionIndexBufferLeft->GetDesc(&m_sIndexBufferDescLeft);
// index buffer length matches vertex buffer size ? TODO !!
/*if ()
{
OutputDebugString(L"OculusRenderer Node : Connected index buffer size mismatch !");
return nullptr;
}*/
}
if (!m_sIndexBufferDescRight.Size)
{
m_pcDistortionIndexBufferRight->GetDesc(&m_sIndexBufferDescRight);
// index buffer length matches vertex buffer size ? TODO !!
/*if ()
{
OutputDebugString(L"OculusRenderer Node : Connected index buffer size mismatch !");
return nullptr;
}*/
}
}
// start to render
pcDevice->BeginScene();
// save states
IDirect3DStateBlock9* pStateBlock = nullptr;
pcDevice->CreateStateBlock(D3DSBT_ALL, &pStateBlock);
// set ALL render states to default
SetAllRenderStatesDefault(pcDevice);
// set states
pcDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
pcDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
pcDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
pcDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_CONSTANT);
pcDevice->SetTextureStageState(0, D3DTSS_CONSTANT, 0xffffffff);
pcDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
pcDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
pcDevice->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
pcDevice->SetSamplerState(0, D3DSAMP_SRGBTEXTURE, 0);
pcDevice->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
pcDevice->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
pcDevice->SetSamplerState(0, D3DSAMP_ADDRESSW, D3DTADDRESS_CLAMP);
pcDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_ANISOTROPIC);
pcDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
pcDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
D3DCOLOR clearColor = D3DCOLOR_RGBA(0, 0, 0, 0);
pcDevice->Clear(0, NULL, D3DCLEAR_TARGET, clearColor, 0, 0);
// required fields
D3DSURFACE_DESC sSurfaceDesc;
ovrSizei sTextureSize;
ovrRecti sRenderViewport;
ovrVector2f UVScaleOffset[2];
// LEFT EYE :
// left eye, first set stream source, indices
if (m_bBuffersConnected)
{
// no timewarp here, use standard vertex shader, set pixel shader, set vertex declaration
pcDevice->SetVertexShader( m_pcOculusVertexShader);
pcDevice->SetPixelShader( m_pcOculusPixelShader );
pcDevice->SetVertexDeclaration( m_pcVertexDecl );
// set texture
if (m_pcTextureLeft)
pcDevice->SetTexture( 0, m_pcTextureLeft );
else if (m_pcTextureLeftTest)
pcDevice->SetTexture( 0, m_pcTextureLeftTest );
else pcDevice->SetTexture( 0, 0);
// get texture size
if (m_pcTextureLeft)
m_pcTextureLeft->GetLevelDesc(0, &sSurfaceDesc);
else if (m_pcTextureLeftTest)
m_pcTextureLeftTest->GetLevelDesc(0, &sSurfaceDesc);
else ZeroMemory(&sSurfaceDesc, sizeof(D3DSURFACE_DESC));
sTextureSize.w = (int)sSurfaceDesc.Width;
sTextureSize.h = (int)sSurfaceDesc.Height;
// set render viewport size the same size as the texture size (!)
sRenderViewport.Pos.x = 0;
sRenderViewport.Pos.y = 0;
sRenderViewport.Size.w = sTextureSize.w;
sRenderViewport.Size.h = sTextureSize.h;
// get and set scale and offset
if (m_psFOVPortLeft)
ovrHmd_GetRenderScaleAndOffset(*m_psFOVPortLeft, sTextureSize, sRenderViewport, UVScaleOffset);
else
ovrHmd_GetRenderScaleAndOffset(m_sDefaultFOVPortLeft, sTextureSize, sRenderViewport, UVScaleOffset);
pcDevice->SetVertexShaderConstantF( 0, ( FLOAT* )&UVScaleOffset[0], 1 );
pcDevice->SetVertexShaderConstantF( 2, ( FLOAT* )&UVScaleOffset[1], 1 );
pcDevice->SetStreamSource( 0, m_pcDistortionVertexBufferLeft,0, sizeof(ovrDistortionVertex) );
pcDevice->SetIndices( m_pcDistortionIndexBufferLeft);
// draw
pcDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST,0,0, m_sVertexBufferDescLeft.Size / sizeof(ovrDistortionVertex) , 0, m_sIndexBufferDescLeft.Size / 6 );
}
else
{
pcDevice->SetSamplerState(1, D3DSAMP_SRGBTEXTURE, 0);
pcDevice->SetSamplerState(1, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
pcDevice->SetSamplerState(1, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
pcDevice->SetSamplerState(1, D3DSAMP_ADDRESSW, D3DTADDRESS_CLAMP);
pcDevice->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_ANISOTROPIC);
pcDevice->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
pcDevice->SetSamplerState(1, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
// side by side render
pcDevice->SetVertexShader(NULL);
pcDevice->SetPixelShader(m_pcSideBySidePixelShader);
pcDevice->SetVertexDeclaration( NULL );
pcDevice->SetFVF(D3DFVF_TEXVERTEX);
// set textures
if (m_pcTextureLeft)
pcDevice->SetTexture( 0, m_pcTextureLeft );
else if (m_pcTextureLeftTest)
pcDevice->SetTexture( 0, m_pcTextureLeftTest );
else pcDevice->SetTexture( 0, 0);
if (m_pcTextureRight)
pcDevice->SetTexture( 1, m_pcTextureRight );
else if (m_pcTextureRightTest)
pcDevice->SetTexture( 1, m_pcTextureRightTest );
else pcDevice->SetTexture( 1, 0);
// set stream and draw
pcDevice->SetStreamSource( 0, m_pcVertexBufferDefault,0, sizeof(TEXVERTEX) );
pcDevice->DrawPrimitive(D3DPT_TRIANGLEFAN, 0, 2);
}
// RIGHT EYE:
if (m_bBuffersConnected)
{
// set texture
if (m_pcTextureRight)
pcDevice->SetTexture( 0, m_pcTextureRight );
else if (m_pcTextureRightTest)
pcDevice->SetTexture( 0, m_pcTextureRightTest );
else pcDevice->SetTexture( 0, 0);
// get texture size
if (m_pcTextureRight)
m_pcTextureRight->GetLevelDesc(0, &sSurfaceDesc);
else if (m_pcTextureRightTest)
m_pcTextureRightTest->GetLevelDesc(0, &sSurfaceDesc);
else ZeroMemory(&sSurfaceDesc, sizeof(D3DSURFACE_DESC));
sTextureSize.w = (int)sSurfaceDesc.Width;
sTextureSize.h = (int)sSurfaceDesc.Height;
// get and set scale and offset
if (m_psFOVPortRight)
ovrHmd_GetRenderScaleAndOffset(*m_psFOVPortRight, sTextureSize, sRenderViewport, UVScaleOffset);
else
ovrHmd_GetRenderScaleAndOffset(m_sDefaultFOVPortRight, sTextureSize, sRenderViewport, UVScaleOffset);
pcDevice->SetVertexShaderConstantF( 0, ( FLOAT* )&UVScaleOffset[0], 1 );
pcDevice->SetVertexShaderConstantF( 2, ( FLOAT* )&UVScaleOffset[1], 1 );
// set stream source, indices, draw
pcDevice->SetStreamSource( 0, m_pcDistortionVertexBufferRight,0, sizeof(ovrDistortionVertex) );
pcDevice->SetIndices( m_pcDistortionIndexBufferRight);
// draw
pcDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST,0,0, m_sVertexBufferDescRight.Size / sizeof(ovrDistortionVertex) , 0, m_sIndexBufferDescRight.Size / 6 );
}
pcDevice->EndScene();
// apply and release state block
if (pStateBlock)
{
pStateBlock->Apply();
pStateBlock->Release();
}
// release device if provided by swapchain
if (bReleaseDevice) pcDevice->Release();
return nullptr;
}
////////////////////////////////////////////////////////////////
//
// CEffectTemplateImpl::CreateUnderlyingData
//
//
//
////////////////////////////////////////////////////////////////
void CEffectTemplateImpl::CreateUnderlyingData ( const SString& strFilename, const SString& strRootPath, SString& strOutStatus, bool bDebug )
{
assert ( !m_pD3DEffect );
// Make defines
bool bUsesRAWZ = CGraphics::GetSingleton ().GetRenderItemManager ()->GetDepthBufferFormat () == RFORMAT_RAWZ;
std::vector < D3DXMACRO > macroList;
macroList.push_back ( D3DXMACRO () );
macroList.back ().Name = "IS_DEPTHBUFFER_RAWZ";
macroList.back ().Definition = bUsesRAWZ ? "1" : "0";
macroList.push_back ( D3DXMACRO () );
macroList.back ().Name = NULL;
macroList.back ().Definition = NULL;
// Compile effect
DWORD dwFlags = 0; // D3DXSHADER_PARTIALPRECISION, D3DXSHADER_DEBUG, D3DXFX_NOT_CLONEABLE;
if ( bDebug )
dwFlags |= D3DXSHADER_DEBUG;
SString strMetaPath = strFilename.Right ( strFilename.length () - strRootPath.length () );
CIncludeManager IncludeManager ( strRootPath, ExtractPath ( strMetaPath ) );
LPD3DXBUFFER pBufferErrors = NULL;
HRESULT hr = D3DXCreateEffectFromFile( m_pDevice, ExtractFilename ( strMetaPath ), ¯oList[0], &IncludeManager, dwFlags, NULL, &m_pD3DEffect, &pBufferErrors );
// Handle compile errors
strOutStatus = "";
if( pBufferErrors != NULL )
{
strOutStatus = SStringX ( (CHAR*)pBufferErrors->GetBufferPointer() ).TrimEnd ( "\n" );
// Error messages sometimes contain the current directory. Remove that here.
SString strCurrentDirectory = GetSystemCurrentDirectory();
strOutStatus = strOutStatus.ReplaceI ( strCurrentDirectory + "\\", "" );
strOutStatus = strOutStatus.ReplaceI ( strCurrentDirectory, "" );
}
SAFE_RELEASE( pBufferErrors );
if( !m_pD3DEffect )
{
if ( strOutStatus.empty () )
strOutStatus = SString ( "[D3DXCreateEffectFromFile failed (%08x)%s]", hr, *IncludeManager.m_strReport );
return;
}
// Find first valid technique
D3DXHANDLE hTechnique = NULL;
D3DXEFFECT_DESC EffectDesc;
m_pD3DEffect->GetDesc ( &EffectDesc );
for ( uint uiAttempt = 0 ; true ; uiAttempt++ )
{
SString strProblemInfo = "";
for ( uint i = 0 ; i < EffectDesc.Techniques ; i++ )
{
SString strErrorExtra;
D3DXHANDLE hTemp = m_pD3DEffect->GetTechnique ( i );
HRESULT hr = m_pD3DEffect->ValidateTechnique ( hTemp );
if ( SUCCEEDED( hr ) )
{
// Check depth buffer rules
if ( ValidateDepthBufferUsage ( hTemp, strErrorExtra ) )
{
hTechnique = hTemp;
break;
}
}
// Update problem string
D3DXTECHNIQUE_DESC TechniqueDesc;
m_pD3DEffect->GetTechniqueDesc( hTemp, &TechniqueDesc );
strProblemInfo += SString ( "['%s' (%d/%d) failed (%08x)%s]", TechniqueDesc.Name, i, EffectDesc.Techniques, hr, *strErrorExtra );
}
// Found valid technique
if ( hTechnique )
break;
// Error if can't find a valid technique after 2nd attempt
if ( uiAttempt > 0 )
{
strOutStatus = SString ( "No valid technique; [Techniques:%d %s]%s", EffectDesc.Techniques, *strProblemInfo, *IncludeManager.m_strReport );
SAFE_RELEASE ( m_pD3DEffect );
return;
}
// Try resetting samplers if 1st attempt failed
LPDIRECT3DDEVICE9 pDevice;
m_pD3DEffect->GetDevice ( &pDevice );
for ( uint i = 0 ; i < 16 ; i++ )
{
pDevice->SetSamplerState ( i, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
pDevice->SetSamplerState ( i, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
pDevice->SetSamplerState ( i, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );
}
}
// Set technique
m_pD3DEffect->SetTechnique( hTechnique );
// Inform user of technique name
D3DXTECHNIQUE_DESC TechniqueDesc;
m_pD3DEffect->GetTechniqueDesc( hTechnique, &TechniqueDesc );
strOutStatus = TechniqueDesc.Name;
if ( bDebug )
{
// Disassemble effect
LPD3DXBUFFER pDisassembly = NULL;
if ( SUCCEEDED( D3DXDisassembleEffect( m_pD3DEffect, false, &pDisassembly ) ) && pDisassembly )
{
LPVOID pData = pDisassembly->GetBufferPointer();
DWORD Size = pDisassembly->GetBufferSize();
if( pData && Size )
{
SString strDisassemblyContents;
strDisassemblyContents.assign ( (const char*)pData, Size - 1 );
FileSave ( strFilename + ".dis", strDisassemblyContents );
}
SAFE_RELEASE( pDisassembly );
}
}
// Copy MD5s of all loaded files
m_FileMD5Map = IncludeManager.m_FileMD5Map;
dassert ( !HaveFilesChanged() );
}
//------------------------------------------------------------------------
// Purpose : Constructor
//------------------------------------------------------------------------
ParticleSystem::ParticleSystem(const std::string& fxName, const std::string& techName,
const std::string& texName, const D3DXVECTOR3 &accel,
int maxNumParticles, float timePerParticle)
{
m_VecAccel = accel;
m_fTime = 0.0f;
m_iMaxParticles = maxNumParticles;
m_fTimePerParticle = timePerParticle;
// Allocate memory for maximum number of particles
m_Particles.resize(m_iMaxParticles);
m_AliveParticles.reserve(m_iMaxParticles);
m_DeadParticles.reserve(m_iMaxParticles);
// Make all particles DEAD at start!
for (int i = 0 ; i<m_iMaxParticles ; i++)
{
m_Particles[i].lifeTime = 0.0f;
m_Particles[i].initialTime = 0.0f;
}
D3DXMatrixIdentity(&m_MatWorld);
D3DXMatrixIdentity(&m_MatInvWorld);
// Create the FX
LPDIRECT3DDEVICE9 device = RenderDevice::GetInstance()->getDevice();
LPD3DXBUFFER err = NULL;
HRESULT Hr = D3DXCreateEffectFromFile(device, fxName.c_str(), 0, 0, 0, 0, &m_pFX, &err );
if (Hr != S_OK)
{
LogManager::GetInstance()->WriteToFile("Particle Effect creation FAILED!", (char*)err->GetBufferPointer());
}
// Create the texture
Hr = D3DXCreateTextureFromFile(device, texName.c_str(), &m_pTex);
if (Hr != S_OK)
{
LogManager::GetInstance()->WriteToFile("Particle Texture creation FAILED!");
}
// Create Vertex Buffer
Hr = device->CreateVertexBuffer(maxNumParticles*sizeof(Particle), D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY | D3DUSAGE_POINTS, 0, D3DPOOL_DEFAULT, &m_pVB, 0);
if (Hr != S_OK)
{
LogManager::GetInstance()->WriteToFile("Particle Vertex BUffer creation FAILED!");
}
// Assign all the Shader Handles
m_hAccel = m_pFX->GetParameterByName(0, "gAccel");
m_hMatWVP = m_pFX->GetParameterByName(0, "matWVP");
m_hMatWorld = m_pFX->GetParameterByName(0, "matWorld");
m_hMatView = m_pFX->GetParameterByName(0, "matView");
m_hMatProj = m_pFX->GetParameterByName(0, "matProj");
m_hTech = m_pFX->GetTechniqueByName(techName.c_str());
m_hTex = m_pFX->GetParameterByName(0, "gTex");
m_hTime = m_pFX->GetParameterByName(0, "gTime");
m_hVecEye = m_pFX->GetParameterByName(0, "gCamPos");
m_hViewportHeight = m_pFX->GetParameterByName(0, "gViewportHeight");
// WE don't need to set these every frame since they dont change!
m_pFX->SetTechnique(m_hTech);
m_pFX->SetValue(m_hAccel, m_VecAccel, sizeof(D3DXVECTOR3));
m_pFX->SetTexture(m_hTex, m_pTex);
}
/** load the resource from a file or win32 resource
If the resource file name begins with ':', it is treated as a win32 resource.
e.g.":IDR_FX_OCEANWATER". loads data from a resource of type "TEXTFILE". See MSDN for more information about Windows resources.
*/
HRESULT CEffectFileDirectX::InitDeviceObjects()
{
m_bIsInitialized =true;
m_bIsValid = false;//set to true if created successfully.
LPDIRECT3DDEVICE9 pD3dDevice = CGlobals::GetRenderDevice();
LPD3DXBUFFER pBufferErrors = NULL;
HRESULT result=E_FAIL;
CParaFile file(m_filename.c_str());
if(!file.isEof())
{
/*
// Since we are loading a binary file here and this effect has already been compiled,
// you can not pass compiler flags here (for example to debug the shaders).
// To debug the shaders, one must pass these flags to the compiler that generated the
// binary (for example fxc.exe).
- From within the Solution Explorer window, right click on *.fx and select Properties from the context menu.
- Select Configuration Properties/Custom Build Step to view the custom build step directives.
*/
result = D3DXCreateEffect(
pD3dDevice,
file.getBuffer(),
(UINT)file.getSize(),
NULL, //(D3DXMACRO*) (s_bUseHalfPrecision ? s_halfPrecisionMacroTable : s_fullPrecisionMacroTable),
NULL,
NULL, // D3DXSHADER_PREFER_FLOW_CONTROL | D3DXSHADER_OPTIMIZATION_LEVEL2,
0,
&m_pEffect,
&pBufferErrors );
}
else
{
OUTPUT_LOG("ERROR: shader file %s not found\n", m_filename.c_str());
return result;
}
if( !SUCCEEDED( result ) )
{
char* error = (pBufferErrors!=0) ? (char*)pBufferErrors->GetBufferPointer() : "failed loading effect file\n";
OUTPUT_LOG("Failed Loading Effect file %s: error is %s\n", m_filename.c_str(), error);
SAFE_RELEASE(pBufferErrors);
return result;
}
SAFE_RELEASE(pBufferErrors);
// get the description
m_pEffect->GetDesc( &m_EffectDesc );
m_techniques.clear();
//////////////////////////////////////////////////////////////////////////
// get all valid techniques
TechniqueDescDX tech;
tech.hTechnique = NULL;
bool bHasDefaultTechnique = false;
while ((result = m_pEffect->FindNextValidTechnique(tech.hTechnique, &tech.hTechnique)) == S_OK)
{
// get some info about the technique
result = m_pEffect->GetTechniqueDesc(tech.hTechnique, &tech.techniqueDesc);
if( result == S_OK )
{
if(strcmp(tech.techniqueDesc.Name, "GenShadowMap") == 0)
{
tech.nCategory = TechCategory_GenShadowMap;
}
else if(strcmp(tech.techniqueDesc.Name, "Vegetation") == 0)
{
tech.nCategory = TechCategory_Vegetation;
}
else if(strcmp(tech.techniqueDesc.Name, "Character") == 0)
{
tech.nCategory = TechCategory_Character;
}
else if(strcmp(tech.techniqueDesc.Name, "DetailCharacter") == 0)
{
tech.nCategory = TechCategory_DetailCharacter;
}
else
{
tech.nCategory = TechCategory_default;
bHasDefaultTechnique = true;
}
m_techniques.push_back(tech);
}
else
{
OUTPUT_LOG("ERROR: effect file: %s failed getting its description.\n", m_filename.c_str());
}
}
if(!bHasDefaultTechnique)
{
// at least one default technique must be valid. "GenShadowMap" is not a default technique.
// So if "GenShadowMap" is valid, but others are not valid, the technique is not considered valid.
OUTPUT_LOG("ERROR: effect file: %s not supported by your GPU.\n", m_filename.c_str());
releaseEffect();
result = E_FAIL;
}
else
{
//////////////////////////////////////////////////////////////////////////
// activate the first valid technique
m_nTechniqueIndex = 0;
result = m_pEffect->SetTechnique(m_techniques[m_nTechniqueIndex].hTechnique);
if( result == S_OK)
{
// parse the effect parameters to build a list of handles
parseParameters();
m_bIsValid = true;
}
else
{
OUTPUT_LOG("ERROR: effect file: %s failed loading its technique.\n", m_filename.c_str());
releaseEffect();
}
result = S_OK;
}
return result;
}
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
HRESULT CD3DMesh::Create( LPDIRECT3DDEVICE9 pd3dDevice,
LPDIRECTXFILEDATA pFileData )
{
LPD3DXBUFFER pMtrlBuffer = NULL;
LPD3DXBUFFER pAdjacencyBuffer = NULL;
HRESULT hr;
// Load the mesh from the DXFILEDATA object
if( FAILED( hr = D3DXLoadMeshFromXof( pFileData, D3DXMESH_SYSTEMMEM, pd3dDevice,
&pAdjacencyBuffer, &pMtrlBuffer, NULL,
&m_dwNumMaterials, &m_pSysMemMesh ) ) )
{
return hr;
}
// Optimize the mesh for performance
if( FAILED( hr = m_pSysMemMesh->OptimizeInplace(
D3DXMESHOPT_COMPACT | D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_VERTEXCACHE,
(DWORD*)pAdjacencyBuffer->GetBufferPointer(), NULL, NULL, NULL ) ) )
{
SAFE_RELEASE( pAdjacencyBuffer );
SAFE_RELEASE( pMtrlBuffer );
return hr;
}
// Get material info for the mesh
// Get the array of materials out of the buffer
if( pMtrlBuffer && m_dwNumMaterials > 0 )
{
// Allocate memory for the materials and textures
D3DXMATERIAL* d3dxMtrls = (D3DXMATERIAL*)pMtrlBuffer->GetBufferPointer();
m_pMaterials = new D3DMATERIAL9[m_dwNumMaterials];
if( m_pMaterials == NULL )
{
hr = E_OUTOFMEMORY;
goto LEnd;
}
m_pTextures = new LPDIRECT3DTEXTURE9[m_dwNumMaterials];
if( m_pTextures == NULL )
{
hr = E_OUTOFMEMORY;
goto LEnd;
}
// Copy each material and create its texture
for( DWORD i=0; i<m_dwNumMaterials; i++ )
{
// Copy the material
m_pMaterials[i] = d3dxMtrls[i].MatD3D;
m_pTextures[i] = NULL;
// Create a texture
if( d3dxMtrls[i].pTextureFilename )
{
TCHAR strTexture[MAX_PATH];
TCHAR strTextureTemp[MAX_PATH];
DXUtil_ConvertAnsiStringToGenericCb( strTextureTemp, d3dxMtrls[i].pTextureFilename, sizeof(strTextureTemp) );
DXUtil_FindMediaFileCb( strTexture, sizeof(strTexture), strTextureTemp );
if( FAILED( D3DXCreateTextureFromFile( pd3dDevice, strTexture,
&m_pTextures[i] ) ) )
m_pTextures[i] = NULL;
}
}
}
hr = S_OK;
LEnd:
SAFE_RELEASE( pAdjacencyBuffer );
SAFE_RELEASE( pMtrlBuffer );
return hr;
}
int main(int argc, char* argv[])
{
if( argc < 2 )
{
printf("%s <file0> <file1> ...\n", argv[0]);
return 0;
}
const char* const * nameList = 0L;
int numNames = 0;
if( !_stricmp(argv[1], "all") )
{
// Cut and paste enum and add kNumEnumNames to end
// so you don't have to count.
enum {
vs_WaveFixedFin6,
ps_WaveFixed,
vs_CompCosines,
ps_CompCosines,
vs_ShoreLeave6,
ps_ShoreLeave6,
vs_WaveRip,
ps_WaveRip,
vs_WaveDec1Lay,
vs_WaveDec2Lay11,
vs_WaveDec2Lay12,
vs_WaveDecEnv,
ps_CbaseAbase,
ps_CalphaAbase,
ps_CalphaAMult,
ps_CalphaAadd,
ps_CaddAbase,
ps_CaddAMult,
ps_CaddAAdd,
ps_CmultAbase,
ps_CmultAMult,
ps_CmultAAdd,
ps_WaveDecEnv,
vs_WaveGraph2,
ps_WaveGraph,
vs_WaveGridFin,
ps_WaveGrid,
vs_BiasNormals,
ps_BiasNormals,
vs_ShoreLeave7,
vs_WaveRip7,
ps_MoreCosines,
vs_WaveDec1Lay_7,
vs_WaveDec2Lay11_7,
vs_WaveDec2Lay12_7,
vs_WaveDecEnv_7,
vs_WaveFixedFin7,
vs_GrassShader,
ps_GrassShader,
vs_RiftDistortAssembly,
ps_RiftDistortAssembly,
kNumEnumNames
};
// Just copy in the enum and use Replace on
// vs_ => "vs_
// ps_ => "ps_
// , => ",
const char* kEnumNames[kNumEnumNames] = {
"vs_WaveFixedFin6",
"ps_WaveFixed",
"vs_CompCosines",
"ps_CompCosines",
"vs_ShoreLeave6",
"ps_ShoreLeave6",
"vs_WaveRip",
"ps_WaveRip",
"vs_WaveDec1Lay",
"vs_WaveDec2Lay11",
"vs_WaveDec2Lay12",
"vs_WaveDecEnv",
"ps_CbaseAbase",
"ps_CalphaAbase",
"ps_CalphaAMult",
"ps_CalphaAadd",
"ps_CaddAbase",
"ps_CaddAMult",
"ps_CaddAAdd",
"ps_CmultAbase",
"ps_CmultAMult",
"ps_CmultAAdd",
"ps_WaveDecEnv",
"vs_WaveGraph2",
"ps_WaveGraph",
"vs_WaveGridFin",
"ps_WaveGrid",
"vs_BiasNormals",
"ps_BiasNormals",
"vs_ShoreLeave7",
"vs_WaveRip7",
"ps_MoreCosines",
"vs_WaveDec1Lay_7",
"vs_WaveDec2Lay11_7",
"vs_WaveDec2Lay12_7",
"vs_WaveDecEnv_7",
"vs_WaveFixedFin7",
"vs_GrassShader",
"ps_GrassShader",
"vs_RiftDistortAssembly",
"ps_RiftDistortAssembly"
};
nameList = kEnumNames;
numNames = kNumEnumNames;
}
else
{
nameList = argv+1;
numNames = argc-1;
}
int i;
for( i = 0; i < numNames; i++ )
{
const char* name = nameList[i];
char varName[512];
strcpy(varName, name);
char* p = strrchr(varName, '.');
if( p )
*p = 0;
char inFile[512];
sprintf(inFile, "%s.inl", varName);
char outFile[512];
sprintf(outFile, "%s.h", varName);
printf("Processing %s into %s\n", name, outFile);
FILE* fp = fopen(outFile, "w");
if( !fp )
{
printf("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n");
printf("Error opening file %s for output\n");
printf("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n");
continue;
}
LPD3DXBUFFER compiledShader = 0L;
LPD3DXBUFFER compilationErrors = 0L;
DWORD flags = 0;
LPD3DXINCLUDE include = 0L;
HRESULT hr = D3DXAssembleShaderFromFile(
inFile,
0L,
include,
flags,
&compiledShader,
&compilationErrors);
if( FAILED(hr) )
{
printf("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n");
printf(compilationErrors ? (char*)compilationErrors->GetBufferPointer() : "File not found");
continue;
}
sprintf(inFile, "sha/%s.inl", varName);
ICreateHeader(varName, inFile, fp, compiledShader);
fclose(fp);
}
return 0;
}
