DOF::DOF(IDirect3DDevice9 *device, int width, int height, Type type, float baseRadius)
: Effect(device), width(width), height(height) {
// Setup the defines for compiling the effect
vector<D3DXMACRO> defines;
// Setup pixel size macro
stringstream sp;
sp << "float2(1.0 / " << width << ", 1.0 / " << height << ")";
string pixelSizeText = sp.str();
D3DXMACRO pixelSizeMacro = { "PIXEL_SIZE", pixelSizeText.c_str() };
defines.push_back(pixelSizeMacro);
string radiusText = format("%f", baseRadius);
D3DXMACRO radiusMacro = { "DOF_BASE_BLUR_RADIUS", radiusText.c_str() };
defines.push_back(radiusMacro);
D3DXMACRO null = { NULL, NULL };
defines.push_back(null);
DWORD flags = D3DXFX_NOT_CLONEABLE | D3DXSHADER_OPTIMIZATION_LEVEL3;
// Load effect from file
string shaderFn;
switch(type) {
case BOKEH: shaderFn = "DOFBokeh.fx"; break;
case BASIC: shaderFn = "DOFPseudo.fx"; break;
}
shaderFn = getAssetFileName(shaderFn);
SDLOG(0, "%s load\n", shaderFn.c_str());
ID3DXBuffer* errors;
HRESULT hr = D3DXCreateEffectFromFile(device, shaderFn.c_str(), &defines.front(), NULL, flags, NULL, &effect, &errors);
if(hr != D3D_OK) SDLOG(0, "ERRORS:\n %s\n", errors->GetBufferPointer());
// Create buffers
buffer1 = RSManager::getRTMan().createTexture(width, height, RenderTarget::FMT_ARGB_8);
buffer2 = RSManager::getRTMan().createTexture(width, height, RenderTarget::FMT_ARGB_8);
// get handles
depthTexHandle = effect->GetParameterByName(NULL, "depthTex");
thisframeTexHandle = effect->GetParameterByName(NULL, "thisframeTex");
lastpassTexHandle = effect->GetParameterByName(NULL, "lastpassTex");
}
bool CD3D9Shader::createFromMemory(void* pBuf, int nSize,LPD3DXINCLUDE pInclude)
{
IDirect3DDevice9* pD3D9Device = GetD3D9RenderSystem().GetD3D9Device();
if (ms_pEffectPool==NULL)
{
D3DXCreateEffectPool( & ms_pEffectPool);
}
DWORD dwShaderFlags = D3DXFX_NOT_CLONEABLE;
ID3DXBuffer* errorBuffer = 0;
D3DXCreateEffect(pD3D9Device,pBuf,nSize, NULL, pInclude, dwShaderFlags,
ms_pEffectPool, &m_pEffect, &errorBuffer);
// output any error messages
if(errorBuffer)
{
::MessageBoxA(0, (char*)errorBuffer->GetBufferPointer(), 0, 0);
S_REL(errorBuffer);
}
return m_pEffect!=NULL;
}
void AmbientDiffuseDemo::buildFX()
{
// Create the FX from a .fx file.
ID3DXBuffer* errors = 0;
HR(D3DXCreateEffectFromFile(gd3dDevice, "ambientdiffuse.fx",
0, 0, D3DXSHADER_DEBUG, 0, &mFX, &errors));
if( errors )
MessageBox(0, (char*)errors->GetBufferPointer(), 0, 0);
// Obtain handles.
mhTech = mFX->GetTechniqueByName("AmbientDiffuseTech");
mhWVP = mFX->GetParameterByName(0, "gWVP");
mhWorldInverseTranspose = mFX->GetParameterByName(0, "gWorldInverseTranspose");
mhLightVecW = mFX->GetParameterByName(0, "gLightVecW");
mhDiffuseMtrl = mFX->GetParameterByName(0, "gDiffuseMtrl");
mhDiffuseLight = mFX->GetParameterByName(0, "gDiffuseLight");
mhAmbientMtrl = mFX->GetParameterByName(0, "gAmbientMtrl");
mhAmbientLight = mFX->GetParameterByName(0, "gAmbientLight");
}
void RobotArmDemo::buildFX()
{
// Create the FX from a .fx file.
ID3DXBuffer* errors = 0;
HR(D3DXCreateEffectFromFile(gd3dDevice, "PhongDirLtTex.fx",
0, 0, D3DXSHADER_DEBUG, 0, &mFX, &errors));
if( errors )
MessageBox(0, (char*)errors->GetBufferPointer(), 0, 0);
// Obtain handles.
mhTech = mFX->GetTechniqueByName("PhongDirLtTexTech");
mhWVP = mFX->GetParameterByName(0, "gWVP");
mhWorldInvTrans = mFX->GetParameterByName(0, "gWorldInvTrans");
mhMtrl = mFX->GetParameterByName(0, "gMtrl");
mhLight = mFX->GetParameterByName(0, "gLight");
mhEyePos = mFX->GetParameterByName(0, "gEyePosW");
mhWorld = mFX->GetParameterByName(0, "gWorld");
mhTex = mFX->GetParameterByName(0, "gTex");
}
fResult f2dRenderDeviceImpl::SaveTexture(f2dStream* pStream, f2dTexture2D* pTex)
{
if(m_bDevLost)
return FCYERR_ILLEGAL;
if(!pStream || !pTex || !pStream->CanWrite() || !pStream->CanResize())
return FCYERR_INVAILDPARAM;
IDirect3DSurface9* pSurface = NULL;
if(pTex->IsDynamic())
((IDirect3DTexture9*)((f2dTexture2DDynamic*)pTex)->GetHandle())->GetSurfaceLevel(0, &pSurface);
else if(pTex->IsRenderTarget())
{
pSurface = ((f2dTexture2DRenderTarget*)pTex)->GetSurface();
pSurface->AddRef();
}
else
((IDirect3DTexture9*)((f2dTexture2DStatic*)pTex)->GetHandle())->GetSurfaceLevel(0, &pSurface);
if(!pSurface)
return FCYERR_INTERNALERR;
ID3DXBuffer* pDataBuffer = NULL;
HRESULT tHR = m_API.DLLEntry_D3DXSaveSurfaceToFileInMemory(&pDataBuffer, D3DXIFF_PNG, pSurface, NULL, NULL);
FCYSAFEKILL(pSurface);
if(FAILED(tHR))
{
m_pEngine->ThrowException(fcyWin32COMException("f2dRenderDeviceImpl::SaveTexture", "D3DXSaveSurfaceToFileInMemory Failed.", tHR));
return FCYERR_INTERNALERR;
}
// 保存到流
if(FCYFAILED(pStream->WriteBytes((fcData)pDataBuffer->GetBufferPointer(), pDataBuffer->GetBufferSize(), NULL)))
{
FCYSAFEKILL(pDataBuffer);
return FCYERR_INTERNALERR;
}
FCYSAFEKILL(pDataBuffer);
return FCYERR_OK;
}
VSSAO::VSSAO(IDirect3DDevice9 *device, int width, int height, unsigned strength)
: Effect(device), width(width), height(height) {
// Setup the defines for compiling the effect
vector<D3DXMACRO> defines;
stringstream s;
// Setup pixel size macro
s << "float2(1.0 / " << width << ", 1.0 / " << height << ")";
string pixelSizeText = s.str();
D3DXMACRO pixelSizeMacro = { "PIXEL_SIZE", pixelSizeText.c_str() };
defines.push_back(pixelSizeMacro);
D3DXMACRO strengthMacros[] = {
{ "SSAO_STRENGTH_LOW", "1" },
{ "SSAO_STRENGTH_MEDIUM", "1" },
{ "SSAO_STRENGTH_HIGH", "1" }
};
defines.push_back(strengthMacros[strength]);
D3DXMACRO null = { NULL, NULL };
defines.push_back(null);
DWORD flags = D3DXFX_NOT_CLONEABLE | D3DXSHADER_OPTIMIZATION_LEVEL3;
// Load effect from file
SDLOG(0, "VSSAO load\n");
ID3DXBuffer* errors;
HRESULT hr = D3DXCreateEffectFromFile(device, GetDirectoryFile("dsfix\\VSSAO.fx"), &defines.front(), NULL, flags, NULL, &effect, &errors);
if(hr != D3D_OK) SDLOG(0, "ERRORS:\n %s\n", errors->GetBufferPointer());
// Create buffers
device->CreateTexture(width, height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &buffer1Tex, NULL);
buffer1Tex->GetSurfaceLevel(0, &buffer1Surf);
device->CreateTexture(width, height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &buffer2Tex, NULL);
buffer2Tex->GetSurfaceLevel(0, &buffer2Surf);
// get handles
depthTexHandle = effect->GetParameterByName(NULL, "depthTex2D");
frameTexHandle = effect->GetParameterByName(NULL, "frameTex2D");
prevPassTexHandle = effect->GetParameterByName(NULL, "prevPassTex2D");
}
void DOF::reloadShader() {
// Setup the defines for compiling the effect
vector<D3DXMACRO> defines;
// Setup pixel size macro
stringstream sp;
sp << "float2(1.0 / " << width << ", 1.0 / " << height << ")";
string pixelSizeText = sp.str();
D3DXMACRO pixelSizeMacro = { "PIXEL_SIZE", pixelSizeText.c_str() };
defines.push_back(pixelSizeMacro);
string radiusText = format("%f", baseRadius);
D3DXMACRO radiusMacro = { "DOF_BASE_BLUR_RADIUS", radiusText.c_str() };
defines.push_back(radiusMacro);
// Setup depth reading method
D3DXMACRO readHWDepthMacro = { "USE_HWDEPTH", "true" };
if(readHWDepth) defines.push_back(readHWDepthMacro);
D3DXMACRO null = { NULL, NULL };
defines.push_back(null);
DWORD flags = D3DXFX_NOT_CLONEABLE | D3DXSHADER_OPTIMIZATION_LEVEL3;
// Load effect from file
string shaderFn;
switch(type) {
case BOKEH: shaderFn = "DOFBokeh.fx"; break;
case BASIC: shaderFn = "DOFPseudo.fx"; break;
}
shaderFn = getAssetFileName(shaderFn);
SDLOG(0, "%s load\n", shaderFn.c_str());
ID3DXBuffer* errors;
HRESULT hr = D3DXCreateEffectFromFile(device, shaderFn.c_str(), &defines.front(), NULL, flags, NULL, &effect, &errors);
if(hr != D3D_OK) SDLOG(0, "ERRORS:\n %s\n", errors->GetBufferPointer());
// get handles
depthTexHandle = effect->GetParameterByName(NULL, "depthTex");
thisframeTexHandle = effect->GetParameterByName(NULL, "thisframeTex");
lastpassTexHandle = effect->GetParameterByName(NULL, "lastpassTex");
}
Sky::Sky(const std::string& envmapFilename, float skyRadius)
: mRadius(skyRadius)
{
HR(D3DXCreateSphere(gd3dDevice, skyRadius, 30, 30, &mSphere, 0));
HR(D3DXCreateCubeTextureFromFile(gd3dDevice, envmapFilename.c_str(), &mEnvMap));
ID3DXBuffer* errors = 0;
HR(D3DXCreateEffectFromFile(gd3dDevice, "sky.fx", 0, 0, 0,
0, &mFX, &errors));
if( errors )
MessageBox(0, (char*)errors->GetBufferPointer(), 0, 0);
mhTech = mFX->GetTechniqueByName("SkyTech");
mhWVP = mFX->GetParameterByName(0, "gWVP");
mhEnvMap = mFX->GetParameterByName(0, "gEnvMap");
// Set effect parameters that do not vary.
HR(mFX->SetTechnique(mhTech));
HR(mFX->SetTexture(mhEnvMap, mEnvMap));
}
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);
}
}
void Terrain::buildEffect()
{
ID3DXBuffer* errors = 0;
HR(D3DXCreateEffectFromFile(gd3dDevice, "Terrain.fx",
0, 0, D3DXSHADER_DEBUG, 0, &mFX, &errors));
if( errors )
MessageBox(0, (char*)errors->GetBufferPointer(), 0, 0);
mhTech = mFX->GetTechniqueByName("TerrainTech");
mhViewProj = mFX->GetParameterByName(0, "gViewProj");
mhDirToSunW = mFX->GetParameterByName(0, "gDirToSunW");
mhTex0 = mFX->GetParameterByName(0, "gTex0");
mhTex1 = mFX->GetParameterByName(0, "gTex1");
mhTex2 = mFX->GetParameterByName(0, "gTex2");
mhBlendMap = mFX->GetParameterByName(0, "gBlendMap");
HR(mFX->SetTexture(mhTex0, mTex0));
HR(mFX->SetTexture(mhTex1, mTex1));
HR(mFX->SetTexture(mhTex2, mTex2));
HR(mFX->SetTexture(mhBlendMap, mBlendMap));
}
ID3DXBuffer *PostProcessWater::Initialize(RenderMesh *_meshPtr, LPCWSTR effectFile)
{
meshPtr = _meshPtr;
ID3DXBuffer *errors;
#ifdef _DEBUG
D3DXCreateEffectFromFile(Renderer::theDevicePtr, effectFile, 0, 0,
D3DXSHADER_DEBUG|D3DXSHADER_SKIPOPTIMIZATION, Renderer::theEffectPoolPtr,
&effectPtr, &errors);
#else
D3DXCreateEffectFromFile(Renderer::theDevicePtr, effectFile, 0, 0,
0, Renderer::theEffectPoolPtr, &effectPtr, &errors);
#endif
if (errors)
InternalOutput::GetReference() << (char *)errors->GetBufferPointer();
else
{
// Initialize handles
textureHandle = effectPtr->GetParameterByName(0, "sourceTexture");
effectPtr->SetTechnique("PostProcess");
// Texture handles
reflectionMapTextureHandle = effectPtr->GetParameterByName("gReflectionMapTexture", 0);
heightMapTextueHandle = effectPtr->GetParameterByName("gHeightMapTexture", 0);
noiseTextureHandle = effectPtr->GetParameterByName("gNoiseTexture", 0);
foamTextureHandle = effectPtr->GetParameterByName("gFoamTexture", 0);
causticTextureHandle = effectPtr->GetParameterByName("gCausticTexture", 0);
// Color handles
surfaceColorHandle = effectPtr->GetParameterByName("gSurfaceColor", 0);
ambientColorHandle = effectPtr->GetParameterByName("gAmbientColor", 0);
// Other handles
elapsedTimeHandle = effectPtr->GetParameterByName("gElapsedTime", 0);
}
return errors;
}
void PondWater::buildFX()
{
ID3DXBuffer* errors = 0;
HR(D3DXCreateEffectFromFile(gd3dDevice, _T("PondWater.fx"),
0, 0, D3DXSHADER_DEBUG, 0, &mFX, &errors));
if( errors )
MessageBoxA(0, (char*)errors->GetBufferPointer(), 0, 0);
mhTech = mFX->GetTechniqueByName("WaterTech");
mhWorld = mFX->GetParameterByName(0, "gWorld");
mhWorldInv = mFX->GetParameterByName(0, "gWorldInv");
mhWVP = mFX->GetParameterByName(0, "gWVP");
mhEyePosW = mFX->GetParameterByName(0, "gEyePosW");
mhLight = mFX->GetParameterByName(0, "gLight");
mhMtrl = mFX->GetParameterByName(0, "gMtrl");
mhWaveMap0 = mFX->GetParameterByName(0, "gWaveMap0");
mhWaveMap1 = mFX->GetParameterByName(0, "gWaveMap1");
mhWaveMapOffset0 = mFX->GetParameterByName(0, "gWaveMapOffset0");
mhWaveMapOffset1 = mFX->GetParameterByName(0, "gWaveMapOffset1");
mhRefractBias = mFX->GetParameterByName(0, "gRefractBias");
mhRefractPower = mFX->GetParameterByName(0, "gRefractPower");
mhRippleScale = mFX->GetParameterByName(0, "gRippleScale");
mhReflectMap = mFX->GetParameterByName(0, "gReflectMap");
mhRefractMap = mFX->GetParameterByName(0, "gRefractMap");
// We don't need to set these every frame since they do not change.
HR(mFX->SetMatrix(mhWorld, &mInitInfo.toWorld));
D3DXMATRIX worldInv;
D3DXMatrixInverse(&worldInv, 0, &mInitInfo.toWorld);
HR(mFX->SetMatrix(mhWorldInv, &worldInv));
HR(mFX->SetTechnique(mhTech));
HR(mFX->SetTexture(mhWaveMap0, mWaveMap0));
HR(mFX->SetTexture(mhWaveMap1, mWaveMap1));
HR(mFX->SetValue(mhLight, &mInitInfo.dirLight, sizeof(DirLight)));
HR(mFX->SetValue(mhMtrl, &mInitInfo.mtrl, sizeof(Mtrl)));
HR(mFX->SetValue(mhRefractBias, &mInitInfo.refractBias, sizeof(float)));
HR(mFX->SetValue(mhRefractPower, &mInitInfo.refractPower, sizeof(float)));
HR(mFX->SetValue(mhRippleScale, &mInitInfo.rippleScale, sizeof(D3DXVECTOR2)));
}
LIMBO::LIMBO(IDirect3DDevice9 *device, int width, int height)
: Effect(device), width(width), height(height) {
SDLOG(0, "Limbo construct\n");
// Setup the defines for compiling the effect
vector<D3DXMACRO> defines;
stringstream s;
defines.push_back({ NULL, NULL });
DWORD flags = D3DXFX_NOT_CLONEABLE;
// Load effect from file
SDLOG(0, "Limbo load\n");
ID3DXBuffer* errors;
HRESULT hr = D3DXCreateEffectFromFile(device, GetDirectoryFile("dsfix\\LIMBO.fx"), &defines.front(), NULL, flags, NULL, &effect, &errors);
if (hr != D3D_OK) SDLOG(0, "ERRORS:\n %s\n", errors->GetBufferPointer());
// get handles
frameTexHandle = ConnectGlobal("frameTex2D");
zFarHandle = ConnectGlobal("ZFAR");
zNearHandle = ConnectGlobal("ZNEAR");
}
void DX9Effect::loadFromFile(const char* szPath, HDResourceMgr *pMgr)
{
ASSERT(szPath);
ASSERT(pMgr);
destroy();
//
DX9ResourceMgr* pDX9Mgr = (DX9ResourceMgr*)pMgr;
IDirect3DDevice9* pDev = pDX9Mgr->getDX9Device();
HRESULT hr;
ID3DXEffect *pEffect = NULL;
DWORD dwFlag = 0;
#ifdef SHADER_DEBUG
dwFlag = D3DXSHADER_DEBUG | D3DXSHADER_NO_PRESHADER |D3DXSHADER_SKIPOPTIMIZATION;
#endif
ID3DXBuffer *pError = NULL;
hr = D3DXCreateEffectFromFile(pDev,
szPath,
NULL,NULL,
dwFlag,
NULL,
&pEffect,&pError);
if(FAILED(hr))
{
if(pError)
{
const char* szError = (const char*)pError->GetBufferPointer();
LOG(szError);
}
throw HDAPIException("Effect load failed.");
}
m_pEffect = pEffect;
}
Post::Post(IDirect3DDevice9 *device, int width, int height, bool useSRGB)
: Effect(device), width(width), height(height) {
// Setup the defines for compiling the effect
vector<D3DXMACRO> defines;
// Setup pixel size macro
string pixelSizeText = format("float2(1.0/%d, 1.0/%d)", width, height);
D3DXMACRO pixelSizeMacro = { "PIXEL_SIZE", pixelSizeText.c_str() };
defines.push_back(pixelSizeMacro);
// Setup screen size macro
string screenSizeText = format("float2(%d,%d)", width, height);
D3DXMACRO screenSizeMacro = { "SCREEN_SIZE", screenSizeText.c_str() };
defines.push_back(screenSizeMacro);
D3DXMACRO srgbMacro = { "USE_SRGB", useSRGB ? "true" : "false" };
defines.push_back(srgbMacro);
D3DXMACRO null = { NULL, NULL };
defines.push_back(null);
DWORD flags = D3DXFX_NOT_CLONEABLE | D3DXSHADER_OPTIMIZATION_LEVEL3;
// Load effect from file
string shaderFn = "post.fx";
if(Settings::get().getPostProcessingType() == "asmodean") shaderFn = "post_asmodean.fx";
string customfn = getConfigFileName(getExeFileName() + "\\" + shaderFn);
if(boost::filesystem::exists(customfn)) shaderFn = customfn;
else shaderFn = getAssetFileName(shaderFn);
SDLOG(0, "%s load\n", shaderFn.c_str());
ID3DXBuffer* errors;
HRESULT hr = D3DXCreateEffectFromFile(device, shaderFn.c_str(), &defines.front(), NULL, flags, NULL, &effect, &errors);
if(hr != D3D_OK) SDLOG(0, "ERRORS:\n %s\n", errors->GetBufferPointer());
// Get handles
thisframeTexHandle = effect->GetParameterByName(NULL, "thisframeTex");
}
void Graphics::initEffect()
{
// Create the FX from a .fx file.
ID3DXBuffer* errors = 0;
HR(D3DXCreateEffectFromFile(gd3dDevice, "effects.fx",
0, 0, D3DXSHADER_DEBUG, 0, &mFX, &errors));
if( errors )
MessageBox(0, (char*)errors->GetBufferPointer(), 0, 0);
// Default handles
mhTexTech = mFX->GetTechniqueByName("TexTech");
mhWVP = mFX->GetParameterByName(0, "gWVP");
mhWorld = mFX->GetParameterByName(0, "gWorld");
mhTex = mFX->GetParameterByName(0, "gTex");
mhWorldInverseTranspose = mFX->GetParameterByName(0, "gWorldInverseTranspose");
mhEyePos = mFX->GetParameterByName(0, "gEyePosW");
mhObjectMaterial = mFX->GetParameterByName(0, "gObjectMaterial");
mhLights = mFX->GetParameterByName(0, "gLights");
mhNumLights = mFX->GetParameterByName(0, "gNumLights");
// Terrain handles
mhTerrainTech = mFX->GetTechniqueByName("TerrainTech");
mhTex0 = mFX->GetParameterByName(0, "gTex0");
mhTex1 = mFX->GetParameterByName(0, "gTex1");
mhTex2 = mFX->GetParameterByName(0, "gTex2");
mhBlendMap = mFX->GetParameterByName(0, "gBlendMap");
// Skinned mesh handles
mhSkinnedMeshTech = mFX->GetTechniqueByName("SkinnedMeshTech");
mhFinalXForms = mFX->GetParameterByName(0, "gFinalXForms");
mhBoneTransform = mFX->GetParameterByName(0, "gBoneTransform");
// Load textures from file - TODO: move to Terrain
mTex0 = loadTexture("data/imgs/grass.dds");
mTex1 = loadTexture("data/imgs/stone.dds");
mTex2 = loadTexture("data/imgs/dirt.dds");
mBlendMap = loadTexture("data/imgs/blendmap.jpg");
}
void StencilMirrorDemo::buildFX()
{
ID3DXBuffer *errors = 0;
HR(D3DXCreateEffectFromFile(gd3dDevice, L"../src/chap13/StencilMirror/DirLightTex.fx",
0, 0, D3DXSHADER_DEBUG, 0, &mFX, &errors));
if (errors)
MessageBoxA(0, (char*)errors->GetBufferPointer(), 0, 0);
mhTech = mFX->GetTechniqueByName("DirLightTexTech");
mhWVP = mFX->GetParameterByName(0, "gWVP");
mhWorldInvTrans = mFX->GetParameterByName(0, "gWorldInvTrans");
mhLightVecW = mFX->GetParameterByName(0, "gLightVecW");
mhDiffuseMtrl = mFX->GetParameterByName(0, "gDiffuseMtrl");
mhDiffuseLight = mFX->GetParameterByName(0, "gDiffuseLight");
mhAmbientMtrl = mFX->GetParameterByName(0, "gAmbientMtrl");
mhAmbientLight = mFX->GetParameterByName(0, "gAmbientLight");
mhSpecularMtrl = mFX->GetParameterByName(0, "gSpecularMtrl");
mhSpecularLight = mFX->GetParameterByName(0, "gSpecularLight");
mhSpecularPower = mFX->GetParameterByName(0, "gSpecularPower");
mhEyePos = mFX->GetParameterByName(0, "gEyePosW");
mhWorld = mFX->GetParameterByName(0, "gWorld");
mhTex = mFX->GetParameterByName(0, "gTex");
}
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 C2DBuffer::begin_first( IDirect3DDevice9* dev ) {
HRESULT hr;
if(NULL==vBuff.GetPtr())
dev->CreateVertexBuffer(BatchNum* 4*sizeof(tagVertexFMT),0,0,D3DPOOL_MANAGED,vBuff.ToCreator(),0);
if(NULL==iBuff.GetPtr())
dev->CreateIndexBuffer(BatchNum*2*3*sizeof(WORD),0,D3DFMT_INDEX16,
D3DPOOL_MANAGED,iBuff.ToCreator(),0);
// シェーダ作成
if (effect == 0) {
ID3DXBuffer *error = 0;
if ( FAILED( D3DXCreateEffectFromFile( dev, L"Shader/buffer.fx", 0, 0, 0, 0, &effect, &error) ) ) {
OutputDebugStringA( (const char*)error->GetBufferPointer());
return;
}
}
// 頂点宣言作成
if (decl == 0) {
D3DVERTEXELEMENT9 elems[] = {
{0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
{0, sizeof(float) * 3, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
{0,sizeof(float)*5,D3DDECLTYPE_FLOAT1, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
D3DDECL_END()
};
dev->CreateVertexDeclaration( elems, &decl );
}
tagVertexFMT* pVFMT;
hr = iBuff.GetPtr()->Lock(0,NULL,(void**)&pVFMT,0);
if(FAILED(hr))
{
return;
}
else{
}
drawBuffer.reserve(6*5*1000);
}
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);
}
HRESULT BuildEffect()
{
char* effectFile = "./Effect.fx";
ID3DXBuffer* errors = 0;
// Create Effect from file
HRESULT hr = D3DXCreateEffectFromFile(
g_pd3dDevice,
effectFile,
NULL,
NULL,
D3DXSHADER_DEBUG,
NULL,
&g_pEffect,
&errors);
if( errors )
MessageBox(0, (char*)errors->GetBufferPointer(), 0, 0);
g_hWVP = g_pEffect->GetParameterByName(0, "gWVP");
g_hTech = g_pEffect->GetTechniqueByName("Tech1");
return D3D_OK;
}
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 Effect::loadFromMemory( const u8* data, u32 len )
{
DWORD dwFlag = 0;
ID3DXBuffer *pError = NULL;
HRESULT hr = D3DXCreateEffect(Paras::getInstancePtr()->_device, data, len, NULL, NULL, dwFlag, NULL, &_effect, &pError);
if(FAILED(hr))
{
if(pError)
{
const char* szError = (const char*)pError->GetBufferPointer();
std::ostringstream buf;
buf<<"D3DXCreateEffect failed, reason:"<<szError;
Error(buf.str());
}
else
{
Error("D3DXCreateEffect failed");
}
return false;
}
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;
}
HRESULT Application::Init(HINSTANCE hInstance, bool windowed) {
g_debug << "Application Started \n";
//Create Window Class
WNDCLASS wc;
memset(&wc, 0, sizeof(WNDCLASS));
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = (WNDPROC)WndProc;
wc.hInstance = hInstance;
wc.lpszClassName = "D3DWND";
RECT rc = {0, 0, WINDOW_WIDTH, WINDOW_HEIGHT};
AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, false);
//Register Class and Create new Window
RegisterClass(&wc);
m_mainWindow = ::CreateWindow("D3DWND", "Character Animation with Direct3D: Example 3.3", WS_OVERLAPPEDWINDOW, 0, 0, rc.right - rc.left, rc.bottom - rc.top, 0, 0, hInstance, 0);
SetCursor(NULL);
::ShowWindow(m_mainWindow, SW_SHOW);
::UpdateWindow(m_mainWindow);
//Create IDirect3D9 Interface
IDirect3D9* d3d9 = Direct3DCreate9(D3D_SDK_VERSION);
if (d3d9 == NULL) {
g_debug << "Direct3DCreate9() - FAILED \n";
return E_FAIL;
}
//Check that the Device supports what we need from it
D3DCAPS9 caps;
d3d9->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps);
//Check vertex & pixelshader versions
if (caps.VertexShaderVersion < D3DVS_VERSION(2, 0) || caps.PixelShaderVersion < D3DPS_VERSION(2, 0)) {
g_debug << "Warning - Your graphic card does not support vertex and pixelshaders version 2.0 \n";
}
//Set D3DPRESENT_PARAMETERS
m_present.BackBufferWidth = WINDOW_WIDTH;
m_present.BackBufferHeight = WINDOW_HEIGHT;
m_present.BackBufferFormat = D3DFMT_A8R8G8B8;
m_present.BackBufferCount = 2;
m_present.MultiSampleType = D3DMULTISAMPLE_NONE;
m_present.MultiSampleQuality = 0;
m_present.SwapEffect = D3DSWAPEFFECT_DISCARD;
m_present.hDeviceWindow = m_mainWindow;
m_present.Windowed = windowed;
m_present.EnableAutoDepthStencil = true;
m_present.AutoDepthStencilFormat = D3DFMT_D24S8;
m_present.Flags = 0;
m_present.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
m_present.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
//Hardware Vertex Processing
int vp = 0;
if (caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT)
vp = D3DCREATE_HARDWARE_VERTEXPROCESSING;
else vp = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
//Create the IDirect3DDevice9
if (FAILED(d3d9->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_mainWindow, vp, &m_present, &g_pDevice))) {
g_debug << "Failed to create IDirect3DDevice9 \n";
return E_FAIL;
}
//Release IDirect3D9 interface
d3d9->Release();
//Load Application Specific resources here...
D3DXCreateFont(g_pDevice, 20, 0, FW_BOLD, 1, false,
DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY,
DEFAULT_PITCH | FF_DONTCARE, "Arial", &g_pFont);
//Create Sprite
D3DXCreateSprite(g_pDevice, &g_pSprite);
//Load Effect
ID3DXBuffer *pErrorMsgs = NULL;
HRESULT hRes = D3DXCreateEffectFromFile(g_pDevice, "resources/fx/lighting.fx", NULL, NULL, D3DXSHADER_DEBUG, NULL, &g_pEffect, &pErrorMsgs);
if (FAILED(hRes) && (pErrorMsgs != NULL)) { //Failed to create Effect
g_debug << (char*)pErrorMsgs->GetBufferPointer() << "\n";
return E_FAIL;
}
m_deviceLost = false;
m_drone.Load("resources/meshes/soldier.x");
return S_OK;
}
// 进入循环之前的设置
bool SetUp()
{
HRESULT hr = 0;
hr = D3DXCreateTeapot(g_pDevice, &g_ppMesh[0], NULL);
if (FAILED(hr))
return false;
hr = D3DXCreateSphere(g_pDevice, 1.0f, 20, 20, &g_ppMesh[1], NULL);
if (FAILED(hr))
return false;
hr = D3DXCreateTorus(g_pDevice, 0.5f, 1.0f, 20, 20, &g_ppMesh[2], NULL);
if (FAILED(hr))
return false;
hr = D3DXCreateCylinder(g_pDevice, 0.5f, 1.0f, 2.0f, 20, 20, &g_ppMesh[3], NULL);
if (FAILED(hr))
return false;
D3DXMatrixTranslation(&g_WorldMatrix[0], 0.0f, 2.0f, 0.0f);
D3DXMatrixTranslation(&g_WorldMatrix[1], 0.0f, -2.0f, 0.0f);
D3DXMatrixTranslation(&g_WorldMatrix[2], -3.0f, 0.0f, 0.0f);
D3DXMatrixTranslation(&g_WorldMatrix[3], 3.0f, 0.0f, 0.0f);
g_Color[0] = D3DXVECTOR4(1.0f, 0.0f, 0.0f, 1.0f);
g_Color[1] = D3DXVECTOR4(0.0f, 1.0f, 0.0f, 1.0f);
g_Color[2] = D3DXVECTOR4(0.0f, 0.0f, 1.0f, 1.0f);
g_Color[3] = D3DXVECTOR4(1.0f, 1.0f, 0.0f, 1.0f);
if (!d3d9::CheckShaderVersion(g_pDevice))
{
MessageBox(0, "Shader version can not support!", 0, 0);
return false;
}
ID3DXBuffer *pShaderCache;
ID3DXBuffer *pErrorMsg;
hr = D3DXCompileShaderFromFile(
"Toon.txt",
NULL,
NULL,
"Main",
"vs_1_1",
D3DXSHADER_DEBUG,
&pShaderCache,
&pErrorMsg,
&g_pConstTable
);
if (pErrorMsg)
{
MessageBox(0, (char*)pErrorMsg->GetBufferPointer(), 0, 0);
d3d9::Release(pErrorMsg);
return false;
}
d3d9::Release(pErrorMsg);
if (!g_pConstTable)
{
MessageBox(0, "Const table is NULL!", 0, 0);
return false;
}
if (FAILED(hr))
{
MessageBox(0, "Failed to compile shader from file!", 0, 0);
return false;
}
hr = g_pDevice->CreateVertexShader((DWORD*)pShaderCache->GetBufferPointer(), &g_pVertexShader);
if (FAILED(hr))
{
MessageBox(0, "Failed to create vertex shader!", 0, 0);
d3d9::Release(pShaderCache);
return false;
}
d3d9::Release(pShaderCache);
hr = D3DXCreateTextureFromFile(g_pDevice, "toonshade.bmp", &g_pShadeTex);
if (FAILED(hr))
{
MessageBox(0, "Failed to create texture from file!", 0, 0);
return false;
}
g_pDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
g_pDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
g_pDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
g_hWorldViewMatrix = g_pConstTable->GetConstantByName(NULL, "WorldViewMatrix");
if (!g_hWorldViewMatrix)
{
MessageBox(0, "Get WorldViewMatrix failed!", 0, 0);
return false;
}
g_hWorldViewProjMatrix = g_pConstTable->GetConstantByName(NULL, "WorldViewProjMatrix");
if (!g_hWorldViewProjMatrix)
{
MessageBox(0, "Get WorldViewProjMatrix failed!", 0, 0);
return false;
}
g_hColor = g_pConstTable->GetConstantByName(NULL, "Color");
if (!g_hColor)
{
MessageBox(0, "Get Color failed!", 0, 0);
return false;
}
g_hLightDir = g_pConstTable->GetConstantByName(NULL, "DirToLight");
if (!g_hLightDir)
{
MessageBox(0, "Get DirToLight failed!", 0, 0);
return false;
}
g_pConstTable->SetDefaults(g_pDevice);
D3DXVECTOR4 dirtolight(-0.57f, 0.57f, -0.57f, 0.0f);
g_pConstTable->SetVector(g_pDevice, g_hLightDir, &dirtolight);
// 竖直视角,宽/高比,近裁剪面,远裁剪面
D3DXMatrixPerspectiveFovLH(&g_ProjMatrix, D3DX_PI*0.25f, (float)Width / (float)Height, 1.0f, 100.0f);
return true;
}
//
// Framework functions
//
bool Setup()
{
HRESULT hr = 0;
//
// Init Scene.
//
D3DXVECTOR3 lightDirection(0.0f, 1.0f, 0.0f);
TheTerrain = new Terrain(Device, "coastMountain64.raw", 64, 64, 6, 0.5f);
TheTerrain->genTexture(&lightDirection);
//
// Set texture filters.
//
Device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
Device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
Device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
//
// Set Camera Position.
//
D3DXVECTOR3 pos(100.0f, 100.0f, -250.0f);
TheCamera.setPosition(&pos);
//
// Create effect.
//
ID3DXBuffer* errorBuffer = 0;
hr = D3DXCreateEffectFromFile(
Device,
"fog.txt",
0, // no preprocessor definitions
0, // no ID3DXInclude interface
D3DXSHADER_DEBUG, // compile flags
0, // don't share parameters
&FogEffect,
&errorBuffer);
// output any error messages
if( errorBuffer )
{
::MessageBox(0, (char*)errorBuffer->GetBufferPointer(), 0, 0);
d3d::Release<ID3DXBuffer*>(errorBuffer);
}
if(FAILED(hr))
{
::MessageBox(0, "D3DXCreateEffectFromFile() - FAILED", 0, 0);
return false;
}
//
// Save Frequently Accessed Parameter Handles
//
FogTechHandle = FogEffect->GetTechniqueByName("Fog");
//
// Set Projection.
//
D3DXMATRIX P;
D3DXMatrixPerspectiveFovLH(
&P, D3DX_PI * 0.25f, // 45 - degree
(float)Width / (float)Height,
1.0f, 1000.0f);
Device->SetTransform(D3DTS_PROJECTION, &P);
return true;
}
//-------------------------------------------------------------------------------------
// Name: InitScene()
// Desc: Creates the scene. First we compile our shaders. For the final version
// of a game, you should store the shaders in binary form; don't call
// D3DXCompileShader at runtime. Next, we declare the format of our
// vertices, and then create a vertex buffer. The vertex buffer is basically
// just a chunk of memory that holds vertices. After creating it, we must
// Lock()/Unlock() it to fill it. Finally, we set up our world, projection,
// and view matrices.
//-------------------------------------------------------------------------------------
HRESULT InitScene()
{
// Compile vertex shader.
ID3DXBuffer* pVertexShaderCode;
ID3DXBuffer* pVertexErrorMsg;
HRESULT hr = D3DXCompileShader( g_strVertexShaderProgram,
(UINT)strlen( g_strVertexShaderProgram ),
NULL,
NULL,
"main",
"vs_2_0",
0,
&pVertexShaderCode,
&pVertexErrorMsg,
NULL );
if( FAILED(hr) )
{
if( pVertexErrorMsg )
OutputDebugString( (char*)pVertexErrorMsg->GetBufferPointer() );
return E_FAIL;
}
// Create vertex shader.
g_pd3dDevice->CreateVertexShader( (DWORD*)pVertexShaderCode->GetBufferPointer(),
&g_pVertexShader );
// Compile pixel shader.
ID3DXBuffer* pPixelShaderCode;
ID3DXBuffer* pPixelErrorMsg;
hr = D3DXCompileShader( g_strPixelShaderProgram,
(UINT)strlen( g_strPixelShaderProgram ),
NULL,
NULL,
"main",
"ps_2_0",
0,
&pPixelShaderCode,
&pPixelErrorMsg,
NULL );
if( FAILED(hr) )
{
if( pPixelErrorMsg )
OutputDebugString( (char*)pPixelErrorMsg->GetBufferPointer() );
return E_FAIL;
}
// Create pixel shader.
g_pd3dDevice->CreatePixelShader( (DWORD*)pPixelShaderCode->GetBufferPointer(),
&g_pPixelShader );
// Define the vertex elements and
// Create a vertex declaration from the element descriptions.
D3DVERTEXELEMENT9 VertexElements[3] =
{
{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
{ 0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0 },
D3DDECL_END()
};
g_pd3dDevice->CreateVertexDeclaration( VertexElements, &g_pVertexDecl );
// Create the vertex buffer. Here we are allocating enough memory
// (from the default pool) to hold all our 3 custom vertices.
if( FAILED( g_pd3dDevice->CreateVertexBuffer( 3*sizeof(COLORVERTEX),
D3DUSAGE_WRITEONLY,
NULL,
D3DPOOL_MANAGED,
&g_pVB,
NULL ) ) )
return E_FAIL;
// Now we fill the vertex buffer. To do this, we need to Lock() the VB to
// gain access to the vertices. This mechanism is required because the
// vertex buffer may still be in use by the GPU. This can happen if the
// CPU gets ahead of the GPU. The GPU could still be rendering the previous
// frame.
COLORVERTEX g_Vertices[] =
{
{ 0.0f, -1.1547f, 0.0f, 0xffff0000 }, // x, y, z, color
{ -1.0f, 0.5777f, 0.0f, 0xff00ff00 },
{ 1.0f, 0.5777f, 0.0f, 0xffffff00 },
};
COLORVERTEX* pVertices;
if( FAILED( g_pVB->Lock( 0, 0, (void**)&pVertices, 0 ) ) )
return E_FAIL;
memcpy( pVertices, g_Vertices, 3*sizeof(COLORVERTEX) );
g_pVB->Unlock();
// Initialize the world matrix
g_matWorld = XMMatrixIdentity();
// Initialize the projection matrix
FLOAT fAspect = ( g_bWidescreen ) ? (16.0f / 9.0f) : (4.0f / 3.0f);
g_matProj = XMMatrixPerspectiveFovLH( XM_PIDIV4, fAspect, 1.0f, 200.0f );
// Initialize the view matrix
XMVECTOR vEyePt = { 0.0f, 0.0f,-7.0f, 0.0f };
XMVECTOR vLookatPt = { 0.0f, 0.0f, 0.0f, 0.0f };
XMVECTOR vUp = { 0.0f, 1.0f, 0.0f, 0.0f };
g_matView = XMMatrixLookAtLH( vEyePt, vLookatPt, vUp );
return S_OK;
}
void Initializer::Initialize(HWND hWnd, IDirect3D9* m_pD3DObject,
bool bWindowed, bool m_bVSync, int screenHeight, int screenWidth)
{
// Presentation parameters for creating the D3D9 device
ZeroMemory(&D3Dpp, sizeof(D3Dpp));
D3Dpp.hDeviceWindow = hWnd;
D3Dpp.Windowed = bWindowed;
D3Dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
D3Dpp.EnableAutoDepthStencil = TRUE;
D3Dpp.BackBufferCount = 1;
D3Dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
D3Dpp.BackBufferHeight = screenHeight;
D3Dpp.BackBufferWidth = screenWidth;
D3Dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
D3Dpp.PresentationInterval = m_bVSync ? D3DPRESENT_INTERVAL_DEFAULT : D3DPRESENT_INTERVAL_IMMEDIATE;
D3Dpp.Flags = D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL;
D3Dpp.FullScreen_RefreshRateInHz = bWindowed ? 0 : D3DPRESENT_RATE_DEFAULT;
D3Dpp.MultiSampleQuality = 0;
D3Dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
// Create the Direct3D device using the presentation parameters above
m_pD3DObject->CreateDevice(
D3DADAPTER_DEFAULT, // Primary Display Device
D3DDEVTYPE_HAL, // Device type to use, use HAL
hWnd, // handle to the focus window
D3DCREATE_HARDWARE_VERTEXPROCESSING, // hardware behavior flags
&D3Dpp, // presentation parameters
&m_pD3DDevice); // return created D3DDevice
// Create Font COM object
AddFontResourceEx(L"Spaceracer.ttf", FR_PRIVATE, 0);
D3DXCreateFont(m_pD3DDevice, 30, 0, FW_BOLD, 0, false,
DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY,
DEFAULT_PITCH | FF_DONTCARE, TEXT("Spaceracer"),
&gameFont);
// Create your sprite COM object
D3DXCreateSprite(m_pD3DDevice, &m_pD3DSprite);
// Create player mesh
playerMesh.Init(L"frigate.x");
//create projectile meshes
defaultBulletMesh.Init(L"sphere.x");
missileMesh1.Init(L"missile1.X");
//create enemy ship meshes
viperMesh.Init(L"viperShip.x");
scooterMesh.Init(L"tooter.X");
fighterMesh.Init(L"fighterShip.X");
//create item actor meshes
missilePickup1.Init(L"missileItemActor.X");
healthPickup.Init(L"healthItemActor.X");
starDust.Init(L"starDustItemActor.X");
//create blast mesh
blastRadiusMesh1.Init(L"blastRadius1.X");
// initialize decl
D3DVERTEXELEMENT9 particleElements[] =
{
{0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
{0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
{0, 24, D3DDECLTYPE_FLOAT1, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
{0, 28, D3DDECLTYPE_FLOAT1, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 2},
{0, 32, D3DDECLTYPE_FLOAT1, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 3},
{0, 36, D3DDECLTYPE_FLOAT1, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 4},
{0, 40, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
D3DDECL_END()
};
m_pD3DDevice->CreateVertexDeclaration(particleElements, &Decl);
// Create PSystem Texture
D3DXCreateTextureFromFileA(Initializer::GetInstance()->GetDevice(),
"torch.dds", &mPSysTex);
// create PSys shader effect
ID3DXBuffer* errorCheck;
D3DXCreateEffectFromFileA(Initializer::GetInstance()->GetDevice(),
"firering.fx", 0, 0, 0, 0,
&mPSysFX, &errorCheck);
if(errorCheck)
{
MessageBoxA(0,(char*)errorCheck->GetBufferPointer(), 0, 0);
}
SAFE_RELEASE(errorCheck);
}
