HRESULT KG3DSceneShadowMap::SetParametersForShader(LPD3DXEFFECT pShader)
{
KGLOG_PROCESS_ERROR(pShader);
pShader->SetTexture("tShadowmap1",m_ShadowLevel[0].m_lpSMShadowMap);
pShader->SetTexture("tShadowmap2",m_ShadowLevel[1].m_lpSMShadowMap);
pShader->SetTexture("tShadowmap3",m_ShadowLevel[2].m_lpSMShadowMap);
pShader->SetMatrix("matLightVP1",&m_ShadowLevel[0].m_matVP);
pShader->SetMatrix("matLightVP2",&m_ShadowLevel[1].m_matVP);
pShader->SetMatrix("matLightVP3",&m_ShadowLevel[2].m_matVP);
/*
D3DXVECTOR4 UV[9];
float x = 1.0F/m_ShadowLevel[0].m_dwShadowmapSize;
float y = 1.0F/m_ShadowLevel[0].m_dwShadowmapSize;
UV[0] = D3DXVECTOR4( 0, 0,0,0.3F);
UV[1] = D3DXVECTOR4(-x, 0,0,0.3F);
UV[2] = D3DXVECTOR4( x, 0,0,0.3F);
UV[3] = D3DXVECTOR4( 0,-y,0,0.3F);
UV[4] = D3DXVECTOR4( 0, y,0,0.3F);
UV[5] = D3DXVECTOR4(-x, y,0,0.3F);
UV[6] = D3DXVECTOR4( x, y,0,0.3F);
UV[7] = D3DXVECTOR4( x,-y,0,0.3F);
UV[8] = D3DXVECTOR4( x,-y,0,0.8F);
pShader->SetVectorArray("g_avSampleOffsets",UV,9);
*/
return S_OK;
Exit0:
return E_FAIL;
}
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 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();
}
// 3D 물체등을 그린다.
void RenderScene()
{
// 뷰 행렬을 만든다.
D3DXMATRIXA16 matView;
D3DXVECTOR3 vEyePt(gWorldCameraPosition.x, gWorldCameraPosition.y, gWorldCameraPosition.z);
D3DXVECTOR3 vLookatPt(0.0f, 0.0f, 0.0f);
D3DXVECTOR3 vUpVec(0.0f, 1.0f, 0.0f);
D3DXMatrixLookAtLH(&matView, &vEyePt, &vLookatPt, &vUpVec);
// 투영행렬을 만든다.
D3DXMATRIXA16 matProjection;
D3DXMatrixPerspectiveFovLH(&matProjection, FOV, ASPECT_RATIO, NEAR_PLANE, FAR_PLANE);
// 프레임마다 0.4도씩 회전을 시킨다.
gRotationY += 0.4f * PI / 180.0f;
if (gRotationY > 2 * PI)
{
gRotationY -= 2 * PI;
}
// 월드행렬을 만든다.
D3DXMATRIXA16 matWorld;
D3DXMatrixRotationY(&matWorld, gRotationY);
// 월드/뷰/투영행렬을 미리 곱한다.
D3DXMATRIXA16 matWorldView;
D3DXMATRIXA16 matWorldViewProjection;
D3DXMatrixMultiply(&matWorldView, &matWorld, &matView);
D3DXMatrixMultiply(&matWorldViewProjection, &matWorldView, &matProjection);
// 쉐이더 전역변수들을 설정
gpEnvironmentMappingShader->SetMatrix("gWorldMatrix", &matWorld);
gpEnvironmentMappingShader->SetMatrix("gWorldViewProjectionMatrix", &matWorldViewProjection);
gpEnvironmentMappingShader->SetVector("gWorldLightPosition", &gWorldLightPosition);
gpEnvironmentMappingShader->SetVector("gWorldCameraPosition", &gWorldCameraPosition);
gpEnvironmentMappingShader->SetVector("gLightColor", &gLightColor);
gpEnvironmentMappingShader->SetTexture("DiffuseMap_Tex", gpStoneDM);
gpEnvironmentMappingShader->SetTexture("SpecularMap_Tex", gpStoneSM);
gpEnvironmentMappingShader->SetTexture("NormalMap_Tex", gpStoneNM);
gpEnvironmentMappingShader->SetTexture("EnvironmentMap_Tex", gpSnowENV);
// 쉐이더를 시작한다.
UINT numPasses = 0;
gpEnvironmentMappingShader->Begin(&numPasses, NULL);
{
for (UINT i = 0; i < numPasses; ++i)
{
gpEnvironmentMappingShader->BeginPass(i);
{
// 구체를 그린다.
gpTeapot->DrawSubset(0);
}
gpEnvironmentMappingShader->EndPass();
}
}
gpEnvironmentMappingShader->End();
}
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();
}
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;
}
void SetupFX()
{
// 텍스처와 행렬값을 ID3DXEffect(여기서는 정점쉐이더)에 전달한다.
g_pEffect->SetTexture( "tex0", g_pTexture );
g_pEffect->SetMatrix( "matW", &g_matWorld );
g_pEffect->SetMatrix( "matV", &g_matView );
g_pEffect->SetMatrix( "matP", &g_matProj );
}
bool c_gbuffer::SetEffectVar(LPD3DXEFFECT& effect,
bool& variable_used,
cstring texture_semantic,
Render::s_render_target& target,
cstring x_handle_semantic, const int x_index,
cstring y_handle_semantic, const int y_index,
cstring z_handle_semantic, const int z_index,
cstring w_handle_semantic, const int w_index)
{
variable_used = false;
if(!effect) return false;
//find the intended texture handle
D3DXHANDLE tex_handle = effect->GetParameterBySemantic(NULL, texture_semantic);
variable_used = (tex_handle != NULL) ? true : false;
if(!tex_handle) return true;
else if(tex_handle && !target.IsEnabled()) return false;
// set the texture variable
effect->SetTexture(tex_handle, target.texture);
// search for the index variables handles
// then set them to the indices for the intended data
D3DXHANDLE index_handle = NULL;
if(x_handle_semantic)
{
index_handle = effect->GetParameterBySemantic(NULL, x_handle_semantic);
if(!index_handle)
return false;
effect->SetInt(index_handle, x_index);
}
if(y_handle_semantic)
{
index_handle = effect->GetParameterBySemantic(NULL, y_handle_semantic);
if(!index_handle)
return false;
effect->SetInt(index_handle, y_index);
}
if(z_handle_semantic)
{
index_handle = effect->GetParameterBySemantic(NULL, z_handle_semantic);
if(!index_handle)
return false;
effect->SetInt(index_handle, z_index);
}
if(w_handle_semantic)
{
index_handle = effect->GetParameterBySemantic(NULL, w_handle_semantic);
if(!index_handle)
return false;
effect->SetInt(index_handle, w_index);
}
return true;
}
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();
}
}
void RenderFrameDX9(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
device->BeginScene();
AddImpulse();
WaterSimulation();
HeightmapToNormal();
device->SetRenderTarget(0, g_pMainFramebuffer);
device->SetDepthStencilSurface(g_pMainDepthbuffer);
device->Clear(0, NULL, D3DCLEAR_ZBUFFER, 0x0, 1.0f, 0);
RenderWater();
DrawObject();
SwapHeightmaps();
float x = -1.0f;
float y = -1.0f;
float w = 0.4f;
float h = 0.4f;
if ( g_iMode & 0x01 )
{
DrawImage(g_pTextures[TEX_HEIGHT2], x, y, w, h, &g_ImageInfo);
x+=w;
}
if ( g_iMode & 0x02 )
{
D3DXHANDLE shader = g_pWaterEffect->GetTechniqueByName("Heightmap");
D3DXHANDLE heightmap_var = g_pWaterEffect->GetTechniqueByName("heightmap_current");
g_pWaterEffect->SetTechnique(shader);
g_pWaterEffect->SetTexture(heightmap_var, g_pTextures[TEX_HEIGHT2]);
g_pWaterEffect->Begin(NULL, 0);
g_pWaterEffect->BeginPass(0);
GutDrawScreenQuad_DX9(x, y, w, h, &g_ImageInfo);
g_pWaterEffect->EndPass();
g_pWaterEffect->End();
x+=w;
}
if ( g_iMode & 0x04 )
{
DrawImage(g_pTextures[TEX_NORMAL], x, y, w, h, &g_ImageInfo);
x+=w;
}
device->EndScene();
device->Present( NULL, NULL, NULL, NULL );
}
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();
}
void VisualizeTextureLevel(LPDIRECT3DTEXTURE9 tex, int level, int x, int y, int w, int h, float gamma)
{
LPD3DXEFFECT effect = LoadEffect("utils.fx");
if (effect == NULL) return;
CGame2D* g2d = Get2D();
effect->SetTexture("g_Image", tex);
effect->SetFloat("g_Level", (float) level);
effect->SetFloat("g_Gamma", gamma);
effect->SetTechnique("TextureLevel");
DX_BEGIN_EFFECT(effect);
g2d->DrawRect(x, y, w, h, 0xFFFFFFFF);
DX_END_EFFECT(effect);
}
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 MaskTextureLevel(LPDIRECT3DTEXTURE9 tex, int level, int x, int y, int w, int h,
float minMask, float maxMask, int maskValue)
{
LPD3DXEFFECT effect = LoadEffect("utils.fx");
if (effect == NULL) return;
CGame2D* g2d = Get2D();
effect->SetTexture("g_Image", tex);
effect->SetFloat("g_Level", (float) level);
effect->SetFloat("g_MinMask", minMask);
effect->SetFloat("g_MaxMask", maxMask);
effect->SetInt("g_Mask", maskValue);
effect->SetTechnique("MaskTexture");
DX_BEGIN_EFFECT(effect);
g2d->DrawRect(x, y, w, h, 0xFFFFFFFF);
DX_END_EFFECT(effect);
}
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 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 SetMaterialShader(D3DMATERIAL9* pMaterial,
LPDIRECT3DTEXTURE9 pTexture)
{
if (pMaterial) {
g_pFX->SetVector(g_hDiffuse,
(LPD3DXVECTOR4)&pMaterial->Diffuse);
g_pFX->SetVector(g_hSpecular,
(LPD3DXVECTOR4)&pMaterial->Specular);
g_pFX->SetFloat(g_hPower, pMaterial->Power);
g_pFX->SetVector(g_hAmbient,
(LPD3DXVECTOR4)&pMaterial->Ambient);
}
if (pTexture) {
g_pFX->SetTexture(g_hTexture, pTexture);
g_pFX->SetBool(g_hTexEnable, TRUE);
} else {
g_pFX->SetBool(g_hTexEnable, FALSE);
}
g_pFX->CommitChanges();
}
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();
}
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 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();
}
/*
일반 Object, Bone , Skined Mesh 전부 그리고음.
*/
void SkinnedMeshNode::Render()
{
HRESULT hr;
m_pRscVetextBuffer->SetStreamSource(0,sizeof(BLEND_VERTEX));
m_pRscIndexBuffer->SetIndices();
LPD3DXEFFECT pEffect = Graphics::m_pInstance->GetEffect();
if (!m_updateMatrixPallete)
{
UpdateMatrixPallete();
}
pEffect->SetTexture("Tex_MatrixPallete",m_pMatrixPalleteTexture->GetD3DTexture());
HR_V(pEffect->CommitChanges());
HR_V(Graphics::m_pDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST,
0,
0,
m_pRscVetextBuffer->GetVertexCount(),
0,
m_pRscIndexBuffer->GetTriangleCount() ));
}
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);
}
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 );
}
//The user-provided entry point for a graphical Windows-based application.
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE hPreInstance, LPSTR lpCmdLine, int nShowCmd)
{
// Fill out the WNDCLASS structure
WNDCLASS wc;
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc = windowMessageCallback;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = ::GetModuleHandle(NULL);
wc.hIcon = ::LoadIcon(0, IDI_APPLICATION);
wc.hCursor = ::LoadCursor(0, IDC_ARROW);
wc.hbrBackground = static_cast<HBRUSH>(::GetStockObject(BLACK_BRUSH));
wc.lpszMenuName = 0;
wc.lpszClassName = gClassName;
// Register the WNDCLASS description
if (!::RegisterClass(&wc))
{
return false;
}
// Create the window
HWND hwnd = ::CreateWindow(gClassName, TEXT("client"),
WS_OVERLAPPEDWINDOW,
0, 0, 512, 512,
GetDesktopWindow(), 0, ::GetModuleHandle(0), 0);
if (hwnd ==0)
{
return 0;
}
// Show the window
::ShowWindow(hwnd, SW_NORMAL);
// Update the window
::UpdateWindow(hwnd);
//
IDirect3D9* d3d9 = Direct3DCreate9(D3D_SDK_VERSION);
if (NULL == d3d9)
{
return 0;
}
D3DPRESENT_PARAMETERS pp;
memset(&pp, 0, sizeof(D3DPRESENT_PARAMETERS ));
pp.BackBufferWidth = 0;
pp.BackBufferHeight = 0;
pp.BackBufferFormat = D3DFMT_UNKNOWN;
pp.BackBufferCount = 1;
pp.MultiSampleType = D3DMULTISAMPLE_NONE;
pp.MultiSampleQuality = 0;
pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
pp.hDeviceWindow = hwnd;
pp.Windowed = TRUE;
pp.EnableAutoDepthStencil = TRUE;
pp.AutoDepthStencilFormat = D3DFMT_D24S8;
pp.Flags = 0;
pp.FullScreen_RefreshRateInHz = 0;
pp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
d3d9->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd, D3DCREATE_HARDWARE_VERTEXPROCESSING, &pp, &gDevice);
if (gDevice == NULL)
{
return 0;
}
D3DXCreateEffectFromFile(gDevice, TEXT("e:/ZenBin/data/shader/Position.fx"), NULL, NULL, D3DXSHADER_DEBUG, NULL, &gEffect, NULL);
//
D3DXCreateTextureFromFileEx(gDevice, TEXT("e:/ZenBin/data/image/AID_hportal.bmp"), D3DX_DEFAULT, D3DX_DEFAULT, 1, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, &gTexture);
// Message Structure
MSG msg;
::ZeroMemory(&msg, sizeof(msg));
// Loop until getting a WM_QUIT message
while(true)
{
if (::PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
{
if (msg.message == WM_QUIT)
{
break;
}
::TranslateMessage(&msg);
::DispatchMessage(&msg);
}
else
{
gDevice->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0x000020, 1, 0);
gDevice->BeginScene();
gDevice->SetFVF(gVertexFVF);
sVertex v[4];
size_t intdex = 0;
v[intdex].x = -0.5f;
v[intdex].y = 0.5f;
v[intdex].z = 0.0f;
v[intdex].diffuse = D3DCOLOR_RGBA(0, 100, 0, 0);
v[intdex].u = 0;
v[intdex].v = 0;
intdex = 1;
v[intdex].x = 0.5f;
v[intdex].y = 0.5f;
v[intdex].z = 0.0f;
v[intdex].diffuse = D3DCOLOR_RGBA(0, 100, 0, 0);
v[intdex].u = 1;
v[intdex].v = 0;
intdex = 2;
v[intdex].x = -0.5f;
v[intdex].y = -0.5f;
v[intdex].z = 0.0f;
v[intdex].diffuse = D3DCOLOR_RGBA(0, 100, 0, 0);
v[intdex].u = 0;
v[intdex].v = 1;
intdex = 3;
v[intdex].x = 0.5f;
v[intdex].y = -0.5f;
v[intdex].z = 0.0f;
v[intdex].diffuse = D3DCOLOR_RGBA(0, 100, 0, 0);
v[intdex].u = 1;
v[intdex].v = 1;
gEffect->SetTexture("lay0", gTexture);
UINT pPasses = 0;
gEffect->SetTechnique("PP0");
gEffect->Begin(&pPasses, D3DXFX_DONOTSAVESTATE);
for (int i = 0; i != pPasses; ++i)
{
gEffect->BeginPass(i);
gDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, v, sizeof(sVertex));
gEffect->EndPass();
}
gEffect->End();
gDevice->EndScene();
gDevice->Present(NULL, NULL, 0, NULL);
}
}
//
if (gTexture)
{
gTexture->Release();
gTexture = NULL;
}
//
if (gEffect)
{
gEffect->Release();
gEffect = NULL;
}
//
if (gDevice)
{
gDevice->Release();
gDevice = NULL;
}
//
d3d9->Release();
d3d9 = NULL;
return 0;
}
void sc_lights_MaterialEventSun()
{
SC_SCREEN* screen = (SC_SCREEN*)(mtl.SC_SKILL);
if(screen == NULL) return;
switch(render_view)
{
case screen.views.sunEdge:
screen.views.sunEdge.bmap = screen.renderTargets.quarter0;
break;
case screen.views.sunExpand:
screen.views.sunExpand.bmap = screen.renderTargets.eighth0;
break;
case screen.views.sunShadow:
screen.views.sunShadow.bmap = screen.renderTargets.full1;
break;
case screen.views.sun:
screen.views.sun.bmap = screen.renderTargets.full0;
//LPD3DXEFFECT pEffect = (LPD3DXEFFECT)mtl->d3deffect;
#ifndef SC_A7
LPD3DXEFFECT pEffect = (LPD3DXEFFECT)mtl->d3deffect;
#else
LPD3DXEFFECT pEffect = (LPD3DXEFFECT)render_d3dxeffect;
#endif
//LPD3DXEFFECT pEffect = (LPD3DXEFFECT)(mtl->d3deffect);
if(pEffect != NULL)
{
pEffect->SetVector("frustumPoints", screen.frustumPoints);
//pEffect->SetFloat("clipFar", screen.views.main.clip_far);
pEffect->SetTexture("texBRDFLut", sc_deferredLighting_texBRDFLUT); //assign volumetric brdf lut
pEffect->SetTexture("texMaterialLUT", sc_materials_mapData.d3dtex);
pEffect->SetTexture("texShadowMask", screen.renderTargets.eighth0.d3dtex);
pEffect->SetTexture("texShadowSun", screen.renderTargets.full1.d3dtex);
pEffect->SetInt("shadowmapSize", (screen.settings.lights.sunShadowResolution) );
pEffect->SetFloat("shadowBias", (screen.settings.lights.sunShadowBias) );
}
break;
default:
break;
}
/*
if(render_view == screen.views.sun)
{
screen.views.sun.bmap = screen.renderTargets.full0;
//LPD3DXEFFECT pEffect = (LPD3DXEFFECT)mtl->d3deffect;
#ifndef SC_A7
LPD3DXEFFECT pEffect = (LPD3DXEFFECT)mtl->d3deffect;
#else
LPD3DXEFFECT pEffect = (LPD3DXEFFECT)render_d3dxeffect;
#endif
//LPD3DXEFFECT pEffect = (LPD3DXEFFECT)(mtl->d3deffect);
if(pEffect != NULL)
{
pEffect->SetVector("frustumPoints", screen.frustumPoints);
//pEffect->SetFloat("clipFar", screen.views.main.clip_far);
pEffect->SetTexture("texBRDFLut", sc_deferredLighting_texBRDFLUT); //assign volumetric brdf lut
pEffect->SetTexture("texMaterialLUT", sc_materials_mapData.d3dtex);
pEffect->SetInt("shadowmapSize", (screen.settings.lights.sunShadowResolution) );
pEffect->SetFloat("shadowBias", (screen.settings.lights.sunShadowBias) );
}
}
*/
}
// 3D 물체등을 그린다.
void RenderScene()
{
// 뷰행렬 초기화.
D3DXMATRIXA16 matView;
// D3DXVECTOR3 vEyePt(0.0f, 0.0f, -200.0f);
D3DXVECTOR3 vEyePt(gWorldCameraPosition.x, gWorldCameraPosition.y, gWorldCameraPosition.z);
D3DXVECTOR3 vLookatPt(0.0f, 0.0f, 0.0f);
D3DXVECTOR3 vUpVec(0.0f, 1.0f, 0.0f);
D3DXMatrixLookAtLH(&matView, &vEyePt, &vLookatPt, &vUpVec);
// 투영행렬 초기화.
D3DXMATRIXA16 matProjection;
D3DXMatrixPerspectiveFovLH(&matProjection, FOV, ASPECT_RATIO, NEAR_PLANE, FAR_PLANE);
// 회전.
gRotationY += ((0.4f * PI) / 180.0f);
if (gRotationY > 2 * PI)
gRotationY -= 2 * PI;
// 월드행렬 초기화.
D3DXMATRIXA16 matWorld;
// D3DXMatrixIdentity(&matWorld);
D3DXMatrixRotationY(&matWorld, gRotationY);
// 월드_뷰_투영행렬
D3DXMATRIXA16 matWorldView;
D3DXMATRIXA16 matWorldViewProjection;
D3DXMatrixMultiply(&matWorldView, &matWorld, &matView);
D3DXMatrixMultiply(&matWorldViewProjection, &matWorldView, &matProjection);
// 쉐이더에 전달.
gpNormalMappingShader->SetMatrix("gWorldMatrix", &matWorld);
gpNormalMappingShader->SetMatrix("gWorldViewProjectionMatrix", &matWorldViewProjection);
gpNormalMappingShader->SetVector("gWorldLightPosition", &gWorldLightPosition);
gpNormalMappingShader->SetVector("gWorldCameraPosition", &gWorldCameraPosition);
gpNormalMappingShader->SetVector("gLightColor", &gLightColor);
gpNormalMappingShader->SetTexture("DiffuseMap_Tex", gpStoneDM);
gpNormalMappingShader->SetTexture("SpecularMap_Tex", gpStoneSM);
gpNormalMappingShader->SetTexture("NormalMap_Tex", gpStoneNM);
// 쉐이더 적용.
UINT numPasses = 0;
gpNormalMappingShader->Begin(&numPasses, NULL);
for (UINT i = 0; i < numPasses; ++i) {
gpNormalMappingShader->BeginPass(i);
gpSphere->DrawSubset(0);
gpNormalMappingShader->EndPass();
}
gpNormalMappingShader->End();
}
//-----------------------------------------------------------------------------
// Name: FrameMove
// Desc:
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::FrameMove()
{
HRESULT hr;
//
// Process keyboard input
//
D3DXVECTOR3 vecT(0.0f, 0.0f, 0.0f);
D3DXVECTOR3 vecR(0.0f, 0.0f, 0.0f);
if(m_bKey[VK_NUMPAD1] || m_bKey[VK_LEFT]) vecT.x -= 1.0f; // Slide Left
if(m_bKey[VK_NUMPAD3] || m_bKey[VK_RIGHT]) vecT.x += 1.0f; // Slide Right
if(m_bKey[VK_DOWN]) vecT.y -= 1.0f; // Slide Down
if(m_bKey[VK_UP]) vecT.y += 1.0f; // Slide Up
if(m_bKey['W']) vecT.z -= 2.0f; // Move Forward
if(m_bKey['S']) vecT.z += 2.0f; // Move Backward
if(m_bKey['A'] || m_bKey[VK_NUMPAD8]) vecR.x -= 1.0f; // Pitch Down
if(m_bKey['Z'] || m_bKey[VK_NUMPAD2]) vecR.x += 1.0f; // Pitch Up
if(m_bKey['E'] || m_bKey[VK_NUMPAD6]) vecR.y -= 1.0f; // Turn Right
if(m_bKey['Q'] || m_bKey[VK_NUMPAD4]) vecR.y += 1.0f; // Turn Left
if(m_bKey[VK_NUMPAD9]) vecR.z -= 2.0f; // Roll CW
if(m_bKey[VK_NUMPAD7]) vecR.z += 2.0f; // Roll CCW
m_vecVelocity = m_vecVelocity * 0.9f + vecT * 0.1f;
m_vecAngularVelocity = m_vecAngularVelocity * 0.9f + vecR * 0.1f;
//
// Update position and view matricies
//
D3DXMATRIX matT, matR;
D3DXQUATERNION qR;
vecT = m_vecVelocity * m_fElapsedTime * m_fSpeed;
vecR = m_vecAngularVelocity * m_fElapsedTime * m_fAngularSpeed;
D3DXMatrixTranslation(&matT, vecT.x, vecT.y, vecT.z);
D3DXMatrixMultiply(&m_matPosition, &matT, &m_matPosition);
D3DXQuaternionRotationYawPitchRoll(&qR, vecR.y, vecR.x, vecR.z);
D3DXMatrixRotationQuaternion(&matR, &qR);
D3DXMatrixMultiply(&m_matPosition, &matR, &m_matPosition);
D3DXMatrixInverse(&m_matView, NULL, &m_matPosition);
//
// Update simulation
//
if(!m_bPause && m_bDrawWater)
{
BOOL bCaustics = m_bDrawCaustics && m_pEffect->IsParameterUsed("tCAU");
D3DXVECTOR3 vecPos(m_matPosition._41, m_matPosition._42, m_matPosition._43);
D3DXVECTOR3 vecLight(0.0f, 1.0f, 0.0f);
m_Water.Update(vecPos, vecLight, bCaustics);
m_fTime += m_fSecsPerFrame;
if(bCaustics)
{
if(SUCCEEDED(m_pRenderToSurface->BeginScene(m_pCausticSurf, NULL)))
{
D3DXMATRIX matProj;
D3DXMATRIX matView;
D3DXMatrixOrthoRH(&matProj, 63.0f, 63.0f, 1.0f, 100.0f);
D3DXMatrixRotationX(&matView, 0.5f * D3DX_PI);
matView._43 = -50.0f;
m_pd3dDevice->SetTransform(D3DTS_PROJECTION, &matProj);
m_pd3dDevice->SetTransform(D3DTS_VIEW, &matView);
m_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET, 0xff000000, 0.0f, 0);
m_pd3dDevice->SetRenderState(D3DRS_ZENABLE, FALSE);
m_pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
m_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
m_Water.DrawCaustics();
m_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
m_pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW);
m_pd3dDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
m_pRenderToSurface->EndScene();
}
else
{
m_bDrawCaustics = FALSE;
m_pEffect->SetTexture("tCAU", NULL);
if(FAILED(hr = GetNextTechnique(0, FALSE)))
return hr;
}
}
}
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: RestoreDeviceObjects
// Desc:
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::RestoreDeviceObjects()
{
HRESULT hr;
// Restore the font
m_pFont->RestoreDeviceObjects();
m_pFontSmall->RestoreDeviceObjects();
// Create light
D3DLIGHT8 light;
ZeroMemory(&light, sizeof(light));
light.Type = D3DLIGHT_DIRECTIONAL;
light.Diffuse.r = m_colorLight.r;
light.Diffuse.g = m_colorLight.g;
light.Diffuse.b = m_colorLight.b;
light.Diffuse.a = m_colorLight.a;
light.Specular.r = 1.0f;
light.Specular.g = 1.0f;
light.Specular.b = 1.0f;
light.Specular.a = 0.0f;
light.Direction.x = m_vecLight.x;
light.Direction.y = m_vecLight.y;
light.Direction.z = m_vecLight.z;
m_pd3dDevice->SetLight(0, &light);
m_pd3dDevice->LightEnable(0, TRUE);
// Create material
D3DMATERIAL8 material;
ZeroMemory(&material, sizeof(material));
material.Diffuse.a = 1.0f;
material.Specular.r = 0.5f;
material.Specular.g = 0.5f;
material.Specular.b = 0.5f;
material.Power = 20.0f;
m_pd3dDevice->SetMaterial(&material);
// Setup render states
m_pd3dDevice->SetVertexShader(D3DFVF_XYZ);
m_pd3dDevice->SetTransform(D3DTS_VIEW, &m_matView);
m_pd3dDevice->SetTransform(D3DTS_WORLD, &m_matIdentity);
m_pd3dDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
m_pd3dDevice->SetRenderState(D3DRS_SPECULARENABLE, FALSE);
m_pd3dDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL);
m_pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW);
m_pd3dDevice->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_GOURAUD);
m_pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);
m_pd3dDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);
m_pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_DISABLE);
m_pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
m_pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_CURRENT);
m_pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
m_pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
m_pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
m_pd3dDevice->SetTextureStageState(0, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
m_pd3dDevice->SetTextureStageState(0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
m_pd3dDevice->SetTextureStageState(0, D3DTSS_MIPFILTER, D3DTEXF_POINT);
m_pd3dDevice->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 0);
m_pd3dDevice->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
m_pd3dDevice->SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
m_pd3dDevice->SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_CURRENT);
m_pd3dDevice->SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
m_pd3dDevice->SetTextureStageState(1, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
m_pd3dDevice->SetTextureStageState(1, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
m_pd3dDevice->SetTextureStageState(1, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
m_pd3dDevice->SetTextureStageState(1, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
m_pd3dDevice->SetTextureStageState(1, D3DTSS_MIPFILTER, D3DTEXF_POINT);
m_pd3dDevice->SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, 0);
// Create caustic texture
D3DDISPLAYMODE mode;
m_pd3dDevice->GetDisplayMode(&mode);
if(FAILED(hr = D3DXCreateTexture(m_pd3dDevice, WATER_CAUSTICS_SIZE, WATER_CAUSTICS_SIZE, 1, D3DUSAGE_RENDERTARGET, mode.Format, D3DPOOL_DEFAULT, &m_pCausticTex)) &&
FAILED(hr = D3DXCreateTexture(m_pd3dDevice, WATER_CAUSTICS_SIZE, WATER_CAUSTICS_SIZE, 1, 0, mode.Format, D3DPOOL_DEFAULT, &m_pCausticTex)))
{
return hr;
}
D3DSURFACE_DESC desc;
m_pCausticTex->GetSurfaceLevel(0, &m_pCausticSurf);
m_pCausticSurf->GetDesc(&desc);
if(FAILED(hr = D3DXCreateRenderToSurface(m_pd3dDevice, desc.Width, desc.Height,
desc.Format, FALSE, D3DFMT_UNKNOWN, &m_pRenderToSurface)))
{
return hr;
}
// Shader
TCHAR sz[512];
DXUtil_FindMediaFile(sz, _T("water.sha"));
if(FAILED(hr = D3DXCreateEffectFromFile(m_pd3dDevice, sz, &m_pEffect, NULL)))
return hr;
m_pEffect->SetMatrix("mID", &m_matIdentity);
m_pEffect->SetMatrix("mENV", &m_matIdentity);
m_pEffect->SetTexture("tFLR", m_pFloorTex);
m_pEffect->SetTexture("tCAU", m_pCausticTex);
m_pEffect->SetTexture("tENV", m_pSkyCubeTex);
if(FAILED(hr = GetNextTechnique(0, FALSE)))
return hr;
// Set surfaces
if(FAILED(hr = m_Environment.SetSurfaces(
m_pSkyTex[D3DCUBEMAP_FACE_NEGATIVE_X], m_pSkyTex[D3DCUBEMAP_FACE_POSITIVE_X],
m_pSkyTex[D3DCUBEMAP_FACE_NEGATIVE_Y], m_pSkyTex[D3DCUBEMAP_FACE_POSITIVE_Y],
m_pSkyTex[D3DCUBEMAP_FACE_POSITIVE_Z], m_pSkyTex[D3DCUBEMAP_FACE_NEGATIVE_Z])))
{
return hr;
}
// OnResetDevice
if(FAILED(hr = m_Water.OnResetDevice()))
return hr;
if(FAILED(hr = m_Environment.OnResetDevice()))
return hr;
return S_OK;
}
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();
}
}
//The user-provided entry point for a graphical Windows-based application.
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE hPreInstance, LPSTR lpCmdLine, int nShowCmd)
{
// Fill out the WNDCLASS structure
WNDCLASS wc;
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc = windowMessageCallback;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = ::GetModuleHandle(NULL);
wc.hIcon = ::LoadIcon(0, IDI_APPLICATION);
wc.hCursor = ::LoadCursor(0, IDC_ARROW);
wc.hbrBackground = static_cast<HBRUSH>(::GetStockObject(BLACK_BRUSH));
wc.lpszMenuName = 0;
wc.lpszClassName = gClassName;
// Register the WNDCLASS description
if (!::RegisterClass(&wc))
{
return false;
}
// Create the window
HWND hwnd = ::CreateWindow(gClassName, TEXT("client"),
WS_OVERLAPPEDWINDOW,
0, 0, 512, 512,
GetDesktopWindow(), 0, ::GetModuleHandle(0), 0);
if (hwnd ==0)
{
return 0;
}
// Show the window
::ShowWindow(hwnd, SW_NORMAL);
// Update the window
::UpdateWindow(hwnd);
//
IDirect3D9* d3d9 = Direct3DCreate9(D3D_SDK_VERSION);
if (NULL == d3d9)
{
return 0;
}
D3DPRESENT_PARAMETERS pp;
memset(&pp, 0, sizeof(D3DPRESENT_PARAMETERS ));
pp.BackBufferWidth = 0;
pp.BackBufferHeight = 0;
pp.BackBufferFormat = D3DFMT_UNKNOWN;
pp.BackBufferCount = 1;
pp.MultiSampleType = D3DMULTISAMPLE_NONE;
pp.MultiSampleQuality = 0;
pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
pp.hDeviceWindow = hwnd;
pp.Windowed = TRUE;
pp.EnableAutoDepthStencil = TRUE;
pp.AutoDepthStencilFormat = D3DFMT_D24S8;
pp.Flags = 0;
pp.FullScreen_RefreshRateInHz = 0;
pp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
d3d9->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd, D3DCREATE_HARDWARE_VERTEXPROCESSING, &pp, &gDevice);
if (gDevice == NULL)
{
return 0;
}
D3DXCreateEffectFromFile(gDevice, TEXT("e:/ZenBin/data/shader/Position.fx"), NULL, NULL, D3DXSHADER_DEBUG, NULL, &gEffect, NULL);
//
D3DXCreateTextureFromFileEx(gDevice, TEXT("e:/ZenBin/data/image/AID_hportal.bmp"), D3DX_DEFAULT, D3DX_DEFAULT, 1, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, &gTexture);
int verticesNum = pow((double)2, (double)gMaxLOD) + 1;
//
gDevice->CreateVertexBuffer(verticesNum*verticesNum*sizeof(sVertex), 0, gVertexFVF, D3DPOOL_MANAGED, &gVB, 0);
//
gDevice->CreateIndexBuffer((verticesNum - 1)*(verticesNum - 1)*2*3*2, 0, D3DFMT_INDEX16, D3DPOOL_MANAGED, &gIB, 0);
//
std::vector<sVertex> vertices;
for (size_t z = 0; z != verticesNum; z++)
for (size_t x = 0; x != verticesNum; x++)
{
sVertex v;
v.x = x*3;
v.z = z*3;
v.y = 0;
//v.u = v.x*0.01f;
//v.v = v.y*0.01f;
vertices.push_back(v);
}
{
void* data;
gVB->Lock(0, 0, &data, 0);
memcpy(data, &vertices[0], vertices.size()*sizeof(sVertex));
gVB->Unlock();
}
generateLOD(0);
// Message Structure
MSG msg;
::ZeroMemory(&msg, sizeof(msg));
// Loop until getting a WM_QUIT message
while(true)
{
if (::PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
{
if (msg.message == WM_QUIT)
{
break;
}
::TranslateMessage(&msg);
::DispatchMessage(&msg);
}
else
{
gDevice->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0x000020, 1, 0);
gDevice->BeginScene();
gDevice->SetFVF(gVertexFVF);
gDevice->SetStreamSource(0, gVB, 0, sizeof(sVertex));
gDevice->SetIndices(gIB);
gEffect->SetTexture("lay0", gTexture);
UINT pPasses = 0;
gEffect->SetTechnique("PP0");
gViewMatrix.column(0, Vector4(1, 0, 0, 0));
gViewMatrix.column(1, Vector4(0, 0, 1, 0));
gViewMatrix.column(2, Vector4(0, -1, 0, 150));
gViewMatrix.column(3, Vector4(0, 0, 0, 1));
gEffect->SetMatrix("gView", &gViewMatrix);
D3DXMatrixPerspectiveFovLH(&gProjectionMatrix, 1.5, 1, 0.01, 1000);
gEffect->SetMatrix("gProjection", &gProjectionMatrix);
gEffect->Begin(&pPasses, D3DXFX_DONOTSAVESTATE);
for (int i = 0; i != pPasses; ++i)
{
gEffect->BeginPass(i);
gDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, gMaxLOD*gMaxLOD, 0, gIndices.size()/3);
gEffect->EndPass();
}
gEffect->End();
gDevice->EndScene();
gDevice->Present(NULL, NULL, 0, NULL);
}
}
//
if (gIB)
{
gIB->Release();
gIB = NULL;
}
//
if (gVB)
{
gVB->Release();
gVB = NULL;
}
//
if (gTexture)
{
gTexture->Release();
gTexture = NULL;
}
//
if (gEffect)
{
gEffect->Release();
gEffect = NULL;
}
//
if (gDevice)
{
gDevice->Release();
gDevice = NULL;
}
//
d3d9->Release();
d3d9 = NULL;
return 0;
}
