void CSprite::DrawSmooth(LPDIRECT3DDEVICE7 lpDevice,const D3DVECTOR pos,const float w,const float h,const DWORD color,const int spritenr)
{
D3DVECTOR rightVect,upVect;
D3DMATRIX mat;
{
lpDevice->GetTransform(D3DTRANSFORMSTATE_VIEW,&mat);
rightVect=Normalize(D3DVECTOR(mat._11,mat._21,mat._31))*w*0.5f;
upVect=Normalize(D3DVECTOR(mat._12,mat._22,mat._32))*h*0.5f;
}
const D3DVECTOR n=D3DVECTOR(0,0,0);
D3DLVERTEX verts[4]=
{
D3DLVERTEX(pos-rightVect+upVect, color,0, 1.0f, 0.0f),
D3DLVERTEX(pos+rightVect+upVect, color,0, 0.0f, 0.0f),
D3DLVERTEX(pos-rightVect-upVect, color,0, 1.0f, 1.0f),
D3DLVERTEX(pos+rightVect-upVect, color,0, 0.0f, 1.0f)
};
D3DUtil_SetIdentityMatrix(mat);
lpDevice->SetTransform(D3DTRANSFORMSTATE_WORLD,&mat);
if (Config.alpha)
{
lpDevice->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE,FALSE);
lpDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, TRUE);
lpDevice->SetRenderState(D3DRENDERSTATE_LIGHTING,FALSE);
lpDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
lpDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
lpDevice->SetTextureStageState(0,D3DTSS_COLOROP,D3DTOP_MODULATE);
lpDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND,D3DBLEND_SRCCOLOR);
lpDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND,D3DBLEND_INVSRCCOLOR);
lpDevice->SetRenderState(D3DRENDERSTATE_ALPHATESTENABLE,TRUE);
lpDevice->SetRenderState(D3DRENDERSTATE_ALPHAREF,0x08);
}
lpDevice->SetTexture(0,GetSurface(spritenr));
lpDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP,D3DFVF_LVERTEX,verts,4,0);
lpDevice->SetTexture(0,NULL);
if (Config.alpha)
{
lpDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, FALSE);
lpDevice->SetRenderState(D3DRENDERSTATE_LIGHTING,TRUE);
lpDevice->SetRenderState(D3DRENDERSTATE_ALPHATESTENABLE,FALSE);
lpDevice->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE,TRUE);
}
}
void RenderShadow(LPDIRECT3DDEVICE7 lpDevice,D3DVERTEX* vertices,int numvertices,WORD* indices,DWORD numindices)
{
// Turn depth buffer off, and stencil buffer on
lpDevice->SetRenderState( D3DRENDERSTATE_ZWRITEENABLE, FALSE );
lpDevice->SetRenderState( D3DRENDERSTATE_STENCILENABLE, TRUE );
// Set up stencil compare fuction, reference value, and masks
// Stencil test passes if ((ref & mask) cmpfn (stencil & mask)) is true
lpDevice->SetRenderState( D3DRENDERSTATE_STENCILFUNC, D3DCMP_ALWAYS );
lpDevice->SetRenderState( D3DRENDERSTATE_STENCILREF, 0x1 );
lpDevice->SetRenderState( D3DRENDERSTATE_STENCILMASK, 0xffffffff );
lpDevice->SetRenderState( D3DRENDERSTATE_STENCILWRITEMASK,0xffffffff );
// If ztest passes, write 1 into stencil buffer
lpDevice->SetRenderState( D3DRENDERSTATE_STENCILZFAIL, D3DSTENCILOP_KEEP );
lpDevice->SetRenderState( D3DRENDERSTATE_STENCILFAIL, D3DSTENCILOP_KEEP );
lpDevice->SetRenderState( D3DRENDERSTATE_STENCILPASS, D3DSTENCILOP_REPLACE );
// Make sure that no pixels get drawn to the frame buffer
lpDevice->SetRenderState( D3DRENDERSTATE_ALPHABLENDENABLE, TRUE );
lpDevice->SetRenderState( D3DRENDERSTATE_SRCBLEND, D3DBLEND_ZERO );
lpDevice->SetRenderState( D3DRENDERSTATE_DESTBLEND, D3DBLEND_ONE );
lpDevice->SetTexture(0,NULL);
// Draw front-side of shadow volume in stencil/z only
if (indices==NULL)
{
lpDevice->DrawPrimitive( D3DPT_TRIANGLELIST, D3DFVF_VERTEX,
vertices, numvertices,
NULL );
}
else
lpDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, D3DFVF_VERTEX,
vertices, numvertices,
indices, numindices, NULL );
// Now reverse cull order so back sides of shadow volume are written,
// writing 0's into stencil. Result will be any pixel which still has a bit
// set in the stencil buffer, is inside the shadow.
lpDevice->SetRenderState( D3DRENDERSTATE_STENCILREF, 0x0 );
// Draw back-side of shadow volume in stencil/z only
lpDevice->SetRenderState( D3DRENDERSTATE_CULLMODE, D3DCULL_CW );
if (indices==NULL)
{
lpDevice->DrawPrimitive( D3DPT_TRIANGLELIST, D3DFVF_VERTEX,
vertices, numvertices,
NULL );
}
else
lpDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, D3DFVF_VERTEX,
vertices, numvertices,
indices, numindices, NULL );
// Restore render states
lpDevice->SetRenderState( D3DRENDERSTATE_CULLMODE, D3DCULL_CCW );
lpDevice->SetRenderState( D3DRENDERSTATE_ZWRITEENABLE, TRUE );
lpDevice->SetRenderState( D3DRENDERSTATE_STENCILENABLE, FALSE );
lpDevice->SetRenderState( D3DRENDERSTATE_ALPHABLENDENABLE, FALSE );
}
void CGras::DrawUI(LPDIRECT3DDEVICE7 lpDevice)
{
if (lpVertices==NULL)return;
if (game->lpTexture[40]==NULL)
{ // Gras Textur nachladen
game->lpTexture[40]=CreateTextureFromResource(lpDevice,game->lpDD,NULL,"grass.bmp",4,FALSE,TRUE);
MakeTransparent(game->lpTexture[40],FALSE); // Gras
}
lpDevice->SetRenderState(D3DRENDERSTATE_LIGHTING,FALSE);
DWORD old;
lpDevice->GetRenderState(D3DRENDERSTATE_CULLMODE,&old);
lpDevice->SetRenderState(D3DRENDERSTATE_CULLMODE,D3DCULL_NONE);
if (Config.alpha)
{
lpDevice->SetTextureStageState(0,D3DTSS_ALPHAARG1,D3DTA_TEXTURE);
lpDevice->SetRenderState(D3DRENDERSTATE_ALPHATESTENABLE,TRUE);
lpDevice->SetRenderState(D3DRENDERSTATE_ALPHAREF,192);
lpDevice->SetRenderState(D3DRENDERSTATE_ALPHAFUNC,D3DCMP_GREATEREQUAL);
}
lpDevice->SetTexture(0,game->lpTexture[40]);
D3DMATRIX m;
D3DUtil_SetIdentityMatrix(m);
lpDevice->SetTransform(D3DTRANSFORMSTATE_WORLD,&m);
for (int i=0;i<vertexbuffers;i++)
lpDevice->DrawIndexedPrimitiveVB(D3DPT_TRIANGLELIST,lpVertices[i],0,vertexnum[i],Indices,vertexnum[i]/4*6,0);
lpDevice->SetRenderState(D3DRENDERSTATE_ALPHATESTENABLE,0);
lpDevice->SetRenderState(D3DRENDERSTATE_LIGHTING,TRUE);
lpDevice->SetRenderState(D3DRENDERSTATE_CULLMODE,old);
}
void CRadar::DrawUI(LPDIRECT3DDEVICE7 lpDevice)
{
if (!Enabled)return;
if ((lpSurface==NULL)||(lpSurface->IsLost()))
{
UpdateSurface();
Update();
}
const float w=130.0f*game->width/640.0f;
const float h=130.0f*game->width/640.0f;
const float x=game->width-20-w;
const float y=game->height-20-h;
const int c=D3DRGBA(1,1,1,0.45f);
const float r=0.9f;
D3DTLVERTEX v[4]={
D3DTLVERTEX(D3DVECTOR(x,y,0),r,c,0,0,0),
D3DTLVERTEX(D3DVECTOR(x+w,y,0),r,c,0,1,0),
D3DTLVERTEX(D3DVECTOR(x,y+h,0),r,c,0,0,1),
D3DTLVERTEX(D3DVECTOR(x+w,y+h,0),r,c,0,1,1)
};
if (Config.alpha)
{
// lpDevice->SetRenderState(D3DRENDERSTATE_ZENABLE,FALSE);
lpDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE,TRUE);
lpDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND,D3DBLEND_SRCALPHA);
lpDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND,D3DBLEND_INVSRCALPHA);
lpDevice->SetTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_MODULATE);
lpDevice->SetRenderState(D3DRENDERSTATE_ALPHATESTENABLE,TRUE);
lpDevice->SetRenderState(D3DRENDERSTATE_ALPHAREF,8);
lpDevice->SetRenderState(D3DRENDERSTATE_ALPHAFUNC,D3DCMP_GREATEREQUAL);
}
lpDevice->SetTexture(0,lpSurface);
lpDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP,D3DFVF_TLVERTEX,v,4,0);
lpDevice->SetTexture(0,NULL);
lpDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE,0);
lpDevice->SetRenderState(D3DRENDERSTATE_ALPHATESTENABLE,0);
// lpDevice->SetRenderState(D3DRENDERSTATE_ZENABLE,TRUE);
}
void CGolfer::Draw(LPDIRECT3DDEVICE7 lpDevice)
{
if ((parent==NULL)&&(!box->IsVisible()))return;
D3DMATRIX m=BerechneSchlag();
lpDevice->SetTexture(0,NULL);
lpDevice->SetTransform(D3DTRANSFORMSTATE_WORLD,&m);
mesh->Render(lpDevice,FALSE);
}
HRESULT CImageHandler::DrawBillBoard(LPDIRECT3DDEVICE7 lpDevice, D3DVECTOR vTrans, D3DVECTOR vScale, /*D3DVECTOR vRot, */D3DMATERIAL7 mtrl, /*FLOAT fRotRad, */LPDIRECTDRAWSURFACE7 lpddsTextr)
{
if ( lpDevice )
{
if( SUCCEEDED(lpDevice->BeginScene()) )
{
D3DMATRIX matTrans;
D3DMATRIX matScale;
D3DMATRIX matRot;
D3DMATRIX matWorld;
D3DMATRIX matTempWorld;
D3DMATRIX matWorldOriginal;
lpDevice->GetTransform(D3DTRANSFORMSTATE_WORLD, &matWorldOriginal);
vTrans.x = vTrans.x+vScale.x/2-400;
vTrans.y = -vTrans.y-vScale.y/2+300;
D3DUtil_SetTranslateMatrix(matTrans, vTrans);
D3DUtil_SetScaleMatrix(matScale, vScale.x, vScale.y, vScale.z);
// D3DUtil_SetRotationMatrix(matRot, vRot, fRotRad);
D3DMath_MatrixMultiply(/*matTempWorld*/matWorld, matScale, matTrans);
// D3DMath_MatrixMultiply(matWorld, matRot, matTempWorld);
lpDevice->SetTransform(D3DTRANSFORMSTATE_WORLD, &matWorld);
SetBlendRenderState(lpDevice, _BLEND_NORMAL, mtrl);
lpDevice->SetMaterial(&mtrl);
lpDevice->SetTexture(0, lpddsTextr);
lpDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, D3DFVF_VERTEX, m_avBillBoard, 4, NULL);
// 원상복귀.
ZeroMemory(&mtrl, sizeof(mtrl));
mtrl.diffuse.r = mtrl.diffuse.g = mtrl.diffuse.b = 0.1f;
mtrl.ambient.r = mtrl.ambient.g = mtrl.ambient.b = 1.0f;
lpDevice->SetMaterial(&mtrl);
ResetBlendenderState(lpDevice);
lpDevice->SetTransform(D3DTRANSFORMSTATE_WORLD, &matWorldOriginal);
}
lpDevice->EndScene();
return S_OK;
}
return E_FAIL;
}
void CDrescher::Draw(LPDIRECT3DDEVICE7 lpDevice)
{
if (!box2->IsVisible())return;
lpDevice->SetTexture(0,NULL);
D3DMATRIX matrix,m;
D3DUtil_SetTranslateMatrix(matrix,pos.x,pos.y+hoehe,pos.z);
{ // Mähdrescher gemäß Steigung kippen
D3DUtil_SetRotateYMatrix(m,beta);
D3DMath_MatrixMultiply(matrix,m,matrix);
D3DUtil_SetRotateXMatrix(m,alpha);
D3DMath_MatrixMultiply(matrix,m,matrix);
D3DUtil_SetRotateYMatrix(m,-beta);
D3DMath_MatrixMultiply(matrix,m,matrix);
}
D3DUtil_SetRotateYMatrix(m,ang.y);
D3DMath_MatrixMultiply(matrix,m,matrix);
if (schaukelphase>0.0f)
{ // schaukeln
const float mittelpunkt=2.0f;
D3DUtil_SetTranslateMatrix(m,0,0,-mittelpunkt);
D3DMath_MatrixMultiply(matrix,m,matrix);
D3DUtil_SetRotateXMatrix(m,schaukelwinkel());
D3DMath_MatrixMultiply(matrix,m,matrix);
D3DUtil_SetTranslateMatrix(m,0,0,mittelpunkt);
D3DMath_MatrixMultiply(matrix,m,matrix);
}
lpDevice->SetTransform(D3DTRANSFORMSTATE_WORLD,&matrix);
mesh1->Render(lpDevice,FALSE);
// Rolle
D3DUtil_SetRotateXMatrix(m,rolle);
D3DMath_MatrixMultiply(matrix,m,matrix);
lpDevice->SetTransform(D3DTRANSFORMSTATE_WORLD,&matrix);
mesh2->Render(lpDevice,FALSE);
}
void CEi::Draw(LPDIRECT3DDEVICE7 lpDevice)
{
if (!CBoundingTube::IsSphereVisible(pos,EGG_SIZE))return;
D3DMATRIX m,m2;
D3DUtil_SetTranslateMatrix(m,pos);
D3DUtil_SetRotateYMatrix(m2,ang.y);
D3DMath_MatrixMultiply(m,m2,m);
D3DUtil_SetRotateXMatrix(m2,-ang.x+g_PI*0.5f);
D3DMath_MatrixMultiply(m,m2,m);
lpDevice->SetTexture(0,NULL);
lpDevice->SetTransform(D3DTRANSFORMSTATE_WORLD,&m);
lpMesh->Render(lpDevice,FALSE);
}
/// <summary>
/// <c>wSetTexture</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="dwStage"></param>
/// <param name="lpTexture"></param>
/// <returns></returns>
HRESULT __stdcall wSetTexture(
LPDIRECT3DDEVICE7 d3dDevice7, ULONG dwStage, LPDIRECTDRAWSURFACE7 lpTexture)
{
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew("GameOS_Direct3D", "SetTexture(%d,0x%x)", dwStage, lpTexture);
hResult = d3dDevice7->SetTexture(dwStage, lpTexture);
if (FAILED(hResult))
{
if ( hResult != DDERR_SURFACELOST)
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - SetTexture(%d,0x%x)",
hResult, pszErrorMessage, dwStage, lpTexture) )
ENTER_DEBUGGER;
}
}
return hResult;
}
//-----------------------------------------------------------------------------
float CExplosion::Render(LPDIRECT3DDEVICE7 device)
{
if (this->key > 1) return 0;
SETALPHABLEND(device, TRUE);
SETZWRITE(device, FALSE);
device->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE);
device->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ONE);
//calcul du disque
D3DTLVERTEX d3dvs, *d3dv;
EERIE_3D * vertex;
int nb, col, col2;
float rin;
switch (key)
{
case 0:
rin = 255.f * scale;
vertex = disquevertex;
d3dv = disqued3d;
nb = disquenbvertex >> 1;
while (nb)
{
d3dvs.sx = pos.x + (vertex + 1)->x + ((vertex->x - (vertex + 1)->x) * scale);
d3dvs.sy = pos.y;
d3dvs.sz = pos.z + (vertex + 1)->z + ((vertex->z - (vertex + 1)->z) * scale);
EE_RTP(&d3dvs, d3dv);
d3dv->color = RGBA_MAKE(255, 200, 0, 255);
vertex++;
d3dv++;
d3dvs.sx = pos.x + vertex->x;
d3dvs.sy = pos.y;
d3dvs.sz = pos.z + vertex->z;
EE_RTP(&d3dvs, d3dv);
if (!ARXPausedTimer) d3dv->color = RGBA_MAKE((int)(rin * rnd()), 0, 0, 255);
vertex++;
d3dv++;
nb--;
}
if (rnd() > .25f)
{
int j = ARX_PARTICLES_GetFree();
if ((j != -1) && (!ARXPausedTimer))
{
ParticleCount++;
particle[j].exist = 1;
particle[j].zdec = 0;
float a = DEG2RAD(360.f * scale);
float b = rin;
particle[j].ov.x = pos.x + b * EEcos(a);
particle[j].ov.y = pos.y;
particle[j].ov.z = pos.z + b * EEsin(a);
particle[j].move.x = 0.f;
particle[j].move.y = rnd();
particle[j].move.z = 0.f;
particle[j].siz = 10.f + 10.f * rnd();
particle[j].tolive = 500 + (unsigned long)(float)(rnd() * 500.f);
particle[j].scale.x = 1.f;
particle[j].scale.y = 1.f;
particle[j].scale.z = 1.f;
particle[j].timcreation = lARXTime;
particle[j].tc = tp;
particle[j].special = FADE_IN_AND_OUT | ROTATING | MODULATE_ROTATION | DISSIPATING;
particle[j].fparam = 0.0000001f;
particle[j].r = 1.f;
particle[j].g = 1.f;
particle[j].b = 1.f;
}
j = ARX_PARTICLES_GetFree();
if ((j != -1) && (!ARXPausedTimer))
{
ParticleCount++;
particle[j].exist = 1;
particle[j].zdec = 0;
float a = DEG2RAD(-360.f * scale);
float b = this->rin;
particle[j].ov.x = pos.x + b * EEcos(a);
particle[j].ov.y = pos.y;
particle[j].ov.z = pos.z + b * EEsin(a);
particle[j].move.x = 0.f;
particle[j].move.y = rnd();
particle[j].move.z = 0.f;
particle[j].siz = 10.f + 10.f * rnd();
particle[j].tolive = 500 + (unsigned long)(float)(rnd() * 500.f);
particle[j].scale.x = 1.f;
particle[j].scale.y = 1.f;
particle[j].scale.z = 1.f;
particle[j].timcreation = lARXTime;
particle[j].tc = tp;
particle[j].special = FADE_IN_AND_OUT | ROTATING | MODULATE_ROTATION | DISSIPATING;
particle[j].fparam = 0.0000001f;
particle[j].r = 1.f;
particle[j].g = 1.f;
particle[j].b = 1.f;
}
}
if (rnd() > .1f)
{
int j = ARX_PARTICLES_GetFree();
if ((j != -1) && (!ARXPausedTimer))
{
ParticleCount++;
particle[j].exist = 1;
particle[j].zdec = 0;
float a = rnd() * 360.f;
float b = rin * rnd();
particle[j].ov.x = pos.x + b * EEcos(a);
particle[j].ov.y = pos.y + 70.f;
particle[j].ov.z = pos.z + b * EEsin(a);
particle[j].move.x = 0.f;
particle[j].move.y = -(5.f + 10.f * rnd());
particle[j].move.z = 0.f;
particle[j].siz = 10.f + 20.f * rnd();
particle[j].tolive = 1000 + (unsigned long)(float)(rnd() * 1000.f);
particle[j].scale.x = 1.f;
particle[j].scale.y = 1.f;
particle[j].scale.z = 1.f;
particle[j].timcreation = lARXTime;
particle[j].tc = tp2;
particle[j].special = FADE_IN_AND_OUT | ROTATING | MODULATE_ROTATION | DISSIPATING;
particle[j].fparam = 0.0000001f;
particle[j].r = 1.f;
particle[j].g = 1.f;
particle[j].b = 1.f;
}
}
break;
case 1:
D3DTLVERTEX d3dvs2;
rin = 1.f + (puissance * scale);
vertex = disquevertex;
d3dv = disqued3d;
nb = disquenbvertex >> 1;
float a = 1.f - scale;
col = RGBA_MAKE((int)(255.f * a), (int)(200.f * a), 0, 255);
col2 = RGBA_MAKE((int)(255.f * a * rnd()), 0, 0, 0);
while (nb--)
{
d3dvs.sx = pos.x + vertex->x * rin;
d3dvs.sy = pos.y;
d3dvs.sz = pos.z + vertex->z * rin;
vertex++;
d3dvs2.sx = pos.x + vertex->x * rin;
d3dvs2.sy = pos.y;
d3dvs2.sz = pos.z + vertex->z * rin;
vertex++;
if (tactif[nb] >= 0)
{
EERIE_3D pos, dir;
pos.x = d3dvs2.sx;
pos.y = d3dvs2.sy;
pos.z = d3dvs2.sz;
dir.x = d3dvs.sx;
dir.y = d3dvs.sy;
dir.z = d3dvs.sz;
DynLight[tactif[nb]].pos.x = dir.x;
DynLight[tactif[nb]].pos.y = dir.y;
DynLight[tactif[nb]].pos.z = dir.z;
DynLight[tactif[nb]].intensity = .7f + 2.f * rnd();
Collision(nb, &pos, &dir);
ExplosionAddParticule(nb, &d3dvs, tp);
}
EE_RTP(&d3dvs, d3dv);
if (!ARXPausedTimer) d3dv->color = col;
d3dv++;
EE_RTP(&d3dvs2, d3dv);
if (!ARXPausedTimer) d3dv->color = col2;
d3dv++;
}
break;
}
//tracé du disque
SETCULL(device, D3DCULL_NONE);
device->SetTexture(0, NULL);
device->DrawIndexedPrimitive(D3DPT_TRIANGLESTRIP, D3DFVF_TLVERTEX, disqued3d, disquenbvertex, (unsigned short *)disqueind, disquenbvertex + 2, 0);
device->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE);
device->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ZERO);
SETALPHABLEND(device, FALSE);
SETZWRITE(device, TRUE);
return 0;
}
/*--------------------------------------------------------------------------*/
float CLevitate::Render(LPDIRECT3DDEVICE7 device)
{
if (this->key > 1) return 0;
SETALPHABLEND(device, TRUE);
SETZWRITE(device, FALSE);
//calcul du cone
D3DTLVERTEX d3dvs, *d3dv;
EERIE_3D * vertex;
int nb, nbc, col;
float ddu = this->ang;
float u = ddu, du = .99999999f / (float)this->def;
switch (this->key)
{
case 0:
nbc = 2;
while (nbc--)
{
vertex = this->cone[nbc].conevertex;
d3dv = this->cone[nbc].coned3d;
nb = (this->cone[nbc].conenbvertex) >> 1;
while (nb)
{
d3dvs.sx = this->pos.x + (vertex + 1)->x + ((vertex->x - (vertex + 1)->x) * this->scale);
d3dvs.sy = this->pos.y + (vertex + 1)->y + ((vertex->y - (vertex + 1)->y) * this->scale);
d3dvs.sz = this->pos.z + (vertex + 1)->z + ((vertex->z - (vertex + 1)->z) * this->scale);
EE_RT2(&d3dvs, d3dv);
float fRandom = rnd() * 80.f ;
ARX_CHECK_INT(fRandom);
col = ARX_CLEAN_WARN_CAST_INT(fRandom);
if (!ARXPausedTimer) d3dv->color = RGBA_MAKE(col, col, col, col);
d3dv->tu = u;
d3dv->tv = 0.f;
vertex++;
d3dv++;
d3dvs.sx = this->pos.x + vertex->x;
d3dvs.sy = this->pos.y;
d3dvs.sz = this->pos.z + vertex->z;
EE_RT2(&d3dvs, d3dv);
fRandom = rnd() * 80.f ;
ARX_CHECK_INT(fRandom);
col = ARX_CLEAN_WARN_CAST_INT(fRandom);
if (!ARXPausedTimer) d3dv->color = RGBA_MAKE(0, 0, 0, col);
d3dv->tu = u;
d3dv->tv = 0.9999999f;
vertex++;
d3dv++;
u += du;
nb--;
}
u = ddu;
du = -du;
}
nbc = 3;
while (nbc--)
{
int j = ARX_PARTICLES_GetFree();
if ((j != -1) && (!ARXPausedTimer))
{
ParticleCount++;
particle[j].exist = 1;
particle[j].zdec = 0;
float a = DEG2RAD(360.f * rnd());
particle[j].ov.x = this->pos.x + this->rbase * EEcos(a);
particle[j].ov.y = this->pos.y;
particle[j].ov.z = this->pos.z + this->rbase * EEsin(a);
float t = EEDistance3D(&particle[j].ov, &this->pos);
particle[j].move.x = (5.f + 5.f * rnd()) * ((particle[j].ov.x - this->pos.x) / t);
particle[j].move.y = 3.f * rnd();
particle[j].move.z = (5.f + 5.f * rnd()) * ((particle[j].ov.z - this->pos.z) / t);
particle[j].siz = 30.f + 30.f * rnd();
particle[j].tolive = 3000;
particle[j].scale.x = 1.f;
particle[j].scale.y = 1.f;
particle[j].scale.z = 1.f;
particle[j].timcreation = -(long)(ARXTime + 3000); //spells[i].lastupdate;
particle[j].tc = NULL;
particle[j].special = FIRE_TO_SMOKE | FADE_IN_AND_OUT | ROTATING | MODULATE_ROTATION | DISSIPATING;
particle[j].fparam = 0.0000001f;
particle[j].r = 1.f;
particle[j].g = 1.f;
particle[j].b = 1.f;
}
}
break;
case 1:
nbc = 2;
while (nbc--)
{
vertex = this->cone[nbc].conevertex;
d3dv = this->cone[nbc].coned3d;
nb = (this->cone[nbc].conenbvertex) >> 1;
while (nb)
{
d3dvs.sx = this->pos.x + vertex->x;
d3dvs.sy = this->pos.y + vertex->y;
d3dvs.sz = this->pos.z + vertex->z;
EE_RT2(&d3dvs, d3dv);
col = (int)(rnd() * 80.f);
if (!ARXPausedTimer) d3dv->color = RGBA_MAKE(col, col, col, col);
d3dv->tu = u;
d3dv->tv = 0.f;
vertex++;
d3dv++;
d3dvs.sx = this->pos.x + vertex->x;
d3dvs.sy = this->pos.y;
d3dvs.sz = this->pos.z + vertex->z;
EE_RT2(&d3dvs, d3dv);
col = (int)(rnd() * 80.f);
if (!ARXPausedTimer) d3dv->color = RGBA_MAKE(0, 0, 0, col);
d3dv->tu = u;
d3dv->tv = 1;
vertex++;
d3dv++;
u += du;
nb--;
}
u = ddu;
du = -du;
}
nbc = 10;
while (nbc--)
{
int j = ARX_PARTICLES_GetFree();
if ((j != -1) && (!ARXPausedTimer))
{
ParticleCount++;
particle[j].exist = 1;
particle[j].zdec = 0;
float a = DEG2RAD(360.f * rnd());
particle[j].ov.x = this->pos.x + this->rbase * EEcos(a);
particle[j].ov.y = this->pos.y;
particle[j].ov.z = this->pos.z + this->rbase * EEsin(a);
float t = EEDistance3D(&particle[j].ov, &this->pos);
particle[j].move.x = (5.f + 5.f * rnd()) * ((particle[j].ov.x - this->pos.x) / t);
particle[j].move.y = 3.f * rnd();
particle[j].move.z = (5.f + 5.f * rnd()) * ((particle[j].ov.z - this->pos.z) / t);
particle[j].siz = 30.f + 30.f * rnd();
particle[j].tolive = 3000;
particle[j].scale.x = 1.f;
particle[j].scale.y = 1.f;
particle[j].scale.z = 1.f;
particle[j].timcreation = -(long)(ARXTime + 3000);
particle[j].tc = NULL;
particle[j].special = FIRE_TO_SMOKE | FADE_IN_AND_OUT | ROTATING | MODULATE_ROTATION | DISSIPATING;
particle[j].fparam = 0.0000001f;
particle[j].r = 1.f;
particle[j].g = 1.f;
particle[j].b = 1.f;
}
}
break;
}
//tracé du cone back
device->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE);
device->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ONE);
SETALPHABLEND(device, TRUE);
SETTEXTUREWRAPMODE(device, D3DTADDRESS_MIRROR);
if (this->tsouffle) device->SetTexture(0, this->tsouffle->m_pddsSurface);
else device->SetTexture(0, NULL);
SETCULL(device, D3DCULL_CW);
int i = cone[1].conenbfaces - 2;
int j = 0;
while (i--)
{
ARX_DrawPrimitive_SoftClippZ(&cone[1].coned3d[j],
&cone[1].coned3d[j+1],
&cone[1].coned3d[j+2]);
j++;
}
i = cone[0].conenbfaces - 2;
j = 0;
while (i--)
{
ARX_DrawPrimitive_SoftClippZ(&cone[0].coned3d[j],
&cone[0].coned3d[j+1],
&cone[0].coned3d[j+2]);
j++;
}
//tracé du cone front
SETCULL(device, D3DCULL_CCW);
i = cone[1].conenbfaces - 2;
j = 0;
while (i--)
{
ARX_DrawPrimitive_SoftClippZ(&cone[1].coned3d[j],
&cone[1].coned3d[j+1],
&cone[1].coned3d[j+2]);
j++;
}
i = cone[0].conenbfaces - 2;
j = 0;
while (i--)
{
ARX_DrawPrimitive_SoftClippZ(&cone[0].coned3d[j],
&cone[0].coned3d[j+1],
&cone[0].coned3d[j+2]);
j++;
}
//tracé des pierres
device->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_SRCALPHA);
device->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVSRCALPHA);
this->DrawStone(device);
device->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE);
device->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ZERO);
SETALPHABLEND(device, FALSE);
SETZWRITE(device, TRUE);
return 0;
}
/*--------------------------------------------------------------------------*/
float CPortal::Render(LPDIRECT3DDEVICE7 device)
{
SETALPHABLEND(device, TRUE);
SETZWRITE(device, FALSE);
device->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE);
device->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ONE);
//calcul sphere
int nb = this->spherenbpt;
D3DTLVERTEX * v = this->sphered3d, d3dvs;
EERIE_3D * pt = this->spherevertex;
int col = RGBA_MAKE(0, (int)(200.f * this->spherealpha), (int)(255.f * this->spherealpha), 255);
while (nb)
{
d3dvs.sx = pt->x + this->pos.x; //pt du bas
d3dvs.sy = pt->y + this->pos.y;
d3dvs.sz = pt->z + this->pos.z;
EE_RTP(&d3dvs, v);
if (!ARXPausedTimer) v->color = col;
v++;
pt++;
nb--;
}
//update les couleurs aux impacts
nb = 256;
while (nb--)
{
if (this->tabeclair[nb].actif)
{
float a;
a = 1.f - ((float)this->tabeclair[nb].currduration / (float)this->tabeclair[nb].duration);
if (a < 0.f) a = 0.f;
if (this->tabeclair[nb].numpt >= 0)
{
int r = (int)((0.f + (255.f - 0.f) * a) * this->spherealpha * 3.f);
if (r > 255) r = 255;
int g = (int)((200.f + (255.f - 200.f) * a) * this->spherealpha * 3.f);
if (g > 255) g = 255;
int b = (int)(255.f * this->spherealpha * 3.f);
if (b > 255) b = 255;
if (!ARXPausedTimer) this->sphered3d[this->tabeclair[nb].numpt].color = RGBA_MAKE(r, g, b, 255);
}
}
}
//affichage de la sphere back
SETCULL(device, D3DCULL_CW);
device->SetTexture(0, NULL);
device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, D3DFVF_TLVERTEX, this->sphered3d, this->spherenbpt, (unsigned short *)this->sphereind, this->spherenbfaces * 3, 0);
//affichage eclair
this->DrawAllEclair(device);
//affichage des particules à l'interieur
if (rnd() > .25f)
{
int j = ARX_PARTICLES_GetFree();
if ((j != -1) && (!ARXPausedTimer))
{
ParticleCount++;
particle[j].exist = 1;
particle[j].zdec = 0;
float a = rnd() * 360.f;
float b = rnd() * 360.f;
float rr = this->r * (rnd() + .25f) * 0.05f;
particle[j].ov.x = this->pos.x;
particle[j].ov.y = this->pos.y;
particle[j].ov.z = this->pos.z;
particle[j].move.x = rr * EEsin(DEG2RAD(a)) * EEcos(DEG2RAD(b));
particle[j].move.y = rr * EEcos(DEG2RAD(a));
particle[j].move.z = rr * EEsin(DEG2RAD(a)) * EEsin(DEG2RAD(b));
particle[j].siz = 10.f;
particle[j].tolive = 1000 + (unsigned long)(float)(rnd() * 1000.f);
particle[j].scale.x = 1.f;
particle[j].scale.y = 1.f;
particle[j].scale.z = 1.f;
particle[j].timcreation = lARXTime;
particle[j].tc = tp;
particle[j].special = FADE_IN_AND_OUT | ROTATING | MODULATE_ROTATION | DISSIPATING;
particle[j].fparam = 0.0000001f;
particle[j].r = 1.f;
particle[j].g = 1.f;
particle[j].b = 1.f;
}
}
//affichage de la sphere front
SETCULL(device, D3DCULL_CCW);
device->SetTexture(0, NULL);
device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, D3DFVF_TLVERTEX, this->sphered3d, this->spherenbpt, (unsigned short *)this->sphereind, this->spherenbfaces * 3, 0);
device->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE);
device->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ZERO);
SETALPHABLEND(device, FALSE);
SETCULL(device, D3DCULL_NONE);
SETZWRITE(device, TRUE);
return 0;
}
//////////////////////////////////////////////////////////////////////////////
//INITIALIZATION
//////////////////////////////////////////////////////////////////////////////
bool Prog_Init()
{
lpdd=LPDD_Create(hWndMain,DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_ALLOWREBOOT);
//set the display mode
lpdd->SetDisplayMode(SCREENWIDTH,SCREENHEIGHT,SCREENBPP,0,0);
//create primary surface
DDSURFACEDESC2 ddsd;
memset(&ddsd,0,sizeof(DDSURFACEDESC2));
ddsd.dwSize=sizeof(DDSURFACEDESC2);
ddsd.dwFlags=DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
ddsd.dwBackBufferCount=1;
ddsd.ddsCaps.dwCaps=DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX | DDSCAPS_3DDEVICE;
lpdd->CreateSurface(&ddsd,&lpddsPrime,NULL);
//create back buffer
DDSCAPS2 ddscaps;
memset(&ddscaps,0,sizeof(DDSCAPS2));
ddscaps.dwCaps=DDSCAPS_BACKBUFFER | DDSCAPS_3DDEVICE;
lpddsPrime->GetAttachedSurface(&ddscaps,&lpddsBack);
//create the texture surface
memset(&ddsd,0,sizeof(DDSURFACEDESC2));
ddsd.dwSize=sizeof(DDSURFACEDESC2);
ddsd.dwFlags=DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
ddsd.dwWidth=64;
ddsd.dwHeight=64;
ddsd.ddsCaps.dwCaps=DDSCAPS_TEXTURE;
lpdd->CreateSurface(&ddsd,&lpddsTex,NULL);
//used ddfuncs to load a bitmap onto the texture
LPDDS_ReloadFromFile(lpddsTex,"texture.bmp");
//get the idirect3d pointer
lpdd->QueryInterface(IID_IDirect3D7,(void**)&lpd3d);//ICKY COM STUFF!
//create the idirect3ddevice(hack method)
if(FAILED(lpd3d->CreateDevice(IID_IDirect3DTnLHalDevice,lpddsBack,&lpd3ddev)))//try tnl
if(FAILED(lpd3d->CreateDevice(IID_IDirect3DHALDevice,lpddsBack,&lpd3ddev)))//no tnl, try hal
if(FAILED(lpd3d->CreateDevice(IID_IDirect3DMMXDevice,lpddsBack,&lpd3ddev)))//no hal, try mmp
if(FAILED(lpd3d->CreateDevice(IID_IDirect3DRGBDevice,lpddsBack,&lpd3ddev)))//no mmx, resort to rgb
return(false);//problem, return false
//set up viewport
D3DVIEWPORT7 vp;
vp.dwX=0;
vp.dwY=0;
vp.dwWidth=SCREENWIDTH;
vp.dwHeight=SCREENHEIGHT;
vp.dvMinZ=0.0;
vp.dvMaxZ=1.0;
//set viewport for device
lpd3ddev->SetViewport(&vp);
//initialize the vertices(partially, anyway)
vert[0].color=D3DRGB(0.25,0.25,0.25);//set the color for this vertex
vert[0].specular=0;//zero for specular
vert[0].rhw=1.0;//rhw is 1.0
vert[0].tu=0.0;//0.0 for both texture coordinates
vert[0].tv=0.0;
vert[0].sz=0.5;//static z value
vert[1].color=D3DRGB(0.5,0.5,0.5);//set the color for this vertex
vert[1].specular=0;//zero for specular
vert[1].rhw=1.0;//rhw is 1.0
vert[1].tu=1.0;//0.0 for both texture coordinates
vert[1].tv=0.0;
vert[1].sz=0.5;//static z value
vert[2].color=D3DRGB(0.5,0.5,0.5);//set the color for this vertex
vert[2].specular=0;//zero for specular
vert[2].rhw=1.0;//rhw is 1.0
vert[2].tu=0.0;//0.0 for both texture coordinates
vert[2].tv=1.0;
vert[2].sz=0.5;//static z value
vert[3].color=D3DRGB(1.0,1.0,1.0);//set the color for this vertex
vert[3].specular=0;//zero for specular
vert[3].rhw=1.0;//rhw is 1.0
vert[3].tu=1.0;//0.0 for both texture coordinates
vert[3].tv=1.0;
vert[3].sz=0.5;//static z value
//set the texture
lpd3ddev->SetTexture(0,lpddsTex);
return(true);//return success
}
