RiskYourLife/Client
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
4d1b7b3d74d0c690cd859e81088458520b4c99c8
Client/GameTools/Zallad3D SceneClass/범프 스팩 노멀CharacterLightShadowManager.cpp
LGram16 dd97ddec92 Restructure repository to include all source folders 
Move git root from Client/ to src/ to track all source code:
- Client: Game client source (moved to Client/Client/)
- Server: Game server source
- GameTools: Development tools
- CryptoSource: Encryption utilities
- database: Database scripts
- Script: Game scripts
- rylCoder_16.02.2008_src: Legacy coder tools
- GMFont, Game: Additional resources

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
2025-11-29 20:17:20 +09:00

3900 lines
127 KiB
C++
Raw Blame History

// CharacterLightShadowManager.cpp: implementation of the CCharacterLightShadowManager class.
//
//////////////////////////////////////////////////////////////////////
#include "CharacterLightShadowManager.h"
#include "SceneManager.h"
#include "BaseGraphicsLayer.h"
#include "Z3DManagedObject.h"
#include "Z3D_GLOBALS.h"
#include "SceneStateMgr.h"
#include "RenderOption.h"
#include "Shader_IndexHeader.h"
#include "ShaderScene.h"
#include "Shader_SelfShadow.h"
// Rain °ü·Ã VertexBuffer Setting
#include "Shader_Rain.h"
#include <sys/types.h>
#include <sys/timeb.h>
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
inline DWORD F2DW( FLOAT f ) { return *((DWORD*)&f); }
/*
char strCharacterPerPixelLightingAndShadowMapPixelShader[]=
"ps.1.1\n"
"def c0,0.3f,0.3f,0.3f,0.3f\n"
"def c1,0.1f,0.1f,0.1f,0.1f\n"
"tex t0\n"
"tex t1\n"
"tex t2\n"
"dp3 r0,t1_bx2,v0_bx2\n"
"add t2,t2,c1\n"
"mul r0,r0,t2\n"
"sub r1,c0,r0\n"
"mov_sat r1,r1\n"
"add r0,r0,r1\n"
"mul_x2 r0,r0,t0\n";
*/
char strCharacterPerPixelLightingAndShadowMapPixelShader[]=
"ps.1.1\n"
"tex t0\n"
"tex t1\n"
"tex t2\n"
"dp3_sat r0,t1_bx2,v0_bx2\n"
"dp3_sat r1,t1_bx2,v1_bx2\n"
//"mul r1,r1,c2\n"
//"add r0,r1,r0\n"
//"add t2,t2,c1\n"
"mul r0,r0,t2\n"
"mad r0,r1,c2,r0\n"
"sub_sat r1,c0,r0\n"
"mul r0,r0,c3\n"
//"mov_sat r1,r1\n"
"add r0,r0,r1\n"
"mul_x2 r0,r0,t0\n";
char strCharacterPerPixelLightingPixelShader[]=
"ps.1.1\n"
"def c0,0.3f,0.3f,0.3f,0.3f\n"
"def c1,0.1f,0.1f,0.1f,0.1f\n"
"tex t0\n"
"tex t1\n"
"dp3 r0,t1_bx2,v0_bx2\n"
"sub r1,c0,r0\n"
"mov_sat r1,r1\n"
"add r0,r0,r1\n"
"mul_x2 r0,r0,t0\n";
/*
char strChracterSpecAndShadowMapShader[]=
"ps.1.1\n"
"tex t0\n"
"tex t1\n"
"tex t2\n"
"dp3 r0,t1_bx2,v1_bx2\n"
"mul r1,r0,r0\n"
"mul r0,r1,r1\n"
"mul r0,r0,t2\n";
*/
char strChracterSpecAndShadowMapShader[]=
"ps.1.1\n"
"def c0,0.10f,0.10f,0.10f,0.10f\n"
"tex t0\n"
"tex t1\n"
"tex t2\n"
"dp3 r0,t1_bx2,v1_bx2\n"
"mul r1,r0,r0\n"
"mul r0,r1,r1\n"
"mul r0,r0,t2\n"
"dp3 r1,t1_bx2,v0_bx2\n"
//"sub_sat t2,c0,1-r1\n"
//"add r1,t2,1-r1\n"
//"mul r1,r1,t0.a\n"
/*
"mad r1,r1,t0.a,r1
mad dest, src0, src1, src2
dest = src0 * src1 + src2
*/
"mul_x2 r0,r0,1-r1\n";
char strChracterSpecShader[]=
"ps.1.1\n"
"tex t0\n"
"tex t1\n"
"dp3 r0,t1_bx2,v1_bx2\n"
"mul r1,r0,r0\n"
"mul r0,r1,r1\n";
///12 Light Direction;
char strVertexShader[]=
"vs.1.1\n"
"m4x4 oPos, v0, c8\n"// Position World*View*Projection Transform
"m3x3 r3, v8, c0\n" // Normal World Transform
"m3x3 r5, v3, c0\n" // Tangent S vector World Transform
"mul r0, -r3.zxyw, r5.yzxw\n"
"mad r4, -r3.yzxw, r5.zxyw,-r0\n"//r4 is Tangent T
"m4x4 r2, v0, c0\n"
"add r2, -r2, c24\n"//c24 Camera Position
"dp3 r11.x, r2.xyz, r2.xyz\n"
"rsq r11.xyz, r11.x\n"
"mul r2.xyz, r2.xyz, r11.xyz\n"
"add r2.xyz, r2.xyz, -c12\n"
"dp3 r11.x, r2.xyz, r2.xyz\n"
"rsq r11.xyz, r11.x\n"
"mul r2.xyz, r2.xyz, r11.xyz\n"
//"dp3 r8.x,r3,r2\n"
//"dp3 r8.y,r4,r2\n"
//"dp3 r8.z,r5,r2\n"
//"mad oD1.xyz, r8, c33, c33\n"//Specular Vertex Color
"dp3 r8.x, r3, -c12\n"
"dp3 r8.y, r4, -c12\n"
"dp3 r8.z, r5, -c12\n"
"mad oD0.xyz, r8.xyz, c33, c33\n"//Diffuse Vertex Color
"dp3 r8.x, r3, -c13\n"
"dp3 r8.y, r4, -c13\n"
"dp3 r8.z, r5, -c13\n"
"mad oD1.xyz, r8.xyz, c33, c33\n"//Back Diffuse Vertex Color
"mov oT0.xy, v7.xy\n"
"mov oT1.xy, v7.xy\n"
"dp4 oT2.x,v0,c4\n"
"dp4 oT2.y,v0,c5\n"
"dp4 oT2.z,v0,c6\n"
"dp4 oT2.w,v0,c7\n";
char strVertexSpecularShader[]=
"vs.1.1\n"
"m4x4 oPos, v0, c8\n"
"m3x3 r3, v8, c0\n"
"m3x3 r5, v3, c0\n"
"mul r0, -r3.zxyw, r5.yzxw\n"
"mad r4, -r3.yzxw, r5.zxyw,-r0\n"
"m4x4 r2, v0, c0\n"
"add r2, -r2, c24\n"
"dp3 r11.x, r2.xyz, r2.xyz\n"
"rsq r11.xyz, r11.x\n"
"mul r2.xyz, r2.xyz, r11.xyz\n"
"add r2.xyz, r2.xyz, -c12\n"
"dp3 r11.x, r2.xyz, r2.xyz\n"
"rsq r11.xyz, r11.x\n"
"mul r2.xyz, r2.xyz, r11.xyz\n"
"dp3 r8.x,r3,r2\n"
"dp3 r8.y,r4,r2\n"
"dp3 r8.z,r5,r2\n"
"mad oD1.xyz, r8, c33, c33\n"
"dp3 r8.x, r3, -c12\n"
"dp3 r8.y, r4, -c12\n"
"dp3 r8.z, r5, -c12\n"
"mad oD0.xyz, r8.xyz, c33, c33\n"
"mov oT0.xy, v7.xy\n"
"mov oT1.xy, v7.xy\n"
"dp4 oT2.x,v0,c4\n"
"dp4 oT2.y,v0,c5\n"
"dp4 oT2.z,v0,c6\n"
"dp4 oT2.w,v0,c7\n";
//"mul oT2.xy, v7.xy,c[34]\n";
/*
List<CZ3DGeneralChrModel*> CCharacterLightShadowManager::m_CharacterList;
List<CollisionType> CCharacterLightShadowManager::m_CharacterCollisionType;
List<POINT> CCharacterLightShadowManager::m_CharacterScreenPositionList;
//List<CZ3DSoundEventHelper*> CCharacterLightShadowManager::m_CharacterSoundHelperList;
List<bool> CCharacterLightShadowManager::m_CharacterAttackEventList;
List<bool> CCharacterLightShadowManager::m_CharacterTrailOnEventList;
List<bool> CCharacterLightShadowManager::m_CharacterTrailOffEventList;
List<int> CCharacterLightShadowManager::m_CharacterDelayTimer;
List<CCharacterLightShadowManager::CChrLightNode> CCharacterLightShadowManager::m_CharacterLightList;
List<vector3> CCharacterLightShadowManager::m_CharacterPerFrameMove;
List<vector3> CCharacterLightShadowManager::m_CharacterRealPosition;
List<int> CCharacterLightShadowManager::m_CharacterRandomPostionTimer;
List<vector3> CCharacterLightShadowManager::m_CharacterRandomPostionAdder;
*/
CRenderTexture CCharacterLightShadowManager::m_pShadowTexture;//±×¸²ÀÚ
List<CCharacterLightShadowManager::CCharacterDataNode> CCharacterLightShadowManager::m_CharacterList;
CCharacterLightShadowManager::CCharacterLightShadowManager()
{
m_pCharacterLight = NULL;
// Rain
m_lpRainVertexBuffer = NULL;
m_dwRainVertexsNum = 200;
m_dwRainUseNum = 0;
m_bRainBufferSet = false;
m_pRainLoopValue = NULL;
}
CCharacterLightShadowManager::~CCharacterLightShadowManager()
{
if(m_pCharacterLight != NULL)
{
delete m_pCharacterLight;
m_pCharacterLight = NULL;
}
//Rain
if(m_lpRainVertexBuffer != NULL) {
m_lpRainVertexBuffer->Release();
m_lpRainVertexBuffer = NULL;
}
if(m_pRainLoopValue != NULL) {
delete[] m_pRainLoopValue;
m_pRainLoopValue = NULL;
}
//CZ3DSound::Close();
//CZ3DTimingSignaler::Close();
}
void CCharacterLightShadowManager::Create()
{
//Rain
if(CRenderOption::m_bRain) {
if( FAILED( BaseGraphicsLayer::GetDevice()->CreateVertexBuffer( m_dwRainVertexsNum*sizeof(RainVertex),
D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, &m_lpRainVertexBuffer ) ) )
{
return;
}
m_pRainLoopValue = new float[m_dwRainVertexsNum];
for(int iRain = 0;iRain < m_dwRainVertexsNum; iRain++) {
m_pRainLoopValue[iRain] = (float)(100.0f + (float)(rand() % 900)) / 1000.0f;
}
}
if(CRenderOption::m_CharacterProjectShadowTerrain)
m_pShadowTexture.Create(256,256);
/*
char tmp[256] = {0,};
sprintf(tmp, "%sAni\\", CHARACTERDATAPATH);
g_ContAniKeyPack.LoadHandleNameTable(CHARACTERANIPACK,tmp);
sprintf(tmp, "%sMesh\\", CHARACTERDATAPATH);
g_ContLODMesh.SetFilePath(tmp);
sprintf(tmp, "%sAmesh\\", CHARACTERDATAPATH);
g_ContAMesh.SetFilePath(tmp);
if(CRenderOption::m_TextureMethod==1)
{
sprintf(tmp, "%sTexture\\", CHARACTERDATAPATH);
}
else
{
sprintf(tmp, "%s\\LowTexture\\", CHARACTERDATAPATH);
}
g_ContTexture.SetFilePath(tmp);
Z3DTexture::_Init(BaseGraphicsLayer::GetDevice(), CHARACTERTEXTUREDATAPATH, CHRTEXTURESIZE);
CZ3DRenderable::_Init(BaseGraphicsLayer::GetDevice());
CZ3DCharacterModel::_Init(CHARACTERDATAPATH);
if( false == CZ3DGeneralChrModel::_BuildCMDSList() )
{
return;
}
sprintf(tmp, "%s/ChrEvent.EDS", CHARACTERDATAPATH);
if( false == CZ3DChrEventGenerator::_Load( tmp ) )
{
return;
}
*/
_Z3DGlobalInit( CHARACTERDATAPATH, BaseGraphicsLayer::GetDevice() );
/*H3DTextureTag ttag;
g_ContTexture.GetObject( ttag, "fx_item_marker_gradation.dds" );
g_ContTexture.GetObject( ttag, "fx_bomb_04.dds" );
g_ContTexture.GetObject( ttag, "fx_fire2.dds" );*/
//sprintf(tmp, "%sSound\\", CHARACTERDATAPATH);
//CZ3DSound::Init(BaseGraphicsLayer::GethWnd(), Z3DSOUND_3D, SOUNDFILEPATH );
//g_ContTexture.GetObjectByHandle( 6100018 );
//CZ3DSkeletonObject* pObj = new CZ3DSkeletonObject();
//pObj->Link(NULL);
char strSoundTable[256];
sprintf(strSoundTable,"%s%s",CHARACTERDATAPATH,"EventSoundFile.txt");
if(g_MapEvent2SndFile.Load(strSoundTable,SOUNDFILEPATH,g_TokEventName)==false)
{
}
if(0)//CRenderOption::m_CharacterPerPixelLighting)
{
LPD3DXBUFFER pCode;
DWORD dwDecl[] =
{
D3DVSD_STREAM(0),
D3DVSD_REG(0, D3DVSDT_FLOAT3), // position
D3DVSD_REG(3, D3DVSDT_FLOAT3), // normal
D3DVSD_REG(7, D3DVSDT_FLOAT2), // tex
D3DVSD_REG(8, D3DVSDT_FLOAT3), // S
D3DVSD_END()
};
if(CRenderOption::m_CharacterSelfShadow)
{
D3DXAssembleShader(strCharacterPerPixelLightingAndShadowMapPixelShader,strlen(strCharacterPerPixelLightingAndShadowMapPixelShader),0,NULL,&pCode,NULL);
BaseGraphicsLayer::GetDevice()->CreatePixelShader((DWORD*)pCode->GetBufferPointer(),&m_dwCharacterPixelShader);
pCode->Release();
D3DXAssembleShader(strChracterSpecAndShadowMapShader,strlen(strChracterSpecAndShadowMapShader),0,NULL,&pCode,NULL);
BaseGraphicsLayer::GetDevice()->CreatePixelShader((DWORD*)pCode->GetBufferPointer(),&m_dwCharacterSpecPixelShader);
D3DXAssembleShader(strVertexShader,strlen(strVertexShader),0,NULL,&pCode,NULL);
BaseGraphicsLayer::GetDevice()->CreateVertexShader( dwDecl, (DWORD*)pCode->GetBufferPointer(), &m_dwCharacterVertexShader, 0 );
D3DXAssembleShader(strVertexSpecularShader,strlen(strVertexSpecularShader),0,NULL,&pCode,NULL);
BaseGraphicsLayer::GetDevice()->CreateVertexShader( dwDecl, (DWORD*)pCode->GetBufferPointer(), &m_dwCharacterSpecularVertexShader, 0 );
m_CharacterShadowmap.Create(512,512);
}
else
{
D3DXAssembleShader(strCharacterPerPixelLightingPixelShader,strlen(strCharacterPerPixelLightingPixelShader),0,NULL,&pCode,NULL);
BaseGraphicsLayer::GetDevice()->CreatePixelShader((DWORD*)pCode->GetBufferPointer(),&m_dwCharacterPixelShader);
pCode->Release();
D3DXAssembleShader(strChracterSpecShader,strlen(strChracterSpecShader),0,NULL,&pCode,NULL);
BaseGraphicsLayer::GetDevice()->CreatePixelShader((DWORD*)pCode->GetBufferPointer(),&m_dwCharacterSpecPixelShader);
D3DXAssembleShader(strVertexShader,strlen(strVertexShader),0,NULL,&pCode,NULL);
BaseGraphicsLayer::GetDevice()->CreateVertexShader( dwDecl, (DWORD*)pCode->GetBufferPointer(), &m_dwCharacterVertexShader, 0 );
}
}
}
void CCharacterLightShadowManager::Render(LPDIRECT3DDEVICE8 pd3dDevice)
{
CSceneManager::m_bEnv = true;
if(!CRenderOption::m_CharacterPerPixelLighting)
{
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_COLOROP, D3DTOP_DISABLE);
pd3dDevice->LightEnable(0,TRUE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
D3DLIGHT8 light;
ZeroMemory( &light, sizeof(D3DLIGHT8) );
light.Type = D3DLIGHT_DIRECTIONAL;
light.Diffuse.r = CSceneManager::m_WeatherManager.m_InterCharacterLight.r/255.0f;
light.Diffuse.g = CSceneManager::m_WeatherManager.m_InterCharacterLight.g/255.0f;
light.Diffuse.b = CSceneManager::m_WeatherManager.m_InterCharacterLight.b/255.0f;
vector3 vecLight(-1.0f,-1.0f,-1.0f);
vecLight.Normalize();
light.Position.x = light.Direction.x =vecLight.x;
light.Position.y = light.Direction.y =vecLight.y;
light.Position.z = light.Direction.z =vecLight.z;
light.Range = 1000.0f;
pd3dDevice->SetLight(0,&light);
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterCharacterAmbient.c);
}
/*
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_COLORARG1, D3DTA_TEXTURE);
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_COLORARG2, D3DTA_CURRENT);
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_COLOROP, D3DTOP_SELECTARG2);
pd3dDevice->SetTexture(2,CSceneManager::m_LightEffectManager.m_CharcterEnvTexture.GetTexture());
D3DXMATRIX mat;
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACENORMAL);
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_BUMPENVMAT00, F2DW(0.1f) );
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_BUMPENVMAT01, F2DW(0.0f) );
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_BUMPENVMAT10, F2DW(0.0f) );
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_BUMPENVMAT11, F2DW(0.1f) );
mat._11 = -0.5f; mat._12 = 0; mat._13 = 0; mat._14 = 0;
mat._21 = 0; mat._22 = -0.5f; mat._23 = 0; mat._24 = 0;
mat._31 = 0; mat._32 = 0; mat._33 = 0; mat._34 = 0;
mat._41 = 0.5f; mat._42 = 0.5f; mat._43 = 0; mat._44 = 0;
pd3dDevice->SetTransform( D3DTS_TEXTURE1, &mat );
CSceneStateMgr::_SetD3DTextureStageState(2,D3DTSS_COLORARG1, D3DTA_TEXTURE);
CSceneStateMgr::_SetD3DTextureStageState(2,D3DTSS_COLORARG2, D3DTA_CURRENT);
CSceneStateMgr::_SetD3DTextureStageState(2,D3DTSS_COLOROP, D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 0 );
pd3dDevice->SetPixelShader(m_dwCharacterPixelShader);
pd3dDevice->LightEnable(0,TRUE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 1 );
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHAREF,0x0);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP,D3DTOP_MODULATE);
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_ALPHAOP,D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
pd3dDevice->SetVertexShader(BUMPVERTEXFVF);
pd3dDevice->SetPixelShader(m_dwCharacterPixelShader);
*/
//CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,TRUE);
//pd3dDevice->SetVertexShader(m_dwCharacterVertexShader);
//pd3dDevice->SetPixelShader(m_dwCharacterPixelShader);
matrix matWorld;
matWorld.MakeIdent();
pd3dDevice->SetTransform(D3DTS_WORLD,matWorld);
CSceneNode CharScene;
CharScene.m_fRad=300.0f;
vector3 vecCharPos;
vector3 vecCharScreenPos;
float fW;
for(int cChar=0;cChar<m_CharacterList.num;cChar++)
{
if(m_CharacterList[cChar].m_bRender==false)
{
m_CharacterList[cChar].m_pChrmodel->SetCull(true);
m_CharacterList[cChar].m_pChrmodel->SetDisable(true);
}
else
{
m_CharacterList[cChar].m_pChrmodel->SetCull(false);
m_CharacterList[cChar].m_pChrmodel->SetDisable(false);
}
if(m_CharacterList[cChar].m_pChrmodel->IsDisabled()==false)
{
m_CharacterList[cChar].m_pChrmodel->GetPosition(vecCharPos.x,vecCharPos.y,vecCharPos.z);
CharScene.m_AccumulateTM.Translation(vecCharPos);
if(CharScene.isCulling())
{
m_CharacterList[cChar].m_pChrmodel->SetCull(false);
BaseGraphicsLayer::TransformVector(vecCharPos,vecCharScreenPos,fW);
m_CharacterList[cChar].m_ptScreenPosition.x=(int)vecCharScreenPos.x;
m_CharacterList[cChar].m_ptScreenPosition.y=(int)vecCharScreenPos.y;
//m_CharacterScreenPositionList[cChar].x=(int)vecCharScreenPos.x;
//m_CharacterScreenPositionList[cChar].y=(int)vecCharScreenPos.y;
//BaseGraphicsLayer::TransformVector(m_InstanceObjectList[cObject].m_vecPosition,vecResult,w);
}
else
{
m_CharacterList[cChar].m_pChrmodel->SetCull(true);
m_CharacterList[cChar].m_ptScreenPosition.x=-1;
m_CharacterList[cChar].m_ptScreenPosition.y=-1;
//m_CharacterScreenPositionList[cChar].x=-1;
//m_CharacterScreenPositionList[cChar].y=-1;
}
}
/*
if(cChar==0)
m_CharacterList[cChar]->SetCull(false);
*/
}
CZ3DRenderable::Process();
/*
*/
char *pShadowCollision;
vector3 vecChrPos;
float fInterVal=SECTORSIZE/256.0f;
int px,pz;
float fPosx,fPosz;
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
if(0)//CRenderOption::m_CharacterPerPixelLighting)
{
D3DXVECTOR4 LightDir=D3DXVECTOR4( -1.0f, -1.0f, -1.0f, 0.0f );
D3DXVec4Normalize(&LightDir,&LightDir);
pd3dDevice->SetVertexShaderConstant(12, &LightDir, 1 ); // light direction
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 1 );
//CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 0);
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXCOORDINDEX, 2);
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_MIPFILTER,D3DTEXF_POINT);
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_MIPFILTER,D3DTEXF_POINT);
}
vector3 vecSunLightDir( CSceneManager::m_WeatherManager.m_SunLight.Direction.x,
CSceneManager::m_WeatherManager.m_SunLight.Direction.y,
CSceneManager::m_WeatherManager.m_SunLight.Direction.z);
float fBias=0.0f;
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_MIPMAPLODBIAS, *((LPDWORD) (&fBias)));
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_MIPMAPLODBIAS, *((LPDWORD) (&fBias)));
color m_InterCharacterAmbient;
color m_InterCharacterLight;
//float fAmbientColor[4]={0.0f,0.0f,0.0f,0.0f};
float fAmbientColor[4]={CSceneManager::m_WeatherManager.m_InterCharacterAmbient.r/255.0f,
CSceneManager::m_WeatherManager.m_InterCharacterAmbient.g/255.0f,
CSceneManager::m_WeatherManager.m_InterCharacterAmbient.b/255.0f,1.0f};
float fShadowColor[4]={0.0f,0.0f,0.0f,0.0f};
float fLightColor[4]={CSceneManager::m_WeatherManager.m_InterCharacterLight.r/255.0f,
CSceneManager::m_WeatherManager.m_InterCharacterLight.g/255.0f,
CSceneManager::m_WeatherManager.m_InterCharacterLight.b/255.0f,1.0f};
float fBackLightColor[4]={fLightColor[0]*0.6f,fLightColor[1]*0.6f,fLightColor[2]*0.6f,1.0f};
pd3dDevice->SetPixelShaderConstant(0,fAmbientColor,1);
pd3dDevice->SetPixelShaderConstant(1,fShadowColor,1);
pd3dDevice->SetPixelShaderConstant(2,fBackLightColor,1);
pd3dDevice->SetPixelShaderConstant(3,fLightColor,1);
/*static CShader_SelfShadow *pSelfShadowShader = NULL;
if(pSelfShadowShader == NULL)
{
pSelfShadowShader = new CShader_SelfShadow;
}
*/
for(cChar=m_CharacterList.num-1 ;cChar >= 0 ;cChar--)
{
if(m_CharacterList[cChar].m_bRender==false)
continue;
D3DVIEWPORT8 m_pTempViewPort;
pd3dDevice->GetViewport(&m_pTempViewPort);
m_CharacterList[cChar].m_pChrmodel->GetPosition(vecChrPos.x,vecChrPos.y,vecChrPos.z);
bool bInShadowCheck=false;
if( m_CharacterList[cChar].m_CollisionDetectType == CDT_FULL)
//(m_CharacterList[cChar].m_CollisionType == CT_TERRAIN))
{
bInShadowCheck=true;
}
else if( m_CharacterList[cChar].m_CollisionDetectType==CDT_ONLYTERRAIN )
{
bInShadowCheck=true;
}
else if( m_CharacterList[cChar].m_CollisionDetectType==CDT_NONE)
{
bInShadowCheck=true;
}
//if( m_CharacterList[cChar].m_CollisionType != CT_BOTTOM )
if(bInShadowCheck)
{
// ¹ãÀ̸é modulate
if((CSceneManager::GetWeatherTime() <= 19) && (CSceneManager::GetWeatherTime() >= 5)) {
pShadowCollision=m_pHeightField->GetHeightFieldShadowCollision(vecChrPos);
px=(int)(vecChrPos.x/SECTORSIZE);
pz=(int)(vecChrPos.z/SECTORSIZE);
fPosx=vecChrPos.x-(px*SECTORSIZE);
fPosz=vecChrPos.z-(pz*SECTORSIZE);
if(pShadowCollision)
{
fPosx/=fInterVal;
fPosz/=fInterVal;
if(pShadowCollision[(int)fPosx+((int)fPosz)*256]&0x01)
{
//CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR,0xff999999);
//CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR,0xffffffff);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
}
else
{
//CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR,0xffffffff);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
if(BaseGraphicsLayer::m_VoodooOption)
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
else
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
}
}
else
{
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
//CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR,0xffffffff);
}
}
else // ¹ãÀ϶§
{
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
}
}
else
{
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
if(BaseGraphicsLayer::m_VoodooOption)
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
else
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
}
pd3dDevice->SetStreamSource( 0, NULL, 0 );
pd3dDevice->SetStreamSource( 1, NULL, 0 );
pd3dDevice->SetStreamSource( 2, NULL, 0 );
if(m_CharacterList[cChar].m_Light.m_dwTimer>0)
//if(m_CharacterLightList[cChar].m_dwTimer>0)
{
//pd3dDevice->SetLight(1,&m_CharacterLightList[cChar].m_Light);
pd3dDevice->SetLight(1,&m_CharacterList[cChar].m_Light.m_Light);
pd3dDevice->LightEnable(1,TRUE);
pd3dDevice->LightEnable(0,FALSE);
}
else
{
pd3dDevice->LightEnable(1,FALSE);
pd3dDevice->LightEnable(0,TRUE);
}
////////////////
//Sector Light ij¸¯ÅÍ ¼¼ÆÃ
if((CSceneManager::GetWeatherTime() > 19) || (CSceneManager::GetWeatherTime() < 5))
{
D3DXVECTOR3 vecPos = D3DXVECTOR3(m_CharacterList[cChar].m_vecRealPosition.x,
m_CharacterList[cChar].m_vecRealPosition.y,
m_CharacterList[cChar].m_vecRealPosition.z);
int indexx=(int)(vecPos.x/SECTORSIZE);
int indexy=(int)(vecPos.z/SECTORSIZE);
for(int cSector = 0; cSector < CSceneManager::m_HeightField.GetLSizeX()*CSceneManager::m_HeightField.GetLSizeY(); cSector++ )
{
int sectorindexx = CSceneManager::m_HeightField.m_SectorScene[cSector].m_AccumulateTM._41/SECTORSIZE;
int sectorindexy = CSceneManager::m_HeightField.m_SectorScene[cSector].m_AccumulateTM._43/SECTORSIZE;
if(sectorindexx == indexx &&
sectorindexy == indexy)
{
CSectorScene *pSector = &(CSceneManager::m_HeightField.m_SectorScene[cSector]);
if(pSector != NULL){
pSector->m_SectorLightManager.SelectObjLight(vecPos.x,vecPos.y,vecPos.z);
if(pSector->m_SectorLightManager.m_iSelectObjLights)
{
D3DLIGHT8 pCurrentLight;
ZeroMemory(&(pCurrentLight),sizeof(D3DLIGHT8));
pCurrentLight.Type=D3DLIGHT_POINT;
pCurrentLight.Attenuation0=0.2f;
pCurrentLight.Attenuation1=0.005f;
pCurrentLight.Attenuation2=0.0f;
pCurrentLight.Diffuse.r = (pSector->m_SectorLightManager.m_lstSelectObjLights[0].m_vecColor.x / 255.0f);
pCurrentLight.Diffuse.g = (pSector->m_SectorLightManager.m_lstSelectObjLights[0].m_vecColor.y / 255.0f);
pCurrentLight.Diffuse.b = (pSector->m_SectorLightManager.m_lstSelectObjLights[0].m_vecColor.z / 255.0f);
pCurrentLight.Position.x = pSector->m_SectorLightManager.m_lstSelectObjLights[0].m_vecPos.x;
pCurrentLight.Position.y = pSector->m_SectorLightManager.m_lstSelectObjLights[0].m_vecPos.y;
pCurrentLight.Position.z = pSector->m_SectorLightManager.m_lstSelectObjLights[0].m_vecPos.z;
pCurrentLight.Range= pSector->m_SectorLightManager.m_lstSelectObjLights[0].m_fRange;
pCurrentLight.Falloff = 1.0f;
pd3dDevice->SetLight(0,&(pCurrentLight));
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
//pd3dDevice->LightEnable(1,TRUE);
}
else
{
//pd3dDevice->LightEnable(1,FALSE);
}
}
}
}
}
if(CSceneManager::m_bCharacterLight) // ij¸¯ÅÍ ¹ã¿ë light Ä×À»¶§
{
bool bLight = true;
if(cChar == 0) // ÀÚ½ÅÀÌ ¾Æ´Ï¶ó¸é.. nfocuschar
{
/*
D3DXVECTOR3 vecPos = D3DXVECTOR3(m_CharacterList[cChar].m_vecRealPosition.x,
m_CharacterList[cChar].m_vecRealPosition.y,
m_CharacterList[cChar].m_vecRealPosition.z);
*/
matrix *view = CSceneManager::m_ViewCamera->GetMatPosition();
D3DXVECTOR3 vecPos = D3DXVECTOR3(view->_41,view->_42,view->_43);
D3DXVECTOR3 vecPersonPos = D3DXVECTOR3(m_CharacterList[cChar].m_vecRealPosition.x,
m_CharacterList[cChar].m_vecRealPosition.y,
m_CharacterList[cChar].m_vecRealPosition.z);
D3DXVECTOR3 vecTmp = vecPos - vecPersonPos;
D3DXVec3Normalize(&vecTmp,&vecTmp);
CSceneManager::m_CharacterLight.Position.x = vecPersonPos.x + vecTmp.x * 250.0f;
CSceneManager::m_CharacterLight.Position.y = vecPersonPos.y + vecTmp.y * 250.0f;
CSceneManager::m_CharacterLight.Position.z = vecPersonPos.z + vecTmp.z * 250.0f;
}
else
{
D3DXVECTOR3 vecPos = D3DXVECTOR3(m_CharacterList[cChar].m_vecRealPosition.x,
m_CharacterList[cChar].m_vecRealPosition.y,
m_CharacterList[cChar].m_vecRealPosition.z);
D3DXVECTOR3 vecRange = D3DXVECTOR3(CSceneManager::m_CharacterLight.Position.x - vecPos.x,
CSceneManager::m_CharacterLight.Position.y - vecPos.y,
CSceneManager::m_CharacterLight.Position.z - vecPos.z);
float fRange = D3DXVec3Length(&vecRange);
if(fRange > CSceneManager::m_CharacterLight.Range)
{
bLight = false;
}
}
if(bLight)
{
pd3dDevice->SetLight(0,&(CSceneManager::m_CharacterLight));
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
}
}
/////////////////
if(0)//CRenderOption::m_CharacterPerPixelLighting)
{
D3DXMATRIX matWorld,matView,matProj;
vector3 vecChrPos;
m_CharacterList[cChar].m_pChrmodel->GetPosition(vecChrPos);
D3DXMatrixTranslation(&matWorld,vecChrPos.x,vecChrPos.y,vecChrPos.z);
pd3dDevice->GetTransform(D3DTS_VIEW,&matView);
pd3dDevice->GetTransform(D3DTS_PROJECTION,&matProj);
D3DXMATRIX matTemp;
D3DXMatrixTranspose(&matTemp,&(matWorld * matView * matProj));
pd3dDevice->SetVertexShaderConstant(8, &matTemp, 4);
D3DXMatrixTranspose(&matTemp,&matWorld);
pd3dDevice->SetVertexShaderConstant(0, &matTemp, 4);
D3DXVECTOR4 tmp;
tmp.x = CSceneManager::m_ViewCamera->GetMatPosition()->GetLoc().x;
tmp.y = CSceneManager::m_ViewCamera->GetMatPosition()->GetLoc().y;
tmp.z = CSceneManager::m_ViewCamera->GetMatPosition()->GetLoc().z;
tmp.w = 0.0f;
pd3dDevice->SetVertexShaderConstant(24, tmp, 1);
vecChrPos.y+=150.0f;
vector3 vecViewPos(tmp.x,tmp.y,tmp.z);
vector3 vecRelateLight=vecChrPos-vecViewPos;
//vecRelateLight.y=0.0f;
vecRelateLight.Normalize();
//vecRelateLight.y=0.5f;
//vecRelateLight.Normalize();
float fRelateLight[4]={vecRelateLight.x,vecRelateLight.y,vecRelateLight.z,0.0f};
pd3dDevice->SetVertexShaderConstant(13,fRelateLight,1);
D3DXVECTOR4 half(0.5f,0.5f,0.5f,0.5f);
pd3dDevice->SetVertexShaderConstant(33, &half, 1);
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE,FALSE);
}
if(m_CharacterList[cChar].m_pChrmodel->IsDisabled()==false)
{
m_CharacterList[cChar].m_pChrmodel->PreRender();
if(CRenderOption::m_CharacterSelfShadow)
{
matrix matOldView,matWorld,matProjection;
pd3dDevice->GetTransform(D3DTS_VIEW,matOldView);
pd3dDevice->GetTransform(D3DTS_PROJECTION,matProjection);
pd3dDevice->EndScene();
m_CharacterShadowmap.Begin(pd3dDevice);
pd3dDevice->Clear(0, NULL, D3DCLEAR_ZBUFFER,0xffffffff, 1.0f, 0);
pd3dDevice->BeginScene();
//CSceneStateMgr::_SetD3DRenderState(D3DRS_COLORWRITEENABLE,0);
pd3dDevice->SetVertexShader(BUMPVERTEXFVF);
vector3 vecChrPos;
m_CharacterList[cChar].m_pChrmodel->GetPosition(vecChrPos);
matWorld.Translation(vecChrPos);
matrix matCharCamera;
matCharCamera.CameraLookAt(
vecChrPos-vecSunLightDir*450.0f+vector3(0.0f,85.0f,0.0f),
vector3(0.0f,80.0f,0.0f)+vecChrPos,
vector3(0.0f,1.0f,0.0f));
matrix matShadowProj;
D3DXMatrixOrthoLH(matShadowProj,200,200,10.0f, 10000.0f);
pd3dDevice->SetTransform(D3DTS_VIEW,matCharCamera);
pd3dDevice->SetTransform(D3DTS_PROJECTION,matShadowProj);
CSceneStateMgr::_SetD3DRenderState(D3DRS_COLORWRITEENABLE,0);
m_CharacterList[cChar].m_pChrmodel->Render();
CSceneStateMgr::_SetD3DRenderState(D3DRS_COLORWRITEENABLE,D3DCOLORWRITEENABLE_BLUE|D3DCOLORWRITEENABLE_GREEN|D3DCOLORWRITEENABLE_RED);
pd3dDevice->EndScene();
m_CharacterShadowmap.End(pd3dDevice);
pd3dDevice->BeginScene();
pd3dDevice->SetTexture(2,m_CharacterShadowmap.GetShadowMapZTexture());
matrix matTexture,matTextureScale;
float fOffsetX=0.5f+(0.5f/(float)512);
float fOffsetY=0.5f+(0.5f/(float)512);
unsigned int range=0xffffffff >> (32-16);
float fBias=-0.001f*(float)range;
matTextureScale._11=0.5f;matTextureScale._12=0.0f;matTextureScale._13=0.0f;matTextureScale._14=0.0f;
matTextureScale._21=0.0f;matTextureScale._22=-0.5f;matTextureScale._23=0.0f;matTextureScale._24=0.0f;
matTextureScale._31=0.0f;matTextureScale._32=0.0f;matTextureScale._33=(float)range;matTextureScale._34=0.0f;
matTextureScale._41=fOffsetX;matTextureScale._42=fOffsetY;matTextureScale._43=fBias;matTextureScale._44=1.0f;
matrix matWVP;
matWVP=matWorld*matCharCamera;
matWVP=matWVP*matShadowProj;
matTexture=matWVP*matTextureScale;
matTexture.Transpose();
pd3dDevice->SetVertexShaderConstant(4,&matTexture,4);
pd3dDevice->SetTransform(D3DTS_VIEW,matOldView);
pd3dDevice->SetTransform(D3DTS_PROJECTION,matProjection);
}
if(0)//CRenderOption::m_CharacterPerPixelLighting)
{
pd3dDevice->SetPixelShader(m_dwCharacterPixelShader);
pd3dDevice->SetVertexShader(m_dwCharacterVertexShader);
}
if( (m_CharacterList[cChar].m_fAlphaValue) > 0.0f )
{
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_ALPHAARG1,D3DTA_TFACTOR);
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_COLOROP,D3DTOP_SELECTARG1);
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_COLOROP,D3DTOP_DISABLE);
color alpha;
alpha.r = 255;
alpha.g = 255;
alpha.b = 255;
alpha.a = m_CharacterList[cChar].m_fAlphaValue * 255;
CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR, alpha.c );
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
}
//////////////////////////
int iShaderIndex = -1;
if(CRenderOption::m_CharacterPerPixelLighting) { // Bump-DiffSpec.
iShaderIndex = CSceneManager::m_ShaderManager.GetShader((char *)SHADER_STR_BUMPDIFFSPEC);
if(iShaderIndex >= 0) {
CShaderScene *pShader = CSceneManager::m_ShaderManager.GetShaderPtr((char *)SHADER_STR_BUMPDIFFSPEC);
///////////////
D3DXVECTOR3 vecppDir = D3DXVECTOR3(1.0f,1.0f,1.0f);
matrix *view = CSceneManager::m_ViewCamera->GetMatPosition();
D3DXVECTOR3 vecPos = D3DXVECTOR3(view->_41,view->_42,view->_43);
D3DXVECTOR3 vecPersonPos = D3DXVECTOR3(m_CharacterList[cChar].m_vecRealPosition.x,
m_CharacterList[cChar].m_vecRealPosition.y + 100.0f,
m_CharacterList[cChar].m_vecRealPosition.z);
D3DXVECTOR3 vecTmp = vecPos - vecPersonPos;
D3DXVec3Normalize(&vecTmp,&vecTmp);
vecppDir.x = vecPersonPos.x + vecTmp.x * 250.0f;
vecppDir.y = vecPersonPos.y + vecTmp.y * 250.0f;
vecppDir.z = vecPersonPos.z + vecTmp.z * 250.0f;
vecppDir.x = vecPersonPos.x - vecppDir.x;
vecppDir.y = vecPersonPos.y - vecppDir.y;
vecppDir.z = vecPersonPos.z - vecppDir.z;
D3DXVec3Normalize(&vecppDir,&vecppDir);
//////////////
pShader->SetLightDirection(vecppDir);
CSceneManager::m_ShaderManager.Apply(iShaderIndex);
D3DXVECTOR4 vecDir;
D3DXVECTOR4 vecLightColor;
if(CSceneManager::m_bCharacterLight)
{
vecDir = D3DXVECTOR4(-vecppDir.x,-vecppDir.y,-vecppDir.z,0.0f);
vecLightColor=D3DXVECTOR4(CSceneManager::m_CharacterLight.Diffuse.r,
CSceneManager::m_CharacterLight.Diffuse.g,
CSceneManager::m_CharacterLight.Diffuse.b,1.0f);
}
else
{
vecDir=D3DXVECTOR4( 1.0f, 1.0f, 1.0f, 0.0f );
vecLightColor=D3DXVECTOR4(CSceneManager::m_WeatherManager.m_InterCharacterLight.r/255.0f,
CSceneManager::m_WeatherManager.m_InterCharacterLight.g/255.0f,
CSceneManager::m_WeatherManager.m_InterCharacterLight.b/255.0f,1.0f);
}
//D3DXVECTOR4 vecDir = D3DXVECTOR4(-vecppDir.x,-vecppDir.y,-vecppDir.z,1.0f);
//D3DXVECTOR4 vecDir=D3DXVECTOR4( 1.0f, 1.0f, 1.0f, 0.0f );
D3DXVec4Normalize(&vecDir,&vecDir);
CSceneManager::GetDevice()->SetVertexShaderConstant(21, vecDir, 1);
// lighting scaling
/*
vecLightColor *= 2.0f;
vecLightColor.w = 1.0f;
vecLightColor.x = (vecLightColor.x > 1.0f) ? (1.0f) : vecLightColor.x;
vecLightColor.y = (vecLightColor.y > 1.0f) ? (1.0f) : vecLightColor.y;
vecLightColor.z = (vecLightColor.z > 1.0f) ? (1.0f) : vecLightColor.z;
*/
CSceneManager::GetDevice()->SetPixelShaderConstant(PCN_LIGHTCOLOR,vecLightColor,1);
/*
D3DXVECTOR4 vecAmb = D3DXVECTOR4(CSceneManager::m_WeatherManager.m_InterCharacterAmbient.r/255.0f,
CSceneManager::m_WeatherManager.m_InterCharacterAmbient.g/255.0f,
CSceneManager::m_WeatherManager.m_InterCharacterAmbient.b/255.0f,
1.0f);
CSceneManager::GetDevice()->SetPixelShaderConstant(PCN_AMBIENTCOLOR,vecAmb,1);
*/
}
}
if(CRenderOption::m_bShadowMap)
{
static CShader_SelfShadow *pTestShader = NULL;
if(!pTestShader)
{
pTestShader = new CShader_SelfShadow;
}
}
m_CharacterList[cChar].m_pChrmodel->Render();
if(CRenderOption::m_CharacterPerPixelLighting) {
if(iShaderIndex >= 0)
CSceneManager::m_ShaderManager.UnApply(iShaderIndex);
}
////////////////////////////
if( m_CharacterList[cChar].m_fAlphaValue > 0.0f )
{
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
}
}
}
fBias=0.0f;
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_MIPMAPLODBIAS, *((LPDWORD) (&fBias)));
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_MIPMAPLODBIAS, *((LPDWORD) (&fBias)));
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHAREF,0xee);
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHAREF,0x0);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP,D3DTOP_SELECTARG1);
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
pd3dDevice->SetPixelShader(NULL);
CZ3DRenderable::SecondProcess();
for(int i=1;i<8;i++)
pd3dDevice->LightEnable(i,FALSE);
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 1 );
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXCOORDINDEX, 2);
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_MIPFILTER,D3DTEXF_LINEAR);
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_MIPFILTER,D3DTEXF_LINEAR);
matrix mat;
mat._11 = 1.0f; mat._12 = 0; mat._13 = 0; mat._14 = 0;
mat._21 = 0; mat._22 = 1.0f; mat._23 = 0; mat._24 = 0;
mat._31 = 0; mat._32 = 0; mat._33 = 1.0f; mat._34 = 0;
mat._41 = 0; mat._42 = 0; mat._43 = 0; mat._44 = 1.0f;
pd3dDevice->SetTransform( D3DTS_TEXTURE1, mat );
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_COLOROP, D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DTextureStageState(2,D3DTSS_COLOROP, D3DTOP_DISABLE);
pd3dDevice->SetTexture(1,NULL);
pd3dDevice->SetTexture(2,NULL);
pd3dDevice->SetTexture(3,NULL);
/*
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
pd3dDevice->SetLight(0,&m_WeatherManager.m_SunLight);
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,m_WeatherManager.m_AmbientColor->c);
pd3dDevice->LightEnable(0,TRUE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
CSceneNode CharScene;
CharScene.m_fRad=300.0f;
vector3 vecCharPos;
for(int cChar=0;cChar<m_CharacterList.num;cChar++)
{
m_CharacterList[cChar]->GetPosition(vecCharPos.x,vecCharPos.y,vecCharPos.x);
CharScene.m_AccumulateTM.Translation(vecCharPos);
if(CharScene.isCulling())
m_CharacterList[cChar]->SetCull(true);
else
m_CharacterList[cChar]->SetCull(false);
if(cChar==0)
m_CharacterList[cChar]->SetCull(false);
}
CZ3DRenderable::Process();
*/
}
void CCharacterLightShadowManager::HeightFieldCharacterLightRender(LPDIRECT3DDEVICE8 pd3dDevice)
{
if(CSceneManager::m_bCharacterLight == true)
{
pd3dDevice->EndScene();
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG2);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP );
matrix matTexScale;
matTexScale.MakeIdent();
matTexScale._11= 0.5f;
matTexScale._22= -0.5f;
matTexScale._33=0.0f;
matTexScale._41=0.5f;
matTexScale._42=0.5f;
matTexScale._43=1.0f;
matTexScale._44=1.0f;
matrix matView,matOldProj,matInv,matTex,matIndent;
matIndent.MakeIdent();
pd3dDevice->GetTransform(D3DTS_VIEW,matView);
matInv.Inverse(matView);
matrix matAdjLightProj,matLightProj;
matAdjLightProj.MakeAdjustedProjectionMatrix(3.14159f/8.0f,1.0f,1.0f,500.0f,0.5f,-0.5f,(float)SHADOWSIZE, (float)SHADOWSIZE);
matLightProj.MakeAdjustedProjectionMatrix(3.14159f/8.0f, 1.0f, 1.0f, 500.0f,0.0f, 0.0f,(float)SHADOWSIZE, (float)SHADOWSIZE);
matrix matShadowProj;
//matShadowProj.MakeProjection(3.14159f/4.0f,1.0f,10.0f,10000.0f);
matShadowProj.MakeNoProjection(3.14159f/3.0f,(float)SHADOWSIZE+CSceneManager::m_fGlowPlaneRange,(float)SHADOWSIZE+CSceneManager::m_fGlowPlaneRange,10.0f,5500.f);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_TEXCOORDINDEX,D3DTSS_TCI_CAMERASPACEPOSITION );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_PROJECTED | D3DTTFF_COUNT3 );
pd3dDevice->LightEnable(0,FALSE);
pd3dDevice->LightEnable(1,FALSE);
pd3dDevice->LightEnable(2,FALSE);
pd3dDevice->LightEnable(3,FALSE);
pd3dDevice->LightEnable(4,FALSE);
pd3dDevice->LightEnable(5,FALSE);
pd3dDevice->LightEnable(6,FALSE);
pd3dDevice->LightEnable(7,FALSE);
pd3dDevice->LightEnable(8,FALSE);
// CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
// CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,0xff999999);
// CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
vector3 vecSunLightDir( CSceneManager::m_WeatherManager.m_SunLight.Direction.x,
CSceneManager::m_WeatherManager.m_SunLight.Direction.y,
CSceneManager::m_WeatherManager.m_SunLight.Direction.z);
vecSunLightDir.Normalize();
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE,FALSE);
vector3 vecSelfChrPos;
vector3 vecLens;
if(m_CharacterList.num>0)
{
m_CharacterList[0].m_pChrmodel->GetPosition(vecSelfChrPos.x,vecSelfChrPos.y,vecSelfChrPos.z);
}
for(int cChar=0;cChar<m_CharacterList.num;cChar++)
{
if(m_CharacterList[cChar].m_pChrmodel->IsCulled())
continue;
if(m_CharacterList[cChar].m_bRender==false)
continue;
if(cChar != 0)
continue;
vector3 vecChrPos;
m_CharacterList[cChar].m_pChrmodel->GetPosition(vecChrPos.x,vecChrPos.y,vecChrPos.z);
if(m_pHeightField->GetHeight(vecChrPos)-10.0f > vecChrPos.y)
continue;
if(cChar>0)
{
vecLens=vecSelfChrPos-vecChrPos;
if(vecLens.GetLens()>1500.0f)
continue;
}
matrix matCharCamera;
matCharCamera.CameraLookAt(
vecChrPos+vector3(0.0f,185.0f,1.0f),
vector3(0.0f,80.0f,0.0f)+vecChrPos,
vector3(0.0f,1.0f,0.0f));
pd3dDevice->BeginScene();
List<vector3> CharPoly;
m_pHeightField->GetHeightFieldShadowPoly(vecChrPos,CharPoly);
vector3 vecLightPosList=vecChrPos- (vecChrPos+vector3(0.0f,105.0f,1.0f) );
if(CRenderOption::m_CharacterProjectShadowBuilding)
m_pHeightField->GetInHouseShadowPoly(vecChrPos,CharPoly,vecLightPosList);
//m_pHeightField->GetShadowPoly(vecChrPos,CharPoly);
TTVertex *pCharVertex=new TTVertex[CharPoly.num];
WORD *pCharIndices=new WORD[CharPoly.num];
for(int cIndices=0;cIndices<CharPoly.num;cIndices++)
{
pCharVertex[cIndices].v=CharPoly[cIndices];
pCharVertex[cIndices].diff.c=0xffff0000;
pCharIndices[cIndices]=cIndices;
//pCharVertex[cIndices].v.y+=2.0f;
}
pd3dDevice->SetTransform(D3DTS_VIEW,CSceneManager::m_ViewCamera->GetMatView());
matrix mat,mat2;
mat=matShadowProj*matTexScale;
//mat=matLightProj*matTexScale;
mat2=matCharCamera*mat;
matTex=matInv*mat2;
pd3dDevice->SetTransform(D3DTS_TEXTURE0,matTex);
// pd3dDevice->SetTexture(0,m_pCharacterLight.GetTexture());
if(m_pCharacterLight == NULL) {
m_pCharacterLight = new CTexture;
CTexture::SetPath(EFFECTTEXTUREPATH);
m_pCharacterLight->Load("CL_Glow.dds");
}
pd3dDevice->SetTexture(0,m_pCharacterLight->GetTexture());
pd3dDevice->SetVertexShader(TTVERTEXFVF);
CSceneStateMgr::_SetD3DRenderState(D3DRS_TEXTUREFACTOR,0xffffffff);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_TFACTOR);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP,D3DTOP_MODULATE2X);
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP,D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_DESTCOLOR);
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,TRUE);
//CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
pd3dDevice->SetTransform(D3DTS_WORLD,matIndent);
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZBIAS,14);
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZWRITEENABLE,FALSE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
pd3dDevice->DrawIndexedPrimitiveUP(D3DPT_TRIANGLELIST,0,CharPoly.num,CharPoly.num/3,pCharIndices,
D3DFMT_INDEX16,pCharVertex,sizeof(TTVertex));
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZWRITEENABLE,TRUE);
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZBIAS,0);
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
delete [] pCharVertex;
delete [] pCharIndices;
pd3dDevice->EndScene();
}
matTex.MakeIdent();
pd3dDevice->SetTransform(D3DTS_TEXTURE0,matTex);
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE,TRUE);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0 );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_DISABLE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP );
pd3dDevice->BeginScene();
}
}
void CCharacterLightShadowManager::HeightFieldShadowRender(LPDIRECT3DDEVICE8 pd3dDevice)
{
if(!CRenderOption::m_CharacterProjectShadowTerrain)
return;
pd3dDevice->EndScene();
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG2);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP );
matrix matTexScale;
matTexScale.MakeIdent();
matTexScale._11=0.5f;
matTexScale._22=-0.5f;
matTexScale._33=0.0f;
matTexScale._41=0.5f;
matTexScale._42=0.5f;
matTexScale._43=1.0f;
matTexScale._44=1.0f;
matrix matView,matOldProj,matInv,matTex,matIndent;
matIndent.MakeIdent();
pd3dDevice->GetTransform(D3DTS_VIEW,matView);
pd3dDevice->GetTransform(D3DTS_PROJECTION,matOldProj);
matInv.Inverse(matView);
matrix matAdjLightProj,matLightProj;
matAdjLightProj.MakeAdjustedProjectionMatrix(3.14159f/8.0f,1.0f,1.0f,500.0f,0.5f,-0.5f,(float)SHADOWSIZE, (float)SHADOWSIZE);
matLightProj.MakeAdjustedProjectionMatrix(3.14159f/8.0f, 1.0f, 1.0f, 500.0f,0.0f, 0.0f,(float)SHADOWSIZE, (float)SHADOWSIZE);
matrix matShadowProj;
//matShadowProj.MakeProjection(3.14159f/4.0f,1.0f,10.0f,10000.0f);
matShadowProj.MakeNoProjection(3.14159f/3.0f,(float)SHADOWSIZE+150.0f,(float)SHADOWSIZE+150.0f,10.0f,5500.f);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_TEXCOORDINDEX,D3DTSS_TCI_CAMERASPACEPOSITION );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_PROJECTED | D3DTTFF_COUNT3 );
pd3dDevice->LightEnable(0,FALSE);
pd3dDevice->LightEnable(1,FALSE);
pd3dDevice->LightEnable(2,FALSE);
pd3dDevice->LightEnable(3,FALSE);
pd3dDevice->LightEnable(4,FALSE);
pd3dDevice->LightEnable(5,FALSE);
pd3dDevice->LightEnable(6,FALSE);
pd3dDevice->LightEnable(7,FALSE);
pd3dDevice->LightEnable(8,FALSE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,0xff999999);
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
vector3 vecSunLightDir( CSceneManager::m_WeatherManager.m_SunLight.Direction.x,
CSceneManager::m_WeatherManager.m_SunLight.Direction.y,
CSceneManager::m_WeatherManager.m_SunLight.Direction.z);
vecSunLightDir.Normalize();
TLVertex Vertex[4];
Vertex[0].Diffuse.c=Vertex[1].Diffuse.c=Vertex[2].Diffuse.c=Vertex[3].Diffuse.c=0xffffffff;
Vertex[0].Specular.c=Vertex[1].Specular.c=Vertex[2].Specular.c=Vertex[3].Specular.c=0;
Vertex[0].w=Vertex[1].w=Vertex[2].w=Vertex[3].w=0.1f;
Vertex[0].v.z=Vertex[1].v.z=Vertex[2].v.z=Vertex[3].v.z=0.1f;
Vertex[0].v.x=Vertex[1].v.x=0;
Vertex[2].v.x=Vertex[3].v.x=SHADOWSIZE-1;
Vertex[0].v.y=Vertex[2].v.y=0;
Vertex[1].v.y=Vertex[3].v.y=SHADOWSIZE-1;
Vertex[0].tu=Vertex[1].tu=0.0f;
Vertex[2].tu=Vertex[3].tu=1.0f;
Vertex[0].tv=Vertex[2].tv=0.0f;
Vertex[1].tv=Vertex[3].tv=1.0f;
WORD pLineIndices[8]={0,1,1,3,3,2,2,0};
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE,FALSE);
vector3 vecSelfChrPos;
vector3 vecLens;
if(m_CharacterList.num>0)
{
m_CharacterList[0].m_pChrmodel->GetPosition(vecSelfChrPos.x,vecSelfChrPos.y,vecSelfChrPos.z);
}
for(int cChar=0;cChar<m_CharacterList.num;cChar++)
{
///////////////////// °ø¼º//////////////////////
if(cChar != 0)
break;
if(m_CharacterList[cChar].m_pChrmodel->IsCulled())
continue;
if(m_CharacterList[cChar].m_bRender==false)
continue;
vector3 vecChrPos;
m_CharacterList[cChar].m_pChrmodel->GetPosition(vecChrPos.x,vecChrPos.y,vecChrPos.z);
if(m_pHeightField->GetHeight(vecChrPos)-10.0f > vecChrPos.y)
continue;
if(cChar>0)
{
vecLens=vecSelfChrPos-vecChrPos;
if(vecLens.GetLens()>1500.0f)
continue;
}
m_pShadowTexture.Begin(pd3dDevice);
pd3dDevice->Clear(0, NULL, D3DCLEAR_ZBUFFER|D3DCLEAR_TARGET,0xffffffff, 1.0f, 0);
pd3dDevice->BeginScene();
matrix matCharCamera;
matCharCamera.CameraLookAt(
vecChrPos-vecSunLightDir*550.0f+vector3(0.0f,85.0f,0.0f),
vector3(0.0f,80.0f,0.0f)+vecChrPos,
vector3(0.0f,1.0f,0.0f));
pd3dDevice->SetTransform(D3DTS_VIEW,matCharCamera);
pd3dDevice->SetTransform(D3DTS_PROJECTION,matShadowProj);
//m_pd3dDevice->SetTransform(D3DTS_PROJECTION,matAdjLightProj);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1,D3DTA_DIFFUSE);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP,D3DTOP_SELECTARG1);
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP,D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
if(0)//CRenderOption::m_CharacterPerPixelLighting)
{
pd3dDevice->SetVertexShader(BUMPVERTEXFVF);
}
m_CharacterList[cChar].m_pChrmodel->DrawShadow();
pd3dDevice->SetVertexShader(TLVERTEXFVF);
//CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
pd3dDevice->DrawIndexedPrimitiveUP(D3DPT_LINELIST,0,4,4,pLineIndices,D3DFMT_INDEX16,Vertex,sizeof(TLVertex));
//CSceneStateMgr::_SetD3DRenderState( D3DRS_CULLMODE ,D3DCULL_NONE);
//pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,Vertex,sizeof(TLVertex));
//CSceneStateMgr::_SetD3DRenderState( D3DRS_CULLMODE ,D3DCULL_CCW);
pd3dDevice->EndScene();
m_pShadowTexture.End(pd3dDevice);
pd3dDevice->BeginScene();
List<vector3> CharPoly;
m_pHeightField->GetHeightFieldShadowPoly(vecChrPos,CharPoly);
vector3 vecLightPosList=vecChrPos-vecSunLightDir*550.0f;
if(CRenderOption::m_CharacterProjectShadowBuilding)
m_pHeightField->GetInHouseShadowPoly(vecChrPos,CharPoly,vecLightPosList);
//m_pHeightField->GetShadowPoly(vecChrPos,CharPoly);
TTVertex *pCharVertex=new TTVertex[CharPoly.num];
WORD *pCharIndices=new WORD[CharPoly.num];
for(int cIndices=0;cIndices<CharPoly.num;cIndices++)
{
pCharVertex[cIndices].v=CharPoly[cIndices];
pCharVertex[cIndices].diff.c=0xffff0000;
pCharIndices[cIndices]=cIndices;
//pCharVertex[cIndices].v.y+=2.0f;
}
//Rain
RainVertex *pRainVert = NULL;
if(CRenderOption::m_bRain && (cChar == 0)) {
static DWORD dwStartTime = timeGetTime();
DWORD dwTick;
static DWORD dwPlay = 0;
dwTick = timeGetTime();
if(((dwTick - dwStartTime) / 100) > dwPlay ) {
dwPlay = ((dwTick - dwStartTime) / 100);
m_lpRainVertexBuffer->Lock(0,0,(BYTE **)&pRainVert,0);
int iCount = 0;
m_dwRainUseNum = 0;
int iTri = (CharPoly.num / 3);
int iUnit = m_dwRainVertexsNum / iTri;
int iUnitNum = 0;
D3DXVECTOR3 vecA,vecB,vecC;
D3DXVECTOR3 vecS,vecT;
float fR1,fR2;
float fSLength,fTLength,fTotalLength;
for(int iTriangle = 0; iTriangle < iTri; iTriangle++) {
vecA = D3DXVECTOR3(pCharVertex[iCount].v.x,pCharVertex[iCount].v.y,pCharVertex[iCount].v.z);
iCount++;
vecB = D3DXVECTOR3(pCharVertex[iCount].v.x,pCharVertex[iCount].v.y,pCharVertex[iCount].v.z);
iCount++;
vecC = D3DXVECTOR3(pCharVertex[iCount].v.x,pCharVertex[iCount].v.y,pCharVertex[iCount].v.z);
iCount++;
vecS = vecB - vecA;
vecT = vecC - vecA;
fSLength = D3DXVec3Length(&vecS);
fTLength = D3DXVec3Length(&vecT);
fTotalLength = fSLength + fTLength;
if(fTotalLength > 10000.0f)
iUnitNum = iUnit;
else if(fTotalLength >= 5000 && fTotalLength <= 10000) {
iUnitNum = iUnit / 2;
}
else if(fTotalLength > 2000 && fTotalLength < 5000){
iUnitNum = iUnit / 3;
}
else {
iUnitNum = iUnit / 9;
}
for(int iVert = 0 ; iVert < iUnitNum; iVert++) {
fR1 = ((float)(rand() % 1000)) / 1000.0f;
fR2 = 1.0f - fR1;
fR2 = fR2 * ((float)(rand() % 1000) / 1000.0f);
pRainVert[m_dwRainUseNum].vecPos = D3DXVECTOR3((vecA.x + vecS.x * fR1 + vecT.x * fR2),
(vecA.y + vecS.y * fR1 + vecT.y * fR2),
(vecA.z + vecS.z * fR1 + vecT.z * fR2));
pRainVert[m_dwRainUseNum].fLoop = m_pRainLoopValue[m_dwRainUseNum];
pRainVert[m_dwRainUseNum].vecNormal = D3DXVECTOR3(0.0f,1.0f,0.0f);
m_dwRainUseNum++;
}
}
m_lpRainVertexBuffer->Unlock();
m_bRainBufferSet = true;
}// if(((dwTick - dwStartTime) / 500) > dwPlaySound ) {
}
pd3dDevice->SetTransform(D3DTS_VIEW,CSceneManager::m_ViewCamera->GetMatView());
matrix mat,mat2;
mat=matShadowProj*matTexScale;
//mat=matLightProj*matTexScale;
mat2=matCharCamera*mat;
matTex=matInv*mat2;
pd3dDevice->SetTransform(D3DTS_PROJECTION,matOldProj);
pd3dDevice->SetTransform(D3DTS_TEXTURE0,matTex);
pd3dDevice->SetTexture(0,m_pShadowTexture.GetTexture());
pd3dDevice->SetVertexShader(TTVERTEXFVF);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP,D3DTOP_SELECTARG1);
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP,D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_ZERO);
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_SRCCOLOR);
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,TRUE);
//CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
pd3dDevice->SetTransform(D3DTS_WORLD,matIndent);
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZBIAS,14);
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZWRITEENABLE,FALSE);
if(CharPoly.num > 0) {
pd3dDevice->DrawIndexedPrimitiveUP(D3DPT_TRIANGLELIST,0,CharPoly.num,CharPoly.num/3,pCharIndices,
D3DFMT_INDEX16,pCharVertex,sizeof(TTVertex));
}
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZWRITEENABLE,TRUE);
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZBIAS,0);
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
delete [] pCharVertex;
delete [] pCharIndices;
pd3dDevice->EndScene();
}
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE,TRUE);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0 );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_DISABLE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP );
pd3dDevice->BeginScene();
// Rain Render
if(CRenderOption::m_bRain) {
pd3dDevice->SetVertexShader(NULL);
pd3dDevice->SetPixelShader(NULL);
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_COLOROP,D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_ALPHAOP,D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DTextureStageState(2, D3DTSS_COLOROP,D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DTextureStageState(2, D3DTSS_ALPHAOP,D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DTextureStageState(3, D3DTSS_COLOROP,D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DTextureStageState(3, D3DTSS_ALPHAOP,D3DTOP_DISABLE);
pd3dDevice->SetStreamSource(0,m_lpRainVertexBuffer, sizeof(RainVertex));
int iShaderIndex = CSceneManager::m_ShaderManager.GetShader((char *)SHADER_STR_RAIN);
CSceneManager::m_ShaderManager.Apply(iShaderIndex);
static _timeb start;
static int firstTime = 1;
if (firstTime!=0)
{
_ftime(&start);
firstTime = 0;
}
struct _timeb now;
_ftime(&now);
float deltaTime(static_cast<float>(now.time - start.time));
deltaTime += static_cast<float>(0.001f * (now.millitm - start.millitm));
//deltaTime *= 0.3f;
deltaTime *= 1.3f;
pd3dDevice->SetVertexShaderConstant(CV_RAINANI, D3DXVECTOR4(deltaTime, 0.0f, 0.0f, 0.0f), 1); // Anim Time index 19->61
D3DXVECTOR4 vecConstNumber(0.0f, 0.5f, 1.0f, 2.0f);
pd3dDevice->SetVertexShaderConstant(CV_CONSTS_1, &vecConstNumber, 1); // 9->42
D3DXVECTOR4 vecConstNumber2(45000.0f, 0.05f, 0.1f, 0.2f);
//D3DXVECTOR4 vecConstNumber2(100.0f, 0.05f, 0.1f, 0.2f);
pd3dDevice->SetVertexShaderConstant(CV_CONSTS_2, &vecConstNumber2, 1); //18->55
pd3dDevice->DrawPrimitive( D3DPT_POINTLIST, 0, m_dwRainUseNum);
CSceneStateMgr::_SetD3DRenderState(D3DRS_POINTSPRITEENABLE, FALSE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_POINTSCALEENABLE, FALSE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_POINTSIZE, FtoDW(1.0f) );
CSceneStateMgr::_SetD3DRenderState( D3DRS_POINTSIZE_MIN, FtoDW(0.0f) );
CSceneStateMgr::_SetD3DRenderState( D3DRS_POINTSIZE_MAX, FtoDW(64.0f) );
CSceneStateMgr::_SetD3DRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZWRITEENABLE,TRUE);
pd3dDevice->SetVertexShader(NULL);
pd3dDevice->SetPixelShader(NULL);
}
}
void CCharacterLightShadowManager::HeightFieldRainRender(LPDIRECT3DDEVICE8 pd3dDevice) {
}
CZ3DGeneralChrModel* CCharacterLightShadowManager::AddCharacter( const char* szGCMDSName, const char* szFaceType, const char* szHairStyle )
{
CZ3DGeneralChrModel* pChrModel;
pChrModel = new CZ3DGeneralChrModel;
if( false == pChrModel->Init( szGCMDSName ) )
{
return NULL;
}
pChrModel->SetStaticSlot( "FACE", szFaceType );
pChrModel->SetStaticSlot( "HAIR", szHairStyle );
pChrModel->SetDisable(false);
CCharacterDataNode AddNode;
AddNode.m_pChrmodel=pChrModel;
AddNode.m_CollisionType=CT_NONE;
AddNode.m_ptScreenPosition.x=0;
AddNode.m_ptScreenPosition.y=0;
AddNode.m_dwEvent=0;
memset(&AddNode.m_Light,0,sizeof(CChrLightNode));
AddNode.m_vecPerFrameMove=vector3(0.0f,0.0f,0.0f);
AddNode.m_vecRealPosition=vector3(0.0f,0.0f,0.0f);
AddNode.m_RandomPositionTimer=0;
AddNode.m_vecRandomPositionAdder=vector3(0.0f,0.0f,0.0f);
AddNode.m_fFallSpeed=0.0f;
AddNode.m_fAccelate=0.0f;
AddNode.m_vecZeroVelocity=vector3(0.0f,0.0f,0.0f);
AddNode.m_bFirstAccelate=false;
AddNode.m_bCollisionDetectAble=true;
AddNode.m_DelayTimer=0;
AddNode.m_bGravityAble=true;
AddNode.m_bRender=true;
AddNode.m_cAttackEvent=0;
AddNode.m_cJumpEvent=0;
AddNode.m_cWalkEvent=0;
AddNode.m_cCancelEvent=0;
AddNode.m_cShotEvent=0;
AddNode.m_cJustEvent=0;
AddNode.m_cJustStartEvent = 0;
AddNode.m_cJustEndEvent = 0;
AddNode.m_fAlphaValue = -1.0f;
m_CharacterList.Add(AddNode);
return pChrModel;
/*
m_CharacterList.Add(pChrModel);
m_CharacterCollisionType.Add(CT_BOTTOM);
POINT ptChr;
ptChr.x=0;ptChr.y=0;
m_CharacterScreenPositionList.Add(ptChr);
// »ç¿îµå °ü·ÃºÎºÐ ÃßÈÄ ¼öÁ¤¿ä
//CZ3DSoundEventHelper* pChrSoundHelper=new CZ3DSoundEventHelper();
//pChrSoundHelper->Init(m_CharacterList[m_CharacterList.num-1]);
//m_CharacterSoundHelperList.Add(pChrSoundHelper);
m_CharacterAttackEventList.Add(false);
m_CharacterTrailOnEventList.Add(false);
m_CharacterTrailOffEventList.Add(false);
m_CharacterDelayTimer.Add(0);
m_CharacterPerFrameMove.Add(vector3(0.0f,0.0f,0.0f));
m_CharacterRealPosition.Add(vector3(0.0f,0.0f,0.0f));
m_CharacterRandomPostionTimer.Add(0);
m_CharacterRandomPostionAdder.Add(vector3(0.0f,0.0f,0.0f));
CChrLightNode AddLightNode;
memset(&AddLightNode,0,sizeof(AddLightNode));
m_CharacterLightList.Add(AddLightNode);
return m_CharacterList[m_CharacterList.num-1];
*/
}
void CCharacterLightShadowManager::UpdateFrame(int m_nFocuesCharacter)
{
if(m_CharacterList.num==0)
return;
List<vector3> OldPosList;
vector3 vecOldPos;
for(int cChar=0;cChar<m_CharacterList.num;cChar++)
{
m_CharacterList[cChar].m_pChrmodel->GetPosition(vecOldPos.x,vecOldPos.y,vecOldPos.z);
vecOldPos.y+=85.0f;
OldPosList.Add(vecOldPos);
}
ActionProcess();
static int m_UpdateCollision=0;
bool bUpdateCollision=false;
//if(m_UpdateCollision%2==0)
bUpdateCollision=true;
m_UpdateCollision++;
vector3 vecCharPos,vecDir;
for(cChar=0;cChar<m_CharacterList.num;cChar++)
{
/*
if(m_CharacterList[cChar]->CheckEvent()==Z3D_ES_HIT)
{
m_CharacterAttackEventList[cChar]=true;
}
if(m_CharacterList[cChar]->CheckEvent()==Z3D_ES_WEAPON_TRAIL_ON)
{
m_CharacterTrailOnEventList[cChar]=true;
m_CharacterList[cChar]->Act(Z3D_CA_WEAPON_TRAIL_ON);
}
if(m_CharacterList[cChar]->CheckEvent()==Z3D_ES_WEAPON_TRAIL_OFF)
{
m_CharacterTrailOffEventList[cChar]=true;
m_CharacterList[cChar]->Act(Z3D_CA_WEAPON_TRAIL_OFF);
}
*/
if(m_CharacterList[cChar].m_pChrmodel->IsDisabled())
continue;
if(m_CharacterList[cChar].m_CollisionDetectType==CDT_ONLYTERRAIN)
{
vector3 vecChrPos;
m_CharacterList[cChar].m_pChrmodel->GetPosition(vecChrPos);
vecChrPos.y=CSceneManager::m_HeightField.GetHeight(vecChrPos);
//vecChrPos.y+=300.0f;
m_CharacterList[cChar].m_pChrmodel->SetPosition(vecChrPos);
}
/*
CollisionType CT;
m_CharacterList[cChar].m_pChrmodel->GetPosition(vecCharPos.x,vecCharPos.y,vecCharPos.z);
vecCharPos.y+=85.0f;
vecDir=vecCharPos-OldPosList[cChar];
CSceneManager::m_CollisionDetection.m_SelfChr=cChar;
if(cChar==0)
{
vecDir.y-=m_CharacterList[cChar].m_fFallSpeed;
vecCharPos=CSceneManager::m_CollisionDetection.GetPosition(OldPosList[cChar],vecDir,CT,true);
}
else
{
if(bUpdateCollision)
{
//vecDir.y-=m_CharacterList[cChar].m_fFallSpeed;
//vecCharPos=CSceneManager::m_CollisionDetection.GetPosition(OldPosList[cChar],vecDir,CT,true);
//vecCharPos=CSceneManager::m_CollisionDetection.GetPosition(OldPosList[cChar],vecDir,CT,false);
}
}
m_CharacterList[cChar].m_pChrmodel->SetPosition(vecCharPos.x,vecCharPos.y-85.0f,vecCharPos.z);
if((m_CharacterList[cChar].m_CollisionType==CT_NONE ))// && CT!=CT_NONE)
{
m_CharacterList[cChar].m_vecPerFrameMove.x=m_CharacterList[cChar].m_vecPerFrameMove.x;
m_CharacterList[cChar].m_vecPerFrameMove.z=m_CharacterList[cChar].m_vecPerFrameMove.z;
m_CharacterList[cChar].m_vecPerFrameMove.y=0.0f;
}
m_CharacterList[cChar].m_CollisionType=CT;
//m_CharacterCollisionType[cChar]=CT;
// m_CharacterSoundHelperList[cChar]->Process();
*/
}
if(m_nFocuesCharacter==-1)
return;
/*
float fChrInter=CSceneManager::GetCameraInter();
vector3 vecChrPos;
m_CharacterList[m_nFocuesCharacter]->GetPosition(vecChrPos.x,vecChrPos.y,vecChrPos.z);
vecChrPos.y+=150.0f;
vector3 vecCameraPos=CSceneManager::m_ViewCamera->m_vecCameraPosition;
vecCameraPos=vecChrPos+vecCameraPos*fCh rInter;
// ÁýÃæµ¹//
fChrInter=GetCollisionChrCamera(vecChrPos,vecCameraPos);
vecCameraPos=CSceneManager::m_ViewCamera->m_vecCameraPosition;
vecCameraPos=vecChrPos+vecCameraPos*fChrInter;
//vecCameraPos=vecChrPos+vecCameraPos*fChrInter;
// HeightField Ãæµ¹//
float fCameraHeight=m_pHeightField->GetHeight(vecCameraPos);
if(vecCameraPos.y < fCameraHeight +30.0f)
{
vecCameraPos.y=fCameraHeight +30.0f;
}
matrix matView,matTrans;
matView.CameraLookAt(vecCameraPos,vecChrPos,vector3(0.0f,1.0f,0.0f));
matTrans.Inverse(matView);
CSceneManager::m_ViewCamera->m_matPosition=matTrans;
CSceneManager::m_ViewCamera->m_matView=matView;
CSceneManager::m_ViewCamera->MoveFrustum();
CSceneManager::m_ViewCamera->SetVecPosition(vecChrPos);
vector3 vecLens=vecChrPos-vecCameraPos;
float fCameraInter=vecLens.GetLens();
if(100.0f > fCameraInter)
{
if(50.0f > fCameraInter)
{
m_CharacterList[m_nFocuesCharacter]->SetAlphaLevel(0.1f);
}
else
{
fCameraInter-=50.0f;
fCameraInter/=50.0f;
if(fCameraInter < 0.1f)
fCameraInter=0.1f;
m_CharacterList[m_nFocuesCharacter]->SetAlphaLevel(fCameraInter);
}
}
else
{
m_CharacterList[m_nFocuesCharacter]->SetAlphaLevel(1.0f);
}
vector3 vecCamaeraPos=matTrans.GetLoc();
//CZ3DSound::SetListenerPosition(vecCameraPos);
//CZ3DSound::SetListenerDirection(CSceneManager::m_ViewCamera->GetRotationY());
//GetCollisionChrCamera(vecChrPos,vecCameraPos);
/*
CSceneManager::m_ViewCamera->m_matExtraPosition._41=cx;
CSceneManager::m_ViewCamera->m_matExtraPosition._42=cy+150.0f;
CSceneManager::m_ViewCamera->m_matExtraPosition._43=cz;
CSceneManager::m_ViewCamera->InterfaceCharlook(0,0,0.0f);
*/
}
void CCharacterLightShadowManager::CharacterLightSetting(int nChr,LPDIRECT3DDEVICE8 pd3dDevice)
{
vector3 vecCharPos;
List<D3DLIGHT8> LightList;
m_CharacterList[nChr].m_pChrmodel->GetPosition(vecCharPos.x,vecCharPos.y,vecCharPos.z);
m_pHeightField->GetLight(vecCharPos,LightList);
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_AmbientColor->c);
color ChrColor=CSceneManager::m_WeatherManager.m_InterObjectAmbientColor;
ChrColor.r+=140;
ChrColor.g+=140;
ChrColor.b+=140;
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,0xffffffff);
if(LightList.num==0)
{
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
pd3dDevice->LightEnable(0,TRUE);
}
/*
for(int cLight=1;cLight<LightList.num;cLight++)
{
if(cLight==0)
{
/*
if(LightList[cLight].Type==0)
{
color SunLightColor;
SunLightColor.a=0xff;
SunLightColor.r=(CSceneManager::m_WeatherManager.m_SunLight.Diffuse.r*255);
SunLightColor.g=(CSceneManager::m_WeatherManager.m_SunLight.Diffuse.g*255);
SunLightColor.b=(CSceneManager::m_WeatherManager.m_SunLight.Diffuse.b*255);
color InterSunLightColor=color::Interpolation(color(0,0,0),SunLightColor,LightList[cLight].Attenuation0*LightList[cLight].Attenuation0*LightList[cLight].Attenuation0);
D3DLIGHT8 SunLight=CSceneManager::m_WeatherManager.m_SunLight;
SunLight.Diffuse.r=InterSunLightColor.r/255.0f;
SunLight.Diffuse.g=InterSunLightColor.g/255.0f;
SunLight.Diffuse.b=InterSunLightColor.b/255.0f;
pd3dDevice->SetLight(0,&SunLight);
pd3dDevice->LightEnable(0,TRUE);
}
}
else
{
LightList[cLight].Attenuation1=0.0f;
pd3dDevice->SetLight(cLight,&LightList[cLight]);
pd3dDevice->LightEnable(cLight,TRUE);
}
}
*/
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
//m_CharacterList[cChar]->GetPosition(vecCharPos.x,vecCharPos.y,vecCharPos.x);
//m_pHeightField->m_
/*
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
pd3dDevice->LightEnable(0,TRUE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
*/
}
void CCharacterLightShadowManager::InHouseShadowRender(LPDIRECT3DDEVICE8 pd3dDevice)
{
//if(MAXCHRSHADOW==0)
return;
/*
pd3dDevice->EndScene();
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG2);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP );
matrix matTexScale;
matTexScale.MakeIdent();
matTexScale._11=0.5f;
matTexScale._22=-0.5f;
matTexScale._33=0.0f;
matTexScale._41=0.5f;
matTexScale._42=0.5f;
matTexScale._43=1.0f;
matTexScale._44=1.0f;
matrix matView,matOldProj,matInv,matTex;
pd3dDevice->GetTransform(D3DTS_VIEW,matView);
pd3dDevice->GetTransform(D3DTS_PROJECTION,matOldProj);
matInv.Inverse(matView);
matrix matAdjLightProj,matLightProj;
matAdjLightProj.MakeAdjustedProjectionMatrix(3.14159f/8.0f,1.0f,1.0f,500.0f,0.5f,-0.5f,(float)SHADOWSIZE,(float)SHADOWSIZE);
matLightProj.MakeAdjustedProjectionMatrix(3.14159f/8.0f, 1.0f, 1.0f, 500.0f,0.0f, 0.0f,(float)SHADOWSIZE,(float)SHADOWSIZE);
matrix matShadowProj;
//matShadowProj.MakeProjection(3.14159f/4.0f,1.0f,10.0f,10000.0f);
matShadowProj.MakeNoProjection(3.14159f/3.0f,(float)SHADOWSIZE,(float)SHADOWSIZE,10.0f,500.f);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_TEXCOORDINDEX,D3DTSS_TCI_CAMERASPACEPOSITION );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_PROJECTED | D3DTTFF_COUNT3 );
pd3dDevice->LightEnable(0,FALSE);
pd3dDevice->LightEnable(1,FALSE);
pd3dDevice->LightEnable(2,FALSE);
pd3dDevice->LightEnable(3,FALSE);
pd3dDevice->LightEnable(4,FALSE);
pd3dDevice->LightEnable(5,FALSE);
pd3dDevice->LightEnable(6,FALSE);
pd3dDevice->LightEnable(7,FALSE);
pd3dDevice->LightEnable(8,FALSE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,0xffcccccc);
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
for(int cChar=0;cChar<m_CharacterList.num;cChar++)
{
List<vector3> *CharPoly=new List<vector3>[MAXCHRSHADOW];
List<vector3> vecLightPosList;
vector3 vecChrPos;
m_CharacterList[cChar].m_pChrmodel->GetPosition(vecChrPos.x,vecChrPos.y,vecChrPos.z);
m_pHeightField->GetInHouseShadowPoly(vecChrPos,CharPoly,vecLightPosList);
for(int cShadow=0;cShadow<MAXCHRSHADOW;cShadow++)
{
if(CharPoly[cShadow].num<=0)
break;
m_pShadowTexture.Begin(pd3dDevice);
pd3dDevice->Clear(0, NULL, D3DCLEAR_ZBUFFER|D3DCLEAR_TARGET,0xffffffff, 1.0f, 0);
pd3dDevice->BeginScene();
matrix matCharCamera;
matCharCamera.CameraLookAt(
vecLightPosList[cShadow],
vector3(0.0f,80.0f,0.0f)+vecChrPos,
vector3(0.0f,1.0f,0.0f));
pd3dDevice->SetTransform(D3DTS_VIEW,matCharCamera);
pd3dDevice->SetTransform(D3DTS_PROJECTION,matShadowProj);
//m_pd3dDevice->SetTransform(D3DTS_PROJECTION,matAdjLightProj);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
m_CharacterList[cChar].m_pChrmodel->DrawShadow(pd3dDevice);
pd3dDevice->EndScene();
m_pShadowTexture.End(pd3dDevice);
pd3dDevice->BeginScene();
TTVertex *pCharVertex=new TTVertex[CharPoly[cShadow].num];
WORD *pCharIndices=new WORD[CharPoly[cShadow].num];
for(int cIndices=0;cIndices<CharPoly[cShadow].num;cIndices++)
{
pCharVertex[cIndices].v=CharPoly[cShadow][cIndices];
pCharVertex[cIndices].diff.c=0xffff0000;
pCharIndices[cIndices]=cIndices;
pCharVertex[cIndices].v.y+=3.0f;
}
pd3dDevice->SetTransform(D3DTS_VIEW,CSceneManager::m_ViewCamera->GetMatView());
matrix mat,mat2;
mat=matShadowProj*matTexScale;
mat2=matCharCamera*mat;
matTex=matInv*mat2;
pd3dDevice->SetTransform(D3DTS_PROJECTION,matOldProj);
pd3dDevice->SetTransform(D3DTS_TEXTURE0,matTex);
pd3dDevice->SetTexture(0,m_pShadowTexture.GetTexture());
pd3dDevice->SetVertexShader(TTVERTEXFVF);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_TEXTURE);
//CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_ZERO);
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_SRCCOLOR);
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,TRUE);
pd3dDevice->DrawIndexedPrimitiveUP(D3DPT_TRIANGLELIST,0,CharPoly[cShadow].num,CharPoly[cShadow].num/3,pCharIndices,
D3DFMT_INDEX16,pCharVertex,sizeof(TTVertex));
pd3dDevice->EndScene();
delete [] pCharVertex;
delete [] pCharIndices;
}
delete [] CharPoly;
}
pd3dDevice->SetTransform(D3DTS_PROJECTION,matOldProj);
pd3dDevice->SetTransform(D3DTS_VIEW,CSceneManager::m_ViewCamera->GetMatView());
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0 );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_DISABLE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP );
pd3dDevice->BeginScene();
//List< List<PolyNode> >
*/
}
float CCharacterLightShadowManager::GetCollisionChrCamera(vector3 vecStart,vector3 vecEnd)
{
List<vector3> PolyList;
m_pHeightField->GetLineIntersectPoly(vecStart,vecEnd,PolyList);
float fCollisionLens=CSceneManager::GetCameraInter();
float fLens;
vector3 vecPoly[3];
if(PolyList.num>0)
{
for(int cIndices=0;cIndices<PolyList.num/3;cIndices++)
{
vecPoly[0]=PolyList[cIndices*3+0];
vecPoly[1]=PolyList[cIndices*3+1];
vecPoly[2]=PolyList[cIndices*3+2];
if(CIntersection::PolygonRay(vecStart,vecEnd,vecPoly,fLens) && fCollisionLens > fLens && fLens > 0.0f)
{
fCollisionLens=fLens;
}
}
}
return fCollisionLens;
}
void CCharacterLightShadowManager::CameraTest(LPDIRECT3DDEVICE8 pd3dDevice)
{
vector3 vecStart,vecEnd;
float fChrInter=-350.0f;
vector3 vecChrPos;
m_CharacterList[0].m_pChrmodel->GetPosition(vecChrPos.x,vecChrPos.y,vecChrPos.z);
vecChrPos.y+=150.0f;
vector3 vecCameraPos=CSceneManager::m_ViewCamera->m_vecCameraPosition;
vecCameraPos=vecChrPos+vecCameraPos*fChrInter;
//matrix matView,matTrans;
//matView.CameraLookAt(vecCameraPos,vecChrPos,vector3(0.0f,1.0f,0.0f));
//matTrans.Inverse(matView);
vecStart=vecChrPos;
vecEnd=vecCameraPos;
matrix matWorld;
matWorld.MakeIdent();
List<vector3> PolyList;
m_pHeightField->GetLineIntersectPoly(vecStart,vecEnd,PolyList);
if(PolyList.num>0)
{
pd3dDevice->SetTexture(0,NULL);
pd3dDevice->SetTexture(1,NULL);
pd3dDevice->SetTransform(D3DTS_WORLD,matWorld);
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG2);
TTVertex *pCharVertex=new TTVertex[PolyList.num];
WORD *pCharIndices=new WORD[PolyList.num];
for(int cIndices=0;cIndices<PolyList.num;cIndices++)
{
pCharVertex[cIndices].v=PolyList[cIndices];
pCharVertex[cIndices].diff.c=0xffff0000;
pCharIndices[cIndices]=cIndices;
pCharVertex[cIndices].v.y+=2.0f;
}
pd3dDevice->SetVertexShader(TTVERTEXFVF);
pd3dDevice->DrawIndexedPrimitiveUP(D3DPT_TRIANGLELIST,0,PolyList.num,PolyList.num/3,pCharIndices,
D3DFMT_INDEX16,pCharVertex,sizeof(TTVertex));
delete [] pCharVertex;
delete [] pCharIndices;
}
}
void CCharacterLightShadowManager::ActionProcess()
{
if(m_CharacterList.num==0)
return;
CZ3DManagedObject::Process();
bool bUpdate=true;
vector3 vecChrPos;
for(int cChr=0;cChr<m_CharacterList.num;cChr++)
{
if(m_CharacterList[cChr].m_pChrmodel->IsActionFinished(1))
{
m_CharacterList[cChr].m_bFirstAccelate=false;
}
if(m_CharacterList[cChr].m_CollisionType==CT_NONE || m_CharacterList[cChr].m_CollisionType==CT_SIDE)
{
m_CharacterList[cChr].m_fFallSpeed=m_CharacterList[cChr].m_fFallSpeed+98.0f/130.0f;
if(m_CharacterList[cChr].m_fFallSpeed>80.0f)
{
m_CharacterList[cChr].m_fFallSpeed=80.0f;
}
}
else
{
if(m_CharacterList[cChr].m_fFallSpeed>0.0f)
m_CharacterList[cChr].m_fFallSpeed=0.0f;
if(m_CharacterList[cChr].m_fFallSpeed<0.0f)
{
m_CharacterList[cChr].m_fFallSpeed=m_CharacterList[cChr].m_fFallSpeed+98.0f/130.0f;
}
}
if(m_CharacterList[cChr].m_bGravityAble==false)
{
m_CharacterList[cChr].m_fFallSpeed=0.0f;
}
if(m_CharacterList[cChr].m_fAccelate < 0.0f)
{
vector3 vecAdder=m_CharacterList[cChr].m_vecZeroVelocity;
vecAdder.Normalize();
m_CharacterList[cChr].m_vecPerFrameMove+=(m_CharacterList[cChr].m_fAccelate*vecAdder);
}
if(m_CharacterList[cChr].m_pChrmodel->CheckEvent("HIT"))
{
m_CharacterList[cChr].m_dwEvent|=EVENT_HIT;
m_CharacterList[cChr].m_cAttackEvent++;
}
if(m_CharacterList[cChr].m_pChrmodel->CheckEvent("SHOT"))
{
m_CharacterList[cChr].m_dwEvent|=EVENT_SHOT;
m_CharacterList[cChr].m_cShotEvent++;
}
if(m_CharacterList[cChr].m_pChrmodel->CheckEvent("JUST"))
{
m_CharacterList[cChr].m_dwEvent|=EVENT_JUST;
m_CharacterList[cChr].m_cJustEvent++;
}
if(m_CharacterList[cChr].m_pChrmodel->CheckEvent("JUSTSTART"))
{
m_CharacterList[cChr].m_dwEvent|=EVENT_JUSTSTART;
m_CharacterList[cChr].m_cJustStartEvent++;
}
if(m_CharacterList[cChr].m_pChrmodel->CheckEvent("JUSTEND"))
{
m_CharacterList[cChr].m_dwEvent|=EVENT_JUSTEND;
m_CharacterList[cChr].m_cJustEndEvent++;
}
if(m_CharacterList[cChr].m_pChrmodel->CheckEvent( "WP_TRL_ON"))
{
CZ3DWeapon *pWp=m_CharacterList[cChr].m_pChrmodel->GetAttachmentObject("WEAPON");
if(pWp)
{
pWp->TurnOnTrail();
}
}
if(m_CharacterList[cChr].m_pChrmodel->CheckEvent( "WP_TRL_OFF"))
{
CZ3DWeapon *pWp=m_CharacterList[cChr].m_pChrmodel->GetAttachmentObject("WEAPON");
if(pWp)
{
pWp->TurnOffTrail();
}
}
Z3DTOK TokSecond;
if(m_CharacterList[cChr].m_pChrmodel->CheckEvent("SND",&TokSecond))
{
const char* strSoundFileName = g_MapEvent2SndFile.GetFileName(TokSecond);
if(strcmp(strSoundFileName,"")!=0)
{
if(strstr(strSoundFileName,"bow3.wav") != NULL) { // È°¼Ò¸® ·»´ý
try
{
char tmp_SoundFileName[256]= {0};
int tmp_selectnum = 0;
if((rand() % 10)<= 6) {
if(rand() % 2)
tmp_selectnum = 1;
else
tmp_selectnum = 2;
}
else {
if(rand() % 2)
tmp_selectnum = 3;
else
tmp_selectnum = 4;
}
sprintf(tmp_SoundFileName, "%s%s%d%s",SOUNDFILEPATH,"NBOW",tmp_selectnum,".wav");
CSoundManager &SoundManager=CSoundManager::GetInstance();
ISoundObject &sb=SoundManager.GetBuffer(tmp_SoundFileName,true);
vector3 vecChrPos;
m_CharacterList[cChr].m_pChrmodel->GetPosition(vecChrPos);
int nBuffer=sb.Play(false);
sb.SetPosition(nBuffer,vecChrPos.x,vecChrPos.y,vecChrPos.z);
sb.SetDistance(nBuffer,400.0f,2000.0f);
sb.IsPlaying(nBuffer);
}
catch(exception &e)
{
static bool bFirstShowMessage=false;
if(bFirstShowMessage==false)
{
MessageBox(NULL,e.what(),0,0);
bFirstShowMessage=true;
}
}
}
else {
if(strstr(strSoundFileName,"yangfoot"))
{
m_CharacterList[cChr].m_dwEvent|=EVENT_WALK;
m_CharacterList[cChr].m_cWalkEvent++;
}
try
{
CSoundManager &SoundManager=CSoundManager::GetInstance();
ISoundObject &sb=SoundManager.GetBuffer(strSoundFileName,true);
vector3 vecChrPos;
m_CharacterList[cChr].m_pChrmodel->GetPosition(vecChrPos);
int nBuffer=sb.Play(false);
sb.SetPosition(nBuffer,vecChrPos.x,vecChrPos.y,vecChrPos.z);
sb.SetDistance(nBuffer,400.0f,2000.0f);
sb.IsPlaying(nBuffer);
}
catch(exception &e)
{
static bool bFirstShowMessage=false;
if(bFirstShowMessage==false)
{
MessageBox(NULL,e.what(),0,0);
bFirstShowMessage=true;
}
}
}
}
}
if(m_CharacterList[cChr].m_pChrmodel->CheckEvent("JUMP"))
{
m_CharacterList[cChr].m_dwEvent|=EVENT_JUMP;
m_CharacterList[cChr].m_fFallSpeed=-12.0f;
m_CharacterList[cChr].m_cJumpEvent++;
}
if(m_CharacterList[cChr].m_pChrmodel->CheckEvent("CANCEL"))
{
m_CharacterList[cChr].m_dwEvent|=EVENT_CANCEL;
m_CharacterList[cChr].m_cCancelEvent++;
}
if(m_CharacterList[cChr].m_pChrmodel->CheckEvent("TAP_JUMP"))
{
m_CharacterList[cChr].m_fFallSpeed=-6.0f;
}
if(m_CharacterList[cChr].m_RandomPositionTimer>0)
{
vecChrPos=m_CharacterList[cChr].m_vecRealPosition;
vecChrPos+=m_CharacterList[cChr].m_vecPerFrameMove;
m_CharacterList[cChr].m_vecRealPosition=vecChrPos;
vector3 vecAddRand=vector3(rand()%1000-500,rand()%1000-500,rand()%1000-500);
vecAddRand.Normalize();
vecAddRand*=((m_CharacterList[cChr].m_RandomPositionTimer*m_CharacterList[cChr].m_RandomPositionTimer)/(10.0f*10.0f))*3.0f;;
vecChrPos+=vecAddRand;
vecChrPos+=m_CharacterList[cChr].m_vecRandomPositionAdder;
m_CharacterList[cChr].m_vecRandomPositionAdder.Normalize();
m_CharacterList[cChr].m_vecRandomPositionAdder*=m_CharacterList[cChr].m_RandomPositionTimer;
m_CharacterList[cChr].m_pChrmodel->SetPosition(vecChrPos);
if(--m_CharacterList[cChr].m_RandomPositionTimer==0)
{
m_CharacterList[cChr].m_pChrmodel->SetPosition(m_CharacterList[cChr].m_vecRealPosition);
}
}
else
{
m_CharacterList[cChr].m_RandomPositionTimer=0;
m_CharacterList[cChr].m_pChrmodel->GetPosition(vecChrPos);
vecChrPos+=(m_CharacterList[cChr].m_vecPerFrameMove);
m_CharacterList[cChr].m_vecRealPosition=vecChrPos;
m_CharacterList[cChr].m_pChrmodel->SetPosition(vecChrPos);
}
if(m_CharacterList[cChr].m_DelayTimer>0)
{
m_CharacterList[cChr].m_DelayTimer--;
}
else
{
//m_CharacterList[cChr].m_pChrmodel->Pause(false);
m_CharacterList[cChr].m_DelayTimer=0;
}
//m_CharacterList[cChr].m_pChrmodel->GetPosition(vecChrPos.x,vecChrPos.y,vecChrPos.z);
//vecChrPos.y-=m_CharacterList[cChr].m_fFallSpeed;
//m_CharacterList[cChr].m_pChrmodel->SetPosition(vecChrPos.x,vecChrPos.y,vecChrPos.z);
switch(m_CharacterList[cChr].m_CollisionDetectType)
{
case CDT_NONE:
{
}
break;
case CDT_FULL:
{
vector3 vecCharPos;
CollisionType CT;
vector3 vecOldPos;
m_CharacterList[cChr].m_pChrmodel->GetPosition(vecOldPos.x,vecOldPos.y,vecOldPos.z);
vector3 vecBeforePos = m_CharacterList[cChr].m_pChrmodel->GetPrevPosition();
vecBeforePos.y += 85.0f;
vecOldPos.y+=85.0f;
vecCharPos=vecOldPos;
vecOldPos.y-=((m_CharacterList[cChr].m_fFallSpeed > 40.0f) ? 40.0f : m_CharacterList[cChr].m_fFallSpeed);
vector3 vecDir=vecOldPos-vecCharPos;
if(CSceneManager::m_RBspSceneManager.m_pCurrentBspScene == NULL)
{
vecCharPos=CSceneManager::m_CollisionDetection.GetPosition(vecOldPos,vecDir,vecBeforePos,CT,true);
}
else
{
////////////
D3DXVECTOR3 vecBefore = D3DXVECTOR3(vecBeforePos.x,vecBeforePos.y,vecBeforePos.z);
D3DXVECTOR3 vecNew = D3DXVECTOR3(vecOldPos.x,vecOldPos.y,vecOldPos.z);
D3DXVECTOR3 vecInter;
///
D3DXVECTOR3 vecPos = vecBefore;
D3DXMATRIX matTmp;
D3DXMATRIX matInv;
D3DXMatrixIdentity(&matTmp);
matTmp._41 = CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.x;
matTmp._42 = CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.y;
matTmp._43 = CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.z;
D3DXMatrixInverse(&matInv,NULL,&matTmp);
D3DXMatrixIdentity(&matTmp);
matTmp._41 = vecPos.x;
matTmp._42 = vecPos.y;
matTmp._43 = vecPos.z;
D3DXMatrixMultiply(&matTmp,&matTmp,&matInv);
vecPos.x = matTmp._41;
vecPos.y = matTmp._42;
vecPos.z = matTmp._43;
vecBefore = vecPos;
///
vecPos = vecNew;
D3DXMatrixIdentity(&matTmp);
matTmp._41 = CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.x;
matTmp._42 = CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.y;
matTmp._43 = CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.z;
D3DXMatrixInverse(&matInv,NULL,&matTmp);
D3DXMatrixIdentity(&matTmp);
matTmp._41 = vecPos.x;
matTmp._42 = vecPos.y;
matTmp._43 = vecPos.z;
D3DXMatrixMultiply(&matTmp,&matTmp,&matInv);
vecPos.x = matTmp._41;
vecPos.y = matTmp._42;
vecPos.z = matTmp._43;
vecNew = vecPos;
////
vecInter = CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->CollisionCheck(vecBefore,vecNew,85.0f,CT);
vecPos = vecInter;
D3DXMatrixIdentity(&matTmp);
matTmp._41 = CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.x;
matTmp._42 = CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.y;
matTmp._43 = CSceneManager::m_RBspSceneManager.m_pCurrentBspScene->m_vecZeroPos.z;
matInv = matTmp;
D3DXMatrixIdentity(&matTmp);
matTmp._41 = vecPos.x;
matTmp._42 = vecPos.y;
matTmp._43 = vecPos.z;
D3DXMatrixMultiply(&matTmp,&matTmp,&matInv);
vecPos.x = matTmp._41;
vecPos.y = matTmp._42;
vecPos.z = matTmp._43;
vecInter = vecPos;
vecCharPos = vector3(vecInter.x,vecInter.y,vecInter.z);
////////////
}
m_CharacterList[cChr].m_pChrmodel->SetPosition(vecCharPos.x,vecCharPos.y-85.0f,vecCharPos.z);
m_CharacterList[cChr].m_CollisionType=CT;
}
break;
case CDT_ONLYTERRAIN:
{
/*
vector3 vecCharPos;
CollisionType CT;
vector3 vecOldPos;
m_CharacterList[cChr].m_pChrmodel->GetPosition(vecOldPos.x,vecOldPos.y,vecOldPos.z);
vecOldPos.y+=85.0f;
vecCharPos=vecOldPos;
vecOldPos.y-=m_CharacterList[cChr].m_fFallSpeed;
vector3 vecDir=vecOldPos-vecCharPos;
vecCharPos=CSceneManager::m_CollisionDetection.GetPosition(vecOldPos,vecDir,CT,false);
m_CharacterList[cChr].m_pChrmodel->SetPosition(vecCharPos.x,vecCharPos.y-85.0f,vecCharPos.z);
m_CharacterList[cChr].m_CollisionType=CT;
*/
}
break;
case CDT_FIRSTBOTTOM:
{
if( m_CharacterList[cChr].m_CollisionType==CT_SIDE ||
m_CharacterList[cChr].m_CollisionType==CT_CHRSIDE ||
m_CharacterList[cChr].m_CollisionType==CT_NONE ||
m_CharacterList[cChr].m_CollisionType==CT_WATER )
{
vector3 vecCharPos;
CollisionType CT;
vector3 vecOldPos;
m_CharacterList[cChr].m_pChrmodel->GetPosition(vecOldPos.x,vecOldPos.y,vecOldPos.z);
vector3 vecBeforePos = m_CharacterList[cChr].m_pChrmodel->GetPrevPosition();
vecBeforePos.y += 85.0f;
vecOldPos.y+=85.0f;
vecCharPos=vecOldPos;
vecOldPos.y-=m_CharacterList[cChr].m_fFallSpeed;
vector3 vecDir=vecOldPos-vecCharPos;
vecCharPos=CSceneManager::m_CollisionDetection.GetPosition(vecOldPos,vecDir,vecBeforePos,CT,false);
m_CharacterList[cChr].m_pChrmodel->SetPosition(vecCharPos.x,vecCharPos.y-85.0f,vecCharPos.z);
m_CharacterList[cChr].m_CollisionType=CT;
}
}
break;
}
/*
if(cChr==0)
{
}
else
{
vector3 vecCharPos;
CollisionType CT;
vector3 vecOldPos;
m_CharacterList[cChr].m_pChrmodel->GetPosition(vecOldPos.x,vecOldPos.y,vecOldPos.z);
vecOldPos.y+=85.0f;
vecCharPos=vecOldPos;
vecOldPos.y-=m_CharacterList[cChr].m_fFallSpeed;
vector3 vecDir=vecOldPos-vecCharPos;
vecCharPos=CSceneManager::m_CollisionDetection.GetPosition(vecOldPos,vecDir,CT,true);
m_CharacterList[cChr].m_pChrmodel->SetPosition(vecCharPos.x,vecCharPos.y-85.0f,vecCharPos.z);
m_CharacterList[cChr].m_CollisionType=CT;
}
*/
}
if(bUpdate)
CZ3DCharacterModel::Process();
CZ3DObject::Process();
UpdateLight();
}
void CCharacterLightShadowManager::DeleteCharacter(CZ3DGeneralChrModel *pDelChr)
{
for(int i=0;i<m_CharacterList.num;i++)
{
if(m_CharacterList[i].m_pChrmodel==pDelChr)
{
m_CharacterList.DelIndex(i);
delete pDelChr;
/*
m_CharacterList.Remove(pDelChr);
m_CharacterCollisionType.DelIndex(i);
m_CharacterScreenPositionList.DelIndex(i);
//delete m_CharacterSoundHelperList[i];
//m_CharacterSoundHelperList.DelIndex(i);
m_CharacterAttackEventList.DelIndex(i);
m_CharacterTrailOnEventList.DelIndex(i);
m_CharacterTrailOffEventList.DelIndex(i);
m_CharacterDelayTimer.DelIndex(i);
m_CharacterPerFrameMove.DelIndex(i);
m_CharacterRealPosition.DelIndex(i);
m_CharacterRandomPostionTimer.DelIndex(i);
m_CharacterRandomPostionAdder.DelIndex(i);
m_CharacterLightList.DelIndex(i);
delete pDelChr;
*/
return;
}
}
}
CollisionType CCharacterLightShadowManager::CharacterCollisionType(CZ3DGeneralChrModel *pFindCharacter)
{
for(int i=0;i<m_CharacterList.num;i++)
{
//if(m_CharacterList[i]==pFindCharacter)
if(m_CharacterList[i].m_pChrmodel==pFindCharacter)
{
return m_CharacterList[i].m_CollisionType;
//return m_CharacterCollisionType[i];
}
}
return CT_BOTTOM;
}
void CCharacterLightShadowManager::HeightFiledOnChrFixPos()
{
/*
m_CharacterList[cChar]->GetPosition(vecOldPos.x,vecOldPos.y,vecOldPos.z);
vecCharPos=CSceneManager::m_CollisionDetection.GetPosition(OldPosList[cChar],vecDir,CT);
*/
vector3 vecChrPos;
float fHeight;
for(int i=0;i<m_CharacterList.num;i++)
{
//if(m_CharacterCollisionType[i]==CT_TERRAIN)
if(m_CharacterList[i].m_CollisionType==CT_TERRAIN)
{
m_CharacterList[i].m_pChrmodel->GetPosition(vecChrPos.x,vecChrPos.y,vecChrPos.z);
fHeight=m_pHeightField->GetHeight(vecChrPos);
m_CharacterList[i].m_pChrmodel->SetPosition(vecChrPos.x,fHeight,vecChrPos.z);
}
}
}
void CCharacterLightShadowManager::CharacterSoundPlay(CZ3DGeneralChrModel *pChrmodel, char *strSoundFile)
{
for(int cChr=0;cChr<m_CharacterList.num;cChr++)
{
if(m_CharacterList[cChr].m_pChrmodel==pChrmodel)
{
// m_CharacterSoundHelperList[cChr]->Play(strSoundFile);
return;
}
}
}
int CCharacterLightShadowManager::GetCharacterEvent(CZ3DGeneralChrModel *pChrmodel,DWORD Event)
{
for(int cChr=0;cChr<m_CharacterList.num;cChr++)
{
if(m_CharacterList[cChr].m_pChrmodel==pChrmodel)
{
if(Event & m_CharacterList[cChr].m_dwEvent)
{
int nResult = 0;
switch(Event)
{
case EVENT_HIT:
nResult = m_CharacterList[cChr].m_cAttackEvent;
m_CharacterList[cChr].m_cAttackEvent = 0;
break;
case EVENT_JUMP:
nResult = m_CharacterList[cChr].m_cJumpEvent;
m_CharacterList[cChr].m_cJumpEvent = 0;
break;
case EVENT_WALK:
nResult = m_CharacterList[cChr].m_cWalkEvent;
m_CharacterList[cChr].m_cWalkEvent = 0;
break;
case EVENT_CANCEL:
nResult = m_CharacterList[cChr].m_cCancelEvent;
m_CharacterList[cChr].m_cCancelEvent = 0;
break;
case EVENT_SHOT:
nResult = m_CharacterList[cChr].m_cShotEvent;
m_CharacterList[cChr].m_cShotEvent = 0;
break;
case EVENT_JUST:
nResult = m_CharacterList[cChr].m_cJustEvent;
m_CharacterList[cChr].m_cJustEvent = 0;
break;
case EVENT_JUSTSTART:
nResult = m_CharacterList[cChr].m_cJustStartEvent;
m_CharacterList[cChr].m_cJustStartEvent = 0;
break;
case EVENT_JUSTEND:
nResult = m_CharacterList[cChr].m_cJustEndEvent;
m_CharacterList[cChr].m_cJustEndEvent = 0;
break;
}
m_CharacterList[cChr].m_dwEvent = m_CharacterList[cChr].m_dwEvent & (0xFFFFFFFF - Event);
return nResult;
}
return false;
/*
if(z3dEvent==Z3D_ES_HIT)
{
if(m_CharacterAttackEventList[cChr])
{
m_CharacterAttackEventList[cChr]=false;
return true;
}
else
return false;
}
if(z3dEvent==Z3D_ES_WEAPON_TRAIL_ON)
{
if(m_CharacterTrailOnEventList[cChr])
{
m_CharacterTrailOnEventList[cChr]=false;
return true;
}
else
return false;
}
if(z3dEvent==Z3D_ES_WEAPON_TRAIL_OFF)
{
if(m_CharacterTrailOffEventList[cChr])
{
m_CharacterTrailOffEventList[cChr]=false;
return true;
}
else
return false;
}
*/
}
}
return false;
}
void CCharacterLightShadowManager::AddDelayTimer(CZ3DGeneralChrModel *pChr, int nDelay)
{
for(int i=0;i<m_CharacterList.num;i++)
{
//if(m_CharacterList[i]==pChr)
if(m_CharacterList[i].m_pChrmodel==pChr)
{
//m_CharacterDelayTimer[i]+=nDelay;
m_CharacterList[i].m_DelayTimer+=nDelay;
return;
}
}
}
void CCharacterLightShadowManager::CreateEditor()
{
//sprintf(tmp, "%sSound\\",CHARACTERDATAPATH);
//CZ3DSound::Init(BaseGraphicsLayer::GethWnd(), Z3DSOUND_3D,"c:/MP-Project/Sound/");
}
void CCharacterLightShadowManager::AddChrLight(CZ3DGeneralChrModel *pChrmodel,vector3 vecPos,DWORD dwColor,float fLens,DWORD dwTime)
{
static DWORD m_nTotalLight=0;
D3DLIGHT8 Light;
CChrLightNode AddNode;
ZeroMemory(&Light,sizeof(D3DLIGHT8));
Light.Type=D3DLIGHT_POINT;
Light.Attenuation0=0.5f;
Light.Attenuation1=0.0f;
color Color;
Color.c=dwColor;
Light.Diffuse.r=Color.r/255.0f;
Light.Diffuse.g=Color.g/255.0f;
Light.Diffuse.b=Color.b/255.0f;
Light.Position.x=Light.Direction.x=vecPos.x;
Light.Position.y=Light.Direction.y=vecPos.y;
Light.Position.z=Light.Direction.z=vecPos.z;
Light.Range=fLens;
AddNode.m_Light=Light;
AddNode.m_dwTimer=dwTime;
for(int i=0;i<m_CharacterList.num;i++)
{
//if(m_CharacterList[i]==pChrmodel)
if(m_CharacterList[i].m_pChrmodel==pChrmodel)
{
//m_CharacterLightList[i]=AddNode;
memcpy( &m_CharacterList[i].m_Light,&AddNode,sizeof(CChrLightNode));
}
}
}
//DEL D3DLIGHT8 CCharacterLightShadowManager::GetChrLight(DWORD dwLightID)
//DEL {
//DEL /*
//DEL for(int i=0;i<m_CharacterLightList.num;i++)
//DEL {
//DEL if(m_CharacterLightList[i].m_dwLightID==dwLightID)
//DEL {
//DEL return m_CharacterLightList[i].m_Light;
//DEL }
//DEL }
//DEL */
//DEL }
//DEL void CCharacterLightShadowManager::SetChrLight(DWORD dwLightID, D3DLIGHT8 Light)
//DEL {
//DEL for(int i=0;i<m_CharacterLightList.num;i++)
//DEL {
//DEL if(m_CharacterLightList[i].m_dwLightID==dwLightID)
//DEL {
//DEL m_CharacterLightList[i].m_Light=Light;
//DEL }
//DEL }
//DEL }
void CCharacterLightShadowManager::UpdateLight()
{
/*
for(int i=0;i<m_CharacterLightList.num;i++)
{
if(--m_CharacterLightList[i].m_dwTimer<=0)
{
m_CharacterLightList[i].m_dwTimer=0;
}
}
*/
for(int i=0;i<m_CharacterList.num;i++)
{
if(--m_CharacterList[i].m_Light.m_dwTimer<=0)
{
m_CharacterList[i].m_Light.m_dwTimer=0;
}
}
/*
for(i=0;i<DelList.num;i++)
{
DelChrLight(DelList[i]);
}
*/
}
void CCharacterLightShadowManager::DelChrLight(DWORD dwLightID)
{
/*
for(int i=0;i<m_CharacterLightList.num;i++)
{
if(m_CharacterLightList[i].m_dwLightID==dwLightID)
{
m_CharacterLightList.DelIndex(i);
return;
}
}
*/
}
void CCharacterLightShadowManager::CharacterMovementVector(CZ3DGeneralChrModel *pChrmodel, vector3 vecChrMove,float fAccelate)
{
for(int i=0;i<m_CharacterList.num;i++)
{
//if(m_CharacterList[i]==pChrmodel)
if(m_CharacterList[i].m_pChrmodel==pChrmodel)
{
//m_CharacterPerFrameMove[i]=vecChrMove;
/*
if(fabsf(fAccelate) < 1.0f)
{
m_CharacterList[i].m_fAccelate=fAccelate;
m_CharacterList[i].m_vecZeroVelocity=vecChrMove;
m_CharacterList[i].m_vecPerFrameMove=vecChrMove;
}
if( fabsf(m_CharacterList[i].m_fAccelate - fAccelate) > 0.9f)
{
m_CharacterList[i].m_fAccelate=fAccelate;
m_CharacterList[i].m_vecZeroVelocity=vecChrMove;
m_CharacterList[i].m_vecPerFrameMove=vecChrMove;
}
*/
if(fabsf(fAccelate)<=0.01f)
{
m_CharacterList[i].m_bFirstAccelate=false;
m_CharacterList[i].m_fAccelate=fAccelate;
m_CharacterList[i].m_vecZeroVelocity=vecChrMove;
m_CharacterList[i].m_vecPerFrameMove=vecChrMove;
}
else
{
if(m_CharacterList[i].m_bFirstAccelate==false)
{
m_CharacterList[i].m_fAccelate=fAccelate;
m_CharacterList[i].m_vecZeroVelocity=vecChrMove;
m_CharacterList[i].m_vecPerFrameMove=vecChrMove;
m_CharacterList[i].m_bFirstAccelate=true;
}
}
break;
}
}
}
vector3 CCharacterLightShadowManager::GetCharacterMovementVector(CZ3DGeneralChrModel *pChrmodel)
{
for(int i=0;i<m_CharacterList.num;i++)
{
//if(m_CharacterList[i]==pChrmodel)
if(m_CharacterList[i].m_pChrmodel==pChrmodel)
{
//return m_CharacterPerFrameMove[i];
return m_CharacterList[i].m_vecPerFrameMove;
}
}
return vector3(0.0f,0.0f,0.0f);
}
void CCharacterLightShadowManager::CharacterRandomPos(CZ3DGeneralChrModel *pChrmodel,int nTimer, vector3 vecRand)
{
for(int i=0;i<m_CharacterList.num;i++)
{
//if(m_CharacterList[i]==pChrmodel)
if(m_CharacterList[i].m_pChrmodel==pChrmodel)
{
//m_CharacterRandomPostionTimer[i]=nTimer;
//m_CharacterRandomPostionAdder[i]=vecRand;
m_CharacterList[i].m_RandomPositionTimer=nTimer;
m_CharacterList[i].m_vecRandomPositionAdder=vecRand;
break;
}
}
}
void CCharacterLightShadowManager::RenderGlare(LPDIRECT3DDEVICE8 pd3dDevice)
{
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
//pd3dDevice->SetVertexShader(m_dwCharacterVertexShader);
//pd3dDevice->SetPixelShader(m_dwCharacterPixelShader);
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,0xffffffff);
pd3dDevice->LightEnable(0,TRUE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
//pd3dDevice->SetTexture(0,NULL);
//pd3dDevice->SetTexture(2,NULL);
matrix matWorld;
matWorld.MakeIdent();
pd3dDevice->SetTransform(D3DTS_WORLD,matWorld);
CSceneNode CharScene;
CharScene.m_fRad=300.0f;
vector3 vecCharPos;
vector3 vecCharScreenPos;
float fW;
for(int cChar=0;cChar<m_CharacterList.num;cChar++)
{
if(m_CharacterList[cChar].m_pChrmodel->IsDisabled()==false)
{
m_CharacterList[cChar].m_pChrmodel->GetPosition(vecCharPos.x,vecCharPos.y,vecCharPos.z);
CharScene.m_AccumulateTM.Translation(vecCharPos);
if(CharScene.isCulling())
{
m_CharacterList[cChar].m_pChrmodel->SetCull(false);
BaseGraphicsLayer::TransformVector(vecCharPos,vecCharScreenPos,fW);
//m_CharacterScreenPositionList[cChar].x=(int)vecCharScreenPos.x;
//m_CharacterScreenPositionList[cChar].y=(int)vecCharScreenPos.y;
m_CharacterList[cChar].m_ptScreenPosition.x=(int)vecCharScreenPos.x;
m_CharacterList[cChar].m_ptScreenPosition.y=(int)vecCharScreenPos.y;
//BaseGraphicsLayer::TransformVector(m_InstanceObjectList[cObject].m_vecPosition,vecResult,w);
}
else
{
m_CharacterList[cChar].m_pChrmodel->SetCull(true);
m_CharacterList[cChar].m_ptScreenPosition.x=-1;
m_CharacterList[cChar].m_ptScreenPosition.y=-1;
//m_CharacterScreenPositionList[cChar].x=-1;
//m_CharacterScreenPositionList[cChar].y=-1;
}
}
}
/*
if(m_CharacterList.num>0)
{
CharacterLightSetting(0,pd3dDevice);
}
*/
//CZ3DRenderable::Process();
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,TRUE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHAREF,0x0);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP,D3DTOP_MODULATE);
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_ALPHAOP,D3DTOP_DISABLE);
/*
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_MAGFILTER,D3DTEXF_LINEAR);
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_MINFILTER,D3DTEXF_LINEAR);
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_MIPFILTER,D3DTEXF_LINEAR);
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_MAGFILTER,D3DTEXF_LINEAR);
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_MINFILTER,D3DTEXF_LINEAR);
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_MIPFILTER,D3DTEXF_LINEAR);
CSceneStateMgr::_SetD3DTextureStageState(2,D3DTSS_MAGFILTER,D3DTEXF_LINEAR);
CSceneStateMgr::_SetD3DTextureStageState(2,D3DTSS_MINFILTER,D3DTEXF_LINEAR);
CSceneStateMgr::_SetD3DTextureStageState(2,D3DTSS_MIPFILTER,D3DTEXF_LINEAR);
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_MAGFILTER,D3DTEXF_LINEAR);
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_MINFILTER,D3DTEXF_LINEAR);
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_MIPFILTER,D3DTEXF_LINEAR);
*/
//CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHAREF,0xee);
char *pShadowCollision;
vector3 vecChrPos;
float fInterVal=SECTORSIZE/256.0f;
int px,pz;
float fPosx,fPosz;
D3DXVECTOR4 LightDir=D3DXVECTOR4( -1.0f, -1.0f, -1.0f, 0.0f );
D3DXVec4Normalize(&LightDir,&LightDir);
pd3dDevice->SetVertexShaderConstant(12, &LightDir, 1 ); // light direction
vector3 vecSunLightDir( CSceneManager::m_WeatherManager.m_SunLight.Direction.x,
CSceneManager::m_WeatherManager.m_SunLight.Direction.y,
CSceneManager::m_WeatherManager.m_SunLight.Direction.z);
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_MIPFILTER,D3DTEXF_POINT);
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_MIPFILTER,D3DTEXF_POINT);
for(cChar=0;cChar<m_CharacterList.num;cChar++)
{
m_CharacterList[cChar].m_pChrmodel->GetPosition(vecChrPos.x,vecChrPos.y,vecChrPos.z);
pShadowCollision=m_pHeightField->GetHeightFieldShadowCollision(vecChrPos);
px=(int)(vecChrPos.x/SECTORSIZE);
pz=(int)(vecChrPos.z/SECTORSIZE);
fPosx=vecChrPos.x-(px*SECTORSIZE);
fPosz=vecChrPos.z-(pz*SECTORSIZE);
if(pShadowCollision)
{
fPosx/=fInterVal;
fPosz/=fInterVal;
if(pShadowCollision[(int)fPosx+((int)fPosz)*256]&0x01)
{
CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR,0xff999999);
//CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR,0xffffffff);
}
else
{
CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR,0xffffffff);
}
}
else
{
CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR,0xffffffff);
}
pd3dDevice->SetStreamSource( 0, NULL, 0 );
pd3dDevice->SetStreamSource( 1, NULL, 0 );
pd3dDevice->SetStreamSource( 2, NULL, 0 );
//if(m_CharacterLightList[cChar].m_dwTimer>0)
if(m_CharacterList[cChar].m_Light.m_dwTimer>0)
{
//pd3dDevice->SetLight(1,&m_CharacterLightList[cChar].m_Light);
pd3dDevice->SetLight(1,&m_CharacterList[cChar].m_Light.m_Light);
pd3dDevice->LightEnable(1,TRUE);
}
else
{
pd3dDevice->LightEnable(1,FALSE);
}
D3DXMATRIX matWorld,matView,matProj;
vector3 vecChrPos;
m_CharacterList[cChar].m_pChrmodel->GetPosition(vecChrPos);
D3DXMatrixTranslation(&matWorld,vecChrPos.x,vecChrPos.y,vecChrPos.z);
pd3dDevice->GetTransform(D3DTS_VIEW,&matView);
pd3dDevice->GetTransform(D3DTS_PROJECTION,&matProj);
D3DXMATRIX matTemp;
D3DXMatrixTranspose(&matTemp,&(matWorld * matView * matProj));
pd3dDevice->SetVertexShaderConstant(8, &matTemp, 4);
D3DXMatrixTranspose(&matTemp,&matWorld);
pd3dDevice->SetVertexShaderConstant(0, &matTemp, 4);
D3DXVECTOR4 tmp;
tmp.x = CSceneManager::m_ViewCamera->GetMatPosition()->GetLoc().x;
tmp.y = CSceneManager::m_ViewCamera->GetMatPosition()->GetLoc().y;
tmp.z = CSceneManager::m_ViewCamera->GetMatPosition()->GetLoc().z;
tmp.w = 0.0f;
pd3dDevice->SetVertexShaderConstant(24, tmp, 1);
D3DXVECTOR4 half(0.5f,0.5f,0.5f,0.5f);
pd3dDevice->SetVertexShaderConstant(33, &half, 1);
D3DXVECTOR4 ahalf(7.0f,7.0f,7.0f,7.0f);
pd3dDevice->SetVertexShaderConstant(34, &ahalf, 1);
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE,FALSE);
if(m_CharacterList[cChar].m_pChrmodel->IsDisabled()==false)
{
if(CRenderOption::m_CharacterSelfShadow)
{
matrix matOldView,matWorld,matProjection;
pd3dDevice->GetTransform(D3DTS_VIEW,matOldView);
pd3dDevice->GetTransform(D3DTS_PROJECTION,matProjection);
pd3dDevice->EndScene();
m_CharacterShadowmap.Begin(pd3dDevice);
pd3dDevice->Clear(0, NULL, D3DCLEAR_ZBUFFER|D3DCLEAR_TARGET,0x0, 1.0f, 0);
pd3dDevice->BeginScene();
//CSceneStateMgr::_SetD3DRenderState(D3DRS_COLORWRITEENABLE,0);
pd3dDevice->SetVertexShader(BUMPVERTEXFVF);
pd3dDevice->SetPixelShader(NULL);
vector3 vecChrPos;
m_CharacterList[cChar].m_pChrmodel->GetPosition(vecChrPos);
matWorld.Translation(vecChrPos);
matrix matCharCamera;
matCharCamera.CameraLookAt(
vecChrPos-vecSunLightDir*450.0f+vector3(0.0f,85.0f,0.0f),
vector3(0.0f,80.0f,0.0f)+vecChrPos,
vector3(0.0f,1.0f,0.0f));
matrix matShadowProj;
D3DXMatrixOrthoLH(matShadowProj,200,200,10.0f, 10000.0f);
pd3dDevice->SetTransform(D3DTS_VIEW,matCharCamera);
pd3dDevice->SetTransform(D3DTS_PROJECTION,matShadowProj);
CSceneStateMgr::_SetD3DRenderState(D3DRS_COLORWRITEENABLE,0);
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZWRITEENABLE,TRUE);
m_CharacterList[cChar].m_pChrmodel->Render();
CSceneStateMgr::_SetD3DRenderState(D3DRS_COLORWRITEENABLE,D3DCOLORWRITEENABLE_BLUE|D3DCOLORWRITEENABLE_GREEN|D3DCOLORWRITEENABLE_RED);
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZWRITEENABLE,FALSE);
pd3dDevice->EndScene();
m_CharacterShadowmap.End(pd3dDevice);
pd3dDevice->BeginScene();
pd3dDevice->SetTexture(2,m_CharacterShadowmap.GetShadowMapZTexture());
matrix matTexture,matTextureScale;
float fOffsetX=0.5f+(0.5f/(float)512);
float fOffsetY=0.5f+(0.5f/(float)512);
unsigned int range=0xffffffff >> (32-16);
float fBias=-0.001f*(float)range;
matTextureScale._11=0.5f;matTextureScale._12=0.0f;matTextureScale._13=0.0f;matTextureScale._14=0.0f;
matTextureScale._21=0.0f;matTextureScale._22=-0.5f;matTextureScale._23=0.0f;matTextureScale._24=0.0f;
matTextureScale._31=0.0f;matTextureScale._32=0.0f;matTextureScale._33=(float)range;matTextureScale._34=0.0f;
matTextureScale._41=fOffsetX;matTextureScale._42=fOffsetY;matTextureScale._43=fBias;matTextureScale._44=1.0f;
matrix matWVP;
matWVP=matWorld*matCharCamera;
matWVP=matWVP*matShadowProj;
matTexture=matWVP*matTextureScale;
matTexture.Transpose();
pd3dDevice->SetVertexShaderConstant(4,&matTexture,4);
pd3dDevice->SetTransform(D3DTS_VIEW,matOldView);
pd3dDevice->SetTransform(D3DTS_PROJECTION,matProjection);
}
pd3dDevice->SetPixelShader(m_dwCharacterSpecPixelShader);
pd3dDevice->SetVertexShader(m_dwCharacterSpecularVertexShader);
m_CharacterList[cChar].m_pChrmodel->Render();
}
}
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHAREF,0xee);
//CZ3DRenderable::SecondProcess();
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_MIPFILTER,D3DTEXF_LINEAR);
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_MIPFILTER,D3DTEXF_LINEAR);
for(int i=1;i<8;i++)
pd3dDevice->LightEnable(i,FALSE);
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_COLOROP, D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DTextureStageState(2,D3DTSS_COLOROP, D3DTOP_DISABLE);
pd3dDevice->SetTexture(1,NULL);
pd3dDevice->SetTexture(2,NULL);
pd3dDevice->SetTexture(3,NULL);
pd3dDevice->SetPixelShader(NULL);
/*
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
pd3dDevice->SetLight(0,&m_WeatherManager.m_SunLight);
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,m_WeatherManager.m_AmbientColor->c);
pd3dDevice->LightEnable(0,TRUE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
CSceneNode CharScene;
CharScene.m_fRad=300.0f;
vector3 vecCharPos;
for(int cChar=0;cChar<m_CharacterList.num;cChar++)
{
m_CharacterList[cChar]->GetPosition(vecCharPos.x,vecCharPos.y,vecCharPos.x);
CharScene.m_AccumulateTM.Translation(vecCharPos);
if(CharScene.isCulling())
m_CharacterList[cChar]->SetCull(true);
else
m_CharacterList[cChar]->SetCull(false);
if(cChar==0)
m_CharacterList[cChar]->SetCull(false);
}
CZ3DRenderable::Process();
*/
}
CollisionType CCharacterLightShadowManager::GetCharacterCollisionType(CZ3DGeneralChrModel *pChrmodel)
{
for(int i=0;i<m_CharacterList.num;i++)
{
//if(m_CharacterList[i]==pChrmodel)
if(m_CharacterList[i].m_pChrmodel==pChrmodel)
{
return m_CharacterList[i].m_CollisionType;
}
}
return CT_NONE;
}
float CCharacterLightShadowManager::GetCharacterVelocity(CZ3DGeneralChrModel *pChrmodel)
{
for(int i=0;i<m_CharacterList.num;i++)
{
if(m_CharacterList[i].m_pChrmodel==pChrmodel)
{
return m_CharacterList[i].m_fFallSpeed;
}
}
return 0.0f;
}
void CCharacterLightShadowManager::CharacterFirstAccelate(CZ3DGeneralChrModel *pChrmodel,bool bFirstAccelate)
{
for(int i=0;i<m_CharacterList.num;i++)
{
if(m_CharacterList[i].m_pChrmodel==pChrmodel)
{
m_CharacterList[i].m_bFirstAccelate=bFirstAccelate;
return;
}
}
}
void CCharacterLightShadowManager::CharacterCollisionAble(CZ3DGeneralChrModel *pChrmodel, bool bCollisionDetectionAble)
{
for(int i=0;i<m_CharacterList.num;i++)
{
if(m_CharacterList[i].m_pChrmodel==pChrmodel)
{
m_CharacterList[i].m_bCollisionDetectAble=bCollisionDetectionAble;
return;
}
}
}
void CCharacterLightShadowManager::CharacterGravityAble(CZ3DGeneralChrModel *pChrmodel, bool bGravityAble)
{
for(int i=0;i<m_CharacterList.num;i++)
{
if(m_CharacterList[i].m_pChrmodel==pChrmodel)
{
m_CharacterList[i].m_bGravityAble=bGravityAble;
return;
}
}
}
void CCharacterLightShadowManager::CharacterCollisionDetectType(CZ3DGeneralChrModel *pChrmodel, int nType)
{
for(int i=0;i<m_CharacterList.num;i++)
{
if(m_CharacterList[i].m_pChrmodel==pChrmodel)
{
m_CharacterList[i].m_CollisionDetectType=nType;
return;
}
}
}
CCharacterLightShadowManager::CCharacterDataNode CCharacterLightShadowManager::GetCharacterDataNode(CZ3DGeneralChrModel *pChrmodel)
{
for(int i=0;i<m_CharacterList.num;i++)
{
if(m_CharacterList[i].m_pChrmodel==pChrmodel)
{
return m_CharacterList[i];
}
}
}
void CCharacterLightShadowManager::SetCharacterDataNode(CCharacterDataNode SetNode)
{
for(int i=0;i<m_CharacterList.num;i++)
{
if(m_CharacterList[i].m_pChrmodel==SetNode.m_pChrmodel)
{
m_CharacterList[i]=SetNode;
return;
}
}
}
void CCharacterLightShadowManager::RenderCharacterSpecular( LPDIRECT3DDEVICE8 pd3dDevice )
{
/*
m_GlareManager.SetBlendWeight( CGlareManager::GLARE_CHARACTER, w );
m_GlareManager.SetBlendWeight( CGlareManager::GLARE_FULLSCENE, w );
*/
CSceneManager::m_bEnv = false;
CSceneManager::m_GlareManager->SetBlendWeight(CGlareManager::GLARE_CHARACTER,D3DXVECTOR4(0.4f,0.4f,0.4f,1.0f));
CSceneManager::m_GlareManager->SetColor( CGlareManager::GLARE_CHARACTER, D3DCOLOR_ARGB(100,
CSceneManager::m_WeatherManager.m_InterCharacterLight.r,
CSceneManager::m_WeatherManager.m_InterCharacterLight.g,
CSceneManager::m_WeatherManager.m_InterCharacterLight.b) );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_COLOROP, D3DTOP_DISABLE);
/*
for(int i=0;i<8;i++)
pd3dDevice->LightEnable(i,FALSE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
*/
pd3dDevice->LightEnable(0,TRUE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
D3DLIGHT8 light;
ZeroMemory( &light, sizeof(D3DLIGHT8) );
light.Type = D3DLIGHT_DIRECTIONAL;
light.Diffuse.r = CSceneManager::m_WeatherManager.m_InterCharacterLight.r/255.0f;
light.Diffuse.g = CSceneManager::m_WeatherManager.m_InterCharacterLight.g/255.0f;
light.Diffuse.b = CSceneManager::m_WeatherManager.m_InterCharacterLight.b/255.0f;
vector3 vecLight(-1.0f,-1.0f,-1.0f);
vecLight.Normalize();
light.Position.x = light.Direction.x =vecLight.x;
light.Position.y = light.Direction.y =vecLight.y;
light.Position.z = light.Direction.z =vecLight.z;
light.Range = 1000.0f;
pd3dDevice->SetLight(0,&light);
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterCharacterAmbient.c);
matrix matWorld;
matWorld.MakeIdent();
pd3dDevice->SetTransform(D3DTS_WORLD,matWorld);
CSceneNode CharScene;
CharScene.m_fRad=300.0f;
vector3 vecCharPos;
vector3 vecCharScreenPos;
float fW;
for(int cChar=0;cChar<m_CharacterList.num;cChar++)
{
if(m_CharacterList[cChar].m_bRender==false)
{
m_CharacterList[cChar].m_pChrmodel->SetCull(true);
m_CharacterList[cChar].m_pChrmodel->SetDisable(true);
}
else
{
m_CharacterList[cChar].m_pChrmodel->SetCull(false);
m_CharacterList[cChar].m_pChrmodel->SetDisable(false);
}
if(m_CharacterList[cChar].m_pChrmodel->IsDisabled()==false)
{
m_CharacterList[cChar].m_pChrmodel->GetPosition(vecCharPos.x,vecCharPos.y,vecCharPos.z);
CharScene.m_AccumulateTM.Translation(vecCharPos);
if(CharScene.isCulling())
{
m_CharacterList[cChar].m_pChrmodel->SetCull(false);
BaseGraphicsLayer::TransformVector(vecCharPos,vecCharScreenPos,fW);
m_CharacterList[cChar].m_ptScreenPosition.x=(int)vecCharScreenPos.x;
m_CharacterList[cChar].m_ptScreenPosition.y=(int)vecCharScreenPos.y;
//m_CharacterScreenPositionList[cChar].x=(int)vecCharScreenPos.x;
//m_CharacterScreenPositionList[cChar].y=(int)vecCharScreenPos.y;
//BaseGraphicsLayer::TransformVector(m_InstanceObjectList[cObject].m_vecPosition,vecResult,w);
}
else
{
m_CharacterList[cChar].m_pChrmodel->SetCull(true);
m_CharacterList[cChar].m_ptScreenPosition.x=-1;
m_CharacterList[cChar].m_ptScreenPosition.y=-1;
//m_CharacterScreenPositionList[cChar].x=-1;
//m_CharacterScreenPositionList[cChar].y=-1;
}
}
}
CZ3DRenderable::Process();
char *pShadowCollision;
vector3 vecChrPos;
float fInterVal=SECTORSIZE/256.0f;
int px,pz;
float fPosx,fPosz;
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
vector3 vecSunLightDir( CSceneManager::m_WeatherManager.m_SunLight.Direction.x,
CSceneManager::m_WeatherManager.m_SunLight.Direction.y,
CSceneManager::m_WeatherManager.m_SunLight.Direction.z);
float fBias=0.0f;
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_MIPMAPLODBIAS, *((LPDWORD) (&fBias)));
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_MIPMAPLODBIAS, *((LPDWORD) (&fBias)));
color m_InterCharacterAmbient;
color m_InterCharacterLight;
//float fAmbientColor[4]={0.0f,0.0f,0.0f,0.0f};
float fAmbientColor[4]={CSceneManager::m_WeatherManager.m_InterCharacterAmbient.r/255.0f,
CSceneManager::m_WeatherManager.m_InterCharacterAmbient.g/255.0f,
CSceneManager::m_WeatherManager.m_InterCharacterAmbient.b/255.0f,1.0f};
float fShadowColor[4]={0.0f,0.0f,0.0f,0.0f};
float fLightColor[4]={CSceneManager::m_WeatherManager.m_InterCharacterLight.r/255.0f,
CSceneManager::m_WeatherManager.m_InterCharacterLight.g/255.0f,
CSceneManager::m_WeatherManager.m_InterCharacterLight.b/255.0f,1.0f};
float fBackLightColor[4]={fLightColor[0]*0.6f,fLightColor[1]*0.6f,fLightColor[2]*0.6f,1.0f};
pd3dDevice->SetPixelShaderConstant(0,fAmbientColor,1);
pd3dDevice->SetPixelShaderConstant(1,fShadowColor,1);
pd3dDevice->SetPixelShaderConstant(2,fBackLightColor,1);
pd3dDevice->SetPixelShaderConstant(3,fLightColor,1);
for(cChar=m_CharacterList.num-1 ;cChar >= 0 ;cChar--)
{
if(m_CharacterList[cChar].m_bRender==false)
continue;
D3DVIEWPORT8 m_pTempViewPort;
pd3dDevice->GetViewport(&m_pTempViewPort);
m_CharacterList[cChar].m_pChrmodel->GetPosition(vecChrPos.x,vecChrPos.y,vecChrPos.z);
bool bInShadowCheck=false;
if( m_CharacterList[cChar].m_CollisionDetectType == CDT_FULL)
//(m_CharacterList[cChar].m_CollisionType == CT_TERRAIN))
{
bInShadowCheck=true;
}
else if( m_CharacterList[cChar].m_CollisionDetectType==CDT_ONLYTERRAIN )
{
bInShadowCheck=true;
}
else if( m_CharacterList[cChar].m_CollisionDetectType==CDT_NONE)
{
bInShadowCheck=true;
}
//if( m_CharacterList[cChar].m_CollisionType != CT_BOTTOM )
if(bInShadowCheck)
{
// ¹ãÀ̸é modulate
if((CSceneManager::GetWeatherTime() <= 19) && (CSceneManager::GetWeatherTime() >= 5)) {
pShadowCollision=m_pHeightField->GetHeightFieldShadowCollision(vecChrPos);
px=(int)(vecChrPos.x/SECTORSIZE);
pz=(int)(vecChrPos.z/SECTORSIZE);
fPosx=vecChrPos.x-(px*SECTORSIZE);
fPosz=vecChrPos.z-(pz*SECTORSIZE);
if(pShadowCollision)
{
fPosx/=fInterVal;
fPosz/=fInterVal;
if(pShadowCollision[(int)fPosx+((int)fPosz)*256]&0x01)
{
//CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR,0xff999999);
//CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR,0xffffffff);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
}
else
{
//CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR,0xffffffff);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
if(BaseGraphicsLayer::m_VoodooOption)
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
else
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
}
}
else
{
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
//CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR,0xffffffff);
}
}
else // ¹ãÀ϶§
{
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
}
}
else
{
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
if(BaseGraphicsLayer::m_VoodooOption)
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
else
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
}
pd3dDevice->SetStreamSource( 0, NULL, 0 );
pd3dDevice->SetStreamSource( 1, NULL, 0 );
pd3dDevice->SetStreamSource( 2, NULL, 0 );
if(m_CharacterList[cChar].m_Light.m_dwTimer>0)
//if(m_CharacterLightList[cChar].m_dwTimer>0)
{
//pd3dDevice->SetLight(1,&m_CharacterLightList[cChar].m_Light);
pd3dDevice->SetLight(1,&m_CharacterList[cChar].m_Light.m_Light);
pd3dDevice->LightEnable(1,TRUE);
pd3dDevice->LightEnable(0,FALSE);
}
else
{
pd3dDevice->LightEnable(1,FALSE);
pd3dDevice->LightEnable(0,TRUE);
}
////////////////
//Sector Light ij¸¯ÅÍ ¼¼ÆÃ
if((CSceneManager::GetWeatherTime() > 19) || (CSceneManager::GetWeatherTime() < 5))
{
CSceneManager::m_GlareManager->SetColor( CGlareManager::GLARE_CHARACTER, D3DCOLOR_ARGB(40,
40,
40,
40) );
D3DXVECTOR3 vecPos = D3DXVECTOR3(m_CharacterList[cChar].m_vecRealPosition.x,
m_CharacterList[cChar].m_vecRealPosition.y,
m_CharacterList[cChar].m_vecRealPosition.z);
int indexx=(int)(vecPos.x/SECTORSIZE);
int indexy=(int)(vecPos.z/SECTORSIZE);
for(int cSector = 0; cSector < CSceneManager::m_HeightField.GetLSizeX()*CSceneManager::m_HeightField.GetLSizeY(); cSector++ )
{
int sectorindexx = CSceneManager::m_HeightField.m_SectorScene[cSector].m_AccumulateTM._41/SECTORSIZE;
int sectorindexy = CSceneManager::m_HeightField.m_SectorScene[cSector].m_AccumulateTM._43/SECTORSIZE;
if(sectorindexx == indexx &&
sectorindexy == indexy)
{
CSectorScene *pSector = &(CSceneManager::m_HeightField.m_SectorScene[cSector]);
if(pSector != NULL){
pSector->m_SectorLightManager.SelectObjLight(vecPos.x,vecPos.y,vecPos.z);
if(pSector->m_SectorLightManager.m_iSelectObjLights)
{
D3DLIGHT8 pCurrentLight;
ZeroMemory(&(pCurrentLight),sizeof(D3DLIGHT8));
pCurrentLight.Type=D3DLIGHT_POINT;
pCurrentLight.Attenuation0=0.2f;
pCurrentLight.Attenuation1=0.005f;
pCurrentLight.Attenuation2=0.0f;
pCurrentLight.Diffuse.r = (pSector->m_SectorLightManager.m_lstSelectObjLights[0].m_vecColor.x / 255.0f);
pCurrentLight.Diffuse.g = (pSector->m_SectorLightManager.m_lstSelectObjLights[0].m_vecColor.y / 255.0f);
pCurrentLight.Diffuse.b = (pSector->m_SectorLightManager.m_lstSelectObjLights[0].m_vecColor.z / 255.0f);
pCurrentLight.Position.x = pSector->m_SectorLightManager.m_lstSelectObjLights[0].m_vecPos.x;
pCurrentLight.Position.y = pSector->m_SectorLightManager.m_lstSelectObjLights[0].m_vecPos.y;
pCurrentLight.Position.z = pSector->m_SectorLightManager.m_lstSelectObjLights[0].m_vecPos.z;
pCurrentLight.Range= pSector->m_SectorLightManager.m_lstSelectObjLights[0].m_fRange;
pCurrentLight.Falloff = 1.0f;
CSceneManager::m_GlareManager->SetColor( CGlareManager::GLARE_CHARACTER, D3DCOLOR_ARGB(140,
(int)pSector->m_SectorLightManager.m_lstSelectObjLights[0].m_vecColor.x,
(int)pSector->m_SectorLightManager.m_lstSelectObjLights[0].m_vecColor.y,
(int)pSector->m_SectorLightManager.m_lstSelectObjLights[0].m_vecColor.z));
pd3dDevice->SetLight(0,&(pCurrentLight));
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
//pd3dDevice->LightEnable(1,TRUE);
}
else
{
//pd3dDevice->LightEnable(1,FALSE);
}
}
}
}
}
if(CSceneManager::m_bCharacterLight) // ij¸¯ÅÍ ¹ã¿ë light Ä×À»¶§
{
bool bLight = true;
if(cChar == 0) // ÀÚ½ÅÀÌ ¾Æ´Ï¶ó¸é.. nfocuschar
{
/*
D3DXVECTOR3 vecPos = D3DXVECTOR3(m_CharacterList[cChar].m_vecRealPosition.x,
m_CharacterList[cChar].m_vecRealPosition.y,
m_CharacterList[cChar].m_vecRealPosition.z);
*/
matrix *view = CSceneManager::m_ViewCamera->GetMatPosition();
D3DXVECTOR3 vecPos = D3DXVECTOR3(view->_41,view->_42,view->_43);
D3DXVECTOR3 vecPersonPos = D3DXVECTOR3(m_CharacterList[cChar].m_vecRealPosition.x,
m_CharacterList[cChar].m_vecRealPosition.y,
m_CharacterList[cChar].m_vecRealPosition.z);
D3DXVECTOR3 vecTmp = vecPos - vecPersonPos;
D3DXVec3Normalize(&vecTmp,&vecTmp);
CSceneManager::m_CharacterLight.Position.x = vecPersonPos.x + vecTmp.x * 250.0f;
CSceneManager::m_CharacterLight.Position.y = vecPersonPos.y + vecTmp.y * 250.0f;
CSceneManager::m_CharacterLight.Position.z = vecPersonPos.z + vecTmp.z * 250.0f;
CSceneManager::m_GlareManager->SetColor( CGlareManager::GLARE_CHARACTER, D3DCOLOR_ARGB(100,(int)(CSceneManager::m_CharacterLight.Diffuse.r * 255),
(int)(CSceneManager::m_CharacterLight.Diffuse.g* 255),
(int)(CSceneManager::m_CharacterLight.Diffuse.b* 255),
));
}
else
{
D3DXVECTOR3 vecPos = D3DXVECTOR3(m_CharacterList[cChar].m_vecRealPosition.x,
m_CharacterList[cChar].m_vecRealPosition.y,
m_CharacterList[cChar].m_vecRealPosition.z);
D3DXVECTOR3 vecRange = D3DXVECTOR3(CSceneManager::m_CharacterLight.Position.x - vecPos.x,
CSceneManager::m_CharacterLight.Position.y - vecPos.y,
CSceneManager::m_CharacterLight.Position.z - vecPos.z);
float fRange = D3DXVec3Length(&vecRange);
if(fRange > CSceneManager::m_CharacterLight.Range)
{
bLight = false;
}
}
if(bLight)
{
pd3dDevice->SetLight(0,&(CSceneManager::m_CharacterLight));
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
}
}
/////////////////
if(m_CharacterList[cChar].m_pChrmodel->IsDisabled()==false)
{
m_CharacterList[cChar].m_pChrmodel->PreRender();
/*
if(CRenderOption::m_CharacterSelfShadow)
{
matrix matOldView,matWorld,matProjection;
pd3dDevice->GetTransform(D3DTS_VIEW,matOldView);
pd3dDevice->GetTransform(D3DTS_PROJECTION,matProjection);
pd3dDevice->EndScene();
m_CharacterShadowmap.Begin(pd3dDevice);
pd3dDevice->Clear(0, NULL, D3DCLEAR_ZBUFFER,0xffffffff, 1.0f, 0);
pd3dDevice->BeginScene();
//CSceneStateMgr::_SetD3DRenderState(D3DRS_COLORWRITEENABLE,0);
pd3dDevice->SetVertexShader(BUMPVERTEXFVF);
vector3 vecChrPos;
m_CharacterList[cChar].m_pChrmodel->GetPosition(vecChrPos);
matWorld.Translation(vecChrPos);
matrix matCharCamera;
matCharCamera.CameraLookAt(
vecChrPos-vecSunLightDir*450.0f+vector3(0.0f,85.0f,0.0f),
vector3(0.0f,80.0f,0.0f)+vecChrPos,
vector3(0.0f,1.0f,0.0f));
matrix matShadowProj;
D3DXMatrixOrthoLH(matShadowProj,200,200,10.0f, 10000.0f);
pd3dDevice->SetTransform(D3DTS_VIEW,matCharCamera);
pd3dDevice->SetTransform(D3DTS_PROJECTION,matShadowProj);
CSceneStateMgr::_SetD3DRenderState(D3DRS_COLORWRITEENABLE,0);
m_CharacterList[cChar].m_pChrmodel->Render();
CSceneStateMgr::_SetD3DRenderState(D3DRS_COLORWRITEENABLE,D3DCOLORWRITEENABLE_BLUE|D3DCOLORWRITEENABLE_GREEN|D3DCOLORWRITEENABLE_RED);
pd3dDevice->EndScene();
m_CharacterShadowmap.End(pd3dDevice);
pd3dDevice->BeginScene();
pd3dDevice->SetTexture(2,m_CharacterShadowmap.GetShadowMapZTexture());
matrix matTexture,matTextureScale;
float fOffsetX=0.5f+(0.5f/(float)512);
float fOffsetY=0.5f+(0.5f/(float)512);
unsigned int range=0xffffffff >> (32-16);
float fBias=-0.001f*(float)range;
matTextureScale._11=0.5f;matTextureScale._12=0.0f;matTextureScale._13=0.0f;matTextureScale._14=0.0f;
matTextureScale._21=0.0f;matTextureScale._22=-0.5f;matTextureScale._23=0.0f;matTextureScale._24=0.0f;
matTextureScale._31=0.0f;matTextureScale._32=0.0f;matTextureScale._33=(float)range;matTextureScale._34=0.0f;
matTextureScale._41=fOffsetX;matTextureScale._42=fOffsetY;matTextureScale._43=fBias;matTextureScale._44=1.0f;
matrix matWVP;
matWVP=matWorld*matCharCamera;
matWVP=matWVP*matShadowProj;
matTexture=matWVP*matTextureScale;
matTexture.Transpose();
pd3dDevice->SetVertexShaderConstant(4,&matTexture,4);
pd3dDevice->SetTransform(D3DTS_VIEW,matOldView);
pd3dDevice->SetTransform(D3DTS_PROJECTION,matProjection);
}
if(CRenderOption::m_CharacterPerPixelLighting)
{
pd3dDevice->SetPixelShader(m_dwCharacterPixelShader);
pd3dDevice->SetVertexShader(m_dwCharacterVertexShader);
}
*/
if( m_CharacterList[cChar].m_fAlphaValue > 0.0f )
{
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_ALPHAARG1,D3DTA_TFACTOR);
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_COLOROP,D3DTOP_SELECTARG1);
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_COLOROP,D3DTOP_DISABLE);
color alpha;
alpha.r = 255;
alpha.g = 255;
alpha.b = 255;
alpha.a = m_CharacterList[cChar].m_fAlphaValue * 255;
CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR, alpha.c );
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
CSceneStateMgr::_SetD3DRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
CSceneStateMgr::_SetD3DRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
}
//=======================
// Draw Character
//=======================
m_CharacterList[cChar].m_pChrmodel->DrawSpecular();
if( m_CharacterList[cChar].m_fAlphaValue > 0.0f )
{
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
}
}
}
/* */
fBias=0.0f;
CSceneStateMgr::_SetD3DTextureStageState(0, D3DTSS_MIPMAPLODBIAS, *((LPDWORD) (&fBias)));
CSceneStateMgr::_SetD3DTextureStageState(1, D3DTSS_MIPMAPLODBIAS, *((LPDWORD) (&fBias)));
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHAREF,0xee);
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHAREF,0x0);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_ALPHAOP,D3DTOP_SELECTARG1);
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
pd3dDevice->SetPixelShader(NULL);
CZ3DRenderable::SecondProcess();
for(int i=1;i<8;i++)
pd3dDevice->LightEnable(i,FALSE);
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 1 );
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXCOORDINDEX, 2);
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_MIPFILTER,D3DTEXF_LINEAR);
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_MIPFILTER,D3DTEXF_LINEAR);
matrix mat;
mat._11 = 1.0f; mat._12 = 0; mat._13 = 0; mat._14 = 0;
mat._21 = 0; mat._22 = 1.0f; mat._23 = 0; mat._24 = 0;
mat._31 = 0; mat._32 = 0; mat._33 = 1.0f; mat._34 = 0;
mat._41 = 0; mat._42 = 0; mat._43 = 0; mat._44 = 1.0f;
pd3dDevice->SetTransform( D3DTS_TEXTURE1, mat );
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_COLOROP, D3DTOP_DISABLE);
CSceneStateMgr::_SetD3DTextureStageState(2,D3DTSS_COLOROP, D3DTOP_DISABLE);
pd3dDevice->SetTexture(1,NULL);
pd3dDevice->SetTexture(2,NULL);
pd3dDevice->SetTexture(3,NULL);
}
void CCharacterLightShadowManager::RenderEnv(LPDIRECT3DDEVICE8 lpDevice)
{
}
Reference in New Issue View Git Blame Copy Permalink