//---------------------------------------------// //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; }