//*************************************************************************************************************
void Star()
{
tmpvert[6] = tmpvert[24] = tmpvert[30] = (float)screenwidth / 4.0f - 0.5f;
tmpvert[13] = tmpvert[19] = tmpvert[31] = (float)screenheight / 4.0f - 0.5f;
texelsize.x = 4.0f / (float)screenwidth;
texelsize.y = 4.0f / (float)screenheight;
hdreffect->SetTechnique("star");
hdreffect->SetVector("texelsize", &texelsize);
hdreffect->Begin(NULL, 0);
hdreffect->BeginPass(0);
for( int i = 0; i < 4; ++i )
{
hdreffect->SetInt("stardir", i);
for( int j = 0; j < 3; ++j )
{
int ind = (j % 2);
device->SetRenderTarget(0, starsurfaces[i][ind]);
device->SetTexture(0, (j == 0 ? dstargets[1] : startargets[i][1 - ind]));
hdreffect->SetInt("starpass", j);
hdreffect->CommitChanges();
device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, tmpvert, sizeof(D3DXVECTOR4) + sizeof(D3DXVECTOR2));
}
}
hdreffect->EndPass();
hdreffect->End();
// combine star textures
hdreffect->SetTechnique("starcombine");
device->SetRenderTarget(0, blursurfaces[1]);
device->SetTexture(0, startargets[0][0]);
device->SetTexture(1, startargets[1][0]);
device->SetTexture(2, startargets[2][0]);
device->SetTexture(3, startargets[3][0]);
hdreffect->Begin(NULL, 0);
hdreffect->BeginPass(0);
{
device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, tmpvert, sizeof(D3DXVECTOR4) + sizeof(D3DXVECTOR2));
}
hdreffect->EndPass();
hdreffect->End();
}
//*************************************************************************************************************
void LensFlare()
{
texelsize.x = 2.0f / (float)screenwidth;
texelsize.y = 2.0f / (float)screenheight;
hdreffect->SetTechnique("ghost");
hdreffect->SetVector("texelsize", &texelsize);
device->SetRenderTarget(0, ghostsurfaces[0]);
device->SetTexture(0, dstargets[0]);
device->SetTexture(1, dstargets[1]);
device->SetTexture(2, dstargets[2]);
device->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_BORDER);
device->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_BORDER);
tmpvert[6] = tmpvert[24] = tmpvert[30] = (float)screenwidth / 2.0f - 0.5f;
tmpvert[13] = tmpvert[19] = tmpvert[31] = (float)screenheight / 2.0f - 0.5f;
// 1 iteration only (not too spectatular...)
hdreffect->Begin(NULL, 0);
hdreffect->BeginPass(0);
{
device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, tmpvert, sizeof(D3DXVECTOR4) + sizeof(D3DXVECTOR2));
}
hdreffect->EndPass();
hdreffect->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();
}
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 DownSample()
{
hdreffect->SetTechnique("downsample");
hdreffect->Begin(NULL, 0);
hdreffect->BeginPass(0);
for( int i = 1; i < 5; ++i )
{
device->SetRenderTarget(0, dssurfaces[i]);
device->SetTexture(0, dstargets[i - 1]);
texelsize.x = (float)(2 << i) / (float)screenwidth;
texelsize.y = (float)(2 << i) / (float)screenheight;
tmpvert[6] = tmpvert[24] = tmpvert[30] = (float)screenwidth / ((float)(2 << i)) - 0.5f;
tmpvert[13] = tmpvert[19] = tmpvert[31] = (float)screenheight / ((float)(2 << i)) - 0.5f;
hdreffect->SetVector("texelsize", &texelsize);
hdreffect->CommitChanges();
device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, tmpvert, sizeof(D3DXVECTOR4) + sizeof(D3DXVECTOR2));
}
hdreffect->EndPass();
hdreffect->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;
}
/**-----------------------------------------------------------------------------
* 화면 그리기
*------------------------------------------------------------------------------
*/
VOID Render()
{
UINT nPass;
/// 후면버퍼와 Z버퍼 초기화
g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(200,200,200), 1.0f, 0 );
g_pd3dDevice->SetRenderState( D3DRS_FILLMODE, g_bWireframe ? D3DFILL_WIREFRAME : D3DFILL_SOLID );
/// 애니메이션 행렬설정
Animate();
/// 렌더링 시작
if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
{
if( g_bUseVS ) // 정점 쉐이더를 사용하여 출력?
{
g_pEffect->SetFloat( "g_fTime", (float)(timeGetTime()) / 100 );
/// 정점선언값과 정점 설정
g_pd3dDevice->SetVertexDeclaration( g_pDecl );
g_pd3dDevice->SetStreamSource( 0, g_pVB, 0, sizeof(MYVERTEX) );
/// fx출력에 사용할 테크닉 선정
g_pEffect->SetTechnique( "MyShader" );
/// fx를 사용한 출력개시
g_pEffect->Begin( &nPass, D3DXFX_DONOTSAVESTATE );
/// PASS 개수만큼 출력
for( int i = 0; i < nPass ; i++ )
{
g_pEffect->BeginPass( i );
g_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 0, 1 );
g_pEffect->EndPass();
}
/// fx를 사용한 출력종료
g_pEffect->End();
}
else
{
// fx를 사용한뒤에는 이 값을 NULL로 해야 D3D고정 파이프라인을 사용할 수 있다.
g_pd3dDevice->SetVertexShader( NULL );
g_pd3dDevice->SetPixelShader( NULL );
g_pd3dDevice->SetStreamSource( 0, g_pVB, 0, sizeof(MYVERTEX) );
g_pd3dDevice->SetFVF( MYVERTEX::FVF );
g_pd3dDevice->SetTexture( 0, g_pTexture );
g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE ); /// MODULATE연산으로 색깔을 섞음
g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE ); /// 첫번째 섞을색은 텍스쳐 색
g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE ); /// 두번째 섞을색은 정점 색
g_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_DISABLE ); /// alpha연산은 사용하지 않음
g_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 0, 1 );
}
g_pd3dDevice->EndScene();
}
/// 후면버퍼를 보이는 화면으로!
g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
}
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 );
}
HRESULT KG3DPointLightShadow::ExportToCubeSurface(KG3DRenderTargetTool* pTool,LPDIRECT3DSURFACE9 pDestSurface,BOOL bOutputDepth)
{
HRESULT hr = E_FAIL;
KGLOG_PROCESS_ERROR(pTool);
pTool->BeginNewRenderTarget(NULL,NULL,NULL);
//////////////////////////////////////////////////////////////////////////
hr = g_pd3dDevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL, 0x00808080, 1, 0);
KGLOG_COM_PROCESS_ERROR(hr);
{
D3DXVECTOR2 A(0,0);
D3DXVECTOR2 C(m_vShadowMap.m_dwShadowmapSize,m_vShadowMap.m_dwShadowmapSize);
if(bOutputDepth)
{
D3DXMATRIX matInv;
D3DXMatrixInverse(&matInv,NULL,&m_vShadowMap.m_vCameraLight.GetProjectionMatrix());
LPD3DXEFFECT pShader = g_cGraphicsTool.GetDefaultShader(DEFST_LINEARDEPTHOUTPUT);
pShader->SetMatrix("invProj",&matInv);
pShader->SetTechnique("tec0");
UINT uPass = 0;
pShader->Begin(&uPass,0);
pShader->BeginPass(0);
hr = g_pd3dDevice->BeginScene();
KGLOG_COM_PROCESS_ERROR(hr);
g_cGraphicsTool.DrawScreenRect(&A,&C,0,0xFFFFFFFF,m_vShadowMap.m_lpSMShadowMap);
hr = g_pd3dDevice->EndScene();
KGLOG_COM_PROCESS_ERROR(hr);
pShader->EndPass();
pShader->End();
}
else
{
g_cGraphicsTool.DrawScreenRect(&A,&C,0,0xFFFFFFFF,m_vShadowMap.m_lpSMColorMap);
}
}
hr = S_OK;
Exit0:
pTool->EndNewRenderTarget();
pTool->ExportRenderData(pDestSurface,FALSE);
return hr;
}
//-----------------------------------------------------------------------------
// Name: GetNextTechnique
// Desc:
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::GetNextTechnique(INT nDir, BOOL bBypassValidate)
{
D3DXEFFECT_DESC effect;
UINT_PTR iTechnique = m_iTechnique;
m_pEffect->GetDesc(&effect);
for(;;)
{
iTechnique += nDir;
if(((INT_PTR) iTechnique) < 0)
iTechnique = effect.Techniques - 1;
if(iTechnique >= effect.Techniques)
iTechnique = 0;
if(nDir && (iTechnique == m_iTechnique))
break;
if(!nDir)
nDir = 1;
m_pEffect->SetTechnique((LPCSTR) iTechnique);
if(bBypassValidate || (iTechnique == effect.Techniques - 1) ||
(m_bDrawCaustics || !m_pEffect->IsParameterUsed("tCAU")) && SUCCEEDED(m_pEffect->Validate()))
{
m_iTechnique = iTechnique;
char szText[256];
sprintf(szText, "Water - Technique %d", m_iTechnique);
SetWindowText(m_hWnd, szText);
return S_OK;
}
}
m_pEffect->SetTechnique((LPCSTR) m_iTechnique);
return E_FAIL;
}
//---------------------------------------------------------------------------------------
// シェーダ開始
//---------------------------------------------------------------------------------------
void BeginShader(int nTechnique)
{
if (nTechnique < 0 || nTechnique >= MAX_TECHNIQUE) {
nTechnique = 0;
}
// テクニック設定
g_pFX->SetTechnique(g_hTech[nTechnique]);
g_pFX->Begin(NULL, 0);
// パス開始
g_pFX->BeginPass(0);
}
//*************************************************************************************************************
void BrightPass()
{
device->SetRenderTarget(0, dssurfaces[0]);
device->SetTexture(0, scenetarget);
tmpvert[6] = tmpvert[24] = tmpvert[30] = (float)screenwidth * 0.5f - 0.5f;
tmpvert[13] = tmpvert[19] = tmpvert[31] = (float)screenheight * 0.5f - 0.5f;
hdreffect->SetTechnique("brightpass");
hdreffect->Begin(NULL, 0);
hdreffect->BeginPass(0);
{
device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, tmpvert, sizeof(D3DXVECTOR4) + sizeof(D3DXVECTOR2));
}
hdreffect->EndPass();
hdreffect->End();
// generate afterimage now
device->SetRenderTarget(0, aftersurfaces[afterimagetex]);
if( afterimage )
{
device->SetTexture(0, afterimages[1 - afterimagetex]);
device->SetTexture(1, dstargets[0]);
hdreffect->SetTechnique("afterimage");
hdreffect->Begin(NULL, 0);
hdreffect->BeginPass(0);
{
device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, tmpvert, sizeof(D3DXVECTOR4) + sizeof(D3DXVECTOR2));
}
hdreffect->EndPass();
hdreffect->End();
}
else
device->Clear(0, NULL, D3DCLEAR_TARGET, 0, 1, 0);
afterimagetex = 1 - afterimagetex;
}
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 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 CRenderTarget::Fill(CGame2D* g2d, int x, int y, int w, int h, float color[4])
{
LPD3DXEFFECT effect = LoadEffect("utils.fx");
if (effect == NULL) return;
BeginRenderTarget(0);
if (SUCCEEDED(GetDevice()->BeginScene()))
{
CGame2D* g2d = Get2D();
effect->SetFloatArray("g_Fill", color, 4);
effect->SetTechnique("FillTexture");
DX_BEGIN_EFFECT(effect);
g2d->DrawRect(x, y, w, h, 0xFFFFFFFF);
DX_END_EFFECT(effect);
GetDevice()->EndScene();
}
EndRenderTarget();
}
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);
}
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();
}
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();
}
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 CollisionMesh::DrawMesh(const Matrix& projection, const Matrix& view, const D3DXVECTOR3& color)
{
if(m_draw && m_geometry)
{
LPD3DXEFFECT shader = m_geometry->GetShader();
D3DXMATRIX wvp = m_world.GetMatrix() * view.GetMatrix() * projection.GetMatrix();
shader->SetMatrix(DxConstant::WordViewProjection, &wvp);
shader->SetTechnique(DxConstant::DefaultTechnique);
shader->SetFloatArray(DxConstant::VertexColor, &(color.x), 3);
UINT nPasses = 0;
shader->Begin(&nPasses, 0);
for(UINT pass = 0; pass < nPasses; ++pass)
{
shader->BeginPass(pass);
m_geometry->GetMesh()->DrawSubset(0);
shader->EndPass();
}
shader->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();
}
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 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 AdaptLuminance(float dt)
{
char othertex = 4 + (5 - adapttex);
// adapt luminance with time into other 1x1 texture (ping-pong them)
device->SetRenderTarget(0, avglumsurfaces[othertex]);
device->SetTexture(0, avglumtargets[adapttex]); // old adapted luminance
device->SetTexture(1, avglumtargets[3]); // result of MeasureLuminance()
hdreffect->SetTechnique("adaptluminance");
hdreffect->SetFloat("elapsedtime", dt);
hdreffect->Begin(NULL, 0);
hdreffect->BeginPass(0);
{
device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, tmpvert, sizeof(D3DXVECTOR4) + sizeof(D3DXVECTOR2));
}
hdreffect->EndPass();
hdreffect->End();
device->SetTexture(5, avglumtargets[othertex]);
adapttex = othertex;
}
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 Render(float alpha, float elapsedtime)
{
static float time = 0;
D3DXMATRIX inv;
D3DXVECTOR3 axis(0, 1, 0);
D3DXVECTOR4 texelsize(1.0f / (float)screenwidth, 1.0f / (float)screenheight, 0, 1);
LPDIRECT3DSURFACE9 oldtarget = NULL;
time += elapsedtime;
D3DXMatrixRotationAxis(&inv, &axis, time);
D3DXMatrixScaling(&world, 0.3f, 0.3f, 0.3f);
//D3DXMatrixScaling(&world, 0.6f, 0.6f, 0.6f);
D3DXMatrixMultiply(&world, &world, &inv);
D3DXMatrixInverse(&inv, NULL, &world);
device->SetTexture(0, texture);
device->SetTexture(1, intensity);
effect->SetMatrix("matWorld", &world);
effect->SetMatrix("matWorldInv", &inv);
effect->SetMatrix("matView", &view);
effect->SetMatrix("matProj", &proj);
if( useedgedetect )
{
device->GetRenderTarget(0, &oldtarget);
device->SetRenderTarget(0, colorsurface);
device->SetRenderTarget(1, normalsurface);
}
device->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL, 0xff6694ed, 1.0f, 0);
if( SUCCEEDED(device->BeginScene()) )
{
// draw scene + normals/depth
effect->SetTechnique("celshading");
effect->Begin(NULL, 0);
effect->BeginPass(0);
{
mesh->DrawSubset(0);
}
effect->EndPass();
effect->End();
if( useedgedetect )
{
// edge detection
device->SetVertexDeclaration(vertexdecl);
device->SetRenderTarget(0, edgesurface);
device->SetRenderTarget(1, NULL);
device->SetTexture(0, normaltarget);
device->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0xff6694ed, 1.0f, 0);
effect->SetTechnique("edgedetect");
effect->SetVector("texelSize", &texelsize);
effect->Begin(NULL, 0);
effect->BeginPass(0);
{
device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, vertices, sizeof(D3DXVECTOR4) + sizeof(D3DXVECTOR2));
}
effect->EndPass();
effect->End();
// put together
device->SetRenderTarget(0, oldtarget);
device->SetTexture(0, colortarget);
device->SetTexture(2, edgetarget);
device->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0xff6694ed, 1.0f, 0);
oldtarget->Release();
effect->SetTechnique("final");
effect->Begin(NULL, 0);
effect->BeginPass(0);
{
device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, vertices, sizeof(D3DXVECTOR4) + sizeof(D3DXVECTOR2));
}
effect->EndPass();
effect->End();
}
else
{
D3DXMATRIX offproj;
// use the stencil buffer
device->SetRenderState(D3DRS_COLORWRITEENABLE, 0);
device->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
device->SetRenderState(D3DRS_STENCILENABLE, TRUE);
device->SetRenderState(D3DRS_ZENABLE, FALSE);
device->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_ALWAYS);
device->SetRenderState(D3DRS_STENCILREF, 1);
device->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_REPLACE);
device->SetTransform(D3DTS_WORLD, &world);
device->SetTransform(D3DTS_VIEW, &view);
float thickness = 3.5f;
// render object 4 times with offseted frustum
for( float i = -thickness; i < thickness + 1; i += 2 * thickness )
{
for( float j = -thickness; j < thickness + 1; j += 2 * thickness )
{
D3DXMatrixTranslation(&offproj, i / (float)screenwidth, j / (float)screenheight, 0);
D3DXMatrixMultiply(&offproj, &proj, &offproj);
device->SetTransform(D3DTS_PROJECTION, &offproj);
mesh->DrawSubset(0);
}
}
// erase area in the center
device->SetRenderState(D3DRS_STENCILREF, 0);
device->SetTransform(D3DTS_PROJECTION, &proj);
mesh->DrawSubset(0);
// now render outlines
device->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED|D3DCOLORWRITEENABLE_GREEN|D3DCOLORWRITEENABLE_BLUE|D3DCOLORWRITEENABLE_ALPHA);
device->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_NOTEQUAL);
device->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_KEEP);
device->SetRenderState(D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP);
device->SetFVF(D3DFVF_XYZRHW|D3DFVF_TEX1);
device->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_CONSTANT);
device->SetTextureStageState(0, D3DTSS_CONSTANT, 0);
{
device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, vertices, sizeof(D3DXVECTOR4) + sizeof(D3DXVECTOR2));
}
device->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
device->SetRenderState(D3DRS_ZENABLE, TRUE);
device->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
device->SetRenderState(D3DRS_STENCILENABLE, FALSE);
}
device->SetTexture(2, NULL);
// render text
device->SetFVF(D3DFVF_XYZRHW|D3DFVF_TEX1);
device->SetRenderState(D3DRS_ZENABLE, FALSE);
device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
device->SetTexture(0, text);
device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, textvertices, 6 * sizeof(float));
device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
device->SetRenderState(D3DRS_ZENABLE, TRUE);
device->SetTexture(0, NULL);
device->EndScene();
}
device->Present(NULL, NULL, NULL, NULL);
}
