LGram16
dd97ddec92
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>
4362 lines
148 KiB
C++
4362 lines
148 KiB
C++
// HouseObject.cpp: implementation of the CHouseObject class.
|
||
//
|
||
//////////////////////////////////////////////////////////////////////
|
||
|
||
#include "HouseObject.h"
|
||
#include "SceneManager.h"
|
||
#include "BaseGraphicsLayer.h"
|
||
#include "RenderOption.h"
|
||
#include "SceneStateMgr.h"
|
||
|
||
|
||
#include "WBLightMapGenerator.h"
|
||
|
||
DWORD CHouseObject::m_dwShadowMapVertexShader=0xffffffff;
|
||
DWORD CHouseObject::m_dwShadowMapPixelShader=0xffffffff;
|
||
|
||
DWORD CHouseObject::m_dwHouseDiffuseVertexShader=0xffffffff;
|
||
DWORD CHouseObject::m_dwHouseDiffusePixelShader=0xffffffff;
|
||
|
||
DWORD CHouseObject::m_dwHouseSpecularVertexShader=0xffffffff;
|
||
DWORD CHouseObject::m_dwHouseSpecularPixelShader=0xffffffff;
|
||
|
||
LPDIRECT3DCUBETEXTURE8 CHouseObject::m_pNormalizeCubeMap=NULL;
|
||
|
||
char strHouseDiffuseVertexShader[]=
|
||
"vs.1.1\n"
|
||
"m4x4 oPos,v0,c16\n"
|
||
"m4x4 r0,v0,c16\n"
|
||
"mov oT0.xy,v2.xy\n"//Diffuse
|
||
"mov oT1.xy,v2.xy\n"//Diffuse
|
||
"mov oT2.xy,v3.xy\n"//Lightmap
|
||
"mov oFog.x,r0.z\n";
|
||
|
||
char strHouseDiffusePixelShader[]=
|
||
"ps.1.1\n"
|
||
"tex t0\n"//Diffuse
|
||
"tex t1\n"//Diffuse
|
||
"tex t2\n"//Lightmap"
|
||
"mov r0,t0\n"
|
||
"mul r0,r0,c0\n"
|
||
"mul_x2 r0,r0,t2\n";
|
||
|
||
char strHouseSpecularVertexShader[]=
|
||
"vs.1.0\n"
|
||
"m4x4 oPos, v0, c16\n"
|
||
"mov oT0.xy, v2.xy\n" // Texture Coords
|
||
"mov oT1.xy, v2.xy\n" // Bump
|
||
"mov oT2.xy, v3.xy\n" // Lightmap
|
||
|
||
//;r9 = tangent U vector = normal cross tangent V vector
|
||
"mov r8, v4\n"
|
||
"mul r9, r8.yzxw, v1.zxyw\n"
|
||
"mad r9, -r8.zxyw, v1.yzxw, r9\n"
|
||
/*
|
||
*/
|
||
|
||
"sub r1, c32, v0\n" // Light direction
|
||
//Normalize
|
||
"dp3 r11.x,r1.xyz,r1.xyz\n"
|
||
"rsq r11.xyz,r11.x\n"
|
||
"mul r1.xyz, r1.xyz, r11.xyz\n"
|
||
|
||
"sub r0, c35, v0\n" //Viewer direction
|
||
//Normalize
|
||
"dp3 r11.x,r0.xyz,r0.xyz\n"
|
||
"rsq r11.xyz,r11.x\n"
|
||
"mul r0.xyz, r0.xyz, r11.xyz\n"
|
||
"add r4.xyz, r0.xyz, r1.xyz\n" //Halfway
|
||
|
||
//;r4 = tangent space halfway vector
|
||
"dp3 r6.x, r9, r4\n"
|
||
"dp3 r6.y, r8, r4\n"
|
||
"dp3 r6.z, v1, r4\n"
|
||
|
||
"mov oT3.xyz,r6.xyz\n"; // Halfway vector to be renormalized by cube map
|
||
|
||
|
||
|
||
char strHouseSpecularPixelShader[]=
|
||
"ps.1.1\n"
|
||
"def c0,0.9,0.9,0.9,0.9\n"
|
||
"tex t0\n"//diffuse
|
||
"tex t1\n"//normal
|
||
"tex t2\n"//Light
|
||
"tex t3\n"//
|
||
//"mov r0,t3\n";
|
||
"dp3_sat r0,t1_bx2,t3_bx2\n"//N.H
|
||
"mul r1,r0,r0\n"
|
||
"mul r0,r1,r1\n"
|
||
"mul r1,r0,r0\n"
|
||
"mul r0,r1,r1\n"
|
||
"mul r0,r0,t2\n"
|
||
"mul r0,r0,t2\n"
|
||
"mul r0,r0,t1.a\n";
|
||
|
||
|
||
//"mul_x2 r0,r1,t1.a\n";
|
||
|
||
|
||
|
||
|
||
|
||
//////////////////////////////////////////////////////////////////////
|
||
// Construction/Destruction
|
||
//////////////////////////////////////////////////////////////////////
|
||
|
||
CHouseObject::CHouseObject()
|
||
{
|
||
m_pBackupTmp.num = 0;
|
||
m_pBackupVertex.num = 0;
|
||
|
||
m_pInHouseObject=NULL;
|
||
m_pMedHouseObject=NULL;
|
||
m_pOutHouseObject=NULL;
|
||
m_pLodHouseObject=NULL;
|
||
m_pOctree=NULL;
|
||
m_isHaveLightmap=false;
|
||
m_isHaveInLightmap = false;
|
||
|
||
m_bConvertNight = false;
|
||
m_bNightMap = false;
|
||
m_bNightUv = false;
|
||
m_bModulate2X = false;
|
||
|
||
if(CRenderOption::m_AllObjectBump && m_dwHouseDiffusePixelShader==0xffffffff)
|
||
{
|
||
DWORD dwBumpVertexDecl[]=
|
||
{
|
||
D3DVSD_STREAM( 0 ),
|
||
D3DVSD_REG( 0, D3DVSDT_FLOAT3 ), // Position
|
||
D3DVSD_REG( 1, D3DVSDT_FLOAT3 ), // Normal
|
||
D3DVSD_REG( 2, D3DVSDT_FLOAT2 ), // Tex coords 1
|
||
D3DVSD_REG( 3, D3DVSDT_FLOAT2 ), // Tex coords 2
|
||
D3DVSD_REG( 4, D3DVSDT_FLOAT3 ), // Tagent U
|
||
D3DVSD_END()
|
||
};
|
||
|
||
LPD3DXBUFFER pCode;
|
||
|
||
D3DXAssembleShader(strHouseDiffusePixelShader,strlen(strHouseDiffusePixelShader),0,NULL,&pCode,NULL);
|
||
BaseGraphicsLayer::GetDevice()->CreatePixelShader((DWORD*)pCode->GetBufferPointer(),&m_dwHouseDiffusePixelShader);
|
||
pCode->Release();
|
||
|
||
D3DXAssembleShader(strHouseDiffuseVertexShader,strlen(strHouseDiffuseVertexShader),0,NULL,&pCode,NULL);
|
||
BaseGraphicsLayer::GetDevice()->CreateVertexShader( dwBumpVertexDecl, (DWORD*)pCode->GetBufferPointer(), &m_dwHouseDiffuseVertexShader, 0 );
|
||
pCode->Release();
|
||
|
||
D3DXAssembleShader(strHouseSpecularPixelShader,strlen(strHouseSpecularPixelShader),0,NULL,&pCode,NULL);
|
||
BaseGraphicsLayer::GetDevice()->CreatePixelShader((DWORD*)pCode->GetBufferPointer(),&m_dwHouseSpecularPixelShader);
|
||
pCode->Release();
|
||
|
||
D3DXAssembleShader(strHouseSpecularVertexShader,strlen(strHouseSpecularVertexShader),0,NULL,&pCode,NULL);
|
||
BaseGraphicsLayer::GetDevice()->CreateVertexShader( dwBumpVertexDecl, (DWORD*)pCode->GetBufferPointer(), &m_dwHouseSpecularVertexShader, 0 );
|
||
pCode->Release();
|
||
|
||
char strNormalizeCubeMap[256];
|
||
sprintf(strNormalizeCubeMap,"%s\\%s",NATURETEXTUREPATH,"NormalizeCubeMap.dds");
|
||
|
||
D3DXCreateCubeTextureFromFile(CSceneManager::GetDevice(),strNormalizeCubeMap,&m_pNormalizeCubeMap);
|
||
|
||
|
||
//D3DXCreateCubeTextureFromFile(CSceneManager::GetDevice(),"c:/NormalizeCubeMap.dds",&m_pNormalizeCubeMap);
|
||
|
||
|
||
|
||
}
|
||
/*
|
||
|
||
if(m_dwShadowMapVertexShader==0xffffffff && GF3OPTION==1)
|
||
{
|
||
|
||
DWORD dwMultiVertexDecl[] =
|
||
{
|
||
D3DVSD_STREAM( 0 ),
|
||
D3DVSD_REG( 0, D3DVSDT_FLOAT3 ), // Position
|
||
D3DVSD_REG( 1, D3DVSDT_D3DCOLOR),
|
||
D3DVSD_REG( 2, D3DVSDT_D3DCOLOR),
|
||
D3DVSD_REG( 3, D3DVSDT_FLOAT2 ), // Tex coords 1
|
||
D3DVSD_REG( 4, D3DVSDT_FLOAT2 ), // Tex coords 2
|
||
D3DVSD_END()
|
||
};
|
||
|
||
DWORD dwDetailVertexDecl[] =
|
||
{
|
||
D3DVSD_STREAM( 0 ),
|
||
D3DVSD_REG( 0, D3DVSDT_FLOAT3 ), // Position
|
||
D3DVSD_REG( 1, D3DVSDT_FLOAT3 ),
|
||
D3DVSD_REG( 2, D3DVSDT_FLOAT2 ), // Tex coords 1
|
||
D3DVSD_REG( 3, D3DVSDT_FLOAT2 ), // Tex coords 2
|
||
D3DVSD_END()
|
||
};
|
||
|
||
char strShaderPath[256];
|
||
sprintf(strShaderPath,"%s%s",SHADERPATH,"ShadowMap.vsh");
|
||
|
||
LPD3DXBUFFER pCode;
|
||
D3DXAssembleShaderFromFile(strShaderPath,0,NULL,&pCode,NULL);
|
||
|
||
BaseGraphicsLayer::GetDevice()->CreateVertexShader( dwDetailVertexDecl,
|
||
(DWORD*)pCode->GetBufferPointer(),
|
||
&m_dwShadowMapVertexShader, 0 );
|
||
pCode->Release();
|
||
|
||
sprintf(strShaderPath,"%s%s",SHADERPATH,"ShadowMap.psh");
|
||
|
||
D3DXAssembleShaderFromFile(strShaderPath,0,NULL,&pCode,NULL);
|
||
|
||
BaseGraphicsLayer::GetDevice()->CreatePixelShader((DWORD*)pCode->GetBufferPointer(),
|
||
&m_dwShadowMapPixelShader);
|
||
pCode->Release();
|
||
|
||
}
|
||
*/
|
||
}
|
||
|
||
CHouseObject::~CHouseObject()
|
||
{
|
||
int i;
|
||
|
||
if(m_pBspObject)
|
||
{
|
||
delete m_pBspObject;
|
||
m_pBspObject=NULL;
|
||
}
|
||
|
||
for(i=0;i<m_pBackupVertex.num;i++)
|
||
delete[] m_pBackupVertex[i];
|
||
for(i=0;i<m_pBackupTmp.num;i++)
|
||
delete[] m_pBackupTmp[i];
|
||
|
||
m_pBackupVertex.num = 0;
|
||
m_pBackupTmp.num = 0;
|
||
|
||
|
||
|
||
}
|
||
bool CHouseObject::SettingNight(bool bNight)
|
||
{
|
||
if(bNight == m_bConvertNight)
|
||
return bNight;
|
||
|
||
|
||
// Data Load failed <20><> <20>ǹ<EFBFBD><C7B9≯<EFBFBD>..
|
||
if(m_bNightMap == false || m_bNightUv == false)
|
||
return false;
|
||
|
||
int cObject = 0;
|
||
|
||
m_bConvertNight = bNight;
|
||
if(m_pOutHouseObject)
|
||
{
|
||
m_pOutHouseObject->AllLockBuffer();
|
||
|
||
for(int i=0;i<m_pOutHouseObject->m_pVertexBuffer.num;i++)
|
||
{
|
||
|
||
memcpy(m_pBackupTmp[i],m_pOutHouseObject->m_pVertex[i],sizeof(MultiVertex) * m_pOutHouseObject->m_nVertex[i]);
|
||
memcpy(m_pOutHouseObject->m_pVertex[i],m_pBackupVertex[i],sizeof(MultiVertex) * m_pOutHouseObject->m_nVertex[i]);
|
||
memcpy(m_pBackupVertex[i],m_pBackupTmp[i],sizeof(MultiVertex) * m_pOutHouseObject->m_nVertex[i]);
|
||
}
|
||
m_pOutHouseObject->AllUnlockBuffer();
|
||
}
|
||
return m_bConvertNight;
|
||
|
||
}
|
||
const long MAX_OBJECT=100;
|
||
void CHouseObject::GenerateNewLightmap(int iValue,matrix matSet,matrix matHouseTM,CSectorLight *pLights,int iLights)
|
||
{
|
||
WBLightMapGenerator NewGenerator;
|
||
int i,j,k,l;
|
||
|
||
char de[256];
|
||
if(m_pOutHouseObject->m_dwShader!=MultiFVF)
|
||
{
|
||
m_pOutHouseObject->ConvertMulti();
|
||
if(m_pMedHouseObject)
|
||
m_pMedHouseObject->ConvertMulti();
|
||
if(m_pInHouseObject)
|
||
m_pInHouseObject->ConvertMulti();
|
||
}
|
||
int cObjectScene=0;
|
||
for(cObjectScene=0;cObjectScene<m_ObjectList.num;cObjectScene++)
|
||
{
|
||
m_ObjectList[cObjectScene]->m_pObject->AllLockBuffer();
|
||
}
|
||
// LightMap Generator
|
||
|
||
List<MultiVertex*> pMeshVertex;
|
||
List<WORD*> pMeshIndices;
|
||
List<int> nMeshVertex;
|
||
List<long> nMeshIndices;
|
||
|
||
List<int*> IndicesUsed;
|
||
|
||
int cObject = 0;
|
||
if(m_pOutHouseObject)
|
||
{
|
||
m_pOutHouseObject->AllLockBuffer();
|
||
for(cObject=0;cObject<m_pOutHouseObject->GetObjectCount();cObject++)
|
||
{
|
||
|
||
int *pUsedIndices=new int[m_pOutHouseObject->m_nIndices[cObject]];
|
||
memset(pUsedIndices,-1,sizeof(int)*m_pOutHouseObject->m_nIndices[cObject]);
|
||
IndicesUsed.Add(pUsedIndices);
|
||
|
||
pMeshVertex.Add((MultiVertex*)m_pOutHouseObject->m_pVertex[cObject]);
|
||
pMeshIndices.Add(m_pOutHouseObject->m_pIndices[cObject]);
|
||
nMeshIndices.Add(m_pOutHouseObject->m_nIndices[cObject]);
|
||
nMeshVertex.Add(m_pOutHouseObject->m_nVertex[cObject]);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/* vector3 *vecTestClassfy[3];
|
||
vector3 vecTestNormal;
|
||
|
||
for(int cInObject=0;cInObject<nMeshIndices.num;cInObject++)
|
||
{
|
||
MultiVertex *pTestVertex=pMeshVertex[cInObject];
|
||
WORD *pTestIndices=pMeshIndices[cInObject];
|
||
for(cIndices=0;cIndices<nMeshIndices[cInObject];cIndices++)
|
||
{
|
||
if(IndicesUsed[cInObject][cIndices]==-1)
|
||
{
|
||
vecTestClassfy[0]=&pTestVertex[pTestIndices[cIndices*3+0]].v;
|
||
vecTestClassfy[1]=&pTestVertex[pTestIndices[cIndices*3+1]].v;
|
||
vecTestClassfy[2]=&pTestVertex[pTestIndices[cIndices*3+2]].v;
|
||
|
||
vecTestNormal=(*vecTestClassfy[1]-*vecTestClassfy[0])^(*vecTestClassfy[2]-*vecTestClassfy[0]);
|
||
vecTestNormal.Normalize();
|
||
|
||
if(!(vecTestNormal == vecFirstNormal))
|
||
continue;
|
||
|
||
fDistance[0]= vecFirstNormal * ( (*vecTestClassfy[0])-(*vecFirstDetect[0]));
|
||
fDistance[1]= vecFirstNormal * ( (*vecTestClassfy[1])-(*vecFirstDetect[0]));
|
||
fDistance[2]= vecFirstNormal * ( (*vecTestClassfy[2])-(*vecFirstDetect[0]));
|
||
|
||
if( fDistance[0] >= -NEARPLANEVALUE && fDistance[0] <= NEARPLANEVALUE &&
|
||
fDistance[1] >= -NEARPLANEVALUE && fDistance[1] <= NEARPLANEVALUE &&
|
||
fDistance[2] >= -NEARPLANEVALUE && fDistance[2] <= NEARPLANEVALUE)
|
||
{
|
||
vecClassfy.Add(vecTestClassfy[0]);
|
||
vecClassfy.Add(vecTestClassfy[1]);
|
||
vecClassfy.Add(vecTestClassfy[2]);
|
||
IndicesUsed[cInObject][cIndices]=UsedPlane;
|
||
cUsedClassfy++;
|
||
continue;
|
||
} //IF
|
||
} //if
|
||
} //for
|
||
}//for
|
||
*/
|
||
/* if(m_pInHouseObject)
|
||
{
|
||
m_pInHouseObject->AllLockBuffer();
|
||
for(cObject=0;cObject<m_pInHouseObject->GetObjectCount();cObject++)
|
||
{
|
||
|
||
pMeshVertex.Add((MultiVertex*)m_pInHouseObject->m_pVertex[cObject]);
|
||
pMeshIndices.Add(m_pInHouseObject->m_pIndices[cObject]);
|
||
nMeshIndices.Add(m_pInHouseObject->m_nIndices[cObject]);
|
||
nMeshVertex.Add(m_pInHouseObject->m_nVertex[cObject]);
|
||
}
|
||
}
|
||
if(m_pMedHouseObject)
|
||
{
|
||
m_pMedHouseObject->AllLockBuffer();
|
||
for(cObject=0;cObject<m_pMedHouseObject->GetObjectCount();cObject++)
|
||
{
|
||
|
||
pMeshVertex.Add((MultiVertex*)m_pMedHouseObject->m_pVertex[cObject]);
|
||
pMeshIndices.Add(m_pMedHouseObject->m_pIndices[cObject]);
|
||
nMeshIndices.Add(m_pMedHouseObject->m_nIndices[cObject]);
|
||
nMeshVertex.Add(m_pMedHouseObject->m_nVertex[cObject]);
|
||
}
|
||
}
|
||
*/
|
||
AllocConsole();
|
||
|
||
HANDLE hStdOut=GetStdHandle(STD_OUTPUT_HANDLE);
|
||
|
||
COORD cd;
|
||
DWORD dwWordLens;
|
||
|
||
char strObjectInfo[256];
|
||
sprintf(strObjectInfo,"Generate Face to House");
|
||
|
||
cd.X=0;
|
||
cd.Y=0;
|
||
WriteConsoleOutputCharacter(hStdOut,strObjectInfo,strlen(strObjectInfo),cd,&dwWordLens);
|
||
|
||
// FILE *fp = fopen("c:\\test.txt","wt");
|
||
|
||
// Generate Face
|
||
for(i = 0; i < nMeshIndices.num; i++ )
|
||
{
|
||
/* for( j = 0 ; j < nMeshVertex[i]; j++)
|
||
{
|
||
fprintf(fp,"%f %f %f\n",pMeshVertex[i][j].v.x,pMeshVertex[i][j].v.y,pMeshVertex[i][j].v.z);
|
||
|
||
}*/
|
||
for( j = 0 ;j < nMeshIndices[i]; j++ )
|
||
{
|
||
|
||
WBLightMapFace *pFace = new WBLightMapFace;
|
||
|
||
pFace->m_iVerts = 3;
|
||
|
||
pFace->m_pVerts = new WBLightVertex[3];
|
||
|
||
pFace->m_iIndex[0] = pMeshIndices[i][(j * 3)];
|
||
pFace->m_iIndex[1] = pMeshIndices[i][(j * 3)+ 1];
|
||
pFace->m_iIndex[2] = pMeshIndices[i][(j * 3)+ 2];
|
||
pFace->m_iObject = i;
|
||
|
||
|
||
/* fprintf(fp,"Object %d : %d %d %d\n",pFace->m_iObject, pFace->m_iIndex[0],
|
||
pFace->m_iIndex[1],
|
||
pFace->m_iIndex[2]);*/
|
||
|
||
pFace->m_pVerts[0].m_vecPos = D3DXVECTOR3(pMeshVertex[i][pFace->m_iIndex[0]].v.x,
|
||
pMeshVertex[i][pFace->m_iIndex[0]].v.y,
|
||
pMeshVertex[i][pFace->m_iIndex[0]].v.z);
|
||
|
||
pFace->m_pVerts[1].m_vecPos = D3DXVECTOR3(pMeshVertex[i][pFace->m_iIndex[1]].v.x,
|
||
pMeshVertex[i][pFace->m_iIndex[1]].v.y,
|
||
pMeshVertex[i][pFace->m_iIndex[1]].v.z);
|
||
|
||
pFace->m_pVerts[2].m_vecPos = D3DXVECTOR3(pMeshVertex[i][pFace->m_iIndex[2]].v.x,
|
||
pMeshVertex[i][pFace->m_iIndex[2]].v.y,
|
||
pMeshVertex[i][pFace->m_iIndex[2]].v.z);
|
||
|
||
/* fprintf(fp,"%f %f %f\n%f %f %f\n%f %f %f\n",pFace->m_pVerts[0].m_vecPos.x,pFace->m_pVerts[0].m_vecPos.y,pFace->m_pVerts[0].m_vecPos.z,
|
||
pFace->m_pVerts[1].m_vecPos.x,pFace->m_pVerts[1].m_vecPos.y,pFace->m_pVerts[1].m_vecPos.z,
|
||
pFace->m_pVerts[2].m_vecPos.x,pFace->m_pVerts[2].m_vecPos.y,pFace->m_pVerts[2].m_vecPos.z);
|
||
|
||
*/
|
||
D3DXVECTOR3 vecNormal;
|
||
D3DXVECTOR3 vec1 = pFace->m_pVerts[2].m_vecPos - pFace->m_pVerts[0].m_vecPos;
|
||
D3DXVECTOR3 vec2 = pFace->m_pVerts[1].m_vecPos - pFace->m_pVerts[0].m_vecPos;
|
||
D3DXVec3Cross(&vecNormal,&vec2,&vec1);
|
||
D3DXVec3Normalize(&vecNormal,&vecNormal);
|
||
|
||
/* if(fabs(vecNormal.x) <= 0.03)
|
||
vecNormal.x = 0.0f;
|
||
if(fabs(vecNormal.y) <= 0.03)
|
||
vecNormal.y = 0.0f;
|
||
if(fabs(vecNormal.z) <= 0.03)
|
||
vecNormal.z = 0.0f;
|
||
|
||
D3DXVec3Normalize(&vecNormal,&vecNormal);
|
||
*/
|
||
|
||
pFace->m_vecNormal = vecNormal;
|
||
|
||
pFace->GetMinMax();
|
||
NewGenerator.InputFace(pFace);
|
||
}
|
||
}
|
||
// fclose(fp);
|
||
|
||
sprintf(strObjectInfo,"Generate Light to House");
|
||
|
||
cd.X=0;
|
||
cd.Y=1;
|
||
WriteConsoleOutputCharacter(hStdOut,strObjectInfo,strlen(strObjectInfo),cd,&dwWordLens);
|
||
|
||
// Input Light
|
||
WBLight *pWBLights = new WBLight[iLights];
|
||
|
||
for( i = 0; i < iLights; i++ )
|
||
{
|
||
////////////////
|
||
|
||
D3DXMATRIX matTmp;
|
||
D3DXMATRIX matInv;
|
||
|
||
D3DXMatrixIdentity(&matTmp);
|
||
|
||
matTmp._11 = matHouseTM._11;
|
||
matTmp._12 = matHouseTM._12;
|
||
matTmp._13 = matHouseTM._13;
|
||
matTmp._14 = matHouseTM._14;
|
||
|
||
matTmp._21 = matHouseTM._21;
|
||
matTmp._22 = matHouseTM._22;
|
||
matTmp._23 = matHouseTM._23;
|
||
matTmp._24 = matHouseTM._24;
|
||
|
||
matTmp._31 = matHouseTM._31;
|
||
matTmp._32 = matHouseTM._32;
|
||
matTmp._33 = matHouseTM._33;
|
||
matTmp._34 = matHouseTM._34;
|
||
|
||
matTmp._41 = matHouseTM._41;
|
||
matTmp._42 = matHouseTM._42;
|
||
matTmp._43 = matHouseTM._43;
|
||
matTmp._44 = matHouseTM._44;
|
||
|
||
D3DXMatrixInverse(&matInv,NULL,&matTmp);
|
||
D3DXMatrixIdentity(&matTmp);
|
||
|
||
matTmp._41 = pLights[i].m_vecPos.x;
|
||
matTmp._42 = pLights[i].m_vecPos.y;
|
||
matTmp._43 = pLights[i].m_vecPos.z;
|
||
|
||
D3DXMatrixMultiply(&matTmp,&matTmp,&matInv);
|
||
pWBLights[i].m_vecPos.x = matTmp._41;
|
||
pWBLights[i].m_vecPos.y = matTmp._42;
|
||
pWBLights[i].m_vecPos.z = matTmp._43;
|
||
/////
|
||
pWBLights[i].m_vecColor = pLights[i].m_vecColor;
|
||
pWBLights[i].m_vecColor.x = pWBLights[i].m_vecColor.x / 255.0f;
|
||
pWBLights[i].m_vecColor.y = pWBLights[i].m_vecColor.y / 255.0f;
|
||
pWBLights[i].m_vecColor.z = pWBLights[i].m_vecColor.z / 255.0f;
|
||
|
||
pWBLights[i].m_fRange = pLights[i].m_fRange;
|
||
|
||
NewGenerator.InputLight(&(pWBLights[i]));
|
||
|
||
NewGenerator.m_fShadowFactor = pLights[i].m_fShadowFactors;
|
||
NewGenerator.m_iLightSamples = pLights[i].m_iLightSamples;
|
||
NewGenerator.m_iShadowSamples = pLights[i].m_iShadowSamples;
|
||
NewGenerator.m_iLightMapAmb = pLights[i].m_iAmbient;
|
||
NewGenerator.m_fExposure = pLights[i].m_fExpose;
|
||
|
||
|
||
}
|
||
|
||
// Calc LightMap
|
||
sprintf(strObjectInfo,"Generate Lightmap");
|
||
|
||
cd.X=0;
|
||
cd.Y=2;
|
||
WriteConsoleOutputCharacter(hStdOut,strObjectInfo,strlen(strObjectInfo),cd,&dwWordLens);
|
||
|
||
|
||
NewGenerator.LightMapGenerate(iValue);
|
||
|
||
delete[] pWBLights;
|
||
|
||
byte m_ucLight[262144];
|
||
int icount = 0;
|
||
int icount2 = 0;
|
||
|
||
|
||
for(j=0;j < 256;j++) {
|
||
for(k=0;k < 256;k++) {
|
||
m_ucLight[icount2++] = (byte)(NewGenerator.m_lstLightMapTexs[0]->bmp[icount + 2]); //B
|
||
m_ucLight[icount2++] = (byte)(NewGenerator.m_lstLightMapTexs[0]->bmp[icount + 1]); //G
|
||
m_ucLight[icount2++] = (byte)(NewGenerator.m_lstLightMapTexs[0]->bmp[icount]); //R
|
||
m_ucLight[icount2++] = (byte)255;
|
||
icount +=3;
|
||
|
||
}
|
||
}
|
||
m_BackupLightmap.CreateEmptyTexture(256,256,0,D3DFMT_A8R8G8B8,D3DPOOL_MANAGED);
|
||
m_BackupLightmap.FillTexture(m_ucLight);
|
||
// fill uv
|
||
|
||
|
||
if(m_pOutHouseObject)
|
||
{
|
||
for(int i=0;i<m_pOutHouseObject->m_pVertexBuffer.num;i++)
|
||
{
|
||
MultiVertex *pVertexNode = new MultiVertex[m_pOutHouseObject->m_nVertex[i]];
|
||
MultiVertex *pVertexNode2 = new MultiVertex[m_pOutHouseObject->m_nVertex[i]];
|
||
memcpy(pVertexNode,m_pOutHouseObject->m_pVertex[i],sizeof(MultiVertex)*(m_pOutHouseObject->m_nVertex[i]));
|
||
m_pBackupVertex.Add(pVertexNode);
|
||
m_pBackupTmp.Add(pVertexNode2);
|
||
|
||
}
|
||
}
|
||
|
||
|
||
|
||
for( i = 0; i < NewGenerator.m_iFaces; i++)
|
||
{
|
||
int iObject = NewGenerator.m_lstFaces[i]->m_iObject;
|
||
|
||
|
||
for(j = 0; j < 3; j++)
|
||
{
|
||
int iCurrent = NewGenerator.m_lstFaces[i]->m_iIndex[j];
|
||
MultiVertex *pVerts = (MultiVertex *)(m_pBackupVertex[iObject]);
|
||
pVerts[iCurrent].tu1 = NewGenerator.m_lstFaces[i]->m_pVerts[j].m_vecTexcoord.x;
|
||
pVerts[iCurrent].tv1 = NewGenerator.m_lstFaces[i]->m_pVerts[j].m_vecTexcoord.y;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
|
||
// Uv save
|
||
/* char HouseMeshObjectPath[MAX_NAMEBUFFER] = {0};
|
||
FILE *fp = NULL;
|
||
|
||
sprintf(HouseMeshObjectPath,"%s%s",HOUSEOBJECTPATH,m_strOutName);
|
||
int iLength = strlen(HouseMeshObjectPath);
|
||
HouseMeshObjectPath[iLength - 1] = '\0';
|
||
HouseMeshObjectPath[iLength - 2] = 'v';
|
||
HouseMeshObjectPath[iLength - 3] = 'u';
|
||
|
||
fp = fopen(HouseMeshObjectPath,"wb");
|
||
|
||
|
||
for(int i=0;i<m_pOutHouseObject->m_pVertexBuffer.num;i++)
|
||
{
|
||
|
||
fwrite((m_pBackupVertex[i]),sizeof(MultiVertex)*(m_pOutHouseObject->m_nVertex[i]),1,fp);
|
||
}
|
||
|
||
m_bConvertNight = false;
|
||
m_bNightData = true;
|
||
|
||
fclose(fp);
|
||
*/
|
||
/*
|
||
for( i = 0; i < NewGenerator.m_iFaces; i++)
|
||
{
|
||
int iObject = NewGenerator.m_lstFaces[i]->m_iObject;
|
||
for(j = 0; j < 3; j++)
|
||
{
|
||
int iCurrent = NewGenerator.m_lstFaces[i]->m_iIndex[j];
|
||
|
||
MultiVertex *pVerts = (MultiVertex *)(m_pOutHouseObject->m_pVertex[iObject]);
|
||
pVerts[iCurrent].tu1 = NewGenerator.m_lstFaces[i]->m_pVerts[j].m_vecTexcoord.x;
|
||
pVerts[iCurrent].tv1 = NewGenerator.m_lstFaces[i]->m_pVerts[j].m_vecTexcoord.y;
|
||
|
||
|
||
}
|
||
|
||
}
|
||
*/
|
||
sprintf(strObjectInfo,"Save Lightmap");
|
||
|
||
cd.X=0;
|
||
cd.Y=3;
|
||
WriteConsoleOutputCharacter(hStdOut,strObjectInfo,strlen(strObjectInfo),cd,&dwWordLens);
|
||
|
||
for(cObjectScene=0;cObjectScene<m_ObjectList.num;cObjectScene++)
|
||
{
|
||
m_ObjectList[cObjectScene]->m_pObject->AllUnlockBuffer();
|
||
}
|
||
|
||
if(m_pOutHouseObject)
|
||
m_pOutHouseObject->AllUnlockBuffer();
|
||
|
||
|
||
|
||
}
|
||
void CHouseObject::GenerateCaldronPointLightmap(matrix matSet,matrix matHouseTM,CSectorLight *pLights,int iLights)
|
||
{
|
||
|
||
char de[256];
|
||
|
||
if(!m_pInHouseObject)
|
||
return;
|
||
|
||
int iValue = 1;
|
||
|
||
|
||
FILE *fp = fopen("c:/mp-project/CaldronLightData.dat","wb+");
|
||
fwrite(&iLights,sizeof(int),1,fp);
|
||
D3DXVECTOR3 vecPos,vecColor;
|
||
float fRad;
|
||
|
||
/// Light Save File Create
|
||
for(int i = 0; i < iLights; i++ )
|
||
{
|
||
////////////////
|
||
|
||
D3DXMATRIX matTmp;
|
||
D3DXMATRIX matInv;
|
||
|
||
D3DXMatrixIdentity(&matTmp);
|
||
|
||
matTmp._11 = matHouseTM._11;
|
||
matTmp._12 = matHouseTM._12;
|
||
matTmp._13 = matHouseTM._13;
|
||
matTmp._14 = matHouseTM._14;
|
||
|
||
matTmp._21 = matHouseTM._21;
|
||
matTmp._22 = matHouseTM._22;
|
||
matTmp._23 = matHouseTM._23;
|
||
matTmp._24 = matHouseTM._24;
|
||
|
||
matTmp._31 = matHouseTM._31;
|
||
matTmp._32 = matHouseTM._32;
|
||
matTmp._33 = matHouseTM._33;
|
||
matTmp._34 = matHouseTM._34;
|
||
|
||
matTmp._41 = matHouseTM._41;
|
||
matTmp._42 = matHouseTM._42;
|
||
matTmp._43 = matHouseTM._43;
|
||
matTmp._44 = matHouseTM._44;
|
||
|
||
D3DXMatrixInverse(&matInv,NULL,&matTmp);
|
||
D3DXMatrixIdentity(&matTmp);
|
||
|
||
matTmp._41 = pLights[i].m_vecPos.x;
|
||
matTmp._42 = pLights[i].m_vecPos.y;
|
||
matTmp._43 = pLights[i].m_vecPos.z;
|
||
|
||
D3DXMatrixMultiply(&matTmp,&matTmp,&matInv);
|
||
vecPos.x = matTmp._41;
|
||
vecPos.y = matTmp._42;
|
||
vecPos.z = matTmp._43;
|
||
|
||
vecColor = pLights[i].m_vecColor / 255.0f;
|
||
fRad = pLights[i].m_fRange;
|
||
fwrite(&vecPos,sizeof(D3DXVECTOR3),1,fp);
|
||
fwrite(&vecColor,sizeof(D3DXVECTOR3),1,fp);
|
||
fwrite(&fRad,sizeof(float),1,fp);
|
||
|
||
}
|
||
fclose(fp);
|
||
|
||
|
||
char strArg[256];
|
||
char strDDSName[MAX_NAMEBUFFER];
|
||
char *strTextureName = strrchr(m_pInHouseObject->m_strMeshName,'\\');
|
||
|
||
sprintf(strDDSName,"%s\\%s",LIGHTMAPTEXTUREPATH,strTextureName);
|
||
strTextureName = strrchr(strDDSName,'.');
|
||
(*strTextureName) = '.';
|
||
strTextureName++;
|
||
(*strTextureName) = 'd';
|
||
strTextureName++;
|
||
(*strTextureName) = 'd';
|
||
strTextureName++;
|
||
(*strTextureName) = 's';
|
||
strTextureName++;
|
||
(*strTextureName) = 0;
|
||
|
||
D3DXVECTOR3 vecLight = D3DXVECTOR3(1.0f,1.0f,1.0f);
|
||
|
||
switch(MessageBox(NULL,"<EFBFBD><EFBFBD><EFBFBD>İ<EFBFBD><EFBFBD><EFBFBD> ?","MSG",MB_YESNO))
|
||
{
|
||
case IDNO:
|
||
sprintf(strArg,"%s %d %f %f %f %s %s %s %d","Caldron_LightmapGenerator",iValue,vecLight.x,vecLight.y,vecLight.z,m_pInHouseObject->m_strMeshName,"t",strDDSName,0);
|
||
|
||
break;
|
||
case IDYES:
|
||
sprintf(strArg,"%s %d %f %f %f %s %s %s %d","Caldron_LightmapGenerator",iValue,vecLight.x,vecLight.y,vecLight.z,m_pInHouseObject->m_strMeshName,"t",strDDSName,1);
|
||
|
||
break;
|
||
}
|
||
|
||
|
||
|
||
|
||
MessageBox(NULL,strArg,"tt",MB_OK);
|
||
if(m_pInHouseObject)
|
||
{
|
||
|
||
|
||
STARTUPINFO si;
|
||
PROCESS_INFORMATION pi;
|
||
|
||
ZeroMemory( &si, sizeof(si) );
|
||
si.cb = sizeof(si);
|
||
ZeroMemory( &pi, sizeof(pi) );
|
||
|
||
// Start the child process.
|
||
if( !CreateProcess(
|
||
"c:/mp-project/Caldron_LightmapGenerator.exe",
|
||
strArg, // Command line.
|
||
NULL, // Process handle not inheritable.
|
||
NULL, // Thread handle not inheritable.
|
||
FALSE, // Set handle inheritance to FALSE.
|
||
CREATE_NEW_PROCESS_GROUP, // No creation flags.
|
||
NULL, // Use parent's environment block.
|
||
"c:/mp-project/", // Use parent's starting directory.
|
||
&si, // Pointer to STARTUPINFO structure.
|
||
&pi ) // Pointer to PROCESS_INFORMATION structure.
|
||
)
|
||
{
|
||
MessageBox(NULL,"CreateProcess failed.","Error",MB_OK);
|
||
|
||
}
|
||
|
||
// Wait until child process exits.
|
||
WaitForSingleObject( pi.hProcess, INFINITE );
|
||
|
||
// Close process and thread handles.
|
||
CloseHandle( pi.hProcess );
|
||
CloseHandle( pi.hThread );
|
||
}
|
||
}
|
||
void CHouseObject::GenerateCaldronLightmap(matrix matSet,matrix matHouseTM,CSectorLight *pLights,int iLights)
|
||
{
|
||
char de[256];
|
||
|
||
if(!m_pOutHouseObject)
|
||
return;
|
||
|
||
|
||
FILE *fp = fopen("c:/mp-project/CaldronLightData.dat","wb+");
|
||
fwrite(&iLights,sizeof(int),1,fp);
|
||
D3DXVECTOR3 vecPos,vecColor;
|
||
float fRad;
|
||
|
||
/// Light Save File Create
|
||
for(int i = 0; i < iLights; i++ )
|
||
{
|
||
////////////////
|
||
|
||
D3DXMATRIX matTmp;
|
||
D3DXMATRIX matInv;
|
||
|
||
D3DXMatrixIdentity(&matTmp);
|
||
|
||
matTmp._11 = matHouseTM._11;
|
||
matTmp._12 = matHouseTM._12;
|
||
matTmp._13 = matHouseTM._13;
|
||
matTmp._14 = matHouseTM._14;
|
||
|
||
matTmp._21 = matHouseTM._21;
|
||
matTmp._22 = matHouseTM._22;
|
||
matTmp._23 = matHouseTM._23;
|
||
matTmp._24 = matHouseTM._24;
|
||
|
||
matTmp._31 = matHouseTM._31;
|
||
matTmp._32 = matHouseTM._32;
|
||
matTmp._33 = matHouseTM._33;
|
||
matTmp._34 = matHouseTM._34;
|
||
|
||
matTmp._41 = matHouseTM._41;
|
||
matTmp._42 = matHouseTM._42;
|
||
matTmp._43 = matHouseTM._43;
|
||
matTmp._44 = matHouseTM._44;
|
||
|
||
D3DXMatrixInverse(&matInv,NULL,&matTmp);
|
||
D3DXMatrixIdentity(&matTmp);
|
||
|
||
matTmp._41 = pLights[i].m_vecPos.x;
|
||
matTmp._42 = pLights[i].m_vecPos.y;
|
||
matTmp._43 = pLights[i].m_vecPos.z;
|
||
|
||
D3DXMatrixMultiply(&matTmp,&matTmp,&matInv);
|
||
vecPos.x = matTmp._41;
|
||
vecPos.y = matTmp._42;
|
||
vecPos.z = matTmp._43;
|
||
|
||
vecColor = pLights[i].m_vecColor / 255.0f;
|
||
fRad = pLights[i].m_fRange;
|
||
fwrite(&vecPos,sizeof(D3DXVECTOR3),1,fp);
|
||
fwrite(&vecColor,sizeof(D3DXVECTOR3),1,fp);
|
||
fwrite(&fRad,sizeof(float),1,fp);
|
||
|
||
}
|
||
fclose(fp);
|
||
|
||
vector3 vecLight(-1.0f,-1.0f,-1.0f);
|
||
vecLight=matSet*vecLight;
|
||
|
||
vecLight.Normalize();
|
||
char strArg[256];
|
||
char strDDSName[MAX_NAMEBUFFER];
|
||
char *strTextureName = strrchr(m_pOutHouseObject->m_strMeshName,'\\');
|
||
|
||
sprintf(strDDSName,"%s\\%s",LIGHTMAPTEXTUREPATH,strTextureName);
|
||
strTextureName = strrchr(strDDSName,'.');
|
||
(*strTextureName) = '.';
|
||
strTextureName++;
|
||
(*strTextureName) = 'd';
|
||
strTextureName++;
|
||
(*strTextureName) = 'd';
|
||
strTextureName++;
|
||
(*strTextureName) = 's';
|
||
strTextureName++;
|
||
(*strTextureName) = 0;
|
||
int iValue = 2;
|
||
/* if(MessageBox(NULL,"<22><EFBFBD> + <20><><EFBFBD><EFBFBD>Ʈ + <20><>ī<EFBFBD><C4AB>?","MSG",MB_YESNO) == IDNO)
|
||
{
|
||
iValue = 3;
|
||
}
|
||
*/
|
||
|
||
switch(MessageBox(NULL,"<EFBFBD><EFBFBD><EFBFBD>İ<EFBFBD><EFBFBD><EFBFBD> ?","MSG",MB_YESNO))
|
||
{
|
||
case IDNO:
|
||
if(m_pMedHouseObject)
|
||
sprintf(strArg,"%s %d %f %f %f %s %s %s %d","Caldron_LightmapGenerator",iValue,vecLight.x,vecLight.y,vecLight.z,m_pOutHouseObject->m_strMeshName,m_pMedHouseObject->m_strMeshName,strDDSName,0);
|
||
else
|
||
sprintf(strArg,"%s %d %f %f %f %s %s %s %d","Caldron_LightmapGenerator",iValue,vecLight.x,vecLight.y,vecLight.z,m_pOutHouseObject->m_strMeshName,"t",strDDSName,0);
|
||
break;
|
||
case IDYES:
|
||
if(m_pMedHouseObject)
|
||
sprintf(strArg,"%s %d %f %f %f %s %s %s %d","Caldron_LightmapGenerator",iValue,vecLight.x,vecLight.y,vecLight.z,m_pOutHouseObject->m_strMeshName,m_pMedHouseObject->m_strMeshName,strDDSName,1);
|
||
else
|
||
sprintf(strArg,"%s %d %f %f %f %s %s %s %d","Caldron_LightmapGenerator",iValue,vecLight.x,vecLight.y,vecLight.z,m_pOutHouseObject->m_strMeshName,"t",strDDSName,1);
|
||
break;
|
||
}
|
||
|
||
|
||
|
||
|
||
MessageBox(NULL,strArg,"tt",MB_OK);
|
||
if(m_pOutHouseObject)
|
||
{
|
||
|
||
|
||
STARTUPINFO si;
|
||
PROCESS_INFORMATION pi;
|
||
|
||
ZeroMemory( &si, sizeof(si) );
|
||
si.cb = sizeof(si);
|
||
ZeroMemory( &pi, sizeof(pi) );
|
||
|
||
// Start the child process.
|
||
if( !CreateProcess(
|
||
"c:/mp-project/Caldron_LightmapGenerator.exe",
|
||
strArg, // Command line.
|
||
NULL, // Process handle not inheritable.
|
||
NULL, // Thread handle not inheritable.
|
||
FALSE, // Set handle inheritance to FALSE.
|
||
CREATE_NEW_PROCESS_GROUP, // No creation flags.
|
||
NULL, // Use parent's environment block.
|
||
"c:/mp-project/", // Use parent's starting directory.
|
||
&si, // Pointer to STARTUPINFO structure.
|
||
&pi ) // Pointer to PROCESS_INFORMATION structure.
|
||
)
|
||
{
|
||
MessageBox(NULL,"CreateProcess failed.","Error",MB_OK);
|
||
|
||
}
|
||
|
||
// Wait until child process exits.
|
||
WaitForSingleObject( pi.hProcess, INFINITE );
|
||
|
||
// Close process and thread handles.
|
||
CloseHandle( pi.hProcess );
|
||
CloseHandle( pi.hThread );
|
||
}
|
||
}
|
||
void CHouseObject::GenerateLightmap(matrix matSet,matrix matHouseTM,int LightmapMode)
|
||
{
|
||
char de[256];
|
||
if(m_pOutHouseObject->m_dwShader!=MultiFVF)
|
||
{
|
||
m_pOutHouseObject->ConvertMulti();
|
||
if(m_pMedHouseObject)
|
||
m_pMedHouseObject->ConvertMulti();
|
||
if(m_pInHouseObject)
|
||
m_pInHouseObject->ConvertMulti();
|
||
}
|
||
|
||
int cObjectScene=0;
|
||
for(cObjectScene=0;cObjectScene<m_ObjectList.num;cObjectScene++)
|
||
{
|
||
m_ObjectList[cObjectScene]->m_pObject->AllLockBuffer();
|
||
}
|
||
vector3 vecLight(1.0f,1.0f,1.0f);
|
||
vecLight=matSet*vecLight;
|
||
|
||
vecLight.Normalize();
|
||
vector3 *vecFirstDetect[3];
|
||
List<vector3*> vecClassfy;
|
||
List<int*> IndicesUsed;
|
||
List<int> LightmapSizeX;
|
||
List<int> LightmapSizeY;
|
||
int UsedPlane=0;
|
||
int cObject=0,cTotalObject=0;
|
||
List<MultiVertex*> pMeshVertex;
|
||
List<WORD*> pMeshIndices;
|
||
List<int> nMeshVertex;
|
||
|
||
int cIntersectionPoly=0;
|
||
int NotUsedPlane=0;
|
||
if(m_pOutHouseObject)
|
||
{
|
||
m_pOutHouseObject->AllLockBuffer();
|
||
for(cObject=0;cObject<m_pOutHouseObject->GetObjectCount();cObject++,cTotalObject++)
|
||
{
|
||
int *pUsedIndices=new int[m_pOutHouseObject->m_nIndices[cObject]];
|
||
memset(pUsedIndices,-1,sizeof(int)*m_pOutHouseObject->m_nIndices[cObject]);
|
||
IndicesUsed.Add(pUsedIndices);
|
||
pMeshVertex.Add((MultiVertex*)m_pOutHouseObject->m_pVertex[cObject]);
|
||
pMeshIndices.Add(m_pOutHouseObject->m_pIndices[cObject]);
|
||
m_nIndices.Add(m_pOutHouseObject->m_nIndices[cObject]);
|
||
nMeshVertex.Add(m_pOutHouseObject->m_nVertex[cObject]);
|
||
}
|
||
}
|
||
if(m_pInHouseObject)
|
||
{
|
||
m_pInHouseObject->AllLockBuffer();
|
||
for(cObject=0;cObject<m_pInHouseObject->GetObjectCount();cObject++,cTotalObject++)
|
||
{
|
||
int *pUsedIndices=new int[m_pInHouseObject->m_nIndices[cObject]];
|
||
memset(pUsedIndices,-1,sizeof(int)*m_pInHouseObject->m_nIndices[cObject]);
|
||
IndicesUsed.Add(pUsedIndices);
|
||
pMeshVertex.Add((MultiVertex*)m_pInHouseObject->m_pVertex[cObject]);
|
||
pMeshIndices.Add(m_pInHouseObject->m_pIndices[cObject]);
|
||
m_nIndices.Add(m_pInHouseObject->m_nIndices[cObject]);
|
||
nMeshVertex.Add(m_pInHouseObject->m_nVertex[cObject]);
|
||
}
|
||
}
|
||
cIntersectionPoly=cTotalObject;
|
||
if(m_pMedHouseObject)
|
||
{
|
||
m_pMedHouseObject->AllLockBuffer();
|
||
for(cObject=0;cObject<m_pMedHouseObject->GetObjectCount();cObject++,cTotalObject++)
|
||
{
|
||
int *pUsedIndices=new int[m_pMedHouseObject->m_nIndices[cObject]];
|
||
memset(pUsedIndices,-1,sizeof(int)*m_pMedHouseObject->m_nIndices[cObject]);
|
||
IndicesUsed.Add(pUsedIndices);
|
||
pMeshVertex.Add((MultiVertex*)m_pMedHouseObject->m_pVertex[cObject]);
|
||
pMeshIndices.Add(m_pMedHouseObject->m_pIndices[cObject]);
|
||
m_nIndices.Add(m_pMedHouseObject->m_nIndices[cObject]);
|
||
nMeshVertex.Add(m_pMedHouseObject->m_nVertex[cObject]);
|
||
}
|
||
}
|
||
|
||
int NoWantedLightmap=0;
|
||
//CTexture *lightmap=new CTexture[1024];
|
||
List<DWORD*> LightmapStorage;
|
||
float fMax_PlaneArea=0.0f;
|
||
float fMin_PlaneArea=100000000.0f;
|
||
float fTotal_PlaneArea=0.0f;
|
||
|
||
AllocConsole();
|
||
|
||
HANDLE hStdOut=GetStdHandle(STD_OUTPUT_HANDLE);
|
||
int a=strlen("abcd");
|
||
COORD cd;
|
||
DWORD dwWordLens;
|
||
|
||
for(cObject=0;cObject<IndicesUsed.num;cObject++)
|
||
{
|
||
bool isRemainIndices=true;
|
||
MultiVertex *pVertex=pMeshVertex[cObject];
|
||
WORD *pIndices=pMeshIndices[cObject];
|
||
char strObjectInfo[256];
|
||
sprintf(strObjectInfo,"Object %d/%d",cObject,IndicesUsed.num);
|
||
|
||
cd.X=0;
|
||
cd.Y=0;
|
||
WriteConsoleOutputCharacter(hStdOut,strObjectInfo,strlen(strObjectInfo),cd,&dwWordLens);
|
||
|
||
while(isRemainIndices)
|
||
{
|
||
int cRemainPoly=0;
|
||
for(int cIndices=0;cIndices<m_nIndices[cObject];cIndices++)
|
||
{
|
||
if(IndicesUsed[cObject][cIndices]==-1)
|
||
{
|
||
vecFirstDetect[0]=&pVertex[ pIndices[cIndices*3+0] ].v;
|
||
vecFirstDetect[1]=&pVertex[ pIndices[cIndices*3+1] ].v;
|
||
vecFirstDetect[2]=&pVertex[ pIndices[cIndices*3+2] ].v;
|
||
IndicesUsed[cObject][cIndices]=UsedPlane;
|
||
break;
|
||
}
|
||
}
|
||
if(cIndices==m_nIndices[cObject])
|
||
break;
|
||
vecClassfy.num=0;
|
||
vecClassfy.Add(vecFirstDetect[0]);
|
||
vecClassfy.Add(vecFirstDetect[1]);
|
||
vecClassfy.Add(vecFirstDetect[2]);
|
||
|
||
int cUsedClassfy=1;
|
||
float fDistance[3];
|
||
vector3 vecFirstNormal=(*vecFirstDetect[1]-*vecFirstDetect[0])^(*vecFirstDetect[2]-*vecFirstDetect[0]);
|
||
vecFirstNormal.Normalize();
|
||
|
||
vector3 *vecTestClassfy[3];
|
||
vector3 vecTestNormal;
|
||
for(int cInObject=0;cInObject<m_nIndices.num;cInObject++)
|
||
{
|
||
MultiVertex *pTestVertex=pMeshVertex[cInObject];
|
||
WORD *pTestIndices=pMeshIndices[cInObject];
|
||
for(cIndices=0;cIndices<m_nIndices[cInObject];cIndices++)
|
||
{
|
||
if(IndicesUsed[cInObject][cIndices]==-1)
|
||
{
|
||
cRemainPoly++;
|
||
vecTestClassfy[0]=&pTestVertex[pTestIndices[cIndices*3+0]].v;
|
||
vecTestClassfy[1]=&pTestVertex[pTestIndices[cIndices*3+1]].v;
|
||
vecTestClassfy[2]=&pTestVertex[pTestIndices[cIndices*3+2]].v;
|
||
|
||
vecTestNormal=(*vecTestClassfy[1]-*vecTestClassfy[0])^(*vecTestClassfy[2]-*vecTestClassfy[0]);
|
||
vecTestNormal.Normalize();
|
||
|
||
|
||
if(!(vecTestNormal == vecFirstNormal))
|
||
continue;
|
||
|
||
// vecTestClassfy[0])-(*vecFirstDetect[0]) <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> vecFirstNormal<61><6C><EFBFBD>Ϳ<EFBFBD> <20>ش<EFBFBD><D8B4>ϴ<EFBFBD> <20><><EFBFBD><EFBFBD>
|
||
fDistance[0]= vecFirstNormal * ( (*vecTestClassfy[0])-(*vecFirstDetect[0]));
|
||
fDistance[1]= vecFirstNormal * ( (*vecTestClassfy[1])-(*vecFirstDetect[0]));
|
||
fDistance[2]= vecFirstNormal * ( (*vecTestClassfy[2])-(*vecFirstDetect[0]));
|
||
|
||
if( fDistance[0] >= -NEARPLANEVALUE && fDistance[0] <= NEARPLANEVALUE &&
|
||
fDistance[1] >= -NEARPLANEVALUE && fDistance[1] <= NEARPLANEVALUE &&
|
||
fDistance[2] >= -NEARPLANEVALUE && fDistance[2] <= NEARPLANEVALUE)
|
||
{
|
||
vecClassfy.Add(vecTestClassfy[0]);
|
||
vecClassfy.Add(vecTestClassfy[1]);
|
||
vecClassfy.Add(vecTestClassfy[2]);
|
||
IndicesUsed[cInObject][cIndices]=UsedPlane;
|
||
cUsedClassfy++;
|
||
continue;
|
||
} //IF
|
||
|
||
} //if
|
||
} //for
|
||
}//for
|
||
|
||
vector3 C= vecFirstNormal^vector3(0.0f,1.0f,0.0f);
|
||
C.Normalize();
|
||
float fAngleZ=acosf(vecFirstNormal.y);
|
||
sprintf(de,"Angle = %f",fAngleZ);
|
||
//MessageBox(0,de,0,0);
|
||
matrix matPlaneRot;
|
||
matPlaneRot.Rotation(C,-fAngleZ);
|
||
if(fAngleZ>=-0.005f && fAngleZ<=0.005f) matPlaneRot.MakeIdent();
|
||
if(fAngleZ>=3.140f) matPlaneRot.MakeIdent();
|
||
|
||
if(vecFirstNormal == vector3(0.0f,1.0f,0.0f))
|
||
matPlaneRot.MakeIdent();
|
||
if(vecFirstNormal == vector3(0.0f,-1.0f,0.0f))
|
||
matPlaneRot.MakeIdent();
|
||
|
||
|
||
matrix matPos;
|
||
matPos.Translation(vector3(vecFirstDetect[0]->x,vecFirstDetect[0]->y,vecFirstDetect[0]->z));
|
||
matPos=matPos*matPlaneRot;
|
||
|
||
sprintf(de,"vector = %f, %f, %f",vecFirstDetect[0]->x,vecFirstDetect[0]->y,vecFirstDetect[0]->z);
|
||
//MessageBox(0,de,0,0);
|
||
|
||
float fMaxX,fMinX,fMaxZ,fMinZ;
|
||
fMaxX=matPos._41;fMaxZ=matPos._43;
|
||
sprintf(de,"Max = %f, %f",fMaxX,fMaxZ);
|
||
//MessageBox(0,de,0,0);
|
||
|
||
fMinX=matPos._41;fMinZ=matPos._43;
|
||
sprintf(de,"Min = %f, %f",fMinX,fMinZ);
|
||
//MessageBox(0,de,0,0);
|
||
|
||
vector3 *TempPos=new vector3[cUsedClassfy*3];
|
||
for(cIndices=0;cIndices<cUsedClassfy;cIndices++)
|
||
{
|
||
for(int Inner=0;Inner<3;Inner++)
|
||
{
|
||
matPos.Translation(vector3(vecClassfy[cIndices*3+Inner]->x,
|
||
vecClassfy[cIndices*3+Inner]->y,
|
||
vecClassfy[cIndices*3+Inner]->z));
|
||
matPos=matPos*matPlaneRot;
|
||
TempPos[cIndices*3+Inner].x=matPos._41;
|
||
TempPos[cIndices*3+Inner].y=matPos._42;
|
||
TempPos[cIndices*3+Inner].z=matPos._43;
|
||
if(fMaxX < TempPos[cIndices*3+Inner].x) fMaxX=TempPos[cIndices*3+Inner].x;
|
||
if(fMaxZ < TempPos[cIndices*3+Inner].z) fMaxZ=TempPos[cIndices*3+Inner].z;
|
||
if(fMinX > TempPos[cIndices*3+Inner].x) fMinX=TempPos[cIndices*3+Inner].x;
|
||
if(fMinZ > TempPos[cIndices*3+Inner].z) fMinZ=TempPos[cIndices*3+Inner].z;
|
||
}
|
||
}
|
||
float fInterX=fMaxX-fMinX;
|
||
|
||
float fInterZ=fMaxZ-fMinZ;
|
||
|
||
if( fabs(fInterX*fInterZ) > fMax_PlaneArea)
|
||
{
|
||
fMax_PlaneArea=fabs(fInterX*fInterZ);
|
||
}
|
||
|
||
if( fabs(fInterX*fInterZ) < fMin_PlaneArea)
|
||
{
|
||
fMin_PlaneArea=fabs(fInterX*fInterZ);
|
||
}
|
||
|
||
fTotal_PlaneArea+=fabs(fInterX*fInterZ);
|
||
int LightX=fabs(fInterX/PERLIGHTMAP)+1;
|
||
int LightY=fabs(fInterZ/PERLIGHTMAP)+1;
|
||
LightmapSizeX.Add(LightX);
|
||
LightmapSizeY.Add(LightY);
|
||
|
||
for(cIndices=0;cIndices<cUsedClassfy;cIndices++)
|
||
{
|
||
((MultiVertex*)vecClassfy[cIndices*3+0])->tu1=(TempPos[cIndices*3+0].x-fMinX)/fInterX;
|
||
((MultiVertex*)vecClassfy[cIndices*3+0])->tv1=(TempPos[cIndices*3+0].z-fMinZ)/fInterZ;
|
||
|
||
((MultiVertex*)vecClassfy[cIndices*3+1])->tu1=(TempPos[cIndices*3+1].x-fMinX)/fInterX;
|
||
((MultiVertex*)vecClassfy[cIndices*3+1])->tv1=(TempPos[cIndices*3+1].z-fMinZ)/fInterZ;
|
||
|
||
((MultiVertex*)vecClassfy[cIndices*3+2])->tu1=(TempPos[cIndices*3+2].x-fMinX)/fInterX;
|
||
((MultiVertex*)vecClassfy[cIndices*3+2])->tv1=(TempPos[cIndices*3+2].z-fMinZ)/fInterZ;
|
||
}
|
||
|
||
vector3 vecOri,vecU,vecV;
|
||
|
||
vecOri.x=fMinX;vecOri.y=TempPos[0].y;vecOri.z=fMinZ;
|
||
vecU.x=fMaxX;vecU.y=TempPos[0].y;vecU.z=fMinZ;
|
||
vecV.x=fMinX;vecV.y=TempPos[0].y;vecV.z=fMaxZ;
|
||
|
||
|
||
matPlaneRot.Rotation(C,fAngleZ);
|
||
if(fAngleZ>=-0.005f && fAngleZ<=0.005f) matPlaneRot.MakeIdent();
|
||
if(fAngleZ>=3.140f) matPlaneRot.MakeIdent();
|
||
if(vecFirstNormal == vector3(0.0f,1.0f,0.0f))
|
||
matPlaneRot.MakeIdent();
|
||
if(vecFirstNormal == vector3(0.0f,-1.0f,0.0f))
|
||
matPlaneRot.MakeIdent();
|
||
|
||
matPos.Translation(vecOri);
|
||
matPos=matPos*matPlaneRot;
|
||
vecOri=matPos.GetLoc();
|
||
|
||
matPos.Translation(vecU);
|
||
matPos=matPos*matPlaneRot;
|
||
vecU=matPos.GetLoc();
|
||
|
||
matPos.Translation(vecV);
|
||
matPos=matPos*matPlaneRot;
|
||
vecV=matPos.GetLoc();
|
||
//delete [] TempPos;
|
||
|
||
//vecU=(vecU-vecOri)/(LIGHTMAPSIZE);
|
||
//vecV=(vecV-vecOri)/(LIGHTMAPSIZE);
|
||
|
||
vecU=(vecU-vecOri)/(LightmapSizeX[UsedPlane]);
|
||
vecV=(vecV-vecOri)/(LightmapSizeY[UsedPlane]);
|
||
|
||
|
||
float fLightBright=vecFirstNormal*vecLight;
|
||
fLightBright+=0.3f;
|
||
color LightColor;
|
||
LightColor.r=(COLORVALUE)(0xff*fLightBright);
|
||
LightColor.g=(COLORVALUE)(0xff*fLightBright);
|
||
LightColor.b=(COLORVALUE)(0xff*fLightBright);
|
||
LightColor.a=0xff;
|
||
|
||
if(fLightBright<=0.0f)
|
||
{
|
||
if(LightmapMode==0)
|
||
{
|
||
LightColor.r=(COLORVALUE)(60);LightColor.g=(COLORVALUE)(60);LightColor.b=(COLORVALUE)(60);
|
||
LightColor.a=0xff;
|
||
}
|
||
else
|
||
{
|
||
LightColor.r=(COLORVALUE)(20);LightColor.g=(COLORVALUE)(20);LightColor.b=(COLORVALUE)(20);
|
||
LightColor.a=0xff;
|
||
}
|
||
}
|
||
if(fLightBright>1.0f)
|
||
{
|
||
LightColor.r=(COLORVALUE)(255);LightColor.g=(COLORVALUE)(255);LightColor.b=(COLORVALUE)(255);
|
||
LightColor.a=0xff;
|
||
}
|
||
vector3 *v[3];
|
||
DWORD *AddLightmap=new DWORD[LightmapSizeX[UsedPlane]*LightmapSizeY[UsedPlane]];
|
||
|
||
for(int j=0;j<LightmapSizeX[UsedPlane];j++)
|
||
{
|
||
for(int k=0;k<LightmapSizeY[UsedPlane];k++)
|
||
{
|
||
AddLightmap[j+k*LightmapSizeX[UsedPlane]]=LightColor.c;
|
||
}
|
||
}
|
||
|
||
//LightmapStorage.Add(AddLightmap);
|
||
DWORD *pSurface=AddLightmap;
|
||
|
||
List<POINT> InTriangle;
|
||
List<POINT> NotInTriangle;
|
||
|
||
|
||
sprintf(strObjectInfo,"Remain poly %d ",cRemainPoly);
|
||
cd.X=0;
|
||
cd.Y=1;
|
||
WriteConsoleOutputCharacter(hStdOut,strObjectInfo,strlen(strObjectInfo),cd,&dwWordLens);
|
||
|
||
{
|
||
int cLightmapCurrentCalc=0;
|
||
for(int iu=0;iu<LightmapSizeX[UsedPlane];iu++)
|
||
{
|
||
for(int iv=0;iv<LightmapSizeY[UsedPlane];iv++)
|
||
{
|
||
cLightmapCurrentCalc++;
|
||
sprintf(strObjectInfo,"Remain poly %d , Lightmap Calc %8d/%8d",cRemainPoly,cLightmapCurrentCalc,LightmapSizeX[UsedPlane]*LightmapSizeY[UsedPlane]);
|
||
cd.X=0;
|
||
cd.Y=1;
|
||
WriteConsoleOutputCharacter(hStdOut,strObjectInfo,strlen(strObjectInfo),cd,&dwWordLens);
|
||
|
||
vector3 vecStart=vecOri+vecU*(float)iu+vecV*(float)iv+vecU*0.5f+vecV*0.5f;
|
||
vector3 vecEnd=vecOri+vecU*(float)iu+vecV*(float)iv+vecU*0.5f+vecV*0.5f+vecLight*10000.0f;
|
||
vector3 vecNormalEnd=vecFirstNormal*10000.0f+vecStart;
|
||
|
||
vector3 vecNegaEnd=vecOri+vecU*(float)iu+vecV*(float)iv+vecU*0.5f+vecV*0.5f+vecLight*(-10000.0f);
|
||
|
||
|
||
bool bInTriangle=true;
|
||
//*
|
||
for(int cOtherObject=0;cOtherObject<cIntersectionPoly;cOtherObject++)
|
||
{
|
||
MultiVertex *pOtherVertex=pMeshVertex[cOtherObject];
|
||
WORD *pIndices=pMeshIndices[cOtherObject];
|
||
for(int cOtherPoly=0;cOtherPoly<m_nIndices[cOtherObject];cOtherPoly++)
|
||
{
|
||
if(IndicesUsed[cOtherObject][cOtherPoly]==UsedPlane)
|
||
{
|
||
v[0]=(vector3*)&pOtherVertex[pIndices[cOtherPoly*3+0]];
|
||
v[1]=(vector3*)&pOtherVertex[pIndices[cOtherPoly*3+1]];
|
||
v[2]=(vector3*)&pOtherVertex[pIndices[cOtherPoly*3+2]];
|
||
vector3 pPoly[3];
|
||
pPoly[0]=*v[0];
|
||
pPoly[1]=*v[1];
|
||
pPoly[2]=*v[2];
|
||
float fLightLens;
|
||
if(CIntersection::PolygonRay( vecStart,vecEnd,
|
||
pPoly,fLightLens))
|
||
{
|
||
bInTriangle=true;
|
||
}
|
||
if(CIntersection::PolygonRay( vecStart,vecNegaEnd,
|
||
pPoly,fLightLens))
|
||
{
|
||
bInTriangle=true;
|
||
}
|
||
}
|
||
}
|
||
if(bInTriangle)
|
||
break;
|
||
}
|
||
if(bInTriangle==false)
|
||
{
|
||
pSurface[iu+iv*(int)LightmapSizeX[UsedPlane]]=LightColor.c;
|
||
POINT AddNot;
|
||
AddNot.x=iu;
|
||
AddNot.y=iv;
|
||
NotInTriangle.Add(AddNot);
|
||
}
|
||
else
|
||
{
|
||
POINT Add;
|
||
Add.x=iu;
|
||
Add.y=iv;
|
||
InTriangle.Add(Add);
|
||
}
|
||
|
||
bool isAmbientWrite=false;
|
||
for(cOtherObject=0;cOtherObject<cIntersectionPoly;cOtherObject++)
|
||
{
|
||
MultiVertex *pOtherVertex=pMeshVertex[cOtherObject];
|
||
WORD *pIndices=pMeshIndices[cOtherObject];
|
||
for(int cOtherPoly=0;cOtherPoly<m_nIndices[cOtherObject];cOtherPoly++)
|
||
{
|
||
if(IndicesUsed[cOtherObject][cOtherPoly]!=UsedPlane)
|
||
{
|
||
v[0]=(vector3*)&pOtherVertex[pIndices[cOtherPoly*3+0]];
|
||
v[1]=(vector3*)&pOtherVertex[pIndices[cOtherPoly*3+1]];
|
||
v[2]=(vector3*)&pOtherVertex[pIndices[cOtherPoly*3+2]];
|
||
vector3 pPoly[3];
|
||
pPoly[0]=*v[0];
|
||
pPoly[1]=*v[1];
|
||
pPoly[2]=*v[2];
|
||
float fLightLens;
|
||
bool bAmbientIntersection=false;
|
||
if(CIntersection::PolygonRay( vecStart,vecEnd,
|
||
pPoly,fLightLens))
|
||
{
|
||
if(LightmapMode==0)
|
||
{
|
||
// <20>Ÿ<EFBFBD><C5B8><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> normal <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> poly <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> collision <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||
vector3 vecPolyCross = (pPoly[1] - pPoly[0]) ^ (pPoly[2] - pPoly[0]);
|
||
vecPolyCross.Normalize();
|
||
float fDot = vecPolyCross * vecFirstNormal;
|
||
|
||
float fDist[3];
|
||
|
||
fDist[0]= vecFirstNormal * ( (pPoly[0])-(*vecFirstDetect[0]));
|
||
fDist[1]= vecFirstNormal * ( (pPoly[1])-(*vecFirstDetect[0]));
|
||
fDist[2]= vecFirstNormal * ( (pPoly[2])-(*vecFirstDetect[0]));
|
||
|
||
float fControlDist = 150.0f;
|
||
if( (fabs(fDist[0]) <= fControlDist) &&
|
||
(fabs(fDist[1]) <= fControlDist) &&
|
||
(fabs(fDist[2]) <= fControlDist) &&
|
||
(fabs(fDot) > 0.6f))
|
||
{
|
||
pSurface[iu+iv*(int)LightmapSizeX[UsedPlane]]=0xff606060;
|
||
}
|
||
else {
|
||
// Ambient Write
|
||
pSurface[iu+iv*(int)LightmapSizeX[UsedPlane]]=0xff606060;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
pSurface[iu+iv*(int)LightmapSizeX[UsedPlane]]=0xff202020;
|
||
for(int cAmbientObject=0;cAmbientObject<cIntersectionPoly;cAmbientObject++)
|
||
{
|
||
MultiVertex *pAmbientVertex=pMeshVertex[cAmbientObject];
|
||
WORD *pAmbientIndices=pMeshIndices[cAmbientObject];
|
||
for(int cAmbientPoly=0;cAmbientPoly<m_nIndices[cAmbientObject];cAmbientPoly++)
|
||
{
|
||
if(IndicesUsed[cAmbientObject][cAmbientPoly]!=UsedPlane)
|
||
{
|
||
v[0]=(vector3*)&pAmbientVertex[pAmbientIndices[cAmbientPoly*3+0]];
|
||
v[1]=(vector3*)&pAmbientVertex[pAmbientIndices[cAmbientPoly*3+1]];
|
||
v[2]=(vector3*)&pAmbientVertex[pAmbientIndices[cAmbientPoly*3+2]];
|
||
vector3 pPoly[3];
|
||
pPoly[0]=*v[0];
|
||
pPoly[1]=*v[1];
|
||
pPoly[2]=*v[2];
|
||
float fLightLens;
|
||
if(CIntersection::PolygonRay( vecStart,vecNormalEnd,pPoly,fLightLens))
|
||
{
|
||
bAmbientIntersection=true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if(bAmbientIntersection==false)
|
||
{
|
||
isAmbientWrite=true;
|
||
pSurface[iu+iv*(int)LightmapSizeX[UsedPlane]]=0xff606060;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
for(cObjectScene=0;cObjectScene<m_ObjectList.num;cObjectScene++)
|
||
{
|
||
matrix matObjectTM=m_ObjectList[cObjectScene]->m_TM;
|
||
if(m_ObjectList[cObjectScene]->m_pObject->m_dwShader==MultiFVF)
|
||
{
|
||
matrix matTransPoly;
|
||
for(int cMesh=0;cMesh<m_ObjectList[cObjectScene]->m_pObject->m_nIndices.num;cMesh++)
|
||
{
|
||
MultiVertex *pVertex=(MultiVertex *)m_ObjectList[cObjectScene]->m_pObject->m_pVertex[cMesh];
|
||
for(int cIndices=0;cIndices<m_ObjectList[cObjectScene]->m_pObject->m_nIndices[cMesh];cIndices++)
|
||
{
|
||
v[0]=(vector3*)&pVertex[m_ObjectList[cObjectScene]->m_pObject->m_pIndices[cMesh][cIndices*3+0]];
|
||
v[1]=(vector3*)&pVertex[m_ObjectList[cObjectScene]->m_pObject->m_pIndices[cMesh][cIndices*3+1]];
|
||
v[2]=(vector3*)&pVertex[m_ObjectList[cObjectScene]->m_pObject->m_pIndices[cMesh][cIndices*3+2]];
|
||
|
||
vector3 pPoly[3];
|
||
pPoly[0]=*v[0];
|
||
pPoly[1]=*v[1];
|
||
pPoly[2]=*v[2];
|
||
|
||
matTransPoly.Translation(pPoly[0]);
|
||
matTransPoly=matTransPoly*matObjectTM;
|
||
pPoly[0]=matTransPoly.GetLoc();
|
||
|
||
matTransPoly.Translation(pPoly[1]);
|
||
matTransPoly=matTransPoly*matObjectTM;
|
||
pPoly[1]=matTransPoly.GetLoc();
|
||
|
||
matTransPoly.Translation(pPoly[2]);
|
||
matTransPoly=matTransPoly*matObjectTM;
|
||
pPoly[2]=matTransPoly.GetLoc();
|
||
float fLightLens;
|
||
if(CIntersection::PolygonRay( vecStart,vecEnd,
|
||
pPoly,fLightLens))
|
||
{
|
||
if(LightmapMode==0)
|
||
{
|
||
pSurface[iu+iv*(int)LightmapSizeX[UsedPlane]]=0xff606060;
|
||
}
|
||
else
|
||
{
|
||
if(isAmbientWrite)
|
||
{
|
||
pSurface[iu+iv*(int)LightmapSizeX[UsedPlane]]=0xff606060;
|
||
}
|
||
else
|
||
{
|
||
pSurface[iu+iv*(int)LightmapSizeX[UsedPlane]]=0xff202020;
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for(int cMesh=0;cMesh<m_ObjectList[cObjectScene]->m_pObject->m_nIndices.num;cMesh++)
|
||
{
|
||
LightVertex *pVertex=(LightVertex *)m_ObjectList[cObjectScene]->m_pObject->m_pVertex[cMesh];
|
||
matrix matTransPoly;
|
||
for(int cIndices=0;cIndices<m_ObjectList[cObjectScene]->m_pObject->m_nIndices[cMesh];cIndices++)
|
||
{
|
||
v[0]=(vector3*)&pVertex[m_ObjectList[cObjectScene]->m_pObject->m_pIndices[cMesh][cIndices*3+0]];
|
||
v[1]=(vector3*)&pVertex[m_ObjectList[cObjectScene]->m_pObject->m_pIndices[cMesh][cIndices*3+1]];
|
||
v[2]=(vector3*)&pVertex[m_ObjectList[cObjectScene]->m_pObject->m_pIndices[cMesh][cIndices*3+2]];
|
||
|
||
vector3 pPoly[3];
|
||
pPoly[0]=*v[0];
|
||
pPoly[1]=*v[1];
|
||
pPoly[2]=*v[2];
|
||
|
||
matTransPoly.Translation(pPoly[0]);
|
||
matTransPoly=matTransPoly*matObjectTM;
|
||
pPoly[0]=matTransPoly.GetLoc();
|
||
|
||
matTransPoly.Translation(pPoly[1]);
|
||
matTransPoly=matTransPoly*matObjectTM;
|
||
pPoly[1]=matTransPoly.GetLoc();
|
||
|
||
matTransPoly.Translation(pPoly[2]);
|
||
matTransPoly=matTransPoly*matObjectTM;
|
||
pPoly[2]=matTransPoly.GetLoc();
|
||
|
||
float fLightLens;
|
||
if(CIntersection::PolygonRay( vecStart,vecEnd,
|
||
pPoly,fLightLens))
|
||
{
|
||
if(LightmapMode==0)
|
||
{
|
||
pSurface[iu+iv*(int)LightmapSizeX[UsedPlane]]=0xff606060;
|
||
}
|
||
else
|
||
{
|
||
if(isAmbientWrite)
|
||
{
|
||
pSurface[iu+iv*(int)LightmapSizeX[UsedPlane]]=0xff606060;
|
||
}
|
||
else
|
||
{
|
||
pSurface[iu+iv*(int)LightmapSizeX[UsedPlane]]=0xff202020;
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
bool isNotIntersection;
|
||
for(int cLightObject=0;cLightObject<m_LightList.num;cLightObject++)
|
||
{
|
||
vector3 vecInterStartLight;
|
||
vecEnd.x=m_LightList[cLightObject]->m_TM._41;
|
||
vecEnd.y=m_LightList[cLightObject]->m_TM._42;
|
||
vecEnd.z=m_LightList[cLightObject]->m_TM._43;
|
||
vecInterStartLight=vecEnd-vecStart;
|
||
float fLightLens=vecInterStartLight.GetLens();
|
||
|
||
if(fLightLens >= m_LightList[cLightObject]->m_pLightObject->m_fLightRange)
|
||
continue;
|
||
|
||
isNotIntersection=false;
|
||
for(int cOtherObject=0;cOtherObject<cIntersectionPoly;cOtherObject++)
|
||
{
|
||
MultiVertex *pOtherVertex=pMeshVertex[cOtherObject];
|
||
WORD *pIndices=pMeshIndices[cOtherObject];
|
||
for(int cOtherPoly=0;cOtherPoly<m_nIndices[cOtherObject];cOtherPoly++)
|
||
{
|
||
if(IndicesUsed[cOtherObject][cOtherPoly]!=UsedPlane)
|
||
{
|
||
v[0]=(vector3*)&pOtherVertex[pIndices[cOtherPoly*3+0]];
|
||
v[1]=(vector3*)&pOtherVertex[pIndices[cOtherPoly*3+1]];
|
||
v[2]=(vector3*)&pOtherVertex[pIndices[cOtherPoly*3+2]];
|
||
float fTempLightLens;
|
||
|
||
vector3 pPoly[3];
|
||
pPoly[0]=*v[0];
|
||
pPoly[1]=*v[1];
|
||
pPoly[2]=*v[2];
|
||
|
||
if(CIntersection::PolygonRay( vecStart,vecEnd,
|
||
pPoly,fTempLightLens))
|
||
{
|
||
isNotIntersection=true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
///*
|
||
|
||
|
||
for(cObjectScene=0;cObjectScene<m_ObjectList.num;cObjectScene++)
|
||
{
|
||
matrix matObjectTM=m_ObjectList[cObjectScene]->m_TM;
|
||
vector3 vecObjectPos=matObjectTM.GetLoc();
|
||
vector3 vecLightPos=m_LightList[cLightObject]->m_TM.GetLoc();
|
||
|
||
vector3 vecInter=vecObjectPos-vecLightPos;
|
||
float fInter=vecInter.GetLens();
|
||
|
||
if(fInter < m_LightList[cLightObject]->m_pLightObject->m_fLightRange + m_ObjectList[cObjectScene]->m_fRad)
|
||
{
|
||
//??
|
||
}
|
||
//matrix matObjectTM=m_ObjectList[cObjectScene]->m_TM;
|
||
if(m_ObjectList[cObjectScene]->m_pObject->m_dwShader==MultiFVF)
|
||
{
|
||
matrix matTransPoly;
|
||
for(int cMesh=0;cMesh<m_ObjectList[cObjectScene]->m_pObject->m_nIndices.num;cMesh++)
|
||
{
|
||
MultiVertex *pVertex=(MultiVertex *)m_ObjectList[cObjectScene]->m_pObject->m_pVertex[cMesh];
|
||
for(int cIndices=0;cIndices<m_ObjectList[cObjectScene]->m_pObject->m_nIndices[cMesh];cIndices++)
|
||
{
|
||
v[0]=(vector3*)&pVertex[m_ObjectList[cObjectScene]->m_pObject->m_pIndices[cMesh][cIndices*3+0]];
|
||
v[1]=(vector3*)&pVertex[m_ObjectList[cObjectScene]->m_pObject->m_pIndices[cMesh][cIndices*3+1]];
|
||
v[2]=(vector3*)&pVertex[m_ObjectList[cObjectScene]->m_pObject->m_pIndices[cMesh][cIndices*3+2]];
|
||
|
||
vector3 pPoly[3];
|
||
pPoly[0]=*v[0];
|
||
pPoly[1]=*v[1];
|
||
pPoly[2]=*v[2];
|
||
|
||
matTransPoly.Translation(pPoly[0]);
|
||
matTransPoly=matTransPoly*matObjectTM;
|
||
pPoly[0]=matTransPoly.GetLoc();
|
||
|
||
matTransPoly.Translation(pPoly[1]);
|
||
matTransPoly=matTransPoly*matObjectTM;
|
||
pPoly[1]=matTransPoly.GetLoc();
|
||
|
||
matTransPoly.Translation(pPoly[2]);
|
||
matTransPoly=matTransPoly*matObjectTM;
|
||
pPoly[2]=matTransPoly.GetLoc();
|
||
float fLightLens;
|
||
if(CIntersection::PolygonRay( vecStart,vecEnd,
|
||
pPoly,fLightLens))
|
||
{
|
||
isNotIntersection=true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for(int cMesh=0;cMesh<m_ObjectList[cObjectScene]->m_pObject->m_nIndices.num;cMesh++)
|
||
{
|
||
LightVertex *pVertex=(LightVertex *)m_ObjectList[cObjectScene]->m_pObject->m_pVertex[cMesh];
|
||
matrix matTransPoly;
|
||
for(int cIndices=0;cIndices<m_ObjectList[cObjectScene]->m_pObject->m_nIndices[cMesh];cIndices++)
|
||
{
|
||
v[0]=(vector3*)&pVertex[m_ObjectList[cObjectScene]->m_pObject->m_pIndices[cMesh][cIndices*3+0]];
|
||
v[1]=(vector3*)&pVertex[m_ObjectList[cObjectScene]->m_pObject->m_pIndices[cMesh][cIndices*3+1]];
|
||
v[2]=(vector3*)&pVertex[m_ObjectList[cObjectScene]->m_pObject->m_pIndices[cMesh][cIndices*3+2]];
|
||
|
||
vector3 pPoly[3];
|
||
pPoly[0]=*v[0];
|
||
pPoly[1]=*v[1];
|
||
pPoly[2]=*v[2];
|
||
|
||
matTransPoly.Translation(pPoly[0]);
|
||
matTransPoly=matTransPoly*matObjectTM;
|
||
pPoly[0]=matTransPoly.GetLoc();
|
||
|
||
matTransPoly.Translation(pPoly[1]);
|
||
matTransPoly=matTransPoly*matObjectTM;
|
||
pPoly[1]=matTransPoly.GetLoc();
|
||
|
||
matTransPoly.Translation(pPoly[2]);
|
||
matTransPoly=matTransPoly*matObjectTM;
|
||
pPoly[2]=matTransPoly.GetLoc();
|
||
|
||
float fLightLens;
|
||
if(CIntersection::PolygonRay( vecStart,vecEnd,
|
||
pPoly,fLightLens))
|
||
{
|
||
//pSurface[iu+iv*(int)LightmapSizeX[UsedPlane]]=0xff666666;
|
||
//pSurface[iu+iv*(int)LightmapSizeX[UsedPlane]]=0xff000000;
|
||
isNotIntersection=true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
if(isNotIntersection==false)
|
||
{
|
||
color lightmapcolor;
|
||
lightmapcolor.c=pSurface[iu+iv*(int)LightmapSizeX[UsedPlane]];
|
||
float fLightRate=1.0f-(fLightLens/m_LightList[cLightObject]->m_pLightObject->m_fLightRange);
|
||
|
||
if(fLightRate>=1.0f)
|
||
fLightRate=1.0f;
|
||
|
||
color AdderColor=color::Interpolation(color(0,0,0),m_LightList[cLightObject]->m_pLightObject->m_LightColor,fLightRate);
|
||
lightmapcolor=lightmapcolor+AdderColor;
|
||
|
||
if(fLightRate>0.5f)
|
||
fLightRate+=0.1f;
|
||
pSurface[iu+iv*(int)LightmapSizeX[UsedPlane]]=lightmapcolor.c;
|
||
}
|
||
}
|
||
//*/
|
||
}
|
||
}
|
||
}
|
||
//*/
|
||
|
||
|
||
pSurface=new DWORD[(LightmapSizeX[UsedPlane]+2)*(LightmapSizeY[UsedPlane]+2)];
|
||
|
||
|
||
for(int ix=0;ix<LightmapSizeX[UsedPlane];ix++)
|
||
{
|
||
for(int iy=0;iy<LightmapSizeY[UsedPlane];iy++)
|
||
{
|
||
pSurface[(ix+1)+(iy+1)*(LightmapSizeX[UsedPlane]+2)]=
|
||
AddLightmap[ix+iy*LightmapSizeX[UsedPlane]];
|
||
}
|
||
}
|
||
|
||
for(ix=0;ix<LightmapSizeX[UsedPlane];ix++)
|
||
{
|
||
pSurface[ix+1]=AddLightmap[ix];
|
||
pSurface[ix+1+(LightmapSizeY[UsedPlane]+1)*(LightmapSizeX[UsedPlane]+2)]=
|
||
AddLightmap[ix+(LightmapSizeY[UsedPlane]-1)*(LightmapSizeX[UsedPlane])];
|
||
}
|
||
for(int iy=0;iy<LightmapSizeY[UsedPlane];iy++)
|
||
{
|
||
pSurface[(iy+1)*(LightmapSizeX[UsedPlane]+2)]
|
||
=AddLightmap[iy*LightmapSizeX[UsedPlane]];
|
||
|
||
pSurface[ (LightmapSizeX[UsedPlane]+1)+(iy+1)*(LightmapSizeX[UsedPlane]+2)]=
|
||
AddLightmap[(LightmapSizeX[UsedPlane]-1)+iy*LightmapSizeX[UsedPlane]];
|
||
|
||
}
|
||
|
||
LightmapSizeX[UsedPlane]+=2;
|
||
LightmapSizeY[UsedPlane]+=2;
|
||
LightmapStorage.Add(pSurface);
|
||
|
||
UsedPlane++;
|
||
for(cIndices=0;cIndices<m_nIndices[cObject];cIndices++)
|
||
{
|
||
if(IndicesUsed[cObject][cIndices]==-1)
|
||
break;
|
||
}
|
||
if(cIndices==m_nIndices[cObject])
|
||
isRemainIndices=false;
|
||
}
|
||
}
|
||
|
||
for(cObjectScene=0;cObjectScene<m_ObjectList.num;cObjectScene++)
|
||
{
|
||
m_ObjectList[cObjectScene]->m_pObject->AllUnlockBuffer();
|
||
}
|
||
|
||
/*
|
||
LPDIRECT3DTEXTURE8 LightmapTexture=(LPDIRECT3DTEXTURE8)m_Lightmap.GetTexture();
|
||
LPDIRECT3DSURFACE8 Lightmap;
|
||
LightmapTexture->GetSurfaceLevel(0,&Lightmap);
|
||
|
||
LPDIRECT3DSURFACE8 LightmapSource=NULL;
|
||
*/
|
||
List<RECT> UsedLightmap;
|
||
|
||
int UsedTextureSizeX=1024,UsedTextureSizeY=512;
|
||
|
||
long PredictSizeX[10]={128,256,256,512,512,1024,1024,2048,2048,4096};
|
||
long PredictSizeY[10]={128,128,256,256,512,512,1024,1024,2048,4096};
|
||
|
||
bool isNotvalid;
|
||
int ix,iy;
|
||
bool isWriteLightmap=true;
|
||
bool inX,inY;
|
||
/*
|
||
for(int cPredict=0;cPredict<10;cPredict++)
|
||
{
|
||
*/
|
||
int cPredict=0;
|
||
isNotvalid=true;
|
||
UsedTextureSizeX=PredictSizeX[cPredict];
|
||
UsedTextureSizeY=PredictSizeY[cPredict];
|
||
char strObjectInfo[256];
|
||
|
||
for(int cPlane=0;cPlane<UsedPlane;cPlane++)
|
||
{
|
||
sprintf(strObjectInfo,"PredictSize %d,%d ",UsedTextureSizeX,UsedTextureSizeY);
|
||
cd.X=0;
|
||
cd.Y=2;
|
||
WriteConsoleOutputCharacter(hStdOut,strObjectInfo,strlen(strObjectInfo),cd,&dwWordLens);
|
||
|
||
sprintf(strObjectInfo,"Plane Calc %d/%d ",cPlane,UsedPlane);
|
||
cd.X=0;
|
||
cd.Y=3;
|
||
WriteConsoleOutputCharacter(hStdOut,strObjectInfo,strlen(strObjectInfo),cd,&dwWordLens);
|
||
isWriteLightmap=false;
|
||
for(iy=0;iy<UsedTextureSizeY-LightmapSizeY[cPlane];iy++)
|
||
{
|
||
isWriteLightmap=false;
|
||
for(ix=0;ix<UsedTextureSizeX-LightmapSizeX[cPlane];ix++)
|
||
{
|
||
isWriteLightmap=true;
|
||
for(int cUsedMap=0;cUsedMap<UsedLightmap.num;cUsedMap++)
|
||
{
|
||
inX=false;
|
||
inY=false;
|
||
|
||
if( ix<=UsedLightmap[cUsedMap].left)
|
||
{
|
||
if( ix+LightmapSizeX[cPlane] >= UsedLightmap[cUsedMap].left)
|
||
inX=true;
|
||
}
|
||
else
|
||
{
|
||
if( ix <=UsedLightmap[cUsedMap].right)
|
||
inX=true;
|
||
}
|
||
|
||
if( iy<=UsedLightmap[cUsedMap].top)
|
||
{
|
||
if( iy+LightmapSizeY[cPlane] >= UsedLightmap[cUsedMap].top)
|
||
inY=true;
|
||
}
|
||
else
|
||
{
|
||
if( iy <=UsedLightmap[cUsedMap].bottom)
|
||
inY=true;
|
||
}
|
||
if( inX && inY)
|
||
{
|
||
isWriteLightmap=false;
|
||
break;
|
||
}
|
||
}
|
||
if(isWriteLightmap)
|
||
{
|
||
RECT AddMap;
|
||
AddMap.left=ix;
|
||
AddMap.right=ix+LightmapSizeX[cPlane]-1;
|
||
AddMap.top=iy;
|
||
AddMap.bottom=iy+LightmapSizeY[cPlane]-1;
|
||
UsedLightmap.Add(AddMap);
|
||
break;
|
||
}
|
||
}
|
||
if(isWriteLightmap)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
if(isWriteLightmap==false)
|
||
{
|
||
cPredict++;
|
||
if(cPredict==10)
|
||
{
|
||
isNotvalid=false;
|
||
break;
|
||
}
|
||
UsedTextureSizeX=PredictSizeX[cPredict];
|
||
UsedTextureSizeY=PredictSizeY[cPredict];
|
||
cPlane--;
|
||
continue;
|
||
//isNotvalid=false;
|
||
//break;
|
||
}
|
||
}
|
||
UsedLightmap.num=0;
|
||
if(isNotvalid==false)
|
||
{
|
||
MessageBox(NULL,"Lightmap is not valid",0,0);
|
||
exit(0);
|
||
}
|
||
/*
|
||
}
|
||
|
||
if(cPredict==10)
|
||
{
|
||
MessageBox(NULL,"Lightmap is not valid",0,0);
|
||
}
|
||
*/
|
||
UsedLightmap.num=0;
|
||
float fSmallToBigX,fSmallToBigY;
|
||
float fStartTu,fStartTv;
|
||
m_Lightmap.CreateEmpty(UsedTextureSizeX,UsedTextureSizeY,D3DFMT_A8R8G8B8,D3DPOOL_MANAGED,1);
|
||
DWORD *pLightmap=(DWORD*)m_Lightmap.Lock();
|
||
// Init Texture
|
||
for(iy = 0; iy < UsedTextureSizeY; iy++) {
|
||
for(ix = 0;ix < UsedTextureSizeX;ix++) {
|
||
pLightmap[ix + (iy * UsedTextureSizeY)] = 0xff606060;
|
||
|
||
}
|
||
}
|
||
|
||
for(cPlane=0;cPlane<UsedPlane;cPlane++)
|
||
{
|
||
for(iy=0;iy<UsedTextureSizeY-LightmapSizeY[cPlane];iy++)
|
||
{
|
||
for(ix=0;ix<UsedTextureSizeX-LightmapSizeX[cPlane];ix++)
|
||
{
|
||
isWriteLightmap=true;
|
||
for(int cUsedMap=0;cUsedMap<UsedLightmap.num;cUsedMap++)
|
||
{
|
||
inX=false;
|
||
inY=false;
|
||
|
||
if( ix<=UsedLightmap[cUsedMap].left)
|
||
{
|
||
if( ix+LightmapSizeX[cPlane] >= UsedLightmap[cUsedMap].left)
|
||
inX=true;
|
||
}
|
||
else
|
||
{
|
||
if( ix <=UsedLightmap[cUsedMap].right)
|
||
inX=true;
|
||
}
|
||
|
||
if( iy<=UsedLightmap[cUsedMap].top)
|
||
{
|
||
if( iy+LightmapSizeY[cPlane] >= UsedLightmap[cUsedMap].top)
|
||
inY=true;
|
||
}
|
||
else
|
||
{
|
||
if( iy <=UsedLightmap[cUsedMap].bottom)
|
||
inY=true;
|
||
}
|
||
if( inX && inY)
|
||
{
|
||
isWriteLightmap=false;
|
||
break;
|
||
}
|
||
}
|
||
if(isWriteLightmap==true)
|
||
goto WRITELIGHTMAP;
|
||
}
|
||
}
|
||
continue;
|
||
WRITELIGHTMAP:
|
||
///*
|
||
sprintf(strObjectInfo,"Lightmap Write Calc %d/%d ",cPlane,UsedPlane);
|
||
cd.X=0;
|
||
cd.Y=4;
|
||
WriteConsoleOutputCharacter(hStdOut,strObjectInfo,strlen(strObjectInfo),cd,&dwWordLens);
|
||
|
||
fStartTu=(float)ix/(float)UsedTextureSizeX+1.0f/(float)UsedTextureSizeX;
|
||
fStartTv=(float)iy/(float)UsedTextureSizeY+1.0f/(float)UsedTextureSizeY;
|
||
fSmallToBigX=(float)(LightmapSizeX[cPlane]-2)/(float)UsedTextureSizeX;
|
||
fSmallToBigY=(float)(LightmapSizeY[cPlane]-2)/(float)UsedTextureSizeY;
|
||
|
||
|
||
//*/
|
||
|
||
RECT AddMap;
|
||
AddMap.left=ix;
|
||
AddMap.right=ix+LightmapSizeX[cPlane]-1;
|
||
AddMap.top=iy;
|
||
AddMap.bottom=iy+LightmapSizeY[cPlane]-1;
|
||
UsedLightmap.Add(AddMap);
|
||
|
||
RECT rect={0,0,LightmapSizeX[cPlane],LightmapSizeY[cPlane]};
|
||
|
||
for(ix=0;ix<LightmapSizeX[cPlane];ix++)
|
||
{
|
||
for(iy=0;iy<LightmapSizeY[cPlane];iy++)
|
||
{
|
||
pLightmap[ AddMap.left + ix + ( AddMap.top + iy ) * UsedTextureSizeX]=
|
||
LightmapStorage[cPlane][ix+iy*LightmapSizeX[cPlane]];
|
||
}
|
||
}
|
||
// Lightmap Blurring
|
||
for(ix = 0; ix < LightmapSizeX[cPlane];ix++) {
|
||
for(iy = 0; iy < LightmapSizeY[cPlane];iy++) {
|
||
|
||
DWORD dwColor = pLightmap[ AddMap.left + ix + ( AddMap.top + iy ) * UsedTextureSizeX];
|
||
DWORD dwTargetPixel;
|
||
|
||
BYTE dwRed = dwColor;
|
||
BYTE dwGreen = dwColor >> 8;
|
||
BYTE dwBlue = dwColor >> 16;
|
||
BYTE dwAlpha = dwColor >> 24;
|
||
float fCurrentPixel[4];
|
||
fCurrentPixel[0] = (float)dwAlpha;
|
||
fCurrentPixel[1] = (float)dwRed;
|
||
fCurrentPixel[2] = (float)dwGreen;
|
||
fCurrentPixel[3] = (float)dwBlue;
|
||
|
||
int iLegal = 0;
|
||
|
||
if(ix > 0) { // Left
|
||
dwTargetPixel = pLightmap[AddMap.left + ix - 1 + (AddMap.top + iy) * UsedTextureSizeX];
|
||
|
||
dwRed= dwTargetPixel;
|
||
dwGreen = dwTargetPixel >> 8;
|
||
dwBlue = dwTargetPixel >> 16;
|
||
dwAlpha = dwTargetPixel >> 24;
|
||
|
||
fCurrentPixel[0] += (float)dwAlpha;
|
||
fCurrentPixel[1] += (float)dwRed;
|
||
fCurrentPixel[2] += (float)dwGreen;
|
||
fCurrentPixel[3] += (float)dwBlue;
|
||
|
||
iLegal++;
|
||
|
||
|
||
}
|
||
if(ix < (LightmapSizeX[cPlane]) -1) { //Right
|
||
dwTargetPixel = pLightmap[AddMap.left + ix + 1 + (AddMap.top + iy) * UsedTextureSizeX];
|
||
|
||
dwRed= dwTargetPixel;
|
||
dwGreen = dwTargetPixel >> 8;
|
||
dwBlue = dwTargetPixel >> 16;
|
||
dwAlpha = dwTargetPixel >> 24;
|
||
|
||
|
||
fCurrentPixel[0] += (float)dwAlpha;
|
||
fCurrentPixel[1] += (float)dwRed;
|
||
fCurrentPixel[2] += (float)dwGreen;
|
||
fCurrentPixel[3] += (float)dwBlue;
|
||
|
||
iLegal++;
|
||
|
||
}
|
||
if(iy > 0) { //Up
|
||
dwTargetPixel = pLightmap[AddMap.left + ix + (AddMap.top + iy - 1) * UsedTextureSizeX];
|
||
|
||
dwRed= dwTargetPixel;
|
||
dwGreen = dwTargetPixel >> 8;
|
||
dwBlue = dwTargetPixel >> 16;
|
||
dwAlpha = dwTargetPixel >> 24;
|
||
|
||
|
||
fCurrentPixel[0] += (float)dwAlpha;
|
||
fCurrentPixel[1] += (float)dwRed;
|
||
fCurrentPixel[2] += (float)dwGreen;
|
||
fCurrentPixel[3] += (float)dwBlue;
|
||
|
||
iLegal++;
|
||
|
||
|
||
}
|
||
if(iy < (LightmapSizeY[cPlane]) -1) { //Down
|
||
dwTargetPixel = pLightmap[AddMap.left + ix + (AddMap.top + iy + 1) * UsedTextureSizeX];
|
||
|
||
dwRed= dwTargetPixel;
|
||
dwGreen = dwTargetPixel >> 8;
|
||
dwBlue = dwTargetPixel >> 16;
|
||
dwAlpha = dwTargetPixel >> 24;
|
||
|
||
fCurrentPixel[0] += (float)dwAlpha;
|
||
fCurrentPixel[1] += (float)dwRed;
|
||
fCurrentPixel[2] += (float)dwGreen;
|
||
fCurrentPixel[3] += (float)dwBlue;
|
||
|
||
iLegal++;
|
||
|
||
}
|
||
if((ix >0) && (iy > 0)) { // Left-Up
|
||
dwTargetPixel = pLightmap[AddMap.left + ix - 1 + (AddMap.top + iy - 1) * UsedTextureSizeX];
|
||
|
||
dwRed= dwTargetPixel;
|
||
dwGreen = dwTargetPixel >> 8;
|
||
dwBlue = dwTargetPixel >> 16;
|
||
dwAlpha = dwTargetPixel >> 24;
|
||
|
||
fCurrentPixel[0] += (float)dwAlpha;
|
||
fCurrentPixel[1] += (float)dwRed;
|
||
fCurrentPixel[2] += (float)dwGreen;
|
||
fCurrentPixel[3] += (float)dwBlue;
|
||
|
||
iLegal++;
|
||
|
||
}
|
||
if((ix < (LightmapSizeX[cPlane]) -1) && (iy < (LightmapSizeY[cPlane]) -1)) { //Right-down
|
||
dwTargetPixel = pLightmap[AddMap.left + ix + 1 + (AddMap.top + iy + 1) * UsedTextureSizeX];
|
||
|
||
dwRed= dwTargetPixel;
|
||
dwGreen = dwTargetPixel >> 8;
|
||
dwBlue = dwTargetPixel >> 16;
|
||
dwAlpha = dwTargetPixel >> 24;
|
||
|
||
fCurrentPixel[0] += (float)dwAlpha;
|
||
fCurrentPixel[1] += (float)dwRed;
|
||
fCurrentPixel[2] += (float)dwGreen;
|
||
fCurrentPixel[3] += (float)dwBlue;
|
||
|
||
iLegal++;
|
||
}
|
||
if((ix < (LightmapSizeX[cPlane]) -1 ) && (iy > 0)) { //Right up
|
||
dwTargetPixel = pLightmap[AddMap.left + ix + 1 + (AddMap.top + iy - 1) * UsedTextureSizeX];
|
||
|
||
dwRed= dwTargetPixel;
|
||
dwGreen = dwTargetPixel >> 8;
|
||
dwBlue = dwTargetPixel >> 16;
|
||
dwAlpha = dwTargetPixel >> 24;
|
||
|
||
|
||
fCurrentPixel[0] += (float)dwAlpha;
|
||
fCurrentPixel[1] += (float)dwRed;
|
||
fCurrentPixel[2] += (float)dwGreen;
|
||
fCurrentPixel[3] += (float)dwBlue;
|
||
|
||
iLegal++;
|
||
}
|
||
if((ix > 0) && (iy <(LightmapSizeY[cPlane]) -1)) { // Left Down
|
||
dwTargetPixel = pLightmap[AddMap.left + ix - 1 + (AddMap.top + iy + 1) * UsedTextureSizeX];
|
||
|
||
dwRed= dwTargetPixel;
|
||
dwGreen = dwTargetPixel >> 8;
|
||
dwBlue = dwTargetPixel >> 16;
|
||
dwAlpha = dwTargetPixel >> 24;
|
||
|
||
fCurrentPixel[0] += (float)dwAlpha;
|
||
fCurrentPixel[1] += (float)dwRed;
|
||
fCurrentPixel[2] += (float)dwGreen;
|
||
fCurrentPixel[3] += (float)dwBlue;
|
||
|
||
iLegal++;
|
||
|
||
}
|
||
int k;
|
||
|
||
for(k = 0; k < 4; k++ ) {
|
||
float fTmp = fCurrentPixel[k];
|
||
|
||
fTmp = (fTmp / (float)( iLegal + 1));
|
||
fCurrentPixel[k] = fTmp;
|
||
|
||
}
|
||
|
||
int iColor[4];
|
||
iColor[0] = (int)fCurrentPixel[0];
|
||
iColor[1] = (int)fCurrentPixel[1];
|
||
iColor[2] = (int)fCurrentPixel[2];
|
||
iColor[3] = (int)fCurrentPixel[3];
|
||
|
||
iColor[0] = (iColor[0] <= 255) ? iColor[0] : 255;
|
||
iColor[1] = (iColor[1] <= 255) ? iColor[1] : 255;
|
||
iColor[2] = (iColor[2] <= 255) ? iColor[2] : 255;
|
||
iColor[3] = (iColor[3] <= 255) ? iColor[3] : 255;
|
||
|
||
DWORD dwResult = D3DCOLOR_ARGB(255,iColor[1],iColor[2],iColor[3]);
|
||
|
||
pLightmap[ AddMap.left + ix + ( AddMap.top + iy ) * UsedTextureSizeX] = dwResult;
|
||
|
||
}
|
||
}
|
||
|
||
for(int cObject=0;cObject<IndicesUsed.num;cObject++)
|
||
{
|
||
MultiVertex *pVertex=pMeshVertex[cObject];
|
||
WORD *pIndices=pMeshIndices[cObject];
|
||
bool *isAlreadyUVTransfer=new bool[nMeshVertex[cObject]];
|
||
memset(isAlreadyUVTransfer,0,sizeof(bool)*nMeshVertex[cObject]);
|
||
for(int cIndices=0;cIndices<m_nIndices[cObject];cIndices++)
|
||
{
|
||
if(IndicesUsed[cObject][cIndices]==cPlane)
|
||
{
|
||
if(isAlreadyUVTransfer[pIndices[cIndices*3+0]] == false)
|
||
{
|
||
pVertex[ pIndices[cIndices*3+0] ].tu1=fStartTu+pVertex[pIndices[cIndices*3+0]].tu1*fSmallToBigX;
|
||
pVertex[ pIndices[cIndices*3+0] ].tv1=fStartTv+pVertex[pIndices[cIndices*3+0]].tv1*fSmallToBigY;
|
||
isAlreadyUVTransfer[pIndices[cIndices*3+0]]=true;
|
||
}
|
||
if(isAlreadyUVTransfer[pIndices[cIndices*3+1]] == false)
|
||
{
|
||
pVertex[ pIndices[cIndices*3+1] ].tu1=fStartTu+pVertex[pIndices[cIndices*3+1]].tu1*fSmallToBigX;
|
||
pVertex[ pIndices[cIndices*3+1] ].tv1=fStartTv+pVertex[pIndices[cIndices*3+1]].tv1*fSmallToBigY;
|
||
isAlreadyUVTransfer[pIndices[cIndices*3+1]]=true;
|
||
}
|
||
|
||
if(isAlreadyUVTransfer[pIndices[cIndices*3+2]] == false)
|
||
{
|
||
pVertex[ pIndices[cIndices*3+2] ].tu1=fStartTu+pVertex[pIndices[cIndices*3+2]].tu1*fSmallToBigX;
|
||
pVertex[ pIndices[cIndices*3+2] ].tv1=fStartTv+pVertex[pIndices[cIndices*3+2]].tv1*fSmallToBigY;
|
||
isAlreadyUVTransfer[pIndices[cIndices*3+2]]=true;
|
||
}
|
||
}
|
||
}
|
||
delete [] isAlreadyUVTransfer;
|
||
}
|
||
}
|
||
m_Lightmap.Unlock();
|
||
if(m_pOutHouseObject)
|
||
m_pOutHouseObject->AllUnlockBuffer();
|
||
if(m_pMedHouseObject)
|
||
m_pMedHouseObject->AllUnlockBuffer();
|
||
if(m_pInHouseObject)
|
||
m_pInHouseObject->AllUnlockBuffer();
|
||
m_isHaveLightmap=true;
|
||
m_nIndices.num=0;
|
||
}
|
||
|
||
void CHouseObject::Render(LPDIRECT3DDEVICE8 pd3dDevice)
|
||
{
|
||
|
||
D3DMATERIAL8 mtrl;
|
||
ZeroMemory( &mtrl, sizeof(D3DMATERIAL8) );
|
||
mtrl.Diffuse.r = mtrl.Ambient.r = 1.0f;
|
||
mtrl.Diffuse.g = mtrl.Ambient.g = 1.0f;
|
||
mtrl.Diffuse.b = mtrl.Ambient.b = 1.0f;
|
||
mtrl.Diffuse.a = mtrl.Ambient.a = 1.0f;
|
||
pd3dDevice->SetMaterial( &mtrl );
|
||
|
||
if(m_pBspObject)
|
||
{
|
||
if(CSceneManager::m_bEditor)
|
||
{
|
||
if(CSceneManager::m_PickHouseScene && CSceneManager::m_PickHouseScene->m_HouseObject == this)
|
||
{
|
||
m_pBspObject->RenderBox(pd3dDevice,0xffff0000);
|
||
}
|
||
else
|
||
{
|
||
m_pBspObject->RenderBox(pd3dDevice,0xffffffff);
|
||
}
|
||
|
||
matrix matTM,matParentWorld;
|
||
pd3dDevice->GetTransform(D3DTS_WORLD,(D3DMATRIX*)&matParentWorld);
|
||
|
||
for(int cObject=0;cObject<m_ObjectList.num;cObject++)
|
||
{
|
||
matTM=m_ObjectList[cObject]->m_TM*matParentWorld;
|
||
pd3dDevice->SetTransform(D3DTS_WORLD,matTM);
|
||
m_ObjectList[cObject]->m_AccumulateTM=matTM;
|
||
//if(m_ObjectList[cObject]->isCulling())
|
||
{
|
||
if(CSceneManager::m_PickObjectScene==m_ObjectList[cObject])
|
||
{
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_TFACTOR );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG2);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR,0xffffffff);
|
||
|
||
m_ObjectList[cObject]->m_pObject->RenderBox(pd3dDevice);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
}
|
||
|
||
m_ObjectList[cObject]->m_pObject->Render(pd3dDevice);
|
||
}
|
||
}
|
||
pd3dDevice->SetTransform(D3DTS_WORLD,(D3DMATRIX*)&matParentWorld);
|
||
|
||
}
|
||
return;
|
||
/*
|
||
matrix matHousePos;
|
||
pd3dDevice->GetTransform(D3DTS_WORLD,matHousePos);
|
||
|
||
//matrix *matViewPosition=GetCamera()->GetMatPosition();
|
||
//m_BspScene.Render(m_pd3dDevice,matViewPosition->GetLoc());
|
||
matrix *matViewPosition=CSceneManager::GetCamera()->GetMatPosition();
|
||
|
||
matrix matViewPos;
|
||
vector3 vecViewPos=matViewPosition->GetLoc();
|
||
matViewPos.Translation(vecViewPos);
|
||
|
||
matrix matInvTM,matPos;
|
||
matInvTM.Inverse(matHousePos);
|
||
|
||
matPos=matViewPos*matInvTM;
|
||
|
||
if( m_pBspObject->m_vecMinBox.x <= matPos._41 && m_pBspObject->m_vecMaxBox.x >= matPos._41 &&
|
||
m_pBspObject->m_vecMinBox.y <= matPos._42 && m_pBspObject->m_vecMaxBox.y >= matPos._42 &&
|
||
m_pBspObject->m_vecMinBox.z <= matPos._43 && m_pBspObject->m_vecMaxBox.z >= matPos._43 )
|
||
{
|
||
if(m_pBspObject->FindCluster(matPos.GetLoc())!=-1)
|
||
{
|
||
m_pBspObject->Render(pd3dDevice,matPos.GetLoc());
|
||
}
|
||
}
|
||
*/
|
||
|
||
/*
|
||
matrix matInvTM,matTM;
|
||
matTM.Translation(vector3(fXp,fYp,fZp));
|
||
matInvTM.Inverse(CSceneManager::m_PickHouseScene->m_AccumulateTM);
|
||
CLightObjectScene *AddLightScene=new CLightObjectScene();
|
||
AddLightScene->m_TM=matTM*matInvTM;
|
||
|
||
m_pBspObject->m_vecMaxBox;
|
||
m_pBspObject->m_vecMinBox;
|
||
*/
|
||
|
||
}
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
|
||
pd3dDevice->SetTexture(2,NULL);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
/*
|
||
pd3dDevice->SetTexture(1,NULL);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
|
||
*/
|
||
|
||
//matrix matWVP=RenderShadow(pd3dDevice);
|
||
|
||
/*
|
||
matrix matProjection,matHeightView,matTexScale,matInv,matView;
|
||
matProjection.MakeProjection(3.14159f/3.0f,1.0f,50,100000.0f);
|
||
float fViewHeight=(SECTORSIZE/2.0f)/tanf(3.14159f/6.0f);
|
||
matHeightView.CameraLookAt(vector3(SECTORSIZE/2.0f,fViewHeight,SECTORSIZE/2.0f),vector3(SECTORSIZE/2.0f,0.0f,SECTORSIZE/2.0f),vector3(0.0f,0.0f,1.0f));
|
||
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;
|
||
pd3dDevice->GetTransform(D3DTS_VIEW,matView);
|
||
matInv.Inverse(matView);
|
||
|
||
mat=matProjection*matTexScale;
|
||
mat2=matHeightView*mat;
|
||
matTex=matInv*mat2;
|
||
|
||
pd3dDevice->SetTransform(D3DTS_TEXTURE2,(D3DMATRIX*)&matTex);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXCOORDINDEX,D3DTSS_TCI_CAMERASPACEPOSITION );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_PROJECTED | D3DTTFF_COUNT3 );
|
||
pd3dDevice->SetTexture(2,CSectorScene::
|
||
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXCOORDINDEX, 2 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_DISABLE );
|
||
|
||
*/
|
||
if(m_pLodHouseObject && !m_pOutHouseObject)
|
||
{
|
||
|
||
pd3dDevice->LightEnable(0,TRUE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
if(BaseGraphicsLayer::m_VoodooOption)
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
else
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
/*
|
||
|
||
if(GF3OPTION)
|
||
{
|
||
matrix matProjection,matHeightView,matTexScale,matInv,matView,mat,mat2,matTex;
|
||
matProjection.MakeProjection(3.14159f/3.0f,1.0f,50,100000.0f);
|
||
float fViewHeight=(SECTORSIZE/2.0f)/tanf(3.14159f/6.0f);
|
||
|
||
matrix matWorld;
|
||
pd3dDevice->GetTransform(D3DTS_WORLD,matWorld);
|
||
float fCloudMoveX=(int)(matWorld._41/SECTORSIZE);
|
||
float fCloudMoveZ=(int)(matWorld._43/SECTORSIZE);
|
||
|
||
matHeightView.CameraLookAt(vector3(SECTORSIZE/2.0f+fCloudMoveX*SECTORSIZE,-fViewHeight,SECTORSIZE/2.0f+fCloudMoveZ*SECTORSIZE),
|
||
vector3(SECTORSIZE/2.0f+fCloudMoveX*SECTORSIZE,0.0f,SECTORSIZE/2.0f+fCloudMoveZ*SECTORSIZE),
|
||
vector3(0.0f,0.0f,-1.0f));
|
||
|
||
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;
|
||
pd3dDevice->GetTransform(D3DTS_VIEW,matView);
|
||
matInv.Inverse(matView);
|
||
|
||
mat=matProjection*matTexScale;
|
||
mat2=matHeightView*mat;
|
||
matTex=matInv*mat2;
|
||
|
||
matrix matTrans;
|
||
matTrans.MakeIdent();
|
||
matTrans._11=0.11f;
|
||
matTrans._22=0.11f;
|
||
|
||
matTrans._31=CSectorScene::m_fCloudMove+fCloudMoveX*0.11f;
|
||
matTrans._32=CSectorScene::m_fCloudMove+fCloudMoveZ*0.11f;
|
||
|
||
matTex=matTex*matTrans;
|
||
|
||
pd3dDevice->SetTransform(D3DTS_TEXTURE1,(D3DMATRIX*)&matTex);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX,D3DTSS_TCI_CAMERASPACEPOSITION );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_PROJECTED | D3DTTFF_COUNT3 );
|
||
|
||
pd3dDevice->SetTexture(1,CSectorScene::m_CloudShadow.GetTexture());
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
}
|
||
*/
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,TRUE);
|
||
|
||
m_pLodHouseObject->Render(pd3dDevice);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
|
||
/*
|
||
if(GF3OPTION)
|
||
{
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_DISABLE );
|
||
}
|
||
*/
|
||
return;
|
||
}
|
||
if(m_pOutHouseObject)
|
||
{
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHAREF,0xaa);
|
||
|
||
if(m_isHaveLightmap)
|
||
{
|
||
if(CRenderOption::m_AllObjectBump)
|
||
{
|
||
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_TEXCOORDINDEX,0);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_TEXCOORDINDEX,1);
|
||
CSceneStateMgr::_SetD3DTextureStageState(2,D3DTSS_TEXCOORDINDEX,2);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_TEXCOORDINDEX,3);
|
||
|
||
pd3dDevice->SetTexture(2,m_Lightmap.GetTexture());
|
||
//pd3dDevice->SetTexture(3,m_pNormalizeCubeMap);
|
||
|
||
float fHouseAmbientLight[4]={CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.r/255.0f,
|
||
CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.g/255.0f,
|
||
CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.b/255.0f,1.0f};
|
||
|
||
pd3dDevice->SetPixelShaderConstant(0,fHouseAmbientLight,1);
|
||
matrix matView,matProjection,matWorld,matWVP;
|
||
pd3dDevice->GetTransform(D3DTS_VIEW,matView);
|
||
pd3dDevice->GetTransform(D3DTS_PROJECTION,matProjection);
|
||
pd3dDevice->GetTransform(D3DTS_WORLD,matWorld);
|
||
matWVP=matWorld*matView*matProjection;
|
||
matWVP.Transpose();
|
||
pd3dDevice->SetVertexShaderConstant(16,&matWVP, 4);
|
||
/*
|
||
|
||
vector3 vecPos=matWorld.GetLoc();
|
||
pd3dDevice->SetVertexShaderConstant(16,&matWVP, 4);
|
||
|
||
matrix matInv;
|
||
|
||
matInv.Inverse(matWorld);
|
||
|
||
matrix *matViewPosition=CSceneManager::GetCamera()->GetMatPosition();
|
||
vector3 vecViewPos=vector3(matViewPosition->_41,matViewPosition->_42,matViewPosition->_43);
|
||
|
||
matrix matViewPos;
|
||
matViewPos.Translation(vecViewPos);
|
||
|
||
matViewPos=matViewPos*matInv;
|
||
|
||
float fObjectSpaceViewPosition[4]={matViewPos._41,matViewPos._42,matViewPos._43,0.0f};
|
||
|
||
pd3dDevice->SetVertexShaderConstant(35,fObjectSpaceViewPosition,1);
|
||
|
||
//////////////////
|
||
|
||
matWorld._41=matWorld._42=matWorld._43=0.0f;
|
||
matInv.Inverse(matWorld);
|
||
|
||
vector3 vecLightPos=vector3(1.0f,2.0f,1.0f);
|
||
vecLightPos.Normalize();
|
||
|
||
vecLightPos=vecLightPos*10000.0f;
|
||
|
||
matrix matLightPos;
|
||
matLightPos.Translation(vecLightPos);
|
||
|
||
//matLightPos=matWorld*matLightPos;
|
||
|
||
|
||
|
||
matLightPos=matLightPos*matInv;
|
||
|
||
float fObjectSpaceLightPosition[4]={matLightPos._41,matLightPos._42,matLightPos._43,1.0f};
|
||
pd3dDevice->SetVertexShaderConstant(32,fObjectSpaceLightPosition,1);
|
||
*/
|
||
|
||
pd3dDevice->SetPixelShader(m_dwHouseDiffusePixelShader);
|
||
|
||
m_pOutHouseObject->m_dwCustomizeShader=m_dwHouseDiffuseVertexShader;
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSU,D3DTADDRESS_CLAMP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSV,D3DTADDRESS_CLAMP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSW,D3DTADDRESS_CLAMP);
|
||
|
||
m_pOutHouseObject->Render(pd3dDevice);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSU,D3DTADDRESS_WRAP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSV,D3DTADDRESS_WRAP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSW,D3DTADDRESS_WRAP);
|
||
|
||
pd3dDevice->SetPixelShader(NULL);
|
||
|
||
m_pOutHouseObject->m_dwCustomizeShader=0xffffffff;
|
||
|
||
|
||
/*
|
||
pd3dDevice->SetPixelShader(m_dwHouseSpecularPixelShader);
|
||
|
||
m_pOutHouseObject->m_dwCustomizeShader=m_dwHouseSpecularVertexShader;
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSU,D3DTADDRESS_CLAMP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSV,D3DTADDRESS_CLAMP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSW,D3DTADDRESS_CLAMP);
|
||
|
||
m_pOutHouseObject->Render(pd3dDevice);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSU,D3DTADDRESS_WRAP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSV,D3DTADDRESS_WRAP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSW,D3DTADDRESS_WRAP);
|
||
|
||
pd3dDevice->SetPixelShader(NULL);
|
||
|
||
m_pOutHouseObject->m_dwCustomizeShader=0xffffffff;
|
||
*/
|
||
|
||
}
|
||
else
|
||
{
|
||
// <20><>
|
||
if(m_bNightUv == true && m_bNightMap == true && m_bConvertNight == true)
|
||
pd3dDevice->SetTexture(1,m_BackupLightmap.GetTexture());
|
||
else
|
||
pd3dDevice->SetTexture(1,m_Lightmap.GetTexture());
|
||
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
/**/
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR, CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
if(m_bModulate2X)
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
else
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
|
||
|
||
/**/
|
||
if(m_bNightUv != true || m_bNightMap != true || m_bConvertNight != true)
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_TFACTOR);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X );
|
||
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_TEXCOORDINDEX,0);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_TEXCOORDINDEX,1);
|
||
////
|
||
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,TRUE);
|
||
//CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,TRUE);
|
||
|
||
m_pOutHouseObject->Render(pd3dDevice);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
|
||
}
|
||
/*
|
||
|
||
if(GF3OPTION)
|
||
{
|
||
|
||
matrix matProjection,matHeightView,matTexScale,matInv,matView,mat,mat2,matTex;
|
||
matProjection.MakeProjection(3.14159f/3.0f,1.0f,50,100000.0f);
|
||
float fViewHeight=(SECTORSIZE/2.0f)/tanf(3.14159f/6.0f);
|
||
|
||
matrix matWorld;
|
||
pd3dDevice->GetTransform(D3DTS_WORLD,matWorld);
|
||
float fCloudMoveX=(int)(matWorld._41/SECTORSIZE);
|
||
float fCloudMoveZ=(int)(matWorld._43/SECTORSIZE);
|
||
|
||
matHeightView.CameraLookAt(vector3(SECTORSIZE/2.0f+fCloudMoveX*SECTORSIZE,-fViewHeight,SECTORSIZE/2.0f+fCloudMoveZ*SECTORSIZE),
|
||
vector3(SECTORSIZE/2.0f+fCloudMoveX*SECTORSIZE,0.0f,SECTORSIZE/2.0f+fCloudMoveZ*SECTORSIZE),
|
||
vector3(0.0f,0.0f,-1.0f));
|
||
|
||
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;
|
||
pd3dDevice->GetTransform(D3DTS_VIEW,matView);
|
||
matInv.Inverse(matView);
|
||
|
||
mat=matProjection*matTexScale;
|
||
mat2=matHeightView*mat;
|
||
matTex=matInv*mat2;
|
||
|
||
matrix matTrans;
|
||
matTrans.MakeIdent();
|
||
matTrans._11=0.11f;
|
||
matTrans._22=0.11f;
|
||
|
||
matTrans._31=CSectorScene::m_fCloudMove+fCloudMoveX*0.11f;
|
||
matTrans._32=CSectorScene::m_fCloudMove+fCloudMoveZ*0.11f;
|
||
|
||
matTex=matTex*matTrans;
|
||
|
||
pd3dDevice->SetTransform(D3DTS_TEXTURE2,(D3DMATRIX*)&matTex);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXCOORDINDEX,D3DTSS_TCI_CAMERASPACEPOSITION );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_PROJECTED | D3DTTFF_COUNT3 );
|
||
|
||
pd3dDevice->SetTexture(2,CSectorScene::m_CloudShadow.GetTexture());
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
|
||
}
|
||
*/
|
||
|
||
|
||
/*
|
||
if(GF3OPTION)
|
||
{
|
||
matrix matTex;
|
||
matTex.MakeIdent();
|
||
pd3dDevice->SetTransform(D3DTS_TEXTURE2,(D3DMATRIX*)&matTex);
|
||
pd3dDevice->SetPixelShader(NULL);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXCOORDINDEX, 2 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_DISABLE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
pd3dDevice->SetTexture(2,NULL);
|
||
}
|
||
*/
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_FOGENABLE,FALSE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXCOORDINDEX,D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2,D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_COUNT3);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_NORMALIZENORMALS,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_LOCALVIEWER,TRUE);
|
||
|
||
pd3dDevice->SetTexture(2,CSceneManager::m_LightCubeTexture);
|
||
|
||
pd3dDevice->SetTexture(2,CSceneManager::m_DiffuseLightCubeTexture.GetTexture());
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP,D3DTOP_SELECTARG1);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP,D3DTOP_SELECTARG1);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_COLOROP,D3DTOP_SELECTARG1);
|
||
CSceneStateMgr::_SetD3DTextureStageState(2, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(2, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(2, D3DTSS_ADDRESSW, D3DTADDRESS_CLAMP);
|
||
|
||
m_pOutHouseObject->Render(pd3dDevice);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_TEXCOORDINDEX,2);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState(2 ,D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
|
||
*/
|
||
|
||
|
||
|
||
|
||
CSceneManager::CGlareNode AddNode;
|
||
AddNode.m_bCubeEnv=true;
|
||
pd3dDevice->GetTransform(D3DTS_WORLD,AddNode.m_matPosition);
|
||
AddNode.m_pMeshObject=m_pOutHouseObject;
|
||
//CSceneManager::AddGlareNode(AddNode);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
pd3dDevice->LightEnable(0,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
|
||
if(BaseGraphicsLayer::m_VoodooOption)
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
else
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
|
||
if(m_Detailmap.GetTexture())
|
||
{
|
||
pd3dDevice->SetTexture(1,m_Detailmap.GetTexture());
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
|
||
|
||
matrix matTex;
|
||
matTex.MakeIdent();
|
||
matTex._11=10.0f;
|
||
matTex._22=10.0f;
|
||
|
||
pd3dDevice->SetTransform(D3DTS_TEXTURE1,(D3DMATRIX*)&matTex);
|
||
pd3dDevice->SetPixelShader(NULL);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 0 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
|
||
|
||
m_pOutHouseObject->Render(pd3dDevice);
|
||
|
||
matTex.MakeIdent();
|
||
pd3dDevice->SetTransform(D3DTS_TEXTURE1,(D3DMATRIX*)&matTex);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_DISABLE );
|
||
}
|
||
else
|
||
{
|
||
pd3dDevice->SetTexture(1,NULL);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
|
||
m_pOutHouseObject->Render(pd3dDevice);
|
||
}
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
|
||
|
||
}
|
||
}
|
||
|
||
|
||
if(m_pMedHouseObject)
|
||
{
|
||
if(m_isHaveLightmap)
|
||
{
|
||
pd3dDevice->SetTexture(1,m_Lightmap.GetTexture());
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
|
||
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
//CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
|
||
|
||
if(BaseGraphicsLayer::m_VoodooOption)
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
else
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,TRUE);
|
||
///////////// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD>
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR, CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
|
||
/**/
|
||
if(m_bNightUv != true || m_bNightMap != true || m_bConvertNight != true)
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_TFACTOR);
|
||
|
||
/////////////
|
||
|
||
m_pMedHouseObject->Render(pd3dDevice);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
}
|
||
else
|
||
{
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
pd3dDevice->LightEnable(0,TRUE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
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);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,TRUE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR, CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
|
||
m_pMedHouseObject->Render(pd3dDevice);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
|
||
}
|
||
}
|
||
|
||
if(m_LightList.num>0 || m_ObjectList.num>0)
|
||
{
|
||
/*
|
||
pd3dDevice->SetTexture(1,NULL);
|
||
|
||
matrix matTM,matParentWorld;
|
||
|
||
|
||
|
||
pd3dDevice->GetTransform(D3DTS_WORLD,(D3DMATRIX*)&matParentWorld);
|
||
int cLight=0;
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
|
||
if(CSceneManager::m_bEditor)
|
||
{
|
||
for(cLight=0;cLight<m_LightList.num;cLight++)
|
||
{
|
||
matTM=m_LightList[cLight]->m_TM*matParentWorld;
|
||
pd3dDevice->SetTransform(D3DTS_WORLD ,matTM);
|
||
m_LightList[cLight]->m_AccumulateTM=matTM;
|
||
if(m_LightList[cLight]->isCulling())
|
||
{
|
||
if(CSceneManager::m_PickLightScene==m_LightList[cLight])
|
||
{
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_TFACTOR );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG2);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR,0xffffffff);
|
||
|
||
m_LightList[cLight]->m_pLightObject->m_pLightObject->RenderBox(pd3dDevice);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
}
|
||
m_LightList[cLight]->m_pLightObject->m_pLightObject->Render(pd3dDevice);
|
||
}
|
||
}
|
||
}
|
||
matrix matLightTM;
|
||
int cEnableLight=1;
|
||
|
||
D3DLIGHT8 light;
|
||
ZeroMemory( &light, sizeof(D3DLIGHT8) );
|
||
light.Type=D3DLIGHT_POINT;
|
||
light.Attenuation0=1.0f;
|
||
|
||
|
||
pd3dDevice->SetLight( 0,&light );
|
||
|
||
vector3 vecLight,vecObject,vecInter;
|
||
float fInter;
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, 0xff303030);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
pd3dDevice->SetTexture(1,NULL);
|
||
|
||
for(int cObject=0;cObject<m_ObjectList.num;cObject++)
|
||
{
|
||
matTM=m_ObjectList[cObject]->m_TM*matParentWorld;
|
||
pd3dDevice->SetTransform(D3DTS_WORLD,matTM);
|
||
m_ObjectList[cObject]->m_AccumulateTM=matTM;
|
||
if(m_ObjectList[cObject]->isCulling())
|
||
{
|
||
if(m_ObjectList[cObject]->m_isAlpha)
|
||
{
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,TRUE);
|
||
}
|
||
cEnableLight=0;
|
||
for(cLight=0;cLight<m_LightList.num;cLight++)
|
||
{
|
||
matLightTM=m_LightList[cLight]->m_TM*matParentWorld;
|
||
|
||
vecLight=matLightTM.GetLoc();
|
||
vecObject=matTM.GetLoc();
|
||
|
||
vecInter=vecObject-vecLight;
|
||
fInter=vecInter.GetLens();
|
||
if(fInter > m_LightList[cLight]->m_pLightObject->m_fLightRange+m_ObjectList[cObject]->m_fRad)
|
||
continue;
|
||
if(matTM._42 <= matLightTM._42)
|
||
{
|
||
light.Diffuse.r=m_LightList[cLight]->m_pLightObject->m_LightColor.r/255.0f;
|
||
light.Diffuse.g=m_LightList[cLight]->m_pLightObject->m_LightColor.g/255.0f;
|
||
light.Diffuse.b=m_LightList[cLight]->m_pLightObject->m_LightColor.b/255.0f;
|
||
light.Position.x = light.Direction.x = matLightTM._41;
|
||
light.Position.y = light.Direction.y = matLightTM._42;
|
||
light.Position.z = light.Direction.z = matLightTM._43;
|
||
light.Range=m_LightList[cLight]->m_pLightObject->m_fLightRange;
|
||
pd3dDevice->SetLight( cEnableLight,&light );
|
||
pd3dDevice->LightEnable(cEnableLight,TRUE);
|
||
cEnableLight++;
|
||
}
|
||
}
|
||
|
||
if(CSceneManager::m_PickObjectScene==m_ObjectList[cObject])
|
||
{
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_TFACTOR );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG2);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR,0xffffffff);
|
||
|
||
m_ObjectList[cObject]->m_pObject->RenderBox(pd3dDevice);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
}
|
||
|
||
m_ObjectList[cObject]->m_pObject->Render(pd3dDevice);
|
||
|
||
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);
|
||
|
||
if(m_ObjectList[cObject]->m_isAlpha)
|
||
{
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
}
|
||
}
|
||
}
|
||
*/
|
||
//pd3dDevice->SetTransform(D3DTS_WORLD,(D3DMATRIX*)&matParentWorld);
|
||
}
|
||
|
||
if(m_pInHouseObject)
|
||
{
|
||
if(m_isHaveInLightmap)
|
||
{
|
||
pd3dDevice->SetTexture(1,m_InLightmap.GetTexture());
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
|
||
|
||
if(BaseGraphicsLayer::m_VoodooOption)
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
else
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, 0xffffffff);
|
||
m_pInHouseObject->Render(pd3dDevice);
|
||
}
|
||
else
|
||
{
|
||
pd3dDevice->LightEnable(0,TRUE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
//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);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
|
||
m_pInHouseObject->Render(pd3dDevice);
|
||
}
|
||
}
|
||
/*
|
||
m_pOutHouseObject->Render(pd3dDevice);
|
||
m_pMedHouseObject>Render(pd3dDevice);
|
||
m_pInHouseObject>Render(pd3dDevice);
|
||
*/
|
||
|
||
/*
|
||
D3DMATERIAL8 mtrl;
|
||
ZeroMemory( &mtrl, sizeof(D3DMATERIAL8) );
|
||
mtrl.Diffuse.r = mtrl.Ambient.r = 1.0f;
|
||
mtrl.Diffuse.g = mtrl.Ambient.g = 1.0f;
|
||
mtrl.Diffuse.b = mtrl.Ambient.b = 1.0f;
|
||
mtrl.Diffuse.a = mtrl.Ambient.a = 1.0f;
|
||
pd3dDevice->SetMaterial( &mtrl );
|
||
|
||
matrix matParentWorld,matTM;
|
||
pd3dDevice->GetTransform(D3DTS_WORLD,(D3DMATRIX*)&matParentWorld);
|
||
|
||
vector3 vecHousePos;
|
||
vecHousePos.x=matParentWorld._41;
|
||
vecHousePos.y=matParentWorld._42;
|
||
vecHousePos.z=matParentWorld._43;
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_AmbientColor->c);
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
|
||
if(m_isHaveLightmap)
|
||
{
|
||
pd3dDevice->SetTexture(1,m_Lightmap.GetTexture());
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
|
||
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
}
|
||
else
|
||
{
|
||
pd3dDevice->SetTexture(1,NULL);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
//CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
}
|
||
|
||
matrix *matViewPosition=(matrix*)CSceneManager::GetCamera()->GetMatPosition();
|
||
vector3 vecViewPos=matViewPosition->GetLoc();
|
||
|
||
vector3 vecViewPosInter;
|
||
vecViewPosInter=vecHousePos-vecViewPos;
|
||
float fViewInter=vecViewPosInter.GetLens();
|
||
|
||
if(fViewInter < MAX_HOUSEVIEWRANGE)
|
||
{
|
||
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);
|
||
if( fViewInter >MAX_HOUSEDISAPPER )
|
||
{
|
||
float fBlend=(fViewInter-MAX_HOUSEDISAPPER)/(MAX_HOUSEVIEWRANGE-MAX_HOUSEDISAPPER);
|
||
color TextureFactorColor;
|
||
TextureFactorColor=color::Interpolation(color(0,0,0,255),color(0,0,0,0),fBlend);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR,TextureFactorColor.c);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,TRUE);
|
||
if(m_pLodHouseObject)
|
||
{
|
||
pd3dDevice->SetTexture(1,NULL);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
//CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
pd3dDevice->LightEnable(0,TRUE);
|
||
m_pLodHouseObject->Render(pd3dDevice);
|
||
}
|
||
else
|
||
{
|
||
if(m_isHaveLightmap)
|
||
{
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
m_pOutHouseObject->Render(pd3dDevice);
|
||
}
|
||
else
|
||
{
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
pd3dDevice->LightEnable(0,TRUE);
|
||
pd3dDevice->SetTexture(1,NULL);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
//CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
|
||
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
m_pOutHouseObject->Render(pd3dDevice);
|
||
}
|
||
}
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
|
||
return;
|
||
}
|
||
if(fViewInter>MAX_OUTVIEWRANGE)//LOD<4F><44>
|
||
{
|
||
if(m_pLodHouseObject)
|
||
{
|
||
pd3dDevice->SetTexture(1,NULL);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
//CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
pd3dDevice->LightEnable(0,TRUE);
|
||
m_pLodHouseObject->Render(pd3dDevice);
|
||
}
|
||
else
|
||
{
|
||
if(m_isHaveLightmap)
|
||
{
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
if(m_pOutHouseObject)
|
||
m_pOutHouseObject->Render(pd3dDevice);
|
||
}
|
||
else
|
||
{
|
||
pd3dDevice->LightEnable(0,TRUE);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
|
||
pd3dDevice->SetTexture(1,NULL);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
//CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
if(m_pOutHouseObject)
|
||
m_pOutHouseObject->Render(pd3dDevice);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if(m_isHaveLightmap)
|
||
{
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
if(m_pOutHouseObject)
|
||
m_pOutHouseObject->Render(pd3dDevice);
|
||
}
|
||
else
|
||
{
|
||
pd3dDevice->LightEnable(0,TRUE);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
|
||
pd3dDevice->SetTexture(1,NULL);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
//CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
//CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
if(m_pOutHouseObject)
|
||
m_pOutHouseObject->Render(pd3dDevice);
|
||
}
|
||
}
|
||
|
||
if(m_pMedHouseObject && fViewInter<MAX_MEDVIEWRANGE)
|
||
{
|
||
if(fViewInter<MAX_MEDVIEWRANGE)
|
||
{
|
||
color TextureFactorColor;
|
||
TextureFactorColor.a=255;
|
||
TextureFactorColor.r=0;
|
||
TextureFactorColor.g=0;
|
||
TextureFactorColor.b=0;
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR,TextureFactorColor.c);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,TRUE);
|
||
|
||
m_pMedHouseObject->Render(pd3dDevice);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
}
|
||
else
|
||
m_pMedHouseObject->Render(pd3dDevice);
|
||
}
|
||
if(m_pInHouseObject && fViewInter<MAX_INVIEWRANGE)
|
||
{
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, 0xffffffff);
|
||
m_pInHouseObject->Render(pd3dDevice);
|
||
}
|
||
if(fViewInter<MAX_INVIEWRANGE)
|
||
{
|
||
D3DMATERIAL8 mtrl;
|
||
ZeroMemory( &mtrl, sizeof(D3DMATERIAL8) );
|
||
mtrl.Diffuse.r = mtrl.Ambient.r = 0.8f;
|
||
mtrl.Diffuse.g = mtrl.Ambient.g = 0.8f;
|
||
mtrl.Diffuse.b = mtrl.Ambient.b = 0.8f;
|
||
mtrl.Diffuse.a = mtrl.Ambient.a = 0.8f;
|
||
pd3dDevice->SetMaterial( &mtrl );
|
||
pd3dDevice->SetTexture(1,NULL);
|
||
int cLight=0;
|
||
if(CSceneManager::m_bEditor)
|
||
{
|
||
for(cLight=0;cLight<m_LightList.num;cLight++)
|
||
{
|
||
matTM=m_LightList[cLight]->m_TM*matParentWorld;
|
||
pd3dDevice->SetTransform(D3DTS_WORLD ,matTM);
|
||
m_LightList[cLight]->m_AccumulateTM=matTM;
|
||
if(m_LightList[cLight]->isCulling())
|
||
{
|
||
if(CSceneManager::m_PickLightScene==m_LightList[cLight])
|
||
{
|
||
m_LightList[cLight]->m_pLightObject->m_pLightObject->RenderBox(pd3dDevice);
|
||
}
|
||
if(CSceneManager::m_bIsPickObjectMoving!=MOVE_LIGHT)
|
||
m_LightList[cLight]->m_pLightObject->m_pLightObject->Render(pd3dDevice);
|
||
else
|
||
{
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZWRITEENABLE,FALSE);
|
||
m_LightList[cLight]->m_pLightObject->m_pLightObject->Render(pd3dDevice);
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZWRITEENABLE,TRUE);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
matrix matLightTM;
|
||
int cEnableLight=1;
|
||
|
||
D3DLIGHT8 light;
|
||
ZeroMemory( &light, sizeof(D3DLIGHT8) );
|
||
light.Type=D3DLIGHT_POINT;
|
||
light.Attenuation0=1.0f;
|
||
|
||
|
||
pd3dDevice->SetLight( 0,&light );
|
||
|
||
vector3 vecLight,vecObject,vecInter;
|
||
float fInter;
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, 0xff303030);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
pd3dDevice->SetTexture(1,NULL);
|
||
|
||
for(int cObject=0;cObject<m_ObjectList.num;cObject++)
|
||
{
|
||
matTM=m_ObjectList[cObject]->m_TM*matParentWorld;
|
||
pd3dDevice->SetTransform(D3DTS_WORLD,matTM);
|
||
m_ObjectList[cObject]->m_AccumulateTM=matTM;
|
||
if(m_ObjectList[cObject]->isCulling())
|
||
{
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR,0xffffffff);
|
||
if(m_ObjectList[cObject]->m_isAlpha)
|
||
{
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,TRUE);
|
||
}
|
||
cEnableLight=0;
|
||
for(cLight=0;cLight<m_LightList.num;cLight++)
|
||
{
|
||
matLightTM=m_LightList[cLight]->m_TM*matParentWorld;
|
||
//vecLight=m_LightList[cLight]->m_TM.GetLoc();
|
||
vecLight=matLightTM.GetLoc();
|
||
vecObject=matTM.GetLoc();
|
||
//vecObject=m_ObjectList[cObject]->m_TM.GetLoc();
|
||
vecInter=vecObject-vecLight;
|
||
fInter=vecInter.GetLens();
|
||
if(fInter > m_LightList[cLight]->m_pLightObject->m_fLightRange+m_ObjectList[cObject]->m_fRad)
|
||
continue;
|
||
if(matTM._42 <= matLightTM._42)
|
||
{
|
||
light.Diffuse.r=m_LightList[cLight]->m_pLightObject->m_LightColor.r/255.0f;
|
||
light.Diffuse.g=m_LightList[cLight]->m_pLightObject->m_LightColor.g/255.0f;
|
||
light.Diffuse.b=m_LightList[cLight]->m_pLightObject->m_LightColor.b/255.0f;
|
||
light.Position.x = light.Direction.x = matLightTM._41;
|
||
light.Position.y = light.Direction.y = matLightTM._42;
|
||
light.Position.z = light.Direction.z = matLightTM._43;
|
||
light.Range=m_LightList[cLight]->m_pLightObject->m_fLightRange;
|
||
pd3dDevice->SetLight( cEnableLight,&light );
|
||
pd3dDevice->LightEnable(cEnableLight,TRUE);
|
||
cEnableLight++;
|
||
}
|
||
}
|
||
|
||
if(CSceneManager::m_PickObjectScene==m_ObjectList[cObject])
|
||
{
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZWRITEENABLE,FALSE);
|
||
m_ObjectList[cObject]->m_pObject->RenderBox(pd3dDevice);
|
||
m_ObjectList[cObject]->m_pObject->Render(pd3dDevice);
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZWRITEENABLE,TRUE);
|
||
}
|
||
if(CSceneManager::m_bIsPickObjectMoving!=MOVE_OBJECT)
|
||
m_ObjectList[cObject]->m_pObject->Render(pd3dDevice);
|
||
else
|
||
{
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZWRITEENABLE,FALSE);
|
||
m_ObjectList[cObject]->m_pObject->Render(pd3dDevice);
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_ZWRITEENABLE,TRUE);
|
||
}
|
||
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);
|
||
|
||
if(m_ObjectList[cObject]->m_isAlpha)
|
||
{
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if( fViewInter >MAX_HOUSEDISAPPER )
|
||
{
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
|
||
}
|
||
}
|
||
*/
|
||
}
|
||
|
||
void CHouseObject::GenerateOctree()
|
||
{
|
||
GetPolygon();
|
||
m_pOctree=new COctreeScene();
|
||
vector3 pPoly[3];
|
||
for(int i=0;i<m_pVertex.num;i++)
|
||
{
|
||
WORD *pIndices=m_pIndices[i];
|
||
vector3 *pVertex=m_pVertex[i];
|
||
for(int cIndices=0;cIndices<m_nIndices[i];cIndices++)
|
||
{
|
||
pPoly[0]=pVertex[pIndices[cIndices*3+0]];
|
||
pPoly[1]=pVertex[pIndices[cIndices*3+1]];
|
||
pPoly[2]=pVertex[pIndices[cIndices*3+2]];
|
||
m_pOctree->AddPoly(pPoly);
|
||
}
|
||
}
|
||
|
||
vector3 vecBoundBox[8];
|
||
vector3 vecPolyTest[3];
|
||
vector3 vecPlaneNormal;
|
||
matrix matTrans;
|
||
float fIntersection;
|
||
|
||
WORD wCollisionIndices[]=
|
||
{
|
||
4,1,0,
|
||
1,4,5,
|
||
|
||
5,3,1,
|
||
3,5,7,
|
||
|
||
7,2,3,
|
||
2,7,6,
|
||
|
||
6,0,2,
|
||
0,6,4
|
||
};
|
||
|
||
vector3 vecDirection[8];
|
||
vecDirection[0]=vector3(0.707f,0.0f,0.707f);
|
||
vecDirection[1]=vector3(0.707f,0.0f,-0.707f);
|
||
vecDirection[2]=vector3(-0.707f,0.0f,0.707f);
|
||
vecDirection[3]=vector3(-0.707f,0.0f,-0.707f);
|
||
|
||
vecDirection[4]=vector3(1.0f,0.0f,0.0f);
|
||
vecDirection[5]=vector3(-1.0f,0.0f,0.0f);
|
||
vecDirection[6]=vector3(0.0f,0.0f,1.0f);
|
||
vecDirection[7]=vector3(0.0f,0.0f,-1.0f);
|
||
|
||
vector3 vecLens;
|
||
|
||
matrix matTM;
|
||
for(int cObject=0;cObject<m_ObjectList.num;cObject++)
|
||
{
|
||
matTM=m_ObjectList[cObject]->m_TM;
|
||
|
||
vecBoundBox[0].x=m_ObjectList[cObject]->m_vecMinBox.x;
|
||
vecBoundBox[0].y=m_ObjectList[cObject]->m_vecMinBox.y;
|
||
vecBoundBox[0].z=m_ObjectList[cObject]->m_vecMinBox.z;
|
||
|
||
vecBoundBox[1].x=m_ObjectList[cObject]->m_vecMaxBox.x;
|
||
vecBoundBox[1].y=m_ObjectList[cObject]->m_vecMinBox.y;
|
||
vecBoundBox[1].z=m_ObjectList[cObject]->m_vecMinBox.z;
|
||
|
||
vecBoundBox[2].x=m_ObjectList[cObject]->m_vecMinBox.x;
|
||
vecBoundBox[2].y=m_ObjectList[cObject]->m_vecMinBox.y;
|
||
vecBoundBox[2].z=m_ObjectList[cObject]->m_vecMaxBox.z;
|
||
|
||
vecBoundBox[3].x=m_ObjectList[cObject]->m_vecMaxBox.x;
|
||
vecBoundBox[3].y=m_ObjectList[cObject]->m_vecMinBox.y;
|
||
vecBoundBox[3].z=m_ObjectList[cObject]->m_vecMaxBox.z;
|
||
|
||
vecBoundBox[4].x=m_ObjectList[cObject]->m_vecMinBox.x;
|
||
vecBoundBox[4].y=m_ObjectList[cObject]->m_vecMaxBox.y+50.0f;
|
||
vecBoundBox[4].z=m_ObjectList[cObject]->m_vecMinBox.z;
|
||
|
||
vecBoundBox[5].x=m_ObjectList[cObject]->m_vecMaxBox.x;
|
||
vecBoundBox[5].y=m_ObjectList[cObject]->m_vecMaxBox.y+50.0f;
|
||
vecBoundBox[5].z=m_ObjectList[cObject]->m_vecMinBox.z;
|
||
|
||
vecBoundBox[6].x=m_ObjectList[cObject]->m_vecMinBox.x;
|
||
vecBoundBox[6].y=m_ObjectList[cObject]->m_vecMaxBox.y+50.0f;
|
||
vecBoundBox[6].z=m_ObjectList[cObject]->m_vecMaxBox.z;
|
||
|
||
vecBoundBox[7].x=m_ObjectList[cObject]->m_vecMaxBox.x;
|
||
vecBoundBox[7].y=m_ObjectList[cObject]->m_vecMaxBox.y+50.0f;
|
||
vecBoundBox[7].z=m_ObjectList[cObject]->m_vecMaxBox.z;
|
||
|
||
for(int i=0;i<8;i++)
|
||
{
|
||
matTrans.Translation(vecBoundBox[i]);
|
||
matTrans=matTrans*matTM;
|
||
vecBoundBox[i]=matTrans.GetLoc();
|
||
}
|
||
|
||
//
|
||
//vecPolyTest[0]=vecBoundBox[4];
|
||
//vecPolyTest[1]=vecBoundBox[0];
|
||
//vecPolyTest[2]=vecBoundBox[1];
|
||
bool bAlready=false;
|
||
for(int cIndices=0;cIndices<8;cIndices++)
|
||
{
|
||
vecPolyTest[0]=vecBoundBox[wCollisionIndices[cIndices*3+0]];
|
||
vecPolyTest[1]=vecBoundBox[wCollisionIndices[cIndices*3+1]];
|
||
vecPolyTest[2]=vecBoundBox[wCollisionIndices[cIndices*3+2]];
|
||
|
||
m_pOctree->AddPoly(vecPolyTest);
|
||
}
|
||
|
||
}
|
||
|
||
|
||
m_pOctree->GenerateOctree();
|
||
}
|
||
|
||
//DEL void CHouseObject::GetVertex()
|
||
//DEL {
|
||
//DEL vector3 *pVertex;
|
||
//DEL WORD *pIndices;
|
||
//DEL if(m_pOutHouseObject)
|
||
//DEL {
|
||
//DEL m_pOutHouseObject->AllLockBuffer();
|
||
//DEL for(int i=0;i<m_pOutHouseObject->GetObjectCount();i++)
|
||
//DEL {
|
||
//DEL pVertex=new vector3[m_pOutHouseObject->m_nVertex[i]];
|
||
//DEL for(int cv=0;cv<m_pOutHouseObject->m_nVertex[i];cv++)
|
||
//DEL //pVertex[cv]=((MultiVertex)m_pOutHouseObject->m_pVertex[i][cv]).v;
|
||
//DEL pVertex[cv]=m_pOutHouseObject->m_pVertex[i]
|
||
//DEL m_pVertex.Add(pVertex);
|
||
//DEL m_nVertex.Add(m_pOutHouseObject->m_nVertex[i]);
|
||
//DEL
|
||
//DEL pIndices=new WORD[m_pOutHouseObject->m_nIndices[i]*3];
|
||
//DEL memcpy(pIndices,m_pOutHouseObject->m_pIndices[i],sizeof(WORD)*m_pOutHouseObject->m_nIndices[i]*3);
|
||
//DEL
|
||
//DEL m_pIndices.Add(pIndices);
|
||
//DEL m_nIndices.Add(m_pOutHouseObject->m_nIndices[i]);
|
||
//DEL //m_pIndices.Add(m_pOutHouseObject->m_pIndices[i]);
|
||
//DEL //m_nIndices.Add(m_pOutHouseObject->m_nIndices[i]);
|
||
//DEL }
|
||
//DEL }
|
||
//DEL if(m_pMedHouseObject)
|
||
//DEL {
|
||
//DEL m_pMedHouseObject->AllLockBuffer();
|
||
//DEL for(int i=0;i<m_pMedHouseObject->GetObjectCount();i++)
|
||
//DEL {
|
||
//DEL pVertex=new vector3[m_pMedHouseObject->m_nVertex[i]];
|
||
//DEL for(int cv=0;cv<m_pMedHouseObject->m_nVertex[i];cv++)
|
||
//DEL pVertex[cv]=m_pMedHouseObject->m_pVertex[i][cv].v;
|
||
//DEL m_pVertex.Add(pVertex);
|
||
//DEL m_nVertex.Add(m_pMedHouseObject->m_nVertex[i]);
|
||
//DEL
|
||
//DEL pIndices=new WORD[m_pMedHouseObject->m_nIndices[i]*3];
|
||
//DEL memcpy(pIndices,m_pMedHouseObject->m_pIndices[i],sizeof(WORD)*m_pMedHouseObject->m_nIndices[i]*3);
|
||
//DEL
|
||
//DEL m_pIndices.Add(pIndices);
|
||
//DEL m_nIndices.Add(m_pMedHouseObject->m_nIndices[i]);
|
||
//DEL
|
||
//DEL
|
||
//DEL //m_pIndices.Add(m_pMedHouseObject->m_pIndices[i]);
|
||
//DEL //m_nIndices.Add(m_pMedHouseObject->m_nIndices[i]);
|
||
//DEL }
|
||
//DEL }
|
||
//DEL if(m_pInHouseObject)
|
||
//DEL {
|
||
//DEL m_pInHouseObject->AllLockBuffer();
|
||
//DEL for(int i=0;i<m_pInHouseObject->GetObjectCount();i++)
|
||
//DEL {
|
||
//DEL pVertex=new vector3[m_pInHouseObject->m_nVertex[i]];
|
||
//DEL for(int cv=0;cv<m_pInHouseObject->m_nVertex[i];cv++)
|
||
//DEL pVertex[cv]=m_pInHouseObject->m_pVertex[i][cv].v;
|
||
//DEL m_pVertex.Add(pVertex);
|
||
//DEL m_nVertex.Add(m_pInHouseObject->m_nVertex[i]);
|
||
//DEL
|
||
//DEL
|
||
//DEL pIndices=new WORD[m_pInHouseObject->m_nIndices[i]*3];
|
||
//DEL memcpy(pIndices,m_pInHouseObject->m_pIndices[i],sizeof(WORD)*m_pInHouseObject->m_nIndices[i]*3);
|
||
//DEL
|
||
//DEL m_pIndices.Add(pIndices);
|
||
//DEL m_nIndices.Add(m_pInHouseObject->m_nIndices[i]);
|
||
//DEL
|
||
//DEL //m_pIndices.Add(m_pInHouseObject->m_pIndices[i]);
|
||
//DEL //m_nIndices.Add(m_pInHouseObject->m_nIndices[i]);
|
||
//DEL }
|
||
//DEL }
|
||
//DEL
|
||
//DEL if(m_pOutHouseObject)
|
||
//DEL m_pOutHouseObject->AllUnlockBuffer();
|
||
//DEL if(m_pMedHouseObject)
|
||
//DEL m_pMedHouseObject->AllUnlockBuffer();
|
||
//DEL if(m_pInHouseObject)
|
||
//DEL m_pInHouseObject->AllUnlockBuffer();
|
||
//DEL
|
||
//DEL }
|
||
|
||
void CHouseObject::CalcBox(vector3 &MinBox, vector3 &MaxBox,int iSelect)
|
||
{
|
||
if(!iSelect)
|
||
{
|
||
if(m_pLodHouseObject)
|
||
{
|
||
MaxBox=m_pLodHouseObject->m_MaxBox;
|
||
MinBox=m_pLodHouseObject->m_MinBox;
|
||
}
|
||
if(m_pOutHouseObject)
|
||
{
|
||
MaxBox=m_pOutHouseObject->m_MaxBox;
|
||
MinBox=m_pOutHouseObject->m_MinBox;
|
||
}
|
||
if(m_pMedHouseObject)
|
||
{
|
||
if(MaxBox.x < m_pMedHouseObject->m_MaxBox.x)
|
||
MaxBox.x=m_pMedHouseObject->m_MaxBox.x;
|
||
if(MaxBox.y < m_pMedHouseObject->m_MaxBox.y)
|
||
MaxBox.y=m_pMedHouseObject->m_MaxBox.y;
|
||
if(MaxBox.z < m_pMedHouseObject->m_MaxBox.z)
|
||
MaxBox.z=m_pMedHouseObject->m_MaxBox.z;
|
||
|
||
if(MinBox.x > m_pMedHouseObject->m_MinBox.x)
|
||
MaxBox.x=m_pMedHouseObject->m_MinBox.x;
|
||
if(MinBox.y > m_pMedHouseObject->m_MinBox.y)
|
||
MinBox.y=m_pMedHouseObject->m_MinBox.y;
|
||
if(MinBox.z > m_pMedHouseObject->m_MinBox.z)
|
||
MinBox.z=m_pMedHouseObject->m_MinBox.z;
|
||
|
||
}
|
||
if(m_pInHouseObject)
|
||
{
|
||
if(MaxBox.x < m_pOutHouseObject->m_MaxBox.x)
|
||
MaxBox.x=m_pOutHouseObject->m_MaxBox.x;
|
||
if(MaxBox.y < m_pOutHouseObject->m_MaxBox.y)
|
||
MaxBox.y=m_pOutHouseObject->m_MaxBox.y;
|
||
if(MaxBox.z < m_pOutHouseObject->m_MaxBox.z)
|
||
MaxBox.z=m_pOutHouseObject->m_MaxBox.z;
|
||
|
||
if(MinBox.x > m_pOutHouseObject->m_MinBox.x)
|
||
MaxBox.x=m_pOutHouseObject->m_MinBox.x;
|
||
if(MinBox.y > m_pOutHouseObject->m_MinBox.y)
|
||
MinBox.y=m_pOutHouseObject->m_MinBox.y;
|
||
if(MinBox.z > m_pOutHouseObject->m_MinBox.z)
|
||
MinBox.z=m_pOutHouseObject->m_MinBox.z;
|
||
}
|
||
}
|
||
else if(iSelect == 1)
|
||
{
|
||
if(m_pInHouseObject)
|
||
{
|
||
MaxBox = m_pInHouseObject->m_MaxBox;
|
||
MinBox = m_pInHouseObject->m_MinBox;
|
||
|
||
}
|
||
}
|
||
}
|
||
void CHouseObject::GetPolygon()
|
||
{
|
||
int cObject;
|
||
m_pIndices.num=0;
|
||
m_nIndices.num=0;
|
||
m_pVertex.num=0;
|
||
|
||
if(m_pOutHouseObject)
|
||
{
|
||
m_pOutHouseObject->AllLockBuffer();
|
||
for(cObject=0;cObject<m_pOutHouseObject->GetObjectCount();cObject++)
|
||
{
|
||
vector3 *AddVertex=new vector3[m_pOutHouseObject->m_nVertex[cObject]];
|
||
|
||
MultiVertex *pVertex=(MultiVertex*)m_pOutHouseObject->m_pVertex[cObject];
|
||
for(int cVertex=0;cVertex<m_pOutHouseObject->m_nVertex[cObject];cVertex++)
|
||
AddVertex[cVertex]=pVertex[cVertex].v;
|
||
|
||
m_pVertex.Add(AddVertex);
|
||
WORD *AddIndices=new WORD[m_pOutHouseObject->m_nIndices[cObject]*3];
|
||
memcpy(AddIndices,m_pOutHouseObject->m_pIndices[cObject],sizeof(WORD)*3*m_pOutHouseObject->m_nIndices[cObject]);
|
||
m_pIndices.Add(AddIndices);
|
||
m_nIndices.Add(m_pOutHouseObject->m_nIndices[cObject]);
|
||
}
|
||
m_pOutHouseObject->AllUnlockBuffer();
|
||
}
|
||
if(m_pInHouseObject)
|
||
{
|
||
m_pInHouseObject->AllLockBuffer();
|
||
for(cObject=0;cObject<m_pInHouseObject->GetObjectCount();cObject++)
|
||
{
|
||
vector3 *AddVertex=new vector3[m_pInHouseObject->m_nVertex[cObject]];
|
||
|
||
MultiVertex *pVertex=(MultiVertex*)m_pInHouseObject->m_pVertex[cObject];
|
||
for(int cVertex=0;cVertex<m_pInHouseObject->m_nVertex[cObject];cVertex++)
|
||
AddVertex[cVertex]=pVertex[cVertex].v;
|
||
|
||
m_pVertex.Add(AddVertex);
|
||
WORD *AddIndices=new WORD[m_pInHouseObject->m_nIndices[cObject]*3];
|
||
memcpy(AddIndices,m_pInHouseObject->m_pIndices[cObject],sizeof(WORD)*3*m_pInHouseObject->m_nIndices[cObject]);
|
||
m_pIndices.Add(AddIndices);
|
||
m_nIndices.Add(m_pInHouseObject->m_nIndices[cObject]);
|
||
}
|
||
m_pInHouseObject->AllUnlockBuffer();
|
||
}
|
||
if(m_pMedHouseObject)
|
||
{
|
||
m_pMedHouseObject->AllLockBuffer();
|
||
for(cObject=0;cObject<m_pMedHouseObject->GetObjectCount();cObject++)
|
||
{
|
||
vector3 *AddVertex=new vector3[m_pMedHouseObject->m_nVertex[cObject]];
|
||
|
||
MultiVertex *pVertex=(MultiVertex*)m_pMedHouseObject->m_pVertex[cObject];
|
||
for(int cVertex=0;cVertex<m_pMedHouseObject->m_nVertex[cObject];cVertex++)
|
||
AddVertex[cVertex]=pVertex[cVertex].v;
|
||
|
||
m_pVertex.Add(AddVertex);
|
||
WORD *AddIndices=new WORD[m_pMedHouseObject->m_nIndices[cObject]*3];
|
||
memcpy(AddIndices,m_pMedHouseObject->m_pIndices[cObject],sizeof(WORD)*3*m_pMedHouseObject->m_nIndices[cObject]);
|
||
m_pIndices.Add(AddIndices);
|
||
m_nIndices.Add(m_pMedHouseObject->m_nIndices[cObject]);
|
||
}
|
||
m_pMedHouseObject->AllUnlockBuffer();
|
||
}
|
||
}
|
||
|
||
matrix CHouseObject::RenderShadow(LPDIRECT3DDEVICE8 pd3dDevice)
|
||
{
|
||
matrix matOldCamera,matOldProjection;
|
||
pd3dDevice->GetTransform(D3DTS_VIEW,matOldCamera);
|
||
pd3dDevice->GetTransform(D3DTS_PROJECTION,matOldProjection);
|
||
|
||
pd3dDevice->EndScene();
|
||
|
||
//CShadowMap::Begin(pd3dDevice);
|
||
|
||
pd3dDevice->BeginScene();
|
||
|
||
//CSceneStateMgr::_SetD3DRenderState(D3DRS_COLORWRITEENABLE, 0);
|
||
|
||
pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x00BFBFBF, 1.0f, 0L);
|
||
|
||
matrix matShadowProj;
|
||
matShadowProj.MakeProjection(3.14159f/3.0f,1.0f,1500.0f,6500.0f);
|
||
|
||
matrix matParentWorld;
|
||
pd3dDevice->GetTransform(D3DTS_WORLD,(D3DMATRIX*)&matParentWorld);
|
||
vector3 vecHousePos=matParentWorld.GetLoc();
|
||
|
||
matrix matShadowCamera;
|
||
pd3dDevice->SetTransform(D3DTS_PROJECTION,matShadowProj);
|
||
|
||
static float fRot=0.0f;
|
||
vector3 vecSunLight;
|
||
vecSunLight.y=0.5f;
|
||
vecSunLight.x=sinf(fRot);
|
||
vecSunLight.z=cosf(fRot);
|
||
vecSunLight.Normalize();
|
||
|
||
fRot+=0.0008f;
|
||
if(m_pOutHouseObject)
|
||
{
|
||
vector3 vecCenter=(m_pOutHouseObject->m_MaxBox+m_pOutHouseObject->m_MinBox)/2.0f;
|
||
|
||
|
||
|
||
|
||
matShadowCamera.CameraLookAt(
|
||
vecHousePos+vecSunLight*4500.0f+vecCenter,
|
||
vecHousePos+vecCenter,
|
||
vector3(0.0f,1.0f,0.0f));
|
||
|
||
pd3dDevice->SetTransform(D3DTS_VIEW,matShadowCamera);
|
||
|
||
|
||
pd3dDevice->SetTexture(1,m_Lightmap.GetTexture());
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
|
||
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
DWORD dwTempShader=m_pOutHouseObject->m_dwCustomizeShader;
|
||
m_pOutHouseObject->m_dwCustomizeShader=0xffffffff;
|
||
m_pOutHouseObject->Render(pd3dDevice);
|
||
m_pOutHouseObject->m_dwCustomizeShader=dwTempShader;
|
||
pd3dDevice->SetVertexShaderConstant(12,&vecSunLight,1);
|
||
}
|
||
|
||
//matParentWorld.Transpose();
|
||
|
||
|
||
matrix matWVP;
|
||
matWVP=matParentWorld*matShadowCamera;
|
||
matWVP=matWVP*matShadowProj;
|
||
|
||
/*
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_BLUE |
|
||
D3DCOLORWRITEENABLE_GREEN |
|
||
D3DCOLORWRITEENABLE_RED);
|
||
*/
|
||
|
||
|
||
pd3dDevice->EndScene();
|
||
|
||
|
||
//CShadowMap::End(pd3dDevice);
|
||
|
||
|
||
pd3dDevice->BeginScene();
|
||
|
||
|
||
pd3dDevice->SetTransform(D3DTS_VIEW,matOldCamera);
|
||
pd3dDevice->SetTransform(D3DTS_PROJECTION,matOldProjection);
|
||
|
||
return matWVP;
|
||
}
|
||
|
||
void CHouseObject::RenderGlare(LPDIRECT3DDEVICE8 pd3dDevice)
|
||
{
|
||
if(m_pBspObject)
|
||
{
|
||
return;
|
||
|
||
}
|
||
if(m_pLodHouseObject && !m_pOutHouseObject)
|
||
{
|
||
return;
|
||
}
|
||
if(m_pOutHouseObject)
|
||
{
|
||
if(m_isHaveLightmap)
|
||
{
|
||
if(CRenderOption::m_AllObjectBump)
|
||
{
|
||
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_TEXCOORDINDEX,0);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_TEXCOORDINDEX,1);
|
||
CSceneStateMgr::_SetD3DTextureStageState(2,D3DTSS_TEXCOORDINDEX,2);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_TEXCOORDINDEX,3);
|
||
|
||
pd3dDevice->SetTexture(2,m_Lightmap.GetTexture());
|
||
pd3dDevice->SetTexture(3,m_pNormalizeCubeMap);
|
||
|
||
matrix matView,matProjection,matWorld,matWVP;
|
||
pd3dDevice->GetTransform(D3DTS_VIEW,matView);
|
||
pd3dDevice->GetTransform(D3DTS_PROJECTION,matProjection);
|
||
pd3dDevice->GetTransform(D3DTS_WORLD,matWorld);
|
||
matWVP=matWorld*matView*matProjection;
|
||
matWVP.Transpose();
|
||
|
||
vector3 vecPos=matWorld.GetLoc();
|
||
pd3dDevice->SetVertexShaderConstant(16,&matWVP, 4);
|
||
|
||
matrix matInv;
|
||
|
||
matInv.Inverse(matWorld);
|
||
|
||
matrix *matViewPosition=CSceneManager::GetCamera()->GetMatPosition();
|
||
vector3 vecViewPos=vector3(matViewPosition->_41,matViewPosition->_42,matViewPosition->_43);
|
||
|
||
matrix matViewPos;
|
||
matViewPos.Translation(vecViewPos);
|
||
|
||
matViewPos=matViewPos*matInv;
|
||
|
||
float fObjectSpaceViewPosition[4]={matViewPos._41,matViewPos._42,matViewPos._43,0.0f};
|
||
|
||
pd3dDevice->SetVertexShaderConstant(35,fObjectSpaceViewPosition,1);
|
||
|
||
//////////////////
|
||
|
||
matWorld._41=matWorld._42=matWorld._43=0.0f;
|
||
matInv.Inverse(matWorld);
|
||
|
||
vector3 vecLightPos=vector3(1.0f,1.0f,1.0f);
|
||
vecLightPos.Normalize();
|
||
|
||
vecLightPos=vecLightPos*10000.0f;
|
||
|
||
matrix matLightPos;
|
||
matLightPos.Translation(vecLightPos);
|
||
|
||
matLightPos=matLightPos*matInv;
|
||
|
||
float fObjectSpaceLightPosition[4]={matLightPos._41,matLightPos._42,matLightPos._43,1.0f};
|
||
pd3dDevice->SetVertexShaderConstant(32,fObjectSpaceLightPosition,1);
|
||
|
||
/*
|
||
|
||
pd3dDevice->SetPixelShader(m_dwHouseDiffusePixelShader);
|
||
|
||
m_pOutHouseObject->m_dwCustomizeShader=m_dwHouseDiffuseVertexShader;
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSU,D3DTADDRESS_CLAMP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSV,D3DTADDRESS_CLAMP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSW,D3DTADDRESS_CLAMP);
|
||
|
||
m_pOutHouseObject->Render(pd3dDevice);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSU,D3DTADDRESS_WRAP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSV,D3DTADDRESS_WRAP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSW,D3DTADDRESS_WRAP);
|
||
|
||
pd3dDevice->SetPixelShader(NULL);
|
||
|
||
m_pOutHouseObject->m_dwCustomizeShader=0xffffffff;
|
||
*/
|
||
pd3dDevice->SetPixelShader(m_dwHouseSpecularPixelShader);
|
||
|
||
m_pOutHouseObject->m_dwCustomizeShader=m_dwHouseSpecularVertexShader;
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_ADDRESSU,D3DTADDRESS_WRAP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_ADDRESSV,D3DTADDRESS_WRAP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_ADDRESSW,D3DTADDRESS_WRAP);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_ADDRESSU,D3DTADDRESS_WRAP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_ADDRESSV,D3DTADDRESS_WRAP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_ADDRESSW,D3DTADDRESS_WRAP);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState(2,D3DTSS_ADDRESSU,D3DTADDRESS_WRAP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(2,D3DTSS_ADDRESSV,D3DTADDRESS_WRAP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(2,D3DTSS_ADDRESSW,D3DTADDRESS_WRAP);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSU,D3DTADDRESS_CLAMP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSV,D3DTADDRESS_CLAMP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSW,D3DTADDRESS_CLAMP);
|
||
|
||
m_pOutHouseObject->Render(pd3dDevice);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSU,D3DTADDRESS_WRAP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSV,D3DTADDRESS_WRAP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSW,D3DTADDRESS_WRAP);
|
||
|
||
pd3dDevice->SetPixelShader(NULL);
|
||
|
||
m_pOutHouseObject->m_dwCustomizeShader=0xffffffff;
|
||
pd3dDevice->SetTexture(3,NULL);
|
||
|
||
}
|
||
}
|
||
}
|
||
}
|
||
void CHouseObject::RenderBlack( LPDIRECT3DDEVICE8 pd3dDevice )
|
||
{
|
||
D3DMATERIAL8 mtrl;
|
||
ZeroMemory( &mtrl, sizeof(D3DMATERIAL8) );
|
||
mtrl.Diffuse.r = mtrl.Ambient.r = 1.0f;
|
||
mtrl.Diffuse.g = mtrl.Ambient.g = 1.0f;
|
||
mtrl.Diffuse.b = mtrl.Ambient.b = 1.0f;
|
||
mtrl.Diffuse.a = mtrl.Ambient.a = 1.0f;
|
||
pd3dDevice->SetMaterial( &mtrl );
|
||
|
||
|
||
if(m_pBspObject)
|
||
{
|
||
if(CSceneManager::m_bEditor)
|
||
{
|
||
if(CSceneManager::m_PickHouseScene && CSceneManager::m_PickHouseScene->m_HouseObject == this)
|
||
{
|
||
m_pBspObject->RenderBox(pd3dDevice,0xffff0000);
|
||
}
|
||
else
|
||
{
|
||
m_pBspObject->RenderBox(pd3dDevice,0xffffffff);
|
||
}
|
||
|
||
matrix matTM,matParentWorld;
|
||
pd3dDevice->GetTransform(D3DTS_WORLD,(D3DMATRIX*)&matParentWorld);
|
||
|
||
for(int cObject=0;cObject<m_ObjectList.num;cObject++)
|
||
{
|
||
matTM=m_ObjectList[cObject]->m_TM*matParentWorld;
|
||
pd3dDevice->SetTransform(D3DTS_WORLD,matTM);
|
||
m_ObjectList[cObject]->m_AccumulateTM=matTM;
|
||
//if(m_ObjectList[cObject]->isCulling())
|
||
{
|
||
if(CSceneManager::m_PickObjectScene==m_ObjectList[cObject])
|
||
{
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_TFACTOR );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG2);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR,0xffffffff);
|
||
|
||
m_ObjectList[cObject]->m_pObject->RenderBox(pd3dDevice);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
}
|
||
|
||
//==============
|
||
// TEST
|
||
//==============
|
||
/*CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR, 0x00 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TFACTOR );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
||
*/
|
||
m_ObjectList[cObject]->m_pObject->RenderGlare(pd3dDevice);
|
||
}
|
||
}
|
||
pd3dDevice->SetTransform(D3DTS_WORLD,(D3DMATRIX*)&matParentWorld);
|
||
|
||
}
|
||
return;
|
||
}
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
pd3dDevice->SetTexture(2,NULL);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 2, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
if(m_pLodHouseObject && !m_pOutHouseObject)
|
||
{
|
||
|
||
pd3dDevice->LightEnable(0,TRUE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
if(BaseGraphicsLayer::m_VoodooOption)
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
else
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
|
||
//==============
|
||
// TEST
|
||
//==============
|
||
/*CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR, 0x00 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TFACTOR );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
||
*/
|
||
/*CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_COLOROP,D3DTOP_SELECTARG1);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
||
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_DISABLE);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_ALPHAOP,D3DTOP_DISABLE);
|
||
*/
|
||
m_pLodHouseObject->RenderGlare(pd3dDevice);
|
||
|
||
return;
|
||
}
|
||
if(m_pOutHouseObject)
|
||
{
|
||
if(m_isHaveLightmap)
|
||
{
|
||
if(CRenderOption::m_AllObjectBump)
|
||
{
|
||
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_TEXCOORDINDEX,0);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_TEXCOORDINDEX,1);
|
||
CSceneStateMgr::_SetD3DTextureStageState(2,D3DTSS_TEXCOORDINDEX,2);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_TEXCOORDINDEX,3);
|
||
|
||
pd3dDevice->SetTexture(2,m_Lightmap.GetTexture());
|
||
//pd3dDevice->SetTexture(3,m_pNormalizeCubeMap);
|
||
|
||
float fHouseAmbientLight[4]={CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.r/255.0f,
|
||
CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.g/255.0f,
|
||
CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.b/255.0f,1.0f};
|
||
|
||
pd3dDevice->SetPixelShaderConstant(0,fHouseAmbientLight,1);
|
||
matrix matView,matProjection,matWorld,matWVP;
|
||
pd3dDevice->GetTransform(D3DTS_VIEW,matView);
|
||
pd3dDevice->GetTransform(D3DTS_PROJECTION,matProjection);
|
||
pd3dDevice->GetTransform(D3DTS_WORLD,matWorld);
|
||
matWVP=matWorld*matView*matProjection;
|
||
matWVP.Transpose();
|
||
pd3dDevice->SetVertexShaderConstant(16,&matWVP, 4);
|
||
|
||
pd3dDevice->SetPixelShader(m_dwHouseDiffusePixelShader);
|
||
|
||
m_pOutHouseObject->m_dwCustomizeShader=m_dwHouseDiffuseVertexShader;
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSU,D3DTADDRESS_CLAMP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSV,D3DTADDRESS_CLAMP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSW,D3DTADDRESS_CLAMP);
|
||
|
||
//==============
|
||
// TEST
|
||
//==============
|
||
/*CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR, 0x00 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TFACTOR );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
||
*/
|
||
|
||
m_pOutHouseObject->RenderGlare(pd3dDevice);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSU,D3DTADDRESS_WRAP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSV,D3DTADDRESS_WRAP);
|
||
CSceneStateMgr::_SetD3DTextureStageState(3,D3DTSS_ADDRESSW,D3DTADDRESS_WRAP);
|
||
|
||
pd3dDevice->SetPixelShader(NULL);
|
||
|
||
m_pOutHouseObject->m_dwCustomizeShader=0xffffffff;
|
||
}
|
||
else
|
||
{
|
||
// <20><>
|
||
if(m_bNightUv == true && m_bNightMap == true && m_bConvertNight == true)
|
||
pd3dDevice->SetTexture(1,m_BackupLightmap.GetTexture());
|
||
else
|
||
pd3dDevice->SetTexture(1,m_Lightmap.GetTexture());
|
||
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
/**/
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR, CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
|
||
/**/
|
||
if(m_bNightUv != true || m_bNightMap != true || m_bConvertNight != true)
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_TFACTOR);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X );
|
||
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_TEXCOORDINDEX,0);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_TEXCOORDINDEX,1);
|
||
////
|
||
//==============
|
||
// TEST
|
||
//==============
|
||
/*CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR, 0x00 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TFACTOR );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
||
*/
|
||
/*CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
||
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_DISABLE);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_ALPHAOP,D3DTOP_DISABLE);
|
||
*/
|
||
m_pOutHouseObject->RenderGlare(pd3dDevice);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
CSceneManager::CGlareNode AddNode;
|
||
AddNode.m_bCubeEnv=true;
|
||
pd3dDevice->GetTransform(D3DTS_WORLD,AddNode.m_matPosition);
|
||
AddNode.m_pMeshObject=m_pOutHouseObject;
|
||
//CSceneManager::AddGlareNode(AddNode);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
pd3dDevice->LightEnable(0,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,TRUE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT);
|
||
|
||
if(BaseGraphicsLayer::m_VoodooOption)
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
else
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
|
||
if(m_Detailmap.GetTexture())
|
||
{
|
||
pd3dDevice->SetTexture(1,m_Detailmap.GetTexture());
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
|
||
|
||
matrix matTex;
|
||
matTex.MakeIdent();
|
||
matTex._11=10.0f;
|
||
matTex._22=10.0f;
|
||
|
||
pd3dDevice->SetTransform(D3DTS_TEXTURE1,(D3DMATRIX*)&matTex);
|
||
pd3dDevice->SetPixelShader(NULL);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 0 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
|
||
|
||
//==============
|
||
// TEST
|
||
//==============
|
||
/*CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR, 0x00 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TFACTOR );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );*/
|
||
/*CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
||
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_DISABLE);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_ALPHAOP,D3DTOP_DISABLE);
|
||
*/
|
||
|
||
m_pOutHouseObject->RenderGlare(pd3dDevice);
|
||
|
||
matTex.MakeIdent();
|
||
pd3dDevice->SetTransform(D3DTS_TEXTURE1,(D3DMATRIX*)&matTex);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_TEXTURETRANSFORMFLAGS,D3DTTFF_DISABLE );
|
||
}
|
||
else
|
||
{
|
||
pd3dDevice->SetTexture(1,NULL);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
|
||
|
||
//==============
|
||
// TEST
|
||
//==============
|
||
/*CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR, 0x00 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TFACTOR );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
||
*/
|
||
/*CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
||
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_DISABLE);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_ALPHAOP,D3DTOP_DISABLE);
|
||
*/
|
||
m_pOutHouseObject->RenderGlare(pd3dDevice);
|
||
}
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_LIGHTING,FALSE);
|
||
|
||
}
|
||
}
|
||
|
||
if(m_pMedHouseObject)
|
||
{
|
||
if(m_isHaveLightmap)
|
||
{
|
||
pd3dDevice->SetTexture(1,m_Lightmap.GetTexture());
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
|
||
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
//CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
|
||
|
||
if(BaseGraphicsLayer::m_VoodooOption)
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
else
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, CSceneManager::m_WeatherManager.m_InterObjectAmbientColor.c);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,TRUE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,TRUE);
|
||
|
||
//==============
|
||
// TEST
|
||
//==============
|
||
/*CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR, 0x00 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TFACTOR );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
||
*/
|
||
/*CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
||
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_DISABLE);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_ALPHAOP,D3DTOP_DISABLE);
|
||
*/
|
||
|
||
m_pMedHouseObject->RenderGlare(pd3dDevice);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHABLENDENABLE,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_ALPHATESTENABLE,FALSE);
|
||
}
|
||
else
|
||
{
|
||
pd3dDevice->LightEnable(0,TRUE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
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);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
|
||
//==============
|
||
// TEST
|
||
//==============
|
||
/*CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR, 0x00 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TFACTOR );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
||
*/
|
||
/*CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
||
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_DISABLE);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_ALPHAOP,D3DTOP_DISABLE);
|
||
*/
|
||
m_pMedHouseObject->RenderGlare(pd3dDevice);
|
||
}
|
||
}
|
||
|
||
if(m_LightList.num>0 || m_ObjectList.num>0)
|
||
{
|
||
|
||
}
|
||
|
||
if(m_pInHouseObject)
|
||
{
|
||
if(m_isHaveLightmap)
|
||
{
|
||
pd3dDevice->SetTexture(1,m_Lightmap.GetTexture());
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLORARG2, D3DTA_CURRENT );
|
||
|
||
if(BaseGraphicsLayer::m_VoodooOption)
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE);
|
||
else
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
|
||
|
||
pd3dDevice->LightEnable(0,FALSE);
|
||
CSceneStateMgr::_SetD3DRenderState( D3DRS_AMBIENT, 0xffffffff);
|
||
|
||
//==============
|
||
// TEST
|
||
//==============
|
||
/*CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR, 0x00 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TFACTOR );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
||
*/
|
||
/*CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
||
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_DISABLE);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_ALPHAOP,D3DTOP_DISABLE);
|
||
*/
|
||
m_pInHouseObject->RenderGlare(pd3dDevice);
|
||
}
|
||
else
|
||
{
|
||
pd3dDevice->LightEnable(0,TRUE);
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
|
||
//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);
|
||
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
|
||
CSceneStateMgr::_SetD3DRenderState(D3DRS_AMBIENT,CSceneManager::m_WeatherManager.m_InterAmbientColor.c);
|
||
pd3dDevice->SetLight(0,&CSceneManager::m_WeatherManager.m_SunLight);
|
||
|
||
//==============
|
||
// TEST
|
||
//==============
|
||
/*CSceneStateMgr::_SetD3DRenderState( D3DRS_TEXTUREFACTOR, 0x00 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TFACTOR );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
||
*/
|
||
/*CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
|
||
CSceneStateMgr::_SetD3DTextureStageState( 1, D3DTSS_COLOROP, D3DTOP_DISABLE );
|
||
CSceneStateMgr::_SetD3DTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_DISABLE);
|
||
CSceneStateMgr::_SetD3DTextureStageState(1,D3DTSS_ALPHAOP,D3DTOP_DISABLE);
|
||
*/
|
||
|
||
m_pInHouseObject->RenderGlare(pd3dDevice);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
|