//初始化像素着色器
bool InitEffect()
{
HRESULT rlt;
ID3DXBuffer* shader = NULL;
ID3DXBuffer* errorBuffer = NULL;
/*
rlt = D3DXCompileShaderFromFileW(
L"effect.txt",0,0,
"effect","ps_2_0",0,&shader,&errorBuffer,&MultiTexCT);//*/
rlt = D3DXCompileShaderFromResource(hmod,MAKEINTRESOURCEW(IDR_RCDATA1),0,0,"effect","ps_2_0",0,&shader,&errorBuffer,&MultiTexCT);
if( errorBuffer )
{
MessageBoxA(0, (char*)errorBuffer->GetBufferPointer(), 0, 0);
errorBuffer->Release();
return false;
}
if(FAILED(rlt))
{
MessageBoxA(0,"执行D3DXCompileShader失败!", "错误", 0);
return false;
}
if(FAILED(g_pd3dD->CreatePixelShader((DWORD*)shader->GetBufferPointer(),&MultiTexPS)))
{
MessageBoxA(0,"执行CreatePixelShader失败!", "错误", 0);
return false;
}
shader->Release();
MultiTexCT->SetDefaults(g_pd3dD);
alphaHandle = MultiTexCT->GetConstantByName(0, "alpha");
alpha_oldHandle = MultiTexCT->GetConstantByName(0, "alpha_old");
alpha_newHandle = MultiTexCT->GetConstantByName(0, "alpha_new");
typeHandle = MultiTexCT->GetConstantByName(0, "type");
sample0Handle = MultiTexCT->GetConstantByName(0, "Samp0");
sample1Handle = MultiTexCT->GetConstantByName(0, "Samp1");
sample2Handle = MultiTexCT->GetConstantByName(0, "Samp2");
UINT count;
MultiTexCT->GetConstantDesc(sample0Handle, &sample0Desc, &count);
MultiTexCT->GetConstantDesc(sample1Handle, &sample1Desc, &count);
MultiTexCT->GetConstantDesc(sample2Handle, &sample2Desc, &count);
return true;
}
HRESULT MESH::Load(char fName[], IDirect3DDevice9* Dev)
{
m_pDevice = Dev;
//Set m_white material
m_white.Ambient = m_white.Specular = m_white.Diffuse = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
m_white.Emissive = D3DXCOLOR(0.0f, 0.0f, 0.0f, 1.0f);
m_white.Power = 1.0f;
Release();
//Load new m_pMesh
ID3DXBuffer * adjacencyBfr = NULL;
ID3DXBuffer * materialBfr = NULL;
DWORD noMaterials = NULL;
if(FAILED(D3DXLoadMeshFromX(fName, D3DXMESH_MANAGED, m_pDevice,
&adjacencyBfr, &materialBfr, NULL,
&noMaterials, &m_pMesh)))
return E_FAIL;
D3DXMATERIAL *mtrls = (D3DXMATERIAL*)materialBfr->GetBufferPointer();
for(int i=0;i<(int)noMaterials;i++)
{
//mtrls[i].MatD3D.Ambient = mt[i].MatD3D.Diffuse;
m_materials.push_back(mtrls[i].MatD3D);
if(mtrls[i].pTextureFilename != NULL)
{
char textureFileName[90];
strcpy(textureFileName, "meshes/");
strcat(textureFileName, mtrls[i].pTextureFilename);
IDirect3DTexture9 * newTexture = NULL;
D3DXCreateTextureFromFile(m_pDevice, textureFileName, &newTexture);
m_textures.push_back(newTexture);
}
else m_textures.push_back(NULL);
}
m_pMesh->OptimizeInplace(D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_COMPACT | D3DXMESHOPT_VERTEXCACHE,
(DWORD*)adjacencyBfr->GetBufferPointer(), NULL, NULL, NULL);
adjacencyBfr->Release();
materialBfr->Release();
return S_OK;
}
bool MGEhud::init(IDirect3DDevice9 *d)
{
device = d;
device->GetViewport(&vp);
LOG::logline(">> HUD init");
HRESULT hr = device->CreateVertexBuffer(max_elements * 4 * 32, D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY, fvfHUD, D3DPOOL_DEFAULT, &vbHUD, 0);
if(hr != D3D_OK)
{
LOG::logline("!! Failed to create HUD verts");
return false;
}
ID3DXBuffer *errors;
hr = D3DXCreateEffectFromFile(device, "Data Files\\shaders\\XE HUD.fx", 0, 0, 0, 0, &effectStandard, &errors);
if(hr != D3D_OK)
{
LOG::logline("!! HUD Shader errors: %s", errors->GetBufferPointer());
errors->Release();
return false;
}
if(element_names.empty())
reset();
else
reload();
LOG::logline("<< HUD init");
return true;
}
Model Model::createFromFile(const GraphicsDevice& device, const std::string& filename)
{
Model model;
ID3DXBuffer* materialBuffer;
unsigned long numMaterials;
D3DXLoadMeshFromXA(filename.c_str(), D3DXMESH_MANAGED, device, 0, &materialBuffer, 0, &numMaterials, &model.mesh);
model.materials = MaterialCollection(numMaterials);
model.textures = TextureCollection(numMaterials);
D3DXMATERIAL* materials = (D3DXMATERIAL*)materialBuffer->GetBufferPointer();
std::string path = filename.substr(0, filename.find_last_of('/') + 1);
for (unsigned i = 0; i < numMaterials; ++i)
{
if (materials[i].pTextureFilename)
model.textures[i] = Texture::createFromFile(device, path + materials[i].pTextureFilename);
model.materials[i] = materials[i].MatD3D;
}
materialBuffer->Release();
return model;
}
Mesh::Mesh(LPCWSTR file)
: _mesh(NULL)
, _meshMaterials(NULL)
, _meshTextures(NULL)
, _meshMaterialCount(0)
{
ID3DXBuffer * meshMaterialBuffer = NULL;
HRESULT hr = D3DXLoadMeshFromX(file, 0, dxr->device, NULL, &meshMaterialBuffer, NULL, &_meshMaterialCount, &_mesh);
_ASSERT(SUCCEEDED(hr));
if (meshMaterialBuffer && _meshMaterialCount > 0)
{
D3DXMATERIAL* d3dxMaterials = (D3DXMATERIAL*)meshMaterialBuffer->GetBufferPointer();
_meshMaterials = new D3DMATERIAL9[_meshMaterialCount];
_meshTextures = new IDirect3DTexture9 * [_meshMaterialCount];
for (unsigned long i = 0; i < _meshMaterialCount; i++)
{
_meshMaterials[i] = d3dxMaterials[i].MatD3D;
if (D3DXCOLOR(0xff000000) == _meshMaterials[i].Ambient)
_meshMaterials[i].Ambient = D3DXCOLOR(0.75,0.75,0.75,0.75);
_meshTextures[i] = NULL;
if (d3dxMaterials[i].pTextureFilename)
{
QString texturePath = native(QFileInfo(QString::fromUtf16((const ushort *)file)).dir() / QFileInfo(d3dxMaterials[i].pTextureFilename).fileName());
hr = D3DXCreateTextureFromFileW(dxr->device, (LPCWSTR)texturePath.utf16(), &_meshTextures[i]);
_ASSERT(SUCCEEDED(hr));
}
}
}
meshMaterialBuffer->Release();
}
void AssetLoader::loadEffect(LPCSTR path)
{
ID3DXEffect * tempFX;
ID3DXBuffer *errors = NULL;
string tech = path;
while (tech.back() != '.')
tech.pop_back();
tech.pop_back(); //.
tech += string("Technique");
int rc = D3DXCreateEffectFromFile(d3dDev,
path,
0, 0, D3DXSHADER_DEBUG | D3DXSHADER_SKIPOPTIMIZATION, 0,
&tempFX,
&errors);
if (errors != NULL)
{
MessageBox(0, (char*) errors->GetBufferPointer(),0,0);
errors->Release();
}
else
{
Effect * tempEffect = new Effect();
tempEffect->name = path;
tempEffect->techniqueName = tech;
tempEffect->inUse = false;
tempEffect->effect = tempFX;
peffects->push_back(tempEffect);
}
}
GBitmap *AtlasTexChunk::loadDDSIntoGBitmap(const U8 *ddsBuffer, U32 ddsBufferSize)
{
D3DXIMAGE_INFO info;
D3D9Assert(GFXD3DX.D3DXGetImageInfoFromFileInMemory(ddsBuffer, ddsBufferSize, &info),
"AtlasTexChunk::loadDDSIntoGBitmap - failed to get image info.");
IDirect3DSurface9 *surf = NULL;
D3D9Assert(((GFXD3D9Device*)GFX)->getDevice()->CreateOffscreenPlainSurface(
info.Width, info.Height, info.Format, D3DPOOL_SCRATCH, &surf, NULL),
"AtlasTexChunk::loadDDSIntoGBitmap - failed to allocate scratch surface.");
// We want JPEGs, let's convert it in a klunky way...
D3D9Assert(GFXD3DX.D3DXLoadSurfaceFromFileInMemory(surf, NULL, NULL,
ddsBuffer, ddsBufferSize, NULL,
D3DX_DEFAULT, 0, NULL),
"AtlasTexChunk::loadDDSIntoGBitmap - D3DX failed to load from buffer.");
ID3DXBuffer *buff = NULL;
D3D9Assert(GFXD3DX.D3DXSaveSurfaceToFileInMemory(&buff, D3DXIFF_PNG, surf, NULL, NULL),
"AtlasTexChunk::loadDDSIntoGBitmap - D3DX failed to save back to buffer.");
MemStream ms(buff->GetBufferSize(), buff->GetBufferPointer(), true, false);
GBitmap *bitmap = new GBitmap[1];
bitmap->readBitmap( "png", ms );
// Cleanup!
buff->Release();
surf->Release();
return bitmap;
}
//--------------------------------------------------------------------------------------
//LoadShader
//--------------------------------------------------------------------------------------
HRESULT CEffect::LoadShader(WCHAR *a_Filename, IDirect3DDevice9 *a_pDevice)
{
HRESULT hr;
ID3DXBuffer *errorBuffer;
WCHAR str[MAX_PATH];
m_pDevice = a_pDevice;
//delete old effect if multiple calls to load shader are made
SAFE_RELEASE(m_pEffect);
// 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_FORCE_VS_SOFTWARE_NOOPT;
#endif
#ifdef DEBUG_PS
dwShaderFlags |= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT;
#endif
// Read the D3DX effect file
hr = DXUTFindDXSDKMediaFileCch( str, MAX_PATH, a_Filename );
// search DX search paths for .fx file
if(FAILED(hr))
{
_snwprintf_s(m_ErrorMsg, MAX_ERROR_MSG, MAX_ERROR_MSG, L"Error: Can't Find Shader %s in any search paths.", a_Filename);
return STG_E_FILENOTFOUND;
}
//load and compile .fx file
// If this fails, there should be debug output as to
// why the .fx file failed to compile
hr = D3DXCreateEffectFromFile( m_pDevice, str, NULL, NULL,
dwShaderFlags, NULL, &m_pEffect, &errorBuffer );
//return failure and record error message if failure
if(FAILED(hr))
{ //error is in 8-bit character format, so for swprintf to use the string, %S (capital S) is used.
_snwprintf_s(m_ErrorMsg, MAX_ERROR_MSG, MAX_ERROR_MSG, L"Shader Compile Error: %S.", errorBuffer->GetBufferPointer() );
errorBuffer->Release();
return hr;
}
_snwprintf_s(m_ErrorMsg, MAX_ERROR_MSG, MAX_ERROR_MSG, L"FX file %s Compiled Successfully.", a_Filename);
return S_OK;
}
bool Blit::setShader(ShaderId source, const char *profile,
HRESULT (WINAPI IDirect3DDevice9::*createShader)(const DWORD *, D3DShaderType**),
HRESULT (WINAPI IDirect3DDevice9::*setShader)(D3DShaderType*))
{
IDirect3DDevice9 *device = getDevice();
D3DShaderType *shader;
if (mCompiledShaders[source] != NULL)
{
shader = static_cast<D3DShaderType*>(mCompiledShaders[source]);
}
else
{
ID3DXBuffer *shaderCode;
HRESULT hr = D3DXCompileShader(mShaderSource[source], strlen(mShaderSource[source]), NULL, NULL, "main", profile, 0, &shaderCode, NULL, NULL);
if (FAILED(hr))
{
ERR("Failed to compile %s shader for blit operation %d, error 0x%08X.", profile, (int)source, hr);
return false;
}
hr = (device->*createShader)(static_cast<const DWORD*>(shaderCode->GetBufferPointer()), &shader);
if (FAILED(hr))
{
shaderCode->Release();
ERR("Failed to create %s shader for blit operation %d, error 0x%08X.", profile, (int)source, hr);
return false;
}
shaderCode->Release();
mCompiledShaders[source] = shader;
}
HRESULT hr = (device->*setShader)(shader);
if (FAILED(hr))
{
ERR("Failed to set %s shader for blit operation %d, error 0x%08X.", profile, (int)source, hr);
return false;
}
return true;
}
bool NavigationLine::CreateDeviceObjects()
{
if (!m_visible)
return true;
ID3DXBuffer* errors = 0;
HRESULT hr;
hr = D3DXCreateTextureFromFileA(g_pDevice, m_textureFile.c_str(), &m_lineTexture);
if (FAILED(hr))
{
DebugSpewAlways("Failed to load texture!");
InvalidateDeviceObjects();
return false;
}
hr = D3DXCreateEffectFromFileA(g_pDevice, m_shaderFile.c_str(),
NULL, NULL, 0, NULL, &m_effect, &errors);
if (FAILED(hr))
{
if (errors)
{
DebugSpewAlways("Effect error: %s", errors->GetBufferPointer());
errors->Release();
errors = nullptr;
}
InvalidateDeviceObjects();
return false;
}
D3DVERTEXELEMENT9 vertexElements[] =
{
{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
{ 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0 },
{ 0, 24, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
{ 0, 40, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1 },
D3DDECL_END()
};
hr = g_pDevice->CreateVertexDeclaration(vertexElements, &m_vDeclaration);
if (FAILED(hr))
{
InvalidateDeviceObjects();
return false;
}
m_effect->SetTexture("lineTexture", m_lineTexture);
m_loaded = true;
return true;
}
void VertexShader::Create(IDirect3DDevice9* device, const char* fileName, const char* entryPoint, const char* macroDefinition)
{
Destroy();
ID3DXBuffer* shaderCode = Shader::CreateFromFile(fileName, "vs_3_0", entryPoint, macroDefinition);
if (shaderCode)
{
device->CreateVertexShader( ( DWORD* )shaderCode->GetBufferPointer(), &vertexShader );
shaderCode->Release();
}
}
bool CompileVertexShader(const char *code, LPDIRECT3DVERTEXSHADER9 *pShader, LPD3DXCONSTANTTABLE *pShaderTable, std::string &errorMessage) {
ID3DXBuffer *pShaderCode = nullptr;
ID3DXBuffer *pErrorMsg = nullptr;
// Compile pixel shader.
HRESULT hr = dyn_D3DXCompileShader(code,
(UINT)strlen(code),
nullptr,
nullptr,
"main",
"vs_2_0",
0,
&pShaderCode,
&pErrorMsg,
pShaderTable);
if (pErrorMsg) {
errorMessage = (CHAR *)pErrorMsg->GetBufferPointer();
pErrorMsg->Release();
} else if (FAILED(hr)) {
errorMessage = GetStringErrorMsg(hr);
} else {
errorMessage = "";
}
if (FAILED(hr) || !pShaderCode) {
if (pShaderCode)
pShaderCode->Release();
return false;
}
// Create pixel shader.
pD3Ddevice->CreateVertexShader( (DWORD*)pShaderCode->GetBufferPointer(),
pShader );
pShaderCode->Release();
return true;
}
bool CompilePixelShader(const char *code, LPDIRECT3DPIXELSHADER9 *pShader, LPD3DXCONSTANTTABLE *pShaderTable, std::string &errorMessage) {
ID3DXBuffer* pShaderCode = NULL;
ID3DXBuffer* pErrorMsg = NULL;
HRESULT hr = -1;
// Compile pixel shader.
hr = dyn_D3DXCompileShader(code,
(UINT)strlen(code),
NULL,
NULL,
"main",
"ps_2_0",
0,
&pShaderCode,
&pErrorMsg,
pShaderTable);
if (pErrorMsg) {
errorMessage = (CHAR *)pErrorMsg->GetBufferPointer();
pErrorMsg->Release();
} else {
errorMessage = "";
}
if (FAILED(hr)) {
if (pShaderCode)
pShaderCode->Release();
return false;
}
// Create pixel shader.
pD3Ddevice->CreatePixelShader( (DWORD*)pShaderCode->GetBufferPointer(),
pShader );
pShaderCode->Release();
return true;
}
bool PrepareShader()
{
ID3DXBuffer *shader ;
ID3DXBuffer *errorBuffer ;
// Compile shader from file, Shader.txt must exist in current directory, and it must contain
// the "Main" function
HRESULT hr = D3DXCompileShaderFromFileA("torus.fx", 0, 0, "Main", "ps_2_0",
D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY, &shader, &errorBuffer, NULL) ;
// output any error messages
if( errorBuffer )
{
MessageBoxA(0, (char*)errorBuffer->GetBufferPointer(), 0, 0);
errorBuffer->Release() ;
}
if(FAILED(hr))
{
MessageBox(0, L"D3DXCompileShaderFromFile() - FAILED", 0, 0);
return false;
}
// Create pixel shader
hr = g_pd3dDevice->CreatePixelShader((DWORD*)shader->GetBufferPointer(), &g_pPixelShader) ;
// handling error
if(FAILED(hr))
{
MessageBox(0, L"CreatePixelShader - FAILED", 0, 0);
return false;
}
// Release DX buffer
shader->Release() ;
return true ;
}
HRESULT CMesh3D::InitialMesh(LPCSTR Name, FILE *FileLog )
{
m_pMesh = 0;
m_pMeshMaterial = 0;
m_pMeshTextura = 0;
m_SizeFVF = 0;
m_Alpha = 1.0f;
ID3DXBuffer *pMaterialBuffer = 0;
if ( FAILED( D3DXLoadMeshFromX( Name, D3DXMESH_SYSTEMMEM, g_pD3DDevice, 0, &pMaterialBuffer, 0, &m_TexturCount, &m_pMesh ) ) )
{
if ( m_pMesh == 0 )
{
if ( FileLog )
fprintf( FileLog, "error load x file '%s'\n", Name );
return E_FAIL;
}
}
if ( m_pMesh->GetFVF() & D3DFVF_XYZ )
m_SizeFVF += sizeof(float)*3;
if ( m_pMesh->GetFVF() & D3DFVF_NORMAL )
m_SizeFVF += sizeof(float)*3;
if ( m_pMesh->GetFVF() & D3DFVF_TEX1 )
m_SizeFVF += sizeof(float)*2;
m_pMesh->GetVertexBuffer( &m_VertexBuffer );
m_pMesh->GetIndexBuffer( &m_IndexBuffer );
// Извлекаем свойства материала и названия{имена} структуры
D3DXMATERIAL *D3DXMeshMaterial = (D3DXMATERIAL *)pMaterialBuffer->GetBufferPointer();
m_pMeshMaterial = new D3DMATERIAL9[m_TexturCount];
m_pMeshTextura = new IDirect3DTexture9*[m_TexturCount];
for ( DWORD i = 0; i < m_TexturCount; i++ )
{
// Копируем материал
m_pMeshMaterial[i] = D3DXMeshMaterial[i].MatD3D;
// Установить окружающего свет
m_pMeshMaterial[i].Ambient = m_pMeshMaterial[i].Diffuse;
// Загружаем текстуру
string FileName = string( "model//" ) + string( D3DXMeshMaterial[i].pTextureFilename );
if ( FAILED( D3DXCreateTextureFromFile( g_pD3DDevice, FileName.c_str(), &m_pMeshTextura[i] )))
{
fprintf( FileLog, "error load texture '%s'\n", D3DXMeshMaterial[i].pTextureFilename );
m_pMeshTextura[i] = 0;
}
}
// Уничтожаем буфер материала
pMaterialBuffer->Release();
return S_OK;
}
MeshObject::MeshObject( const char *name, const char *path, const char *file_name, bool lighten ) :
Object(std::string(name))
{
ID3DXBuffer *pMat = NULL;
_isLightenUp = lighten;
_mesh = 0;
_materials = 0;
_textures = 0;
std::string full_name = std::string(path) + std::string("\\") + std::string(file_name);
HRESULT hr = D3DXLoadMeshFromX(full_name.c_str(), D3DXMESH_SYSTEMMEM, getDevice(),
NULL, &pMat, NULL, &_numMaterials, &_mesh);
if (SUCCEEDED(hr))
{
D3DXMATERIAL* pD3DXMaterials=(D3DXMATERIAL*)pMat->GetBufferPointer();
_materials = new D3DMATERIAL9[_numMaterials];
_textures = new LPDIRECT3DTEXTURE9[_numMaterials];
for (DWORD i = 0; i < _numMaterials; ++i)
{
_materials[i] = pD3DXMaterials[i].MatD3D;
_materials[i].Ambient = _materials[i].Diffuse;
if (pD3DXMaterials[i].pTextureFilename != 0)
{
std::string full_tex_name = std::string(path) +
"\\" + std::string(pD3DXMaterials[i].pTextureFilename);
hr = D3DXCreateTextureFromFile(getDevice(),
full_tex_name.c_str(), &(_textures[i]));
if (FAILED(hr))
_textures[i] = 0;
}
else
_textures[i] = 0;
}
if (pMat)
pMat->Release();
_mesh->OptimizeInplace(D3DXMESHOPT_COMPACT |
D3DXMESHOPT_ATTRSORT, NULL, NULL, NULL, NULL);
}
}
Teapot::Teapot()
{
D3DXCreateTeapot(theDevice, &m_mesh, nullptr);
ID3DXBuffer* errorBuffer;
D3DXCreateEffectFromFile(theDevice, "Teapot.fx", 0, 0,
D3DXSHADER_DEBUG, 0, &m_effect, &errorBuffer);
if (errorBuffer)
{
Error((char*)errorBuffer->GetBufferPointer());
errorBuffer->Release();
}
m_hWorldViewProj = m_effect->GetParameterByName(0, "matWorldViewProj");
}
void initEffect()
{
ID3DXBuffer* errorBuffer = 0;
D3DXCreateEffectFromFile(
device,
L"effect.fx",
NULL, // CONST D3DXMACRO* pDefines,
NULL, // LPD3DXINCLUDE pInclude,
D3DXSHADER_USE_LEGACY_D3DX9_31_DLL,
NULL, // LPD3DXEFFECTPOOL pPool,
&effect,
&errorBuffer);
if(errorBuffer)
{
MessageBoxA(hMainWnd, (char*)errorBuffer->GetBufferPointer(), 0, 0);
errorBuffer->Release();
terminate();
}
D3DXMATRIX W, V, P, Result;
D3DXMatrixIdentity(&Result);
device->GetTransform(D3DTS_WORLD, &W);
device->GetTransform(D3DTS_VIEW, &V);
device->GetTransform(D3DTS_PROJECTION, &P);
D3DXMatrixMultiply(&Result, &W, &V);
D3DXMatrixMultiply(&Result, &Result, &P);
effect->SetMatrix(effect->GetParameterByName(0, "WorldViewProj"), &Result);
effect->SetTechnique(effect->GetTechnique(0));
auto hr = effect->SetTexture(effect->GetParameterByName(NULL, "Overlay"), overlayTexture);
hr |= effect->SetTexture(effect->GetParameterByName(NULL, "Base"), particleTexture);
hr |= effect->SetTexture(effect->GetParameterByName(NULL, "PreRender"), renderTexture);
if(hr != 0)
{
MessageBox(hMainWnd, L"Unable to set effect textures.", L"", MB_ICONHAND);
}
}
bool TerrainLodMap2::save( DataSectionPtr parentSection, const std::string& name ) const
{
BW_GUARD;
bool ok = false;
// copy texture to a file buffer in memory
ID3DXBuffer* pBuffer = NULL;
HRESULT hr = D3DXSaveTextureToFileInMemory( &pBuffer, D3DXIFF_DDS,
pLodMap_.pComObject(), NULL );
if (SUCCEEDED(hr))
{
// copy buffer to binary block
BinaryPtr pBlock = new BinaryBlock( pBuffer->GetBufferPointer(),
pBuffer->GetBufferSize(), "BinaryBlock/TerrainPhotographer" );
pBuffer->Release();
// write binary block to data section
ok = parentSection->writeBinary( name, pBlock );
}
return ok;
}
void MGEhud::setEffect(hud_id hud, const char *effect)
{
Element *e = &elements[hud];
char path[MAX_PATH];
ID3DXBuffer *errors;
// Clear current effect
if(e->effect)
e->effect->Release();
e->effect = 0;
e->effectFilename.clear();
// Load new effect if string is not empty
if(*effect)
{
sprintf_s(path, MAX_PATH, "Data Files\\shaders\\%s.fx", effect);
HRESULT hr = D3DXCreateEffectFromFile(device, path, 0, 0, 0, 0, &e->effect, &errors);
if(hr == D3D_OK)
{
LOG::logline("-- HUD shader %s loaded", path);
e->effectFilename = effect;
}
else
{
e->effect = 0;
LOG::logline("!! HUD shader %s failed to load/compile", path);
if(errors)
{
LOG::logline("!! Shader errors: %s", errors->GetBufferPointer());
errors->Release();
}
}
}
}
void mini3d::D3D9VertexShader::LoadResource(void)
{
IDirect3DDevice9* pDevice = pGraphicsService->GetDevice();
if (pDevice == 0)
return;
// If the buffer exists tear it down.
if (pShaderBuffer != 0)
{
UnloadResource();
}
// compile the shader source
ID3DXBuffer* buffer;
LPD3DXBUFFER ppErroMessage;
D3DXCompileShader((LPCSTR)pShaderBytes, sizeInBytes, 0, 0, "main", "vs_2_0", 0, &buffer, &ppErroMessage, 0);
if (ppErroMessage != 0)
{
OutputDebugStringA((char*)(ppErroMessage->GetBufferPointer()));
isDirty = true;
return;
}
if( FAILED( pDevice->CreateVertexShader((DWORD*)buffer->GetBufferPointer(), &pShaderBuffer)))
{
isDirty = true;
return;
}
buffer->Release();
isDirty = false;
// load the vertex declaration into the pool
pGraphicsService->PoolVertexDeclaration(vertexDeclaration, vertexDataCount);
}
bool DevEffect::CompileVersion(
const char *id, const char *path, vector<byte> &bin,
vector<D3DXMACRO> ¯os, const char *skip_list )
{
ID3DXEffect *fx = NULL;
ID3DXBuffer *errors = NULL;
HRESULT r = D3DXCreateEffectEx(Dev.GetDevice(),&bin[0],(DWORD)bin.size(),¯os[0],NULL,skip_list,
compile_flags,pool,&fx,&errors);
if(FAILED(r) || errors)
{
if(errors)
{
last_error = format("%s:%s: %s",path,id,(char*)errors->GetBufferPointer());
if(!(flags&FXF_NO_ERROR_POPUPS))
if(MessageBox(NULL,last_error.c_str(),format("%s:%s",path,id).c_str(),MB_OKCANCEL)==IDCANCEL)
ExitProcess(0);
errors->Release();
return false;
}
else
{
last_error = format("%s:%s: Unknown error!",path,id);
if(!(flags&FXF_NO_ERROR_POPUPS))
if(MessageBox(NULL,last_error.c_str(),format("%s:%s",path,id).c_str(),MB_OKCANCEL)==IDCANCEL)
ExitProcess(0);
return false;
}
}
version_index[id] = (int)fx_list.size();
fx_list.push_back(fx);
return true;
}
bool CompilePixelShader(const char * code, LPDIRECT3DPIXELSHADER9 * pShader, LPD3DXCONSTANTTABLE * pShaderTable) {
LPD3DXCONSTANTTABLE shaderTable = *pShaderTable;
ID3DXBuffer* pShaderCode = NULL;
ID3DXBuffer* pErrorMsg = NULL;
HRESULT hr = -1;
#ifdef _XBOX
// Compile pixel shader.
hr = D3DXCompileShader( code,
(UINT)strlen( code ),
NULL,
NULL,
"main",
"ps_3_0",
0,
&pShaderCode,
&pErrorMsg,
pShaderTable );
#endif
if( FAILED(hr) )
{
OutputDebugStringA((CHAR*)pErrorMsg->GetBufferPointer());
DebugBreak();
return false;
}
// Create pixel shader.
pD3Ddevice->CreatePixelShader( (DWORD*)pShaderCode->GetBufferPointer(),
pShader );
pShaderCode->Release();
return true;
}
bool Setup()
{
HRESULT hr;
ID3DXBuffer* mtrlBuffer = 0;
DWORD numMtrl = 0;
hr = D3DXLoadMeshFromX(
L"mountain.x",
D3DXMESH_MANAGED,
Device,
0,
&mtrlBuffer,
0,
&numMtrl,
&pMesh);
if (FAILED(hr))
{
::MessageBoxA(0, "D3DXLoadMeshFromX() - Failed!", 0, 0);
return false;
}
if (mtrlBuffer != 0 && numMtrl != 0)
{
D3DXMATERIAL* mtrls = (D3DXMATERIAL*)mtrlBuffer->GetBufferPointer();
for (DWORD i = 0; i < numMtrl; ++i)
{
mtrls[i].MatD3D.Ambient = mtrls[i].MatD3D.Diffuse;
Mtrls.push_back(mtrls[i].MatD3D);
if (mtrls[i].pTextureFilename != 0)
{
IDirect3DTexture9* tex = 0;
D3DXCreateTextureFromFileA(
Device,
mtrls[i].pTextureFilename,
&tex);
Textures.push_back(tex);
}
else
{
Textures.push_back(0);
}
}
}
mtrlBuffer->Release();
ID3DXBuffer* pError;
hr = D3DXCreateEffectFromFile(
Device,
L"light_tex.txt",
0,
0,
D3DXSHADER_DEBUG,
0,
&pLightTexEffect,
&pError);
if (FAILED(hr))
{
::MessageBoxA(0, (char*)pError->GetBufferPointer(), 0, 0);
return false;
}
hWorldMatrix = pLightTexEffect->GetParameterByName(0, "WorldMatrix");
hViewMatrix = pLightTexEffect->GetParameterByName(0, "ViewMatrix");
hProjMatrix = pLightTexEffect->GetParameterByName(0, "ProjMatrix");
hTex = pLightTexEffect->GetParameterByName(0, "Tex");
hLightTexTech = pLightTexEffect->GetTechniqueByName("LightAndTexture");
D3DXMATRIX W, P;
D3DXMatrixIdentity(&W);
pLightTexEffect->SetMatrix(hWorldMatrix, &W);
D3DXMatrixPerspectiveFovLH(
&P,
D3DX_PI*0.25f,
(float)Width / Height,
1.0f, 1000.0f);
pLightTexEffect->SetMatrix(hProjMatrix, &P);
IDirect3DTexture9* tex = 0;
D3DXCreateTextureFromFile(Device, L"Terrain_3x_diffcol.jpg", &tex);
pLightTexEffect->SetTexture(hTex, tex);
tex->Release();
return true;
}
bool SPPixelShaderCore::Load( SPString path )
{
name = path;
SPFilePtr file = SPFileManager::GetSingleton().OpenFile(path);
if (!file)
{
SPLogHelper::WriteLog(L"[SPShader] WARNING: Failed to open shader file: " + path);
return false;
}
ID3DXBuffer* shaderBuffer = NULL;
ID3DXBuffer* errorBuffer = NULL;
LONGLONG length = file->GetFileLength();
char* pData = new char[(UINT)length];
if(!file->Read(pData, (DWORD)length))
{
SPLogHelper::WriteLog(L"[SPShader] WARNING: Failed to read shader file: " + path);
return false;
}
// Compile shader files.
HRESULT hr = D3DXCompileShader(
pData, (UINT)length, 0, 0, "Main", "ps_2_0", D3DXSHADER_DEBUG,
&shaderBuffer, &errorBuffer, &constantTable);
delete [] pData;
SPFileManager::GetSingleton().CloseFile(path);
if (errorBuffer)
{
SPLogHelper::WriteLog(L"[SPShader] WARNING: There is error in shader file: " + path);
SPLogHelper::WriteLog("[SPShader] Message: " + string((char*)errorBuffer->GetBufferPointer()));
errorBuffer->Release();
}
if (FAILED(hr))
{
SPLogHelper::WriteLog(L"[SPShader] WARNING: Failed to compile shader file: " + path);
return false;
}
// Create pixel shader.
hr = SPDevice::GetSingleton().GetD3DDevice()->CreatePixelShader(
(DWORD*)shaderBuffer->GetBufferPointer(), &pixelShader);
if (FAILED(hr))
{
SPLogHelper::WriteLog(L"[SPShader] WARNING: Failed to create pixel shader");
if (shaderBuffer)
{
shaderBuffer->Release();
shaderBuffer = NULL;
}
return false;
}
shaderBuffer->Release();
shaderBuffer = NULL;
return true;
}
bool U2D3DXEffectShader::LoadResource()
{
U2ASSERT(0 == m_pD3DEffect);
HRESULT hr;
IDirect3DDevice9* pD3DDev = m_pRenderer->GetD3DDevice();
U2ASSERT(pD3DDev);
U2FilePath fPath;
TCHAR fullPath[MAX_PATH];
// StackString Memory Leak...
U2DynString includePath(FX_SHADER_PATH);
includePath += _T("\\2.0");
fPath.ConvertToAbs(fullPath, MAX_PATH * sizeof(TCHAR) , m_szFilename.Str(), includePath);
U2File* pFile = U2File::GetFile(fullPath, U2File::READ_ONLY);
if(!pFile)
{
U2_DELETE pFile;
return false;
}
uint32 uBuffLen = pFile->GetfileSize();
if(uBuffLen == 0)
{
U2_DELETE pFile;
return false;
}
unsigned char* pBuffer = U2_ALLOC(unsigned char, uBuffLen);
pFile->Read(pBuffer, uBuffLen);
U2_DELETE pFile;
ID3DXBuffer* pErrorBuffer = NULL;
#ifdef DEBUG_SHADER
DWORD compileFlags = D3DXSHADER_DEBUG | D3DXSHADER_SKIPOPTIMIZATION | D3DXSHADER_USE_LEGACY_D3DX9_31_DLL
| D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT | D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT ;
#else
DWORD compileFlags = D3DXSHADER_USE_LEGACY_D3DX9_31_DLL;
#endif
//U2DynString includePath(FX_SHADER_PATH);
//includePath += _T("\\2.0");
U2D3DXEffectShaderInclude includeHandler(includePath);
ID3DXEffectPool* pEffectPool = m_pRenderer->GetD3DEffectPool();
U2ASSERT(pEffectPool);
// get the highest supported shader profiles
// LPCSTR vsProfile, psProfile;
//#ifdef UNICODE
// vsProfile = ToUnicode( D3DXGetVertexShaderProfile(pD3DDev) );
// psProfile = ToUnicode( D3DXGetPixelShaderProfile(pD3DDev) );
//#else
// vsProfile = D3DXGetVertexShaderProfile(pD3DDev);
// psProfile = D3DXGetPixelShaderProfile(pD3DDev);
//#endif
LPCSTR vsProfile = D3DXGetVertexShaderProfile(pD3DDev);
LPCSTR psProfile = D3DXGetPixelShaderProfile(pD3DDev);
if (0 == vsProfile)
{
FDebug("Invalid Vertex Shader profile! Fallback to vs_2_0!\n");
vsProfile = "vs_2_0";
}
if (0 == psProfile)
{
FDebug("Invalid Pixel Shader profile! Fallback to ps_2_0!\n");
psProfile = "ps_2_0";
}
// create macro definitions for shader compiler
D3DXMACRO defines[] = {
{ "VS_PROFILE", vsProfile },
{ "PS_PROFILE", psProfile },
{ 0, 0 },
};
// create effect
if (compileFlags)
{
hr = D3DXCreateEffectFromFile(
pD3DDev, // pDevice
fullPath, // File name
defines, // pDefines
&includeHandler, // pInclude
compileFlags, // Flags
pEffectPool, // pPool
&m_pD3DEffect, // ppEffect
&pErrorBuffer); // ppCompilationErrors
}
else
{
hr = D3DXCreateEffect(
pD3DDev, // pDevice
pBuffer, // pFileData
uBuffLen, // DataSize
defines, // pDefines
&includeHandler, // pInclude
compileFlags, // Flags
pEffectPool, // pPool
&(m_pD3DEffect), // ppEffect
&pErrorBuffer); // ppCompilationErrors
}
U2_FREE(pBuffer);
pBuffer = NULL;
if (FAILED(hr))
{
FDebug("nD3D9Shader: failed to load fx file '%s' with:\n\n%s\n",
fullPath,
pErrorBuffer ? pErrorBuffer->GetBufferPointer() : "No D3DX error message.");
if (pErrorBuffer)
{
pErrorBuffer->Release();
}
return false;
}
U2ASSERT(m_pD3DEffect);
m_bValidated = false;
m_bNotValidate = false;
this->ValidateEffect();
return true;
}
//-------------------------------------------------------------------------------
int CMaterialManager::CreateMaterial(
AssetHelper::MeshHelper* pcMesh,const aiMesh* pcSource)
{
ai_assert(NULL != pcMesh);
ai_assert(NULL != pcSource);
ID3DXBuffer* piBuffer;
D3DXMACRO sMacro[64];
// extract all properties from the ASSIMP material structure
const aiMaterial* pcMat = g_pcAsset->pcScene->mMaterials[pcSource->mMaterialIndex];
//
// DIFFUSE COLOR --------------------------------------------------
//
if(AI_SUCCESS != aiGetMaterialColor(pcMat,AI_MATKEY_COLOR_DIFFUSE,
(aiColor4D*)&pcMesh->vDiffuseColor))
{
pcMesh->vDiffuseColor.x = 1.0f;
pcMesh->vDiffuseColor.y = 1.0f;
pcMesh->vDiffuseColor.z = 1.0f;
pcMesh->vDiffuseColor.w = 1.0f;
}
//
// SPECULAR COLOR --------------------------------------------------
//
if(AI_SUCCESS != aiGetMaterialColor(pcMat,AI_MATKEY_COLOR_SPECULAR,
(aiColor4D*)&pcMesh->vSpecularColor))
{
pcMesh->vSpecularColor.x = 1.0f;
pcMesh->vSpecularColor.y = 1.0f;
pcMesh->vSpecularColor.z = 1.0f;
pcMesh->vSpecularColor.w = 1.0f;
}
//
// AMBIENT COLOR --------------------------------------------------
//
if(AI_SUCCESS != aiGetMaterialColor(pcMat,AI_MATKEY_COLOR_AMBIENT,
(aiColor4D*)&pcMesh->vAmbientColor))
{
pcMesh->vAmbientColor.x = 0.0f;
pcMesh->vAmbientColor.y = 0.0f;
pcMesh->vAmbientColor.z = 0.0f;
pcMesh->vAmbientColor.w = 1.0f;
}
//
// EMISSIVE COLOR -------------------------------------------------
//
if(AI_SUCCESS != aiGetMaterialColor(pcMat,AI_MATKEY_COLOR_EMISSIVE,
(aiColor4D*)&pcMesh->vEmissiveColor))
{
pcMesh->vEmissiveColor.x = 0.0f;
pcMesh->vEmissiveColor.y = 0.0f;
pcMesh->vEmissiveColor.z = 0.0f;
pcMesh->vEmissiveColor.w = 1.0f;
}
//
// Opacity --------------------------------------------------------
//
if(AI_SUCCESS != aiGetMaterialFloat(pcMat,AI_MATKEY_OPACITY,&pcMesh->fOpacity))
{
pcMesh->fOpacity = 1.0f;
}
//
// Shading Model --------------------------------------------------
//
bool bDefault = false;
if(AI_SUCCESS != aiGetMaterialInteger(pcMat,AI_MATKEY_SHADING_MODEL,(int*)&pcMesh->eShadingMode ))
{
bDefault = true;
pcMesh->eShadingMode = aiShadingMode_Gouraud;
}
//
// Shininess ------------------------------------------------------
//
if(AI_SUCCESS != aiGetMaterialFloat(pcMat,AI_MATKEY_SHININESS,&pcMesh->fShininess))
{
// assume 15 as default shininess
pcMesh->fShininess = 15.0f;
}
else if (bDefault)pcMesh->eShadingMode = aiShadingMode_Phong;
//
// Shininess strength ------------------------------------------------------
//
if(AI_SUCCESS != aiGetMaterialFloat(pcMat,AI_MATKEY_SHININESS_STRENGTH,&pcMesh->fSpecularStrength))
{
// assume 1.0 as default shininess strength
pcMesh->fSpecularStrength = 1.0f;
}
aiString szPath;
aiTextureMapMode mapU(aiTextureMapMode_Wrap),mapV(aiTextureMapMode_Wrap);
bool bib =false;
if (pcSource->mTextureCoords[0])
{
//
// DIFFUSE TEXTURE ------------------------------------------------
//
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_DIFFUSE(0),&szPath))
{
LoadTexture(&pcMesh->piDiffuseTexture,&szPath);
aiGetMaterialInteger(pcMat,AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0),(int*)&mapU);
aiGetMaterialInteger(pcMat,AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0),(int*)&mapV);
}
//
// SPECULAR TEXTURE ------------------------------------------------
//
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_SPECULAR(0),&szPath))
{
LoadTexture(&pcMesh->piSpecularTexture,&szPath);
}
//
// OPACITY TEXTURE ------------------------------------------------
//
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_OPACITY(0),&szPath))
{
LoadTexture(&pcMesh->piOpacityTexture,&szPath);
}
else
{
int flags = 0;
aiGetMaterialInteger(pcMat,AI_MATKEY_TEXFLAGS_DIFFUSE(0),&flags);
// try to find out whether the diffuse texture has any
// non-opaque pixels. If we find a few, use it as opacity texture
if (pcMesh->piDiffuseTexture && !(flags & aiTextureFlags_IgnoreAlpha) && HasAlphaPixels(pcMesh->piDiffuseTexture))
{
int iVal;
// NOTE: This special value is set by the tree view if the user
// manually removes the alpha texture from the view ...
if (AI_SUCCESS != aiGetMaterialInteger(pcMat,"no_a_from_d",0,0,&iVal))
{
pcMesh->piOpacityTexture = pcMesh->piDiffuseTexture;
pcMesh->piOpacityTexture->AddRef();
}
}
}
//
// AMBIENT TEXTURE ------------------------------------------------
//
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_AMBIENT(0),&szPath))
{
LoadTexture(&pcMesh->piAmbientTexture,&szPath);
}
//
// EMISSIVE TEXTURE ------------------------------------------------
//
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_EMISSIVE(0),&szPath))
{
LoadTexture(&pcMesh->piEmissiveTexture,&szPath);
}
//
// Shininess TEXTURE ------------------------------------------------
//
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_SHININESS(0),&szPath))
{
LoadTexture(&pcMesh->piShininessTexture,&szPath);
}
//
// Lightmap TEXTURE ------------------------------------------------
//
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_LIGHTMAP(0),&szPath))
{
LoadTexture(&pcMesh->piLightmapTexture,&szPath);
}
//
// NORMAL/HEIGHT MAP ------------------------------------------------
//
bool bHM = false;
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_NORMALS(0),&szPath))
{
LoadTexture(&pcMesh->piNormalTexture,&szPath);
}
else
{
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_HEIGHT(0),&szPath))
{
LoadTexture(&pcMesh->piNormalTexture,&szPath);
}
else bib = true;
bHM = true;
}
// normal/height maps are sometimes mixed up. Try to detect the type
// of the texture automatically
if (pcMesh->piNormalTexture)
{
HMtoNMIfNecessary(pcMesh->piNormalTexture, &pcMesh->piNormalTexture,bHM);
}
}
// check whether a global background texture is contained
// in this material. Some loaders set this value ...
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_GLOBAL_BACKGROUND_IMAGE,&szPath))
{
CBackgroundPainter::Instance().SetTextureBG(szPath.data);
}
// BUGFIX: If the shininess is 0.0f disable phong lighting
// This is a workaround for some meshes in the DX SDK (e.g. tiny.x)
// FIX: Added this check to the x-loader, but the line remains to
// catch other loader doing the same ...
if (0.0f == pcMesh->fShininess){
pcMesh->eShadingMode = aiShadingMode_Gouraud;
}
int two_sided = 0;
aiGetMaterialInteger(pcMat,AI_MATKEY_TWOSIDED,&two_sided);
pcMesh->twosided = (two_sided != 0);
// check whether we have already a material using the same
// shader. This will decrease loading time rapidly ...
for (unsigned int i = 0; i < g_pcAsset->pcScene->mNumMeshes;++i)
{
if (g_pcAsset->pcScene->mMeshes[i] == pcSource)
{
break;
}
AssetHelper::MeshHelper* pc = g_pcAsset->apcMeshes[i];
if ((pcMesh->piDiffuseTexture != NULL ? true : false) !=
(pc->piDiffuseTexture != NULL ? true : false))
continue;
if ((pcMesh->piSpecularTexture != NULL ? true : false) !=
(pc->piSpecularTexture != NULL ? true : false))
continue;
if ((pcMesh->piAmbientTexture != NULL ? true : false) !=
(pc->piAmbientTexture != NULL ? true : false))
continue;
if ((pcMesh->piEmissiveTexture != NULL ? true : false) !=
(pc->piEmissiveTexture != NULL ? true : false))
continue;
if ((pcMesh->piNormalTexture != NULL ? true : false) !=
(pc->piNormalTexture != NULL ? true : false))
continue;
if ((pcMesh->piOpacityTexture != NULL ? true : false) !=
(pc->piOpacityTexture != NULL ? true : false))
continue;
if ((pcMesh->piShininessTexture != NULL ? true : false) !=
(pc->piShininessTexture != NULL ? true : false))
continue;
if ((pcMesh->piLightmapTexture != NULL ? true : false) !=
(pc->piLightmapTexture != NULL ? true : false))
continue;
if ((pcMesh->eShadingMode != aiShadingMode_Gouraud ? true : false) !=
(pc->eShadingMode != aiShadingMode_Gouraud ? true : false))
continue;
if ((pcMesh->fOpacity != 1.0f ? true : false) != (pc->fOpacity != 1.0f ? true : false))
continue;
if (pcSource->HasBones() != g_pcAsset->pcScene->mMeshes[i]->HasBones())
continue;
// we can reuse this material
if (pc->piEffect)
{
pcMesh->piEffect = pc->piEffect;
pc->bSharedFX = pcMesh->bSharedFX = true;
pcMesh->piEffect->AddRef();
return 2;
}
}
m_iShaderCount++;
// build macros for the HLSL compiler
unsigned int iCurrent = 0;
if (pcMesh->piDiffuseTexture)
{
sMacro[iCurrent].Name = "AV_DIFFUSE_TEXTURE";
sMacro[iCurrent].Definition = "1";
++iCurrent;
if (mapU == aiTextureMapMode_Wrap)
sMacro[iCurrent].Name = "AV_WRAPU";
else if (mapU == aiTextureMapMode_Mirror)
sMacro[iCurrent].Name = "AV_MIRRORU";
else // if (mapU == aiTextureMapMode_Clamp)
sMacro[iCurrent].Name = "AV_CLAMPU";
sMacro[iCurrent].Definition = "1";
++iCurrent;
if (mapV == aiTextureMapMode_Wrap)
sMacro[iCurrent].Name = "AV_WRAPV";
else if (mapV == aiTextureMapMode_Mirror)
sMacro[iCurrent].Name = "AV_MIRRORV";
else // if (mapV == aiTextureMapMode_Clamp)
sMacro[iCurrent].Name = "AV_CLAMPV";
sMacro[iCurrent].Definition = "1";
++iCurrent;
}
if (pcMesh->piSpecularTexture)
{
sMacro[iCurrent].Name = "AV_SPECULAR_TEXTURE";
sMacro[iCurrent].Definition = "1";
++iCurrent;
}
if (pcMesh->piAmbientTexture)
{
sMacro[iCurrent].Name = "AV_AMBIENT_TEXTURE";
sMacro[iCurrent].Definition = "1";
++iCurrent;
}
if (pcMesh->piEmissiveTexture)
{
sMacro[iCurrent].Name = "AV_EMISSIVE_TEXTURE";
sMacro[iCurrent].Definition = "1";
++iCurrent;
}
char buff[32];
if (pcMesh->piLightmapTexture)
{
sMacro[iCurrent].Name = "AV_LIGHTMAP_TEXTURE";
sMacro[iCurrent].Definition = "1";
++iCurrent;
int idx;
if(AI_SUCCESS == aiGetMaterialInteger(pcMat,AI_MATKEY_UVWSRC_LIGHTMAP(0),&idx) && idx >= 1 && pcSource->mTextureCoords[idx]) {
sMacro[iCurrent].Name = "AV_TWO_UV";
sMacro[iCurrent].Definition = "1";
++iCurrent;
sMacro[iCurrent].Definition = "IN.TexCoord1";
}
else sMacro[iCurrent].Definition = "IN.TexCoord0";
sMacro[iCurrent].Name = "AV_LIGHTMAP_TEXTURE_UV_COORD";
++iCurrent;float f= 1.f;
aiGetMaterialFloat(pcMat,AI_MATKEY_TEXBLEND_LIGHTMAP(0),&f);
sprintf(buff,"%f",f);
sMacro[iCurrent].Name = "LM_STRENGTH";
sMacro[iCurrent].Definition = buff;
++iCurrent;
}
if (pcMesh->piNormalTexture && !bib)
{
sMacro[iCurrent].Name = "AV_NORMAL_TEXTURE";
sMacro[iCurrent].Definition = "1";
++iCurrent;
}
if (pcMesh->piOpacityTexture)
{
sMacro[iCurrent].Name = "AV_OPACITY_TEXTURE";
sMacro[iCurrent].Definition = "1";
++iCurrent;
if (pcMesh->piOpacityTexture == pcMesh->piDiffuseTexture)
{
sMacro[iCurrent].Name = "AV_OPACITY_TEXTURE_REGISTER_MASK";
sMacro[iCurrent].Definition = "a";
++iCurrent;
}
else
{
sMacro[iCurrent].Name = "AV_OPACITY_TEXTURE_REGISTER_MASK";
sMacro[iCurrent].Definition = "r";
++iCurrent;
}
}
if (pcMesh->eShadingMode != aiShadingMode_Gouraud && !g_sOptions.bNoSpecular)
{
sMacro[iCurrent].Name = "AV_SPECULAR_COMPONENT";
sMacro[iCurrent].Definition = "1";
++iCurrent;
if (pcMesh->piShininessTexture)
{
sMacro[iCurrent].Name = "AV_SHININESS_TEXTURE";
sMacro[iCurrent].Definition = "1";
++iCurrent;
}
}
if (1.0f != pcMesh->fOpacity)
{
sMacro[iCurrent].Name = "AV_OPACITY";
sMacro[iCurrent].Definition = "1";
++iCurrent;
}
if( pcSource->HasBones())
{
sMacro[iCurrent].Name = "AV_SKINNING";
sMacro[iCurrent].Definition = "1";
++iCurrent;
}
// If a cubemap is active, we'll need to lookup it for calculating
// a physically correct reflection
if (CBackgroundPainter::TEXTURE_CUBE == CBackgroundPainter::Instance().GetMode())
{
sMacro[iCurrent].Name = "AV_SKYBOX_LOOKUP";
sMacro[iCurrent].Definition = "1";
++iCurrent;
}
sMacro[iCurrent].Name = NULL;
sMacro[iCurrent].Definition = NULL;
// compile the shader
if(FAILED( D3DXCreateEffect(g_piDevice,
g_szMaterialShader.c_str(),(UINT)g_szMaterialShader.length(),
(const D3DXMACRO*)sMacro,NULL,0,NULL,&pcMesh->piEffect,&piBuffer)))
{
// failed to compile the shader
if( piBuffer)
{
MessageBox(g_hDlg,(LPCSTR)piBuffer->GetBufferPointer(),"HLSL",MB_OK);
piBuffer->Release();
}
// use the default material instead
if (g_piDefaultEffect)
{
pcMesh->piEffect = g_piDefaultEffect;
g_piDefaultEffect->AddRef();
}
// get the name of the material and use it in the log message
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_NAME,&szPath) &&
'\0' != szPath.data[0])
{
std::string sz = "[ERROR] Unable to load material: ";
sz.append(szPath.data);
CLogDisplay::Instance().AddEntry(sz);
}
else
{
CLogDisplay::Instance().AddEntry("Unable to load material: UNNAMED");
}
return 0;
} else
{
// use Fixed Function effect when working with shaderless cards
if( g_sCaps.PixelShaderVersion < D3DPS_VERSION(2,0))
pcMesh->piEffect->SetTechnique( "MaterialFX_FF");
}
if( piBuffer) piBuffer->Release();
// now commit all constants to the shader
//
// This is not necessary for shared shader. Shader constants for
// shared shaders are automatically recommited before the shader
// is being used for a particular mesh
if (1.0f != pcMesh->fOpacity)
pcMesh->piEffect->SetFloat("TRANSPARENCY",pcMesh->fOpacity);
if (pcMesh->eShadingMode != aiShadingMode_Gouraud && !g_sOptions.bNoSpecular)
{
pcMesh->piEffect->SetFloat("SPECULARITY",pcMesh->fShininess);
pcMesh->piEffect->SetFloat("SPECULAR_STRENGTH",pcMesh->fSpecularStrength);
}
pcMesh->piEffect->SetVector("DIFFUSE_COLOR",&pcMesh->vDiffuseColor);
pcMesh->piEffect->SetVector("SPECULAR_COLOR",&pcMesh->vSpecularColor);
pcMesh->piEffect->SetVector("AMBIENT_COLOR",&pcMesh->vAmbientColor);
pcMesh->piEffect->SetVector("EMISSIVE_COLOR",&pcMesh->vEmissiveColor);
if (pcMesh->piDiffuseTexture)
pcMesh->piEffect->SetTexture("DIFFUSE_TEXTURE",pcMesh->piDiffuseTexture);
if (pcMesh->piOpacityTexture)
pcMesh->piEffect->SetTexture("OPACITY_TEXTURE",pcMesh->piOpacityTexture);
if (pcMesh->piSpecularTexture)
pcMesh->piEffect->SetTexture("SPECULAR_TEXTURE",pcMesh->piSpecularTexture);
if (pcMesh->piAmbientTexture)
pcMesh->piEffect->SetTexture("AMBIENT_TEXTURE",pcMesh->piAmbientTexture);
if (pcMesh->piEmissiveTexture)
pcMesh->piEffect->SetTexture("EMISSIVE_TEXTURE",pcMesh->piEmissiveTexture);
if (pcMesh->piNormalTexture)
pcMesh->piEffect->SetTexture("NORMAL_TEXTURE",pcMesh->piNormalTexture);
if (pcMesh->piShininessTexture)
pcMesh->piEffect->SetTexture("SHININESS_TEXTURE",pcMesh->piShininessTexture);
if (pcMesh->piLightmapTexture)
pcMesh->piEffect->SetTexture("LIGHTMAP_TEXTURE",pcMesh->piLightmapTexture);
if (CBackgroundPainter::TEXTURE_CUBE == CBackgroundPainter::Instance().GetMode()){
pcMesh->piEffect->SetTexture("lw_tex_envmap",CBackgroundPainter::Instance().GetTexture());
}
return 1;
}
HRESULT CMesh3D::InitMesh( LPCSTR Name, IDirect3DDevice9* pD3DDevice )
{
if( !pD3DDevice )
{
Log( "Error pointer x-file" );
return E_FAIL;
}
m_pD3DDevice = pD3DDevice;
ID3DXBuffer* pMaterialBuffer = 0;
if ( FAILED( D3DXLoadMeshFromX( Name, D3DXMESH_SYSTEMMEM, m_pD3DDevice, 0, &pMaterialBuffer, 0, &m_TexturCount, &m_pMesh ) ) )
{
Log( "error load x-file" );
return E_FAIL;
}
Log( "Load x-file" );
DWORD i = m_pMesh->GetNumFaces();// — Возвращает количество граней (треугольных ячеек) в сетке.
m_pMesh->GetVertexBuffer( &m_VertexBuffer );
m_pMesh->GetIndexBuffer( &m_IndexBuffer );
// Извлекаем свойства материала и названия{имена} структуры
D3DXMATERIAL * MaterialMesh = (D3DXMATERIAL*)pMaterialBuffer->GetBufferPointer();
m_pMeshMaterial = new D3DMATERIAL9[ m_TexturCount ];
std::string FilePath( Name );
size_t f = FilePath.find_last_of( "\\" );
if( f != -1 )
FilePath.erase( f + 1, FilePath.size() );
for ( DWORD i = 0; i < m_TexturCount; i++ )
{
// Копируем материал
m_pMeshMaterial[i] = MaterialMesh[i].MatD3D;
// Установить окружающего свет
m_pMeshMaterial[i].Ambient = m_pMeshMaterial[i].Diffuse;
// Загружаем текстуру
if( MaterialMesh[i].pTextureFilename )
{
IDirect3DTexture9* Tex = 0;
std::string FileName = FilePath + std::string( MaterialMesh[i].pTextureFilename );
if( FAILED( D3DXCreateTextureFromFileEx( m_pD3DDevice, FileName.c_str(), 0, 0, 0, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0xff000000, 0, 0, &Tex ) ) )
{
Log( "error load texture Mesh" );
m_pMeshTextura.push_back(0);
}
// Сохраняем загруженную текстуру
m_pMeshTextura.push_back(Tex);
}
else
{
// Нет текстуры для i-ой подгруппы
m_pMeshTextura.push_back(0);
}
}
// Уничтожаем буфер материала
pMaterialBuffer->Release();
return S_OK;
}
bool DX9VertexShaderConstantsCompiler::compile( const std::string& shaderCode, const char* entryFunction, std::vector< ShaderConstantDesc >& outConstants )
{
// create a renderer
IDirect3D9* d3d9 = Direct3DCreate9( D3D_SDK_VERSION );
DX9Initializer initializer( *d3d9 );
IDirect3DDevice9* compileDevice = initializer.createNullDevice();
const char* shaderProfile = D3DXGetVertexShaderProfile( compileDevice );
DWORD flags = D3DXSHADER_DEBUG;
ID3DXBuffer* shaderBuf = NULL;
ID3DXBuffer* errorsBuf = NULL;
ID3DXConstantTable* shaderConstants = NULL;
DX9ShaderIncludeLoader includesLoader;
HRESULT res = D3DXCompileShader( shaderCode.c_str(), shaderCode.length(), NULL, &includesLoader, entryFunction, shaderProfile, flags, &shaderBuf, &errorsBuf, &shaderConstants );
// interpret the results
bool result = true;
if ( FAILED(res) || shaderBuf == NULL )
{
if ( errorsBuf != NULL )
{
std::string compilationErrors = ( const char* )errorsBuf->GetBufferPointer();
errorsBuf->Release();
m_errorMsg = std::string( "Shader compilation error: " ) + compilationErrors;
}
else
{
m_errorMsg = translateDxError( "Error while compiling a shader", res );
}
result = false;
}
else
{
std::vector< D3DXCONSTANT_DESC > constants;
ShaderConstantDesc newConstant;
result = ShaderCompilerUtils::parseConstants( shaderConstants, m_errorMsg, constants );
if ( result )
{
unsigned int constantsCount = constants.size();
for ( unsigned int i = 0; i < constantsCount; ++i )
{
if ( createConstant( constants[i], newConstant ) )
{
outConstants.push_back( newConstant );
}
}
}
}
// cleanup
if ( shaderConstants )
{
shaderConstants->Release();
}
compileDevice->Release();
d3d9->Release();
return result;
}
//--------------------------------------------------------------------------------------
// Name: Create()
// Desc: Creates the help class' internal objects
//--------------------------------------------------------------------------------------
HRESULT Help::Create( const PackedResource* pResource )
{
// Get access to the gamepad texture
m_pGamepadTexture = pResource->GetTexture( "GamepadTexture" );
// Load the texture used for pointing help text at specific buttons
m_pLineTexture = pResource->GetTexture( "HelpCalloutTexture" );
// Create vertex declaration
if( NULL == g_pHelpVertexDecl )
{
static const D3DVERTEXELEMENT9 decl[] =
{
{ 0, 0, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
{ 0, 8, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
D3DDECL_END()
};
if( FAILED( g_pd3dDevice->CreateVertexDeclaration( decl, &g_pHelpVertexDecl ) ) )
return E_FAIL;
}
// Create vertex shader
ID3DXBuffer* pShaderCode;
if( NULL == g_pHelpVertexShader )
{
if( FAILED( D3DXCompileShader( g_strHelpShader, strlen( g_strHelpShader ),
NULL, NULL, "HelpVertexShader", "vs.2.0", 0,
&pShaderCode, NULL, NULL ) ) )
return E_FAIL;
if( FAILED( g_pd3dDevice->CreateVertexShader( ( DWORD* )pShaderCode->GetBufferPointer(),
&g_pHelpVertexShader ) ) )
return E_FAIL;
pShaderCode->Release();
}
// Create pixel shader.
if( NULL == g_pHelpPixelShader )
{
if( FAILED( D3DXCompileShader( g_strHelpShader, strlen( g_strHelpShader ),
NULL, NULL, "HelpPixelShader", "ps.2.0", 0,
&pShaderCode, NULL, NULL ) ) )
return E_FAIL;
if( FAILED( g_pd3dDevice->CreatePixelShader( ( DWORD* )pShaderCode->GetBufferPointer(),
&g_pHelpPixelShader ) ) )
return E_FAIL;
pShaderCode->Release();
}
if( NULL == g_pDarkPixelShader )
{
if( FAILED( D3DXCompileShader( g_strHelpShader, strlen( g_strHelpShader ),
NULL, NULL, "DarkPixelShader", "ps.2.0", 0,
&pShaderCode, NULL, NULL ) ) )
return E_FAIL;
if( FAILED( g_pd3dDevice->CreatePixelShader( ( DWORD* )pShaderCode->GetBufferPointer(),
&g_pDarkPixelShader ) ) )
return E_FAIL;
pShaderCode->Release();
}
return S_OK;
}
