void ConverToLogLuminance(LPDIRECT3DTEXTURE9 pSource, sImageInfo *pInfo)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
device->SetRenderTarget(0, g_pFrameSurface[DOWNSAMPLED_256x256]);
device->SetDepthStencilSurface(NULL);
D3DXHANDLE shader = g_pExposureEffect->GetTechniqueByName("LogLuminance");
g_pExposureEffect->SetTechnique(shader);
D3DXHANDLE tablevar = g_pExposureEffect->GetParameterByName(NULL, "vLuminanceTable");
D3DXHANDLE imagevar = g_pExposureEffect->GetParameterByName(NULL, "Image");
Vector4 vTable(0.21f, 0.71f, 0.072f);
g_pExposureEffect->SetVector(tablevar, (D3DXVECTOR4*)&vTable);
g_pExposureEffect->SetTexture(imagevar, pSource);
g_pExposureEffect->Begin(NULL, 0);
g_pExposureEffect->BeginPass(0);
DrawFullScreenQuad(pInfo);
g_pExposureEffect->EndPass();
g_pExposureEffect->End();
}
static void WaterSimulation(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
device->SetRenderTarget(0, g_pSurfaces[TEX_HEIGHT2]);
device->SetDepthStencilSurface(NULL);
D3DXHANDLE shader = g_pWaterEffect->GetTechniqueByName("WaterSimulation");
D3DXHANDLE heightmap_current_var = g_pWaterEffect->GetParameterByName(NULL, "heightmap_current");
D3DXHANDLE heightmap_prev_var = g_pWaterEffect->GetParameterByName(NULL, "heightmap_prev");
D3DXHANDLE texturesize_var = g_pWaterEffect->GetParameterByName(NULL, "texture_size");
D3DXHANDLE damping_var = g_pWaterEffect->GetParameterByName(NULL, "fDamping");
Vector4 texturesize;
texturesize[0] = 1.0f/(float)g_ImageInfo.m_iWidth;
texturesize[1] = 1.0f/(float)g_ImageInfo.m_iHeight;
texturesize[2] = (float)g_ImageInfo.m_iWidth;
texturesize[3] = (float)g_ImageInfo.m_iHeight;
g_pWaterEffect->SetTechnique(shader);
g_pWaterEffect->SetTexture(heightmap_prev_var, g_pTextures[TEX_HEIGHT0]);
g_pWaterEffect->SetTexture(heightmap_current_var, g_pTextures[TEX_HEIGHT1]);
g_pWaterEffect->SetFloat(damping_var, 0.99f);
g_pWaterEffect->SetVector(texturesize_var, (D3DXVECTOR4*)&texturesize);
g_pWaterEffect->Begin(NULL,0);
g_pWaterEffect->BeginPass(0);
GutDrawFullScreenQuad_DX9(&g_ImageInfo);
g_pWaterEffect->EndPass();
g_pWaterEffect->End();
}
void AutoExposure(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
D3DXHANDLE shader = g_pExposureEffect->GetTechniqueByName("AutoExposure");
g_pExposureEffect->SetTechnique(shader);
Vector4 vMiddleGray(0.5f);
Vector4 vMultiplierClamp(0.2f, 3.0f, 0.0f, 0.0f);
D3DXHANDLE middlegray_var = g_pExposureEffect->GetParameterByName(NULL, "vMiddleGray");
D3DXHANDLE clamp_var = g_pExposureEffect->GetParameterByName(NULL, "vMultiplierClamp");
D3DXHANDLE image0_var = g_pExposureEffect->GetParameterByName(NULL, "Image");
D3DXHANDLE image1_var = g_pExposureEffect->GetParameterByName(NULL, "Image2");
g_pExposureEffect->SetVector(middlegray_var, (D3DXVECTOR4*)&vMiddleGray);
g_pExposureEffect->SetVector(clamp_var, (D3DXVECTOR4*)&vMultiplierClamp);
g_pExposureEffect->SetTexture(image0_var, g_pFrameBuffer[FULLSIZE]);
g_pExposureEffect->SetTexture(image1_var, g_pFrameBuffer[LUMINANCE_TEMP]);
g_pExposureEffect->Begin(NULL, 0);
g_pExposureEffect->BeginPass(0);
DrawFullScreenQuad(&g_ImageInfo);
g_pExposureEffect->EndPass();
g_pExposureEffect->End();
}
static void AddImpulse(void)
{
static Vector4 vPosition(0.0f, 0.0f, 0.0f, 0.0f);
//Vector4 vDiff = vPosition - g_vPosition;
Vector4 vDiff = g_vPosition - vPosition;
Vector4 vLength = vDiff.Length();
if ( vLength[0]<2.0f )
return;
Vector4 vDir = vDiff / vLength;
Vector4 vVec0(vDir[1],-vDir[0], 0.0f, 0.0f);
Vector4 vVec1(vDir[0], vDir[1], 0.0f, 0.0f);
vPosition = g_vPosition;
Vector4 vVec0_old = g_orient_matrix[0];
Vector4 vVec1_old = g_orient_matrix[1];
Vector4 vVec0_new = VectorLerp(vVec0_old, vVec0, 0.2f);
Vector4 vVec1_new = VectorLerp(vVec1_old, vVec1, 0.2f);
vVec0_new.Normalize();
vVec1_new.Normalize();
Vector4 vVec2_new = Vector3CrossProduct(vVec0_new, vVec1_new);
g_orient_matrix.Identity();
g_orient_matrix[0] = vVec0_new;
g_orient_matrix[1] = vVec1_new;
g_orient_matrix[2] = vVec2_new;
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
device->SetRenderTarget(0, g_pSurfaces[TEX_HEIGHT1]);
device->SetDepthStencilSurface(NULL);
Matrix4x4 view_matrix = g_Control.GetViewMatrix();
Matrix4x4 world_matrix;
world_matrix.Scale_Replace(g_fRippleSize, g_fRippleSize, 1.0f);
world_matrix[3] = g_vPosition;
Matrix4x4 wvp_matrix = g_orient_matrix * world_matrix * view_matrix * g_proj_matrix;
D3DXHANDLE shader = g_pWaterEffect->GetTechniqueByName("AddImpulse");
D3DXHANDLE wvp_matrix_var = g_pWaterEffect->GetParameterByName(NULL, "wvp_matrix");
D3DXHANDLE force_var = g_pWaterEffect->GetParameterByName(NULL, "fForce");
g_pWaterEffect->SetTechnique(shader);
g_pWaterEffect->SetMatrix(wvp_matrix_var, (D3DXMATRIX *)&wvp_matrix);
g_pWaterEffect->SetFloat(force_var, 0.05f);
g_pWaterEffect->Begin(NULL, 0);
g_pWaterEffect->BeginPass(0);
g_Model_DX9.Render(0);
g_pWaterEffect->EndPass();
g_pWaterEffect->End();
vPosition = g_vPosition;
}
HRESULT CD3DFont::InitDeviceObjects( LPDIRECT3DDEVICE9 pd3dDevice )
{
HRESULT hr;
// Keep a local copy of the device
m_pd3dDevice = pd3dDevice;
// Large fonts need larger textures
//m_dwTexWidth = m_dwTexHeight = 256;
xmlNode *node = XMLParseFile("textures/font.xml");
assert(node);
int count = node->attribute("count").Asint();
m_dwSpacing = node->attribute("spacing").Asint() ;
m_dwTexWidth = node->attribute("width").Asint();
m_dwTexHeight= node->attribute("height").Asint();
String imagefile = "textures/font.png";
StringIter p(node->body);
for( int i=0;i<count;i++)
{
int c;
p >> c;
p >> m_fTexCoords[c-32][0] >> m_fTexCoords[c-32][1] >> m_fTexCoords[c-32][2] >> m_fTexCoords[c-32][3];
}
hr=D3DXCreateTextureFromFile(m_pd3dDevice,(const char*)imagefile,&m_pTexture);
LPD3DXBUFFER error;
extern String effectpath;
D3DXCreateEffectFromFile(m_pd3dDevice,effectpath + "/font.fx",NULL,NULL,0,NULL,&effect,&error) && VERIFY_RESULT;
assert(effect);
diffusemap = effect->GetParameterByName(NULL,"diffusemap");
assert(diffusemap);
effect->SetTexture(diffusemap,m_pTexture) && VERIFY_RESULT;
return S_OK;
}
static void RenderParticle(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
int w, h; GutGetWindowSize(w, h);
Matrix4x4 wvp_matrix = g_Control.GetObjectMatrix() * g_Control.GetViewMatrix() * g_proj_matrix;
Vector4 ScreenSize( (float)w, (float)h, 0.0f, 0.0f);
float fTanW = FastMath::Tan( FastMath::DegToRad(g_fFOV) );
device->SetRenderTarget(0, g_pMainFramebuffer);
device->SetDepthStencilSurface(g_pMainDepthbuffer);
device->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL, 0x0, 1.0f, 0);
D3DXHANDLE shader = g_pParticleRenderFX->GetTechniqueByName("RenderParticle");
D3DXHANDLE positiontex_var = g_pParticleRenderFX->GetParameterByName(NULL, "PositionTex");
D3DXHANDLE velocitytex_var = g_pParticleRenderFX->GetParameterByName(NULL, "VelocityTex");
D3DXHANDLE wvp_matrix_var = g_pParticleRenderFX->GetParameterByName(NULL, "wvp_matrix");
D3DXHANDLE tan_fov_var = g_pParticleRenderFX->GetParameterByName(NULL, "fTanW");
D3DXHANDLE screensize_var = g_pParticleRenderFX->GetParameterByName(NULL, "ScreenSize");
D3DXHANDLE diffusetex_var = g_pParticleRenderFX->GetParameterByName(NULL, "DiffuseTex");
g_pParticleRenderFX->SetTechnique(shader);
g_pParticleRenderFX->SetTexture(positiontex_var, g_pTextures[TEX_POSITION1]);
g_pParticleRenderFX->SetTexture(velocitytex_var, g_pTextures[TEX_VELOCITY1]);
g_pParticleRenderFX->SetMatrix(wvp_matrix_var, (D3DXMATRIX*)&wvp_matrix);
g_pParticleRenderFX->SetVector(screensize_var, (D3DXVECTOR4*)&ScreenSize);
g_pParticleRenderFX->SetFloat(tan_fov_var, fTanW);
g_pParticleRenderFX->SetTexture(diffusetex_var, g_pParticleTexture);
int num_processed_particles = (g_num_particles / g_texture_width) * g_texture_width;
if ( num_processed_particles )
{
device->SetFVF(D3DFVF_TEX1);
g_pParticleRenderFX->Begin(NULL,0);
g_pParticleRenderFX->BeginPass(0);
//device->SetRenderState(D3DRS_POINTSPRITEENABLE, TRUE);
device->DrawPrimitiveUP(D3DPT_POINTLIST, num_processed_particles, g_pParticleArray, sizeof(sParticle));
//device->SetRenderState(D3DRS_POINTSPRITEENABLE, FALSE);
g_pParticleRenderFX->EndPass();
g_pParticleRenderFX->End();
}
}
static void RenderWater(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
D3DXHANDLE shader = g_pWaterEffect->GetTechniqueByName("Water");
D3DXHANDLE normalmap_var = g_pWaterEffect->GetParameterByName(NULL, "NormalmapTex");
D3DXHANDLE watermap_var = g_pWaterEffect->GetParameterByName(NULL, "WaterTex");
D3DXHANDLE texcoordscale_var = g_pWaterEffect->GetParameterByName(NULL, "fTexcoordScale");
g_pWaterEffect->SetTechnique(shader);
g_pWaterEffect->SetTexture(normalmap_var, g_pTextures[TEX_NORMAL]);
g_pWaterEffect->SetTexture(watermap_var, g_pWaterTexture);
g_pWaterEffect->SetFloat(texcoordscale_var, 0.2f);
g_pWaterEffect->Begin(NULL,0);
g_pWaterEffect->BeginPass(0);
GutDrawFullScreenQuad_DX9(&g_ImageInfo);
g_pWaterEffect->EndPass();
g_pWaterEffect->End();
}
static void HeightmapToNormal(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
device->SetRenderTarget(0, g_pSurfaces[TEX_NORMAL]);
device->SetDepthStencilSurface(NULL);
D3DXHANDLE shader = g_pWaterEffect->GetTechniqueByName("ConvertNormal");
D3DXHANDLE heightmap_current_var = g_pWaterEffect->GetParameterByName(NULL, "heightmap_current");
D3DXHANDLE normalscale_var = g_pWaterEffect->GetParameterByName(NULL, "fNormalScale");
g_pWaterEffect->SetTechnique(shader);
g_pWaterEffect->SetTexture(heightmap_current_var, g_pTextures[TEX_HEIGHT2]);
g_pWaterEffect->SetFloat(normalscale_var, 1.0f);
g_pWaterEffect->Begin(NULL,0);
g_pWaterEffect->BeginPass(0);
GutDrawFullScreenQuad_DX9(&g_ImageInfo);
g_pWaterEffect->EndPass();
g_pWaterEffect->End();
}
void AdaptiveLuminance(void)
{
static int count = 0;
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
if ( count )
{
device->SetRenderTarget(0, g_pFrameSurface[LUMINANCE_TEMP]);
D3DXHANDLE shader = g_pExposureEffect->GetTechniqueByName("AdaptiveLuminance");
g_pExposureEffect->SetTechnique(shader);
Vector4 vSpeed(0.03f);
D3DXHANDLE speed_var = g_pExposureEffect->GetParameterByName(NULL, "vAdaptiveSpeed");
D3DXHANDLE image0_var = g_pExposureEffect->GetParameterByName(NULL, "Image");
D3DXHANDLE image1_var = g_pExposureEffect->GetParameterByName(NULL, "Image2");
g_pExposureEffect->SetVector(speed_var, (D3DXVECTOR4*)&vSpeed);
g_pExposureEffect->SetTexture(image0_var, g_pFrameBuffer[LUMINANCE_PREVIOUS]);
g_pExposureEffect->SetTexture(image1_var, g_pFrameBuffer[LUMINANCE_CURRENT]);
g_pExposureEffect->Begin(NULL, 0);
g_pExposureEffect->BeginPass(0);
DrawFullScreenQuad(&g_Image1x1);
g_pExposureEffect->EndPass();
g_pExposureEffect->End();
}
else
{
device->StretchRect(g_pFrameSurface[LUMINANCE_CURRENT], NULL, g_pFrameSurface[LUMINANCE_TEMP], NULL, D3DTEXF_POINT);
}
// copy
//device->StretchRect(g_pFrameSurface[LUMINANCE_TEMP], NULL, g_pFrameSurface[LUMINANCE_PREVIOUS], NULL, D3DTEXF_POINT);
SwapRenderTarget(LUMINANCE_TEMP, LUMINANCE_PREVIOUS);
count++;
}
void RenderFrameDX9(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
device->BeginScene();
device->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL, 0x0, 1.0f, 0);
Matrix4x4 view_matrix = g_Control.GetViewMatrix();
Matrix4x4 world_matrix = g_Control.GetObjectMatrix();
Matrix4x4 wv_matrix = world_matrix * view_matrix;
Matrix4x4 wvp_matrix = wv_matrix * g_proj_matrix;
DrawImage(g_pTexture, &g_ImageInfo);
D3DXHANDLE shader = g_pRefractionFX->GetTechniqueByName("Refraction");
D3DXHANDLE texture = g_pRefractionFX->GetParameterByName(NULL, "BackgroundImage");
D3DXHANDLE wv_matrix_h = g_pRefractionFX->GetParameterByName(NULL, "wv_matrix");
D3DXHANDLE wvp_matrix_h = g_pRefractionFX->GetParameterByName(NULL, "wvp_matrix");
D3DXHANDLE objectcolor_h = g_pRefractionFX->GetParameterByName(NULL, "object_color");
g_pRefractionFX->SetTechnique(shader);
g_pRefractionFX->SetTexture(texture, g_pTexture);
g_pRefractionFX->SetMatrix(wv_matrix_h, (D3DXMATRIX *)&wv_matrix);
g_pRefractionFX->SetMatrix(wvp_matrix_h, (D3DXMATRIX *)&wvp_matrix);
g_pRefractionFX->SetVector(objectcolor_h, (D3DXVECTOR4 *)&g_vObjectColor);
g_pRefractionFX->Begin(NULL, 0);
g_pRefractionFX->BeginPass(0);
g_Model_DX9.Render(0);
g_pRefractionFX->EndPass();
g_pRefractionFX->End();
device->EndScene();
device->Present( NULL, NULL, NULL, NULL );
}
void DrawImage(LPDIRECT3DTEXTURE9 pSource1, sImageInfo *pInfo, float x0, float y0, float width, float height)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
g_pEffect->SetTechnique(g_pAddImageShader);
D3DXHANDLE pTexture1Var = g_pEffect->GetParameterByName(NULL, "Image");
g_pEffect->SetTexture(pTexture1Var, pSource1);
g_pEffect->Begin(NULL, 0);
g_pEffect->BeginPass(0);
DrawScreenQuad(pInfo, x0, y0, width, height);
g_pEffect->EndPass();
g_pEffect->End();
}
void CGlowEffect::SetBlurEffectParameters(float dx,float dy,float blurAmount,CEffectFile* pEffect)
{
const int sampleCount = 9;
float sampleWeights[sampleCount];
float sampleOffset[sampleCount * 2];
sampleWeights[0] = ComputeGaussian(0,blurAmount);
sampleOffset[0] = 0;
sampleOffset[1] = 0;
float totalWeight = sampleWeights[0];
for (int i=0;i<sampleCount/2;i++)
{
float weight = ComputeGaussian( (float)(i+1),blurAmount);
sampleWeights[i*2+1] = weight;
sampleWeights[i*2+2] = weight;
totalWeight += weight * 2;
float offset = i * 2 + 1.5f;
float offsetX = dx * offset;
float offsetY = dy * offset;
int index = (i * 2) * 2 + 2;
sampleOffset[index] = offsetX;
sampleOffset[index+1] = offsetY;
sampleOffset[index+2] = -offsetX;
sampleOffset[index+3] = -offsetY;
}
for(int i=0;i<sampleCount;i++)
{
sampleWeights[i] /= totalWeight;
}
//optimize code here!!!
LPD3DXEFFECT fx = pEffect->GetDXEffect();
fx->SetFloatArray(fx->GetParameterByName(NULL,"sampleWeight"),sampleWeights,sampleCount);
fx->SetFloatArray(fx->GetParameterByName(NULL,"sampleOffset"),sampleOffset,sampleCount * 2);
}
void ExpLuminance(LPDIRECT3DSURFACE9 pSurace, LPDIRECT3DTEXTURE9 pTexture, sImageInfo *pInfo)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
device->SetRenderTarget(0, pSurace);
D3DXHANDLE shader = g_pExposureEffect->GetTechniqueByName("ExpLuminance");
D3DXHANDLE image_var = g_pExposureEffect->GetParameterByName(NULL, "Image");
g_pExposureEffect->SetTechnique(shader);
g_pExposureEffect->SetTexture(image_var, pTexture);
g_pExposureEffect->Begin(NULL, 0);
g_pExposureEffect->BeginPass(0);
DrawFullScreenQuad(pInfo);
g_pExposureEffect->EndPass();
g_pExposureEffect->End();
}
void DrawImage(LPDIRECT3DTEXTURE9 pSource, float x0, float y0, float w, float h, sImageInfo *pInfo, bool bRedOnly = false)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
D3DXHANDLE shader = g_pPostEffect->GetTechniqueByName(bRedOnly ? "DrawImageRedChannel" : "DrawImage");
D3DXHANDLE pTextureVar = g_pPostEffect->GetParameterByName(NULL, "Image");
g_pPostEffect->SetTechnique(shader);
g_pPostEffect->SetTexture(pTextureVar, pSource);
// 設定頂點資料格式
device->SetFVF(D3DFVF_XYZ|D3DFVF_TEX1);
g_pPostEffect->Begin(NULL, 0);
g_pPostEffect->BeginPass(0);
GutDrawScreenQuad_DX9(x0, y0, w, h, pInfo);
g_pPostEffect->EndPass();
g_pPostEffect->End();
}
//---------------------------------------------------------------------------------------
// シェーダ初期化
//---------------------------------------------------------------------------------------
HRESULT InitShader()
{
// シェーダ読み込み
HRESULT hr = D3DXCreateEffectFromFile(g_pD3DDevice,
PATH_FXTEST, NULL, NULL, 0, NULL, &g_pFX, NULL);
if (FAILED(hr)) {
TCHAR szMsg[1024];
_stprintf(szMsg, _T("シェーダ(%s)読み込みエラー"),
PATH_FXTEST);
MessageBox(g_hWnd, szMsg, _T("error"), MB_OK);
return hr;
}
// ハンドル取得
struct _param {
LPCSTR pszName;
D3DXHANDLE* pHandle;
} param[] = {
{"WORLDVIEWPROJECTION", &g_hMatWVP},
{"WORLD", &g_hMatW},
{"CAMERAPOSITION", &g_hCamera},
{"MATERIALDIFFUSE", &g_hDiffuse},
{"MATERIALSPECULAR", &g_hSpecular},
{"MATERIALPOWER", &g_hPower},
{"MATERIALAMBIENT", &g_hAmbient},
{"MATERIALTEXTURE", &g_hTexture},
{"MATERIALTEXTUREVALID", &g_hTexEnable},
};
for (int i = 0; i < _countof(param); i++) {
*param[i].pHandle =
g_pFX->GetParameterBySemantic(NULL,
param[i].pszName);
}
g_hLight = g_pFX->GetParameterByName(NULL, "light");
for (int i = 0; i < MAX_TECHNIQUE; ++i) {
g_hTech[i] = g_pFX->GetTechnique(i);
}
return hr;
}
void DrawImage(LPDIRECT3DTEXTURE9 pSource, sImageInfo *pInfo)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
// 計算貼圖像素的貼圖座標間距
int w = pInfo->m_iWidth;
int h = pInfo->m_iHeight;
float fTexelW = 1.0f/(float)w;
float fTexelH = 1.0f/(float)h;
// Direct3D9會偏移半個像素, 從貼圖座標來把它修正回來
Vector4 vTexoffset(fTexelW*0.5f, fTexelH*0.5f, 0.0f, 1.0f);
Vertex_VT quad[4];
memcpy(quad, g_FullScreenQuad, sizeof(quad));
for ( int i=0; i<4; i++ )
{
quad[i].m_Texcoord[0] += vTexoffset[0];
quad[i].m_Texcoord[1] += vTexoffset[1];
}
D3DXHANDLE shader = g_pEffect->GetTechniqueByName("DrawImage");
D3DXHANDLE pTextureVar = g_pEffect->GetParameterByName(NULL, "Image");
g_pEffect->SetTechnique(shader);
g_pEffect->SetTexture(pTextureVar, pSource);
// 設定頂點資料格式
device->SetFVF(D3DFVF_XYZ|D3DFVF_TEX1);
g_pEffect->Begin(NULL, 0);
g_pEffect->BeginPass(0);
device->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, quad, sizeof(Vertex_VT));
g_pEffect->EndPass();
g_pEffect->End();
}
void ExpLuminance(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
device->SetRenderTarget(0, g_pFrameSurface[LUMINANCE_TEMP]);
D3DXHANDLE shader = g_pExposureEffect->GetTechniqueByName("ExpLuminance");
D3DXHANDLE image_var = g_pExposureEffect->GetParameterByName(NULL, "Image");
g_pExposureEffect->SetTechnique(shader);
g_pExposureEffect->SetTexture(image_var, g_pFrameBuffer[LUMINANCE_CURRENT]);
g_pExposureEffect->Begin(NULL, 0);
g_pExposureEffect->BeginPass(0);
DrawFullScreenQuad(&g_Image1x1);
g_pExposureEffect->EndPass();
g_pExposureEffect->End();
SwapRenderTarget(LUMINANCE_TEMP, LUMINANCE_CURRENT);
}
static void ParticleSimulation(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
device->SetRenderTarget(0, g_pSurfaces[TEX_POSITION1]);
device->SetRenderTarget(1, g_pSurfaces[TEX_VELOCITY1]);
device->SetDepthStencilSurface(NULL);
RECT rect;
rect.left = 0;
rect.right = g_texture_width;
rect.top = 0;
rect.bottom = g_num_particles / g_texture_width;
if ( rect.bottom==0 )
return;
device->SetScissorRect(&rect);
device->SetRenderState(D3DRS_SCISSORTESTENABLE, TRUE);
D3DXHANDLE shader = g_pParticleFX->GetTechniqueByName("Simulate");
D3DXHANDLE positiontex_var = g_pParticleFX->GetParameterByName(NULL, "PositionTex");
D3DXHANDLE velocitytex_var = g_pParticleFX->GetParameterByName(NULL, "VelocityTex");
D3DXHANDLE noisetex_var = g_pParticleFX->GetParameterByName(NULL, "NoiseTex");
D3DXHANDLE force_var = g_pParticleFX->GetParameterByName(NULL, "Force");
D3DXHANDLE time_var = g_pParticleFX->GetParameterByName(NULL, "fTimeAdvance");
D3DXHANDLE rand_var = g_pParticleFX->GetParameterByName(NULL, "Rand");
D3DXHANDLE tan_var = g_pParticleFX->GetParameterByName(NULL, "fTan");
D3DXHANDLE liferange_var = g_pParticleFX->GetParameterByName(NULL, "LifeRange");
D3DXHANDLE speedrange_var = g_pParticleFX->GetParameterByName(NULL, "SpeedRange");
D3DXHANDLE sizerange_var = g_pParticleFX->GetParameterByName(NULL, "SizeRange");
Vector4 vForce = g_vForce * g_fTimeAdvance;
Vector4 vRand[3];
Vector4 vLifeRange(1.0f, 2.0f, 0.0f, 0.0f);
Vector4 vSpeedRange(1.0f, 2.0f, 0.0f, 0.0f);
Vector4 vSizeRange(0.01f, 0.02f, 0.0f, 0.0f);
for ( int i=0; i<3; i++ )
{
vRand[i][0] = float(rand()%1024)/1024.0f;
vRand[i][1] = float(rand()%1024)/1024.0f;
vRand[i][2] = float(rand()%1024)/1024.0f;
vRand[i][3] = float(rand()%1024)/1024.0f;
}
g_pParticleFX->SetTechnique(shader);
g_pParticleFX->SetTexture(positiontex_var, g_pTextures[TEX_POSITION0]);
g_pParticleFX->SetTexture(velocitytex_var, g_pTextures[TEX_VELOCITY0]);
g_pParticleFX->SetTexture(noisetex_var, g_pNoiseTexture);
g_pParticleFX->SetVector(force_var, (D3DXVECTOR4*)&vForce);
g_pParticleFX->SetVectorArray(rand_var, (D3DXVECTOR4*)&vRand, 3);
g_pParticleFX->SetVector(liferange_var, (D3DXVECTOR4*)&vLifeRange);
g_pParticleFX->SetVector(speedrange_var, (D3DXVECTOR4*)&vSpeedRange);
g_pParticleFX->SetVector(sizerange_var, (D3DXVECTOR4*)&vSizeRange);
g_pParticleFX->SetFloat(time_var, g_fTimeAdvance);
g_pParticleFX->SetFloat(tan_var, FastMath::Tan(FastMath::DegToRad(g_fEmitTheta)));
g_pParticleFX->Begin(NULL,0);
g_pParticleFX->BeginPass(0);
GutDrawFullScreenQuad_DX9(&g_ImageInfo);
g_pParticleFX->EndPass();
g_pParticleFX->End();
device->SetRenderTarget(1, NULL);
device->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
}
/************************************************************************
* desc: Load the shader from xml file path
*
* param: string & filePath - path to shader xml file
************************************************************************/
void CShader::LoadFromXML( const string & filePath )
{
HRESULT hr;
// this open and parse the XML file:
XMLNode mainNode = XMLNode::openFileHelper( filePath.c_str(), "shaderLst" );
if( mainNode.isEmpty() )
throw NExcept::CCriticalException("Shader Load Error!",
boost::str( boost::format("Shader XML empty (%s).\n\n%s\nLine: %s") % filePath.c_str() % __FUNCTION__ % __LINE__ ));
for( int i = 0; i < mainNode.nChildNode(); ++i )
{
XMLNode shaderNode = mainNode.getChildNode(i);
// Get the id for this effect file
string idStr = string(shaderNode.getChildNode("effect").getAttribute("strId"));
// See if this shader has already been loaded
effectDataMapIter = spEffectDataMap.find( idStr );
// If it's not found, load the shader and add it to the list
if( effectDataMapIter == spEffectDataMap.end() )
{
LPD3DXEFFECT pEffect = NULL;
LPD3DXBUFFER pBufferError = NULL;
string effectFilePath(shaderNode.getChildNode("effect").getAttribute("file"));
// Try to load the shader into memory
if( FAILED( hr = D3DXCreateEffectFromFile( CXDevice::Instance().GetXDevice(),
effectFilePath.c_str(),
NULL,
NULL,
D3DXFX_NOT_CLONEABLE,
NULL,
&pEffect,
&pBufferError ) ) )
{
throw NExcept::CCriticalException("Shader Load Error!",
boost::str( boost::format("Error creating shader (%s).\n\n%s\nLine: %s") % filePath.c_str() % __FUNCTION__ % __LINE__ ));
}
CEffectData * pEffectData = new CEffectData;
spEffectDataMap.insert( idStr, pEffectData );
pEffectData->spEffect.Attach( pEffect );
pEffectData->effectNameStr = idStr;
// Get the shader type list
XMLNode dataTypeLstNode = shaderNode.getChildNode("dataTypeLst");
if( !dataTypeLstNode.isEmpty() )
{
for( int j = 0; j < dataTypeLstNode.nChildNode(); ++j )
{
string dataTypeName = string(dataTypeLstNode.getChildNode(j).getAttribute("name"));
D3DXHANDLE handle = pEffect->GetParameterByName( NULL, dataTypeName.c_str() );
if( handle == NULL )
throw NExcept::CCriticalException("Shader Load Error!",
boost::str( boost::format("Error getting handle to effect data type. (%s), (%s), (%s)\n\n%s\nLine: %s") % filePath.c_str() % effectFilePath.c_str() % dataTypeName.c_str() % __FUNCTION__ % __LINE__ ));
CEffectType * pEffectType = new CEffectType;
pEffectData->spEffectTypeMap.insert( dataTypeName, pEffectType );
pEffectType->handle = handle;
pEffectType->type = effectTypeMap[string(dataTypeLstNode.getChildNode(j).getAttribute("type"))];
if( dataTypeLstNode.getChildNode(j).isAttributeSet("maxElements") )
pEffectType->arrayCount = atoi(dataTypeLstNode.getChildNode(j).getAttribute("maxElements"));
}
}
}
}
} // LoadFromFile
void AverageLuminance(LPDIRECT3DTEXTURE9 pSource)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
D3DXHANDLE shader = g_pExposureEffect->GetTechniqueByName("Average16Samples");
g_pExposureEffect->SetTechnique(shader);
D3DXHANDLE texoffset_var = g_pExposureEffect->GetParameterByName(NULL, "vTexOffset");
D3DXHANDLE image_var = g_pExposureEffect->GetParameterByName(NULL, "Image");
float fTexX, fTexY;
Vector4 vTexOffset_256x256[16];
Vector4 vTexOffset_64x64[16];
Vector4 vTexOffset_16x16[16];
Vector4 vTexOffset_4x4[16];
int index = 0;
index=0;
fTexX = 1.0f/256.0f;
fTexY = 1.0f/256.0f;
for ( int y=0; y<4; y++ )
{
for ( int x=0; x<4; x++ )
{
vTexOffset_256x256[index].Set(x*fTexX, y*fTexY, 0.0f, 0.0f);
index++;
}
}
index=0;
fTexX = 1.0f/64.0f;
fTexY = 1.0f/64.0f;
for ( int y=0; y<4; y++ )
{
for ( int x=0; x<4; x++ )
{
vTexOffset_64x64[index].Set(x*fTexX, y*fTexY, 0.0f, 0.0f);
index++;
}
}
index=0;
fTexX = 1.0f/16.0f;
fTexY = 1.0f/16.0f;
for ( int y=0; y<4; y++ )
{
for ( int x=0; x<4; x++ )
{
vTexOffset_16x16[index].Set(x*fTexX, y*fTexY, 0.0f, 0.0f);
index++;
}
}
index=0;
fTexX = 1.0f/4.0f;
fTexY = 1.0f/4.0f;
for ( int y=0; y<4; y++ )
{
for ( int x=0; x<4; x++ )
{
vTexOffset_4x4[index].Set(x*fTexX, y*fTexY, 0.0f, 0.0f);
index++;
}
}
// 256x256 -> 64x164
{
device->SetRenderTarget(0, g_pFrameSurface[DOWNSAMPLED_64x64]);
device->SetDepthStencilSurface(NULL);
g_pExposureEffect->SetVectorArray(texoffset_var, (D3DXVECTOR4*)vTexOffset_256x256, 16);
g_pExposureEffect->SetTexture(image_var, pSource);
g_pExposureEffect->Begin(NULL, 0);
g_pExposureEffect->BeginPass(0);
DrawFullScreenQuad(&g_Image64x64);
g_pExposureEffect->EndPass();
g_pExposureEffect->End();
}
// 64x64 -> 16x16
{
device->SetRenderTarget(0, g_pFrameSurface[DOWNSAMPLED_16x16]);
device->SetDepthStencilSurface(NULL);
g_pExposureEffect->SetVectorArray(texoffset_var, (D3DXVECTOR4*)vTexOffset_64x64, 16);
g_pExposureEffect->SetTexture(image_var, pSource);
g_pExposureEffect->Begin(NULL, 0);
g_pExposureEffect->BeginPass(0);
DrawFullScreenQuad(&g_Image64x64);
g_pExposureEffect->EndPass();
g_pExposureEffect->End();
}
// 16x16 -> 4x4
{
device->SetRenderTarget(0, g_pFrameSurface[DOWNSAMPLED_4x4]);
g_pExposureEffect->SetVectorArray(texoffset_var, (D3DXVECTOR4*)vTexOffset_16x16, 16);
g_pExposureEffect->SetTexture(image_var, g_pFrameBuffer[DOWNSAMPLED_16x16]);
g_pExposureEffect->Begin(NULL, 0);
g_pExposureEffect->BeginPass(0);
DrawFullScreenQuad(&g_Image16x16);
g_pExposureEffect->EndPass();
g_pExposureEffect->End();
}
// 4x4 -> 1x1
{
device->SetRenderTarget(0, g_pFrameSurface[LUMINANCE_CURRENT]);
g_pExposureEffect->SetVectorArray(texoffset_var, (D3DXVECTOR4*)vTexOffset_4x4, 16);
g_pExposureEffect->SetTexture(image_var, g_pFrameBuffer[DOWNSAMPLED_4x4]);
g_pExposureEffect->Begin(NULL, 0);
g_pExposureEffect->BeginPass(0);
DrawFullScreenQuad(&g_Image4x4);
g_pExposureEffect->EndPass();
g_pExposureEffect->End();
}
}
void VCND3D9_SelectionFX::CreateParameterHandles( LPD3DXEFFECT pShader )
{
mSelected = pShader->GetParameterByName( NULL, "gSelected" );
}
HRESULT CGlowEffect::Render(float fGlowThreshold, float fGlowAmount, bool bUseAlpha)
{
//#ifdef _DEBUG
// bUseAlpha = true;
//#endif
HRESULT hr=S_OK;
LPDIRECT3DDEVICE9 pd3dDevice = CGlobals::GetRenderDevice();
// get current render target
m_pBackBuffer = CGlobals::GetDirectXEngine().GetRenderTarget();
if(FAILED(pd3dDevice->GetDepthStencilSurface(&m_pZBuffer)))
return E_FAIL;
if(!m_pBackBuffer || !m_pZBuffer)
return E_FAIL;
// Copy scene to lower resolution render target texture
if( FAILED(hr = pd3dDevice->StretchRect( m_pBackBuffer, NULL, m_pRTHalfSizeSurface, NULL, D3DTEXF_LINEAR )) ) {
OUTPUT_LOG("StretchRect() failed!\r\n");
return hr;
}
EffectManager* pEffectManager = CGlobals::GetEffectManager();
pEffectManager->BeginEffect(TECH_FULL_SCREEN_GLOW);
CEffectFile* pEffectFile = pEffectManager->GetCurrentEffectFile();
if(pEffectFile != 0 && pEffectFile->begin(true, 0))
{
// full screen glow effect is completed in four steps.
assert(pEffectFile->totalPasses() == 4);
mesh_vertex_plain quadVertices[4] = {
{Vector3(-1,-1,0), Vector2(0,1)},
{ Vector3(1, -1, 0), Vector2(1, 1) },
{ Vector3(-1, 1, 0), Vector2(0, 0) },
{ Vector3(1, 1, 0), Vector2(1, 0) },
};
// offset the texture coordinate by half texel in order to match texel to pixel.
// This takes me hours to figure out. :-(
float fhalfTexelWidth = 0.5f/m_glowtextureWidth;
float fhalfTexelHeight = 0.5f/m_glowtextureHeight;
for (int i=0;i<4;++i)
{
quadVertices[i].uv.x += fhalfTexelWidth;
quadVertices[i].uv.y += fhalfTexelHeight;
}
// shader constants
/*
#ifdef TEST_GLOW
static int i=0;
++i;
if(i>30){
fGlowAmount = 1.0f;
fGlowThreshold = 0.f;
if(i>60)
i=0;
}
else
{
fGlowAmount = 0.f;
fGlowThreshold = 1.0f;
}
#endif*/
/*
pEffectFile->setParameter(CEffectFile::k_ConstVector0, (const float*)&Vector4(1/m_glowtextureWidth, 1/m_glowtextureHeight, 0.0f, 0.0f));
LinearColor glowness = pEffectManager->GetGlowness();
glowness.a = fGlowThreshold;
glowness.r *= fGlowAmount;
glowness.g *= fGlowAmount;
glowness.b *= fGlowAmount;
pEffectFile->setParameter(CEffectFile::k_ConstVector1, (const float*)&glowness);
*/
bUseAlpha = true;
if(bUseAlpha)
{
//////////////////////////////////////////////////////////////////////////
// make the glow source. Multiply texture alpha * RGB to get the glow sources
pd3dDevice->SetRenderTarget( 0, m_pRTGlowSourceSurface);
pd3dDevice->SetDepthStencilSurface( NULL );
if(pEffectFile->BeginPass(0))
{
pEffectFile->setTexture(0, m_pRTHalfSizeTexture);
LPD3DXEFFECT fx = pEffectFile->GetDXEffect();
fx->SetFloat(fx->GetParameterByName(NULL,"glowThreshold"),fGlowThreshold);
pEffectFile->CommitChanges();
HRESULT hr = RenderDevice::DrawPrimitiveUP( pd3dDevice, RenderDevice::DRAW_PERF_TRIANGLES_MESH, D3DPT_TRIANGLESTRIP,2,quadVertices,sizeof(mesh_vertex_plain));
pEffectFile->EndPass();
}
}
//////////////////////////////////////////////////////////////////////////
// Blur glow sources in the horizontal axis
pd3dDevice->SetRenderTarget( 0, m_pRTBlurHorizSurface );
pd3dDevice->SetDepthStencilSurface( NULL );
// no need to clear alpha channel?
// pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, 0x00, 1.0f, 0 );
if(pEffectFile->BeginPass(1))
{
SetBlurEffectParameters(1.0f / m_glowtextureWidth,0,fGlowAmount,pEffectFile);
pEffectFile->setTexture(0, m_pRTGlowSourceTexture);
pEffectFile->CommitChanges();
HRESULT hr = RenderDevice::DrawPrimitiveUP( pd3dDevice, RenderDevice::DRAW_PERF_TRIANGLES_MESH, D3DPT_TRIANGLESTRIP,2,quadVertices,sizeof(mesh_vertex_plain));
pEffectFile->EndPass();
}
// set texture 0 to NULL so same texture is never simultaneously a source and render target
pEffectFile->setTexture( 0, (LPDIRECT3DTEXTURE9)NULL );
//////////////////////////////////////////////////////////////////////////
// Blur the horizontal blur in the vertical direction
pd3dDevice->SetRenderTarget( 0, m_pRTBlurVertSurface );
pd3dDevice->SetDepthStencilSurface( NULL );
// no need to clear alpha channel?
// pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, 0x00, 1.0f, 0 );
//fGlowAmount = 2;
if(pEffectFile->BeginPass(1))
{
//pEffectFile->setTexture( 1, m_pRTBlurHorizTexture );
SetBlurEffectParameters(0,1.0f / m_glowtextureHeight,fGlowAmount,pEffectFile);
pEffectFile->setTexture(0, m_pRTBlurHorizTexture ); //editor here!!!
pEffectFile->CommitChanges();
HRESULT hr = RenderDevice::DrawPrimitiveUP( pd3dDevice, RenderDevice::DRAW_PERF_TRIANGLES_MESH, D3DPT_TRIANGLESTRIP,2,quadVertices,sizeof(mesh_vertex_plain));
pEffectFile->EndPass();
}
// Set all textures to NULL to prevent RTT being bound as source and destination at the same time,
pEffectFile->setTexture( 0,(LPDIRECT3DTEXTURE9)NULL );
//////////////////////////////////////////////////////////////////////////
// Add the final blur image to the back buffer
pd3dDevice->SetRenderTarget( 0, m_pBackBuffer);
pd3dDevice->SetDepthStencilSurface( NULL );
// no need to clear alpha channel?
// pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, 0x00, 1.0f, 0 );
for (int i=0;i<4;++i)
{
quadVertices[i].uv.x -= fhalfTexelWidth * 0.5f;
quadVertices[i].uv.y -= fhalfTexelHeight * 0.5f;
}
if(pEffectFile->BeginPass(3))
{
pEffectFile->setTexture(0, m_pRTHalfSizeTexture );
pEffectFile->setTexture(1,m_pRTBlurVertTexture);
Vector4 glowParam = pEffectManager->GetGlowness();
LPD3DXEFFECT fx = pEffectFile->GetDXEffect();
fx->SetVector(fx->GetParameterByName(NULL,"glowParams"), (const DeviceVector4*)&glowParam);
pEffectFile->CommitChanges();
HRESULT hr = RenderDevice::DrawPrimitiveUP( pd3dDevice, RenderDevice::DRAW_PERF_TRIANGLES_MESH, D3DPT_TRIANGLESTRIP,2,quadVertices,sizeof(mesh_vertex_plain));
pEffectFile->EndPass();
pEffectFile->setTexture( 0, (LPDIRECT3DTEXTURE9)NULL );
pEffectFile->setTexture(1,(LPDIRECT3DTEXTURE9)NULL);
}
// restore depth stencil buffer
pd3dDevice->SetDepthStencilSurface( m_pZBuffer );
pEffectFile->end();
}
else
{
CGlobals::GetScene()->EnableFullScreenGlow(false);
//Glow effect will not be load when graphics setting set to middle
//so we just disable this warnning
//OUTPUT_LOG("can not set full screen glow effect error \r\n");
}
SAFE_RELEASE(m_pZBuffer);
return hr;
}
