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);
}
/******************************************************************************************************************
함수명 : ResetBlendenderState()
작성자 :
작성일 :
목적 : 렌더링스테이트를 기본상태로 복구한다.
입력 : LPDIRECT3DDEVICE7 pd3dDevice
출력 : void
[일자][수정자] : 수정내용
*******************************************************************************************************************/
void ResetBlendenderState(LPDIRECT3DDEVICE7 pd3dDevice)
{
pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
pd3dDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, FALSE);
pd3dDevice->SetRenderState(D3DRENDERSTATE_COLORKEYENABLE, FALSE);
pd3dDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND , D3DBLEND_ONE);
pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ZERO);
}
//-----------------------------------------------------------------------------
// rendu de la d�chirure spatio temporelle
float CSummonCreature::Render(LPDIRECT3DDEVICE7 m_pd3dDevice)
{
if (ulCurrentTime >= (ulDurationIntro + ulDurationRender + ulDurationOuttro)) return 0.f;
SETTC(m_pd3dDevice, NULL);
SETCULL(m_pd3dDevice, D3DCULL_NONE);
SETZWRITE(m_pd3dDevice, false);
SETTEXTUREWRAPMODE(m_pd3dDevice, D3DTADDRESS_CLAMP);
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE);
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ONE);
SETALPHABLEND(m_pd3dDevice, true);
//-------------------------------------------------------------------------
fTexWrap += 0.02f;
if (fTexWrap >= 1.0f)
{
fTexWrap -= 1.0f;
}
//-------------------------------------------------------------------------
// render intro (opening + rays)
if (ulCurrentTime < ulDurationIntro)
{
if (ulCurrentTime < ulDurationIntro * 0.666f)
{
fSizeIntro = (end + 2) * fOneOnDurationIntro * (1.5f) * ulCurrentTime;
sizeF = 1;
}
else
{
if (bIntro != false)
bIntro = false;
sizeF = (iSize) * (fOneOnDurationIntro * 3) * (ulCurrentTime - ulDurationIntro * 0.666f);
}
}
// do nothing just render
else if (ulCurrentTime < (ulDurationIntro + ulDurationRender))
{
}
// close it all
else if (ulCurrentTime < (ulDurationIntro + ulDurationRender + ulDurationOuttro))
{
//if (sizeF > 0)
{
sizeF = iSize - (iSize) * fOneOnDurationOuttro * (ulCurrentTime - (ulDurationIntro + ulDurationRender));
}
}
SETALPHABLEND(m_pd3dDevice, false);
RenderFissure(m_pd3dDevice);
SETZWRITE(m_pd3dDevice, true);
SETALPHABLEND(m_pd3dDevice, false);
SETTEXTUREWRAPMODE(m_pd3dDevice, D3DTADDRESS_WRAP);
return (fSizeIntro / end);
}
void CSprite::DrawAlpha(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;
}
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_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_SRCALPHA);
lpDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND,D3DBLEND_INVSRCALPHA);
lpDevice->SetRenderState(D3DRENDERSTATE_ALPHATESTENABLE,TRUE);
lpDevice->SetRenderState(D3DRENDERSTATE_ALPHAREF,8);
}
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);
}
}
void DrawShadow(LPDIRECT3DDEVICE7 lpDevice)
{
lpDevice->SetRenderState( D3DRENDERSTATE_ZENABLE, FALSE );
lpDevice->SetRenderState( D3DRENDERSTATE_STENCILENABLE, TRUE );
// Turn on alphablending
lpDevice->SetRenderState( D3DRENDERSTATE_ALPHABLENDENABLE, TRUE );
lpDevice->SetRenderState( D3DRENDERSTATE_SRCBLEND, D3DBLEND_SRCALPHA );
lpDevice->SetRenderState( D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVSRCALPHA );
lpDevice->SetTextureStageState(0,D3DTSS_ALPHAARG1,D3DTA_DIFFUSE);
// Only write where the stencil value == 1
lpDevice->SetRenderState( D3DRENDERSTATE_STENCILREF, 0x1 );
lpDevice->SetRenderState( D3DRENDERSTATE_STENCILFUNC, D3DCMP_EQUAL );
lpDevice->SetRenderState( D3DRENDERSTATE_STENCILPASS, D3DSTENCILOP_KEEP );
// Get viewport dimensions for big, gray square
D3DVIEWPORT7 vp;
lpDevice->GetViewport(&vp);
FLOAT sx = (FLOAT)vp.dwWidth;
FLOAT sy = (FLOAT)vp.dwHeight;
D3DCOLOR color=D3DRGBA(0,0,0,0.5f);
// Draw a big, gray square
D3DTLVERTEX vBigGraySquare[4];
vBigGraySquare[0] = D3DTLVERTEX( D3DVECTOR( 0,sy,0.0f),1.0f,color,0,0,0 );
vBigGraySquare[1] = D3DTLVERTEX( D3DVECTOR( 0, 0,0.0f),1.0f,color,0,0,0 );
vBigGraySquare[2] = D3DTLVERTEX( D3DVECTOR(sx,sy,0.0f),1.0f,color,0,0,0 );
vBigGraySquare[3] = D3DTLVERTEX( D3DVECTOR(sx, 0,0.0f),1.0f,color,0,0,0 );
lpDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, D3DFVF_TLVERTEX,
vBigGraySquare, 4, NULL );
// Restore render states
lpDevice->SetRenderState( D3DRENDERSTATE_ZENABLE, TRUE );
lpDevice->SetRenderState( D3DRENDERSTATE_STENCILENABLE, FALSE );
lpDevice->SetRenderState( D3DRENDERSTATE_ALPHABLENDENABLE, FALSE );
}
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);
}
/// <summary>
/// <c>wSetRenderState</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="dwRenderStateType"></param>
/// <param name="dwRenderState"></param>
/// <returns></returns>
HRESULT __stdcall wSetRenderState(
LPDIRECT3DDEVICE7 d3dDevice7, D3DRENDERSTATETYPE dwRenderStateType, ULONG dwRenderState)
{
PSTR pszRenderState;
PSTR pszErrorMessage;
HRESULT hResult;
++TotalRenderStateChanges;
pszRenderState = GetRenderState(dwRenderStateType, dwRenderState);
InternalFunctionSpew("GameOS_Direct3D", "SetRenderState(%s)", pszRenderState);
hResult = d3dDevice7->SetRenderState(dwRenderStateType, dwRenderState);
if (FAILED(hResult))
{
pszRenderState = GetRenderState(dwRenderStateType, dwRenderState);
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - SetRenderState(%s)",
hResult, pszErrorMessage, pszRenderState) )
ENTER_DEBUGGER;
}
return hResult;
}
//---------------------------------------------------------------------
float CRuneOfGuarding::Render(LPDIRECT3DDEVICE7 m_pd3dDevice)
{
float x = eSrc.x;
float y = eSrc.y - 20;
float z = eSrc.z;
SETZWRITE(m_pd3dDevice, FALSE);
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE);
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ONE);
SETALPHABLEND(m_pd3dDevice, TRUE);
//----------------------------
// long color = D3DRGB(1,1,1);
// int size = 100;
//----------------------------
EERIE_3D stiteangle;
EERIE_3D stitepos;
EERIE_3D stitescale;
EERIE_RGB stitecolor;
float stiteangleb = (float) ulCurrentTime * fOneOnDuration * 120;
stiteangle.a = 0;
stiteangle.g = 0;
stitepos.x = x;
stitepos.y = y;
stitepos.z = z;
float gtc = (float)ARX_TIME_Get();
float v = EEsin(gtc * DIV1000) * DIV10;
stiteangle.b = MAKEANGLE(gtc * DIV1000);
stitecolor.r = 0.4f - v;
stitecolor.g = 0.4f - v;
stitecolor.b = 0.6f - v;
stitescale.x = 1;
stitescale.y = -0.1f;
stitescale.z = 1;
if (slight)
DrawEERIEObjEx(m_pd3dDevice, slight, &stiteangle, &stitepos, &stitescale, &stitecolor);
stiteangle.b = stiteangleb;
stitecolor.r = 0.6f;
stitecolor.g = 0.f;
stitecolor.b = 0.f;
stitescale.x = 2;
stitescale.y = 2;
stitescale.z = 2;
if (ssol)
DrawEERIEObjEx(m_pd3dDevice, ssol, &stiteangle, &stitepos, &stitescale, &stitecolor);
stitecolor.r = 0.6f;
stitecolor.g = 0.3f;
stitecolor.b = 0.45f;
stitescale.z = 1.8f;
stitescale.y = 1.8f;
stitescale.x = 1.8f;
if (srune)
DrawEERIEObjEx(m_pd3dDevice, srune, &stiteangle, &stitepos, &stitescale, &stitecolor);
for (int n = 0; n < 4; n++)
{
int j = ARX_PARTICLES_GetFree();
if ((j != -1) && (!ARXPausedTimer))
{
ParticleCount++;
particle[j].exist = 1;
particle[j].zdec = 0;
particle[j].ov.x = x + frand2() * 40;
particle[j].ov.y = y;
particle[j].ov.z = z + frand2() * 40;
particle[j].move.x = 0.8f * frand2();
particle[j].move.y = -4.f * rnd();
particle[j].move.z = 0.8f * frand2();
particle[j].scale.x = -0.1f;
particle[j].scale.y = -0.1f;
particle[j].scale.z = -0.1f;
particle[j].timcreation = lARXTime;
particle[j].tolive = 2600 + (unsigned long)(rnd() * 600.f);
particle[j].tc = tex_p2;
particle[j].siz = 0.3f;
particle[j].r = 0.4f;
particle[j].g = 0.4f;
particle[j].b = 0.6f;
}
}
return 1.0f - rnd() * 0.3f;
}
/*--------------------------------------------------------------------------*/
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;
}
/*--------------------------------------------------------------------------*/
void CLevitate::DrawStone(LPDIRECT3DDEVICE7 device)
{
device->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_INVDESTCOLOR);
device->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ONE);
SETALPHABLEND(device, TRUE);
int nb = 256;
while (nb--)
{
if (this->tstone[nb].actif)
{
float a = (float)this->tstone[nb].currtime / (float)this->tstone[nb].time;
if (a > 1.f)
{
a = 1.f;
this->tstone[nb].actif = 0;
}
int col = RGBA_MAKE(255, 255, 255, (int)(255.f * (1.f - a)));
if (this->stone[this->tstone[nb].numstone])
DrawEERIEObjExEx(device, this->stone[this->tstone[nb].numstone], &this->tstone[nb].ang, &this->tstone[nb].pos, &this->tstone[nb].scale, col);
int j = ARX_PARTICLES_GetFree();
if ((j != -1) && (!ARXPausedTimer))
{
ParticleCount++;
particle[j].exist = 1;
particle[j].zdec = 0;
particle[j].ov = this->tstone[nb].pos;
particle[j].move.x = 0.f;
particle[j].move.y = 3.f * rnd();
particle[j].move.z = 0.f;
particle[j].siz = 3.f + 3.f * rnd();
particle[j].tolive = 1000;
particle[j].scale.x = 1.f;
particle[j].scale.y = 1.f;
particle[j].scale.z = 1.f;
particle[j].timcreation = -(long)(ARXTime + 1000);
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;
}
//update mvt
if (!ARXPausedTimer)
{
a = (((float)this->currframetime) * 100.f) / (float)this->tstone[nb].time;
this->tstone[nb].pos.y += this->tstone[nb].yvel * a;
this->tstone[nb].ang.a += this->tstone[nb].angvel.a * a;
this->tstone[nb].ang.b += this->tstone[nb].angvel.b * a;
this->tstone[nb].ang.g += this->tstone[nb].angvel.g * a;
this->tstone[nb].yvel *= 1.f - (1.f / 100.f);
this->tstone[nb].currtime += this->currframetime;
}
}
}
SETALPHABLEND(device, FALSE);
}
//---------------------------------------------------------------------
float CRepelUndead::Render(LPDIRECT3DDEVICE7 m_pd3dDevice)
{
if (ulCurrentTime >= ulDuration)
{
return 0.f;
}
SETZWRITE(m_pd3dDevice, FALSE);
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE);
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ONE);
SETALPHABLEND(m_pd3dDevice, TRUE);
//----------------------------
EERIE_3D eObjAngle;
EERIE_3D eObjPos;
EERIE_3D eObjScale;
EERIE_RGB rgbObjColor;
eObjAngle.b = fBeta;
eObjAngle.a = 0;
eObjAngle.g = 0;
eObjPos.x = eSrc.x;
eObjPos.y = eSrc.y - 5.f;
eObjPos.z = eSrc.z;
rgbObjColor.r = 0.6f;
rgbObjColor.g = 0.6f;
rgbObjColor.b = 0.8f;
float vv = 1.f + (EEsin(ARX_TIME_Get() * DIV1000));
vv *= DIV2;
vv += 1.1f;
eObjScale.z = vv;
eObjScale.y = vv;
eObjScale.x = vv;
if (ssol)
DrawEERIEObjEx(m_pd3dDevice, ssol, &eObjAngle, &eObjPos, &eObjScale, &rgbObjColor);
vv *= 100.f;
for (int n = 0; n < 4; n++)
{
int j = ARX_PARTICLES_GetFree();
if ((j != -1) && (!ARXPausedTimer))
{
ParticleCount++;
particle[j].exist = 1;
particle[j].zdec = 0;
particle[j].ov.x = eSrc.x - EEsin(frand2() * 360.f) * vv;
particle[j].ov.y = eSrc.y;
particle[j].ov.z = eSrc.z + EEcos(frand2() * 360.f) * vv;
particle[j].move.x = 0.8f * frand2();
particle[j].move.y = -4.f * rnd();
particle[j].move.z = 0.8f * frand2();
particle[j].scale.x = -0.1f;
particle[j].scale.y = -0.1f;
particle[j].scale.z = -0.1f;
particle[j].timcreation = lARXTime;
particle[j].tolive = 2600 + (unsigned long)(rnd() * 600.f);
particle[j].tc = tex_p2;
particle[j].siz = 0.3f;
particle[j].r = 0.4f;
particle[j].g = 0.4f;
particle[j].b = 0.6f;
}
}
if (this->lLightId == -1)
this->lLightId = GetFreeDynLight();
if (this->lLightId != -1)
{
long id = this->lLightId;
DynLight[id].exist = 1;
DynLight[id].intensity = 2.3f;
DynLight[id].fallend = 350.f;
DynLight[id].fallstart = 150.f;
DynLight[id].rgb.r = 0.8f;
DynLight[id].rgb.g = 0.8f;
DynLight[id].rgb.b = 1;
DynLight[id].pos.x = eSrc.x;
DynLight[id].pos.y = eSrc.y - 50.f;
DynLight[id].pos.z = eSrc.z;
DynLight[id].duration = 200;
DynLight[id].time_creation = ARXTimeUL();
}
return 1;
}
/*--------------------------------------------------------------------------*/
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;
}
void ARXDRAW_DrawAllTransPolysPos( LPDIRECT3DDEVICE7 pd3dDevice, long MODIF )
{
int flg_NOCOUNT_USEVB = EERIE_NOCOUNT | (bSoftRender?EERIE_USEVB:0);
SetZBias( pd3dDevice, 1 );
SETALPHABLEND( pd3dDevice, TRUE );
long i, to = 0;
register EERIEPOLY * ep;
for ( i = 0 ; i < TRANSPOLYSPOS ; i++ )
{
ep = TransPol[i];
if ( ( !( Project.hide & HIDE_BACKGROUND ) ) )
{
if ( ep->type & POLY_DOUBLESIDED ) SETCULL( pd3dDevice, D3DCULL_NONE );
else SETCULL( pd3dDevice, D3DCULL_CW );
if ( ViewMode & VIEWMODE_FLAT ) SETTC( pd3dDevice, NULL );
else SETTC( pd3dDevice, ep->tex );
if ( ep->type & POLY_QUAD ) to = 4;
else to = 3;
float ttt = ep->transval;
if ( ttt >= 2.f ) //MULTIPLICATIVE
{
SETBLENDMODE( pd3dDevice, D3DBLEND_ONE, D3DBLEND_ONE );
ttt *= DIV2;
ttt += 0.5f;
ep->tv[3].color = ep->tv[2].color = ep->tv[1].color = ep->tv[0].color = _EERIERGB( ttt );
}
else if ( ttt >= 1.f ) //ADDITIVE
{
ttt -= 1.f;
SETBLENDMODE( pd3dDevice, D3DBLEND_ONE, D3DBLEND_ONE );
ep->tv[3].color = ep->tv[2].color = ep->tv[1].color = ep->tv[0].color = _EERIERGB( ttt );
}
else if ( ttt > 0.f ) //NORMAL TRANS
{
ttt = 1.f - ttt;
SETBLENDMODE( pd3dDevice, D3DBLEND_DESTCOLOR, D3DBLEND_SRCCOLOR );
ep->tv[3].color = ep->tv[2].color = ep->tv[1].color = ep->tv[0].color = _EERIERGBA(ttt);
}
else //SUBTRACTIVE
{
SETBLENDMODE( pd3dDevice, D3DBLEND_ZERO, D3DBLEND_INVSRCCOLOR );
ttt = 1.f - ttt;
ep->tv[3].color = ep->tv[2].color = ep->tv[1].color = ep->tv[0].color = _EERIERGB( ttt );
}
EERIEDRAWPRIM( pd3dDevice, D3DPT_TRIANGLESTRIP, D3DFVF_TLVERTEX | D3DFVF_DIFFUSE , ep->tv, to, 0, bSoftRender?EERIE_USEVB:0 );
if (ep->type & POLY_LAVA)
{
pd3dDevice->SetRenderState( D3DRENDERSTATE_SRCBLEND, D3DBLEND_DESTCOLOR );
pd3dDevice->SetRenderState( D3DRENDERSTATE_DESTBLEND, D3DBLEND_ONE );
SETALPHABLEND( pd3dDevice, TRUE );
D3DTLVERTEX verts[4];
SETTC( pd3dDevice, enviro );
ARX_CHECK(to > 0);
for ( long j = 0 ; j < to ; j++ )
{
verts[j].sx = ep->tv[j].sx;
verts[j].sy = ep->tv[j].sy;
verts[j].sz = ep->tv[j].sz;
verts[j].rhw = ep->tv[j].rhw;
verts[j].color = 0xFFFFFFFF;
verts[j].tu = ep->v[j].sx * DIV1000 + EEsin( ( ep->v[j].sx ) * DIV200 + (float) FrameTime * DIV2000 ) * DIV20;
verts[j].tv = ep->v[j].sz * DIV1000 + EEcos( (ep->v[j].sz) * DIV200 + (float) FrameTime * DIV2000 ) * DIV20;
}
EERIEDRAWPRIM(pd3dDevice, D3DPT_TRIANGLESTRIP, D3DFVF_TLVERTEX | D3DFVF_DIFFUSE, verts, to, 0, flg_NOCOUNT_USEVB );
for ( i = 0 ; i < to ; i++ )
{
verts[i].tu = ep->v[i].sx * DIV1000 + EEsin( ( ep->v[i].sx ) * DIV100 + (float)FrameTime * DIV2000 ) * DIV10;
verts[i].tv = ep->v[i].sz * DIV1000 + EEcos( ( ep->v[i].sz ) * DIV100 + (float)FrameTime * DIV2000 ) * DIV10;
}
EERIEDRAWPRIM(pd3dDevice, D3DPT_TRIANGLESTRIP, D3DFVF_TLVERTEX | D3DFVF_DIFFUSE, verts, to, 0, flg_NOCOUNT_USEVB );
for ( i = 0 ; i < to ; i++ )
{
verts[i].tu = ep->v[i].sx * DIV600 + EEsin ( ( ep->v[i].sx ) * DIV160 + (float)FrameTime * DIV2000 ) * DIV11;
verts[i].tv = ep->v[i].sz * DIV600 + EEcos ( ( ep->v[i].sz ) * DIV160 + (float)FrameTime * DIV2000 ) * DIV11;
verts[i].color = 0xFF666666;
}
pd3dDevice->SetRenderState( D3DRENDERSTATE_SRCBLEND, D3DBLEND_ZERO );
pd3dDevice->SetRenderState( D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVSRCCOLOR );
EERIEDRAWPRIM(pd3dDevice, D3DPT_TRIANGLESTRIP, D3DFVF_TLVERTEX | D3DFVF_DIFFUSE, verts, to, 0, flg_NOCOUNT_USEVB );
}
}
if ( ep->type & POLY_WATER )
{
pd3dDevice->SetRenderState( D3DRENDERSTATE_SRCBLEND, D3DBLEND_DESTCOLOR );
pd3dDevice->SetRenderState( D3DRENDERSTATE_DESTBLEND, D3DBLEND_ONE );
SETALPHABLEND( pd3dDevice, TRUE );
D3DTLVERTEX verts[4];
SETTC( pd3dDevice, enviro );
ARX_CHECK(to > 0);
for ( long j = 0 ; j < to ; j++ )
{
verts[j].sx = ep->tv[j].sx;
verts[j].sy = ep->tv[j].sy;
verts[j].sz = ep->tv[j].sz;
verts[j].rhw = ep->tv[j].rhw;
verts[j].color = 0xFF505050;
verts[j].tu = ep->v[j].sx * DIV1000 + EEsin( ( ep->v[j].sx ) * DIV200 + (float)FrameTime * DIV1000 ) * DIV32;
verts[j].tv = ep->v[j].sz * DIV1000 + EEcos( ( ep->v[j].sz ) * DIV200 + (float)FrameTime * DIV1000 ) * DIV32;
if ( ep->type & POLY_FALL ) verts[j].tv += (float)FrameTime * DIV4000;
}
EERIEDRAWPRIM(pd3dDevice, D3DPT_TRIANGLESTRIP, D3DFVF_TLVERTEX | D3DFVF_DIFFUSE, verts, to, 0, flg_NOCOUNT_USEVB );
for ( i = 0 ; i < to ; i++ )
{
verts[i].tu = ( ep->v[i].sx + 30.f ) * DIV1000 + EEsin( ( ep->v[i].sx + 30 ) * DIV200 + (float)FrameTime * DIV1000 ) * DIV28;
verts[i].tv = ( ep->v[i].sz + 30.f ) * DIV1000 - EEcos( ( ep->v[i].sz + 30 ) * DIV200 + (float)FrameTime * DIV1000 ) * DIV28;
if ( ep->type & POLY_FALL ) verts[i].tv += (float)FrameTime * DIV4000;
}
EERIEDRAWPRIM(pd3dDevice, D3DPT_TRIANGLESTRIP, D3DFVF_TLVERTEX | D3DFVF_DIFFUSE, verts, to, 0, flg_NOCOUNT_USEVB );
for ( i = 0 ; i < to ; i++ )
{
verts[i].tu = ( ep->v[i].sx + 60.f ) * DIV1000 - EEsin( ( ep->v[i].sx + 60 ) * DIV200 + (float)FrameTime * DIV1000 ) * DIV40;
verts[i].tv = ( ep->v[i].sz + 60.f ) * DIV1000 - EEcos( ( ep->v[i].sz + 60 ) * DIV200 + (float)FrameTime * DIV1000 ) * DIV40;
if ( ep->type & POLY_FALL ) verts[i].tv += (float)FrameTime * DIV4000;
}
EERIEDRAWPRIM(pd3dDevice, D3DPT_TRIANGLESTRIP, D3DFVF_TLVERTEX | D3DFVF_DIFFUSE, verts, to, 0, flg_NOCOUNT_USEVB );
}
}
SetZBias( pd3dDevice, 0 );
}
//-----------------------------------------------------------------------------
void CParticleSystem::Render(LPDIRECT3DDEVICE7 _lpD3DDevice, int _iSRCBLEND, int _iDESTBLEND)
{
SETCULL(_lpD3DDevice, D3DCULL_NONE);
SETZWRITE(_lpD3DDevice, false);
_lpD3DDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, iSrcBlend);
_lpD3DDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, iDstBlend);
SETALPHABLEND(_lpD3DDevice, true);
int inumtex = 0;
list<CParticle *>::iterator i;
for (i = listParticle.begin(); i != listParticle.end(); ++i)
{
CParticle * p = *i;
if (p->isAlive())
{
if (fParticleFlash > 0)
{
if (rnd() < fParticleFlash)
continue;
}
if (iNbTex > 0)
{
inumtex = p->iTexNum;
if (iTexTime == 0)
{
float fNbTex = (p->ulTime * p->fOneOnTTL) * (iNbTex);
ARX_CHECK_INT(fNbTex);
inumtex = ARX_CLEAN_WARN_CAST_INT(fNbTex);
if (inumtex >= iNbTex)
{
inumtex = iNbTex - 1;
}
}
else
{
if (p->iTexTime > iTexTime)
{
p->iTexTime -= iTexTime;
p->iTexNum++;
if (p->iTexNum > iNbTex - 1)
{
if (bTexLoop)
{
p->iTexNum = 0;
}
else
{
p->iTexNum = iNbTex - 1;
}
}
inumtex = p->iTexNum;
}
}
}
D3DTLVERTEX p3pos;
p3pos.sx = p->p3Pos.x;
p3pos.sy = p->p3Pos.y;
p3pos.sz = p->p3Pos.z;
if (bParticleFollow)
{
p3pos.sx += p3Pos.x;
p3pos.sy += p3Pos.y;
p3pos.sz += p3Pos.z;
}
float fRot = 0;
if (fParticleRotation != 0)
{
if (p->iRot == 1)
fRot = (fParticleRotation) * p->ulTime + p->fRotStart;
else
fRot = (-fParticleRotation) * p->ulTime + p->fRotStart;
if ((tex_tab[inumtex] && tex_tab[inumtex]->m_pddsSurface))
EERIEDrawRotatedSprite(_lpD3DDevice, &p3pos, p->fSize, tex_tab[inumtex], p->ulColor, 2, fRot);
}
else
{
if ((tex_tab[inumtex] && tex_tab[inumtex]->m_pddsSurface))
EERIEDrawSprite(_lpD3DDevice, &p3pos, p->fSize, tex_tab[inumtex], p->ulColor, 2);
}
}
}
}
//---------------------------------------------------------------------
float CNegateMagic::Render(LPDIRECT3DDEVICE7 m_pd3dDevice)
{
int i = 0;
if (spells[spellinstance].caster == 0)
{
eSrc.x = player.pos.x;
eSrc.y = player.pos.y + 170.f;
eSrc.z = player.pos.z;
}
else
{
eSrc.x = inter.iobj[spells[spellinstance].caster]->pos.x;
eSrc.y = inter.iobj[spells[spellinstance].caster]->pos.y;
eSrc.z = inter.iobj[spells[spellinstance].caster]->pos.z;
}
float x = eSrc.x;
float y = eSrc.y - 10.f;
float z = eSrc.z;
if (ulCurrentTime >= ulDuration)
{
return 0.f;
}
SETZWRITE(m_pd3dDevice, false);
SETALPHABLEND(m_pd3dDevice, true);
if (tex_sol && tex_sol->m_pddsSurface)
{
SETTC(m_pd3dDevice, tex_sol);
}
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE);
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ONE);
SETALPHABLEND(m_pd3dDevice, true);
fSize = ulCurrentTime * fOneOnDuration * 200;
float size = 50;
for (i = 0; i < 360; i++)
{
float t = rnd();
if (t < 0.04f)
{
t = rnd();
int j = ARX_PARTICLES_GetFree();
if ((j != -1) && (!ARXPausedTimer))
{
ParticleCount++;
particle[j].exist = 1;
particle[j].zdec = 0;
particle[j].ov.x = x + frand2() * 150.f;
particle[j].ov.y = y;
particle[j].ov.z = z + frand2() * 150.f;
particle[j].move.x = 0;
particle[j].move.y = - 3.0f * rnd();
particle[j].move.z = 0;
particle[j].siz = 0.3f;
particle[j].tolive = 2000 + (unsigned long)(float)(rnd() * 2000.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 = tex_p2;
particle[j].special = FADE_IN_AND_OUT | ROTATING | MODULATE_ROTATION | DISSIPATING | SUBSTRACT;
particle[j].fparam = 0.0000001f;
particle[j].r = 1.0f;
particle[j].g = 1.0f;
particle[j].b = 1.0f;
}
}
}
//----------------------------
size = 100;
EERIE_3D stiteangle;
EERIE_3D stitepos;
EERIE_3D stitescale;
EERIE_RGB stitecolor;
stiteangle.b = (float) ulCurrentTime * fOneOnDuration * 120;
stiteangle.a = 0;
stiteangle.g = 0;
stitepos.x = x;
stitepos.y = y;
stitepos.z = z;
SETALPHABLEND(m_pd3dDevice, true);
stiteangle.b = -stiteangle.b;
stitecolor.r = 0.4f;
stitecolor.g = 0.4f;
stitecolor.b = 0.4f;
stitescale.x = 3.f;
stitescale.y = 3.f;
stitescale.z = 3.f;
DrawEERIEObjEx(m_pd3dDevice, ssol, &stiteangle, &stitepos, &stitescale, &stitecolor);
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE);
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ONE);
stitecolor.r = 0.5f;
stitecolor.g = 0.f;
stitecolor.b = 0.5f;
stitescale.x = 3.1f;
stitescale.y = 3.1f;
stitescale.z = 3.1f;
DrawEERIEObjEx(m_pd3dDevice, ssol, &stiteangle, &stitepos, &stitescale, &stitecolor);
return 1;
}
//---------------------------------------------------------------------
float CPoisonProjectile::Render(LPDIRECT3DDEVICE7 m_pd3dDevice)
{
int i = 0;
if (ulCurrentTime >= ulDuration)
{
return 0.f;
}
SETCULL(m_pd3dDevice, D3DCULL_NONE);
SETZWRITE(m_pd3dDevice, FALSE);
//-------------------------------------------------------------------------
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE);
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ONE);
SETALPHABLEND(m_pd3dDevice, TRUE);
// ------------------------------------------------------------------------
int n = BEZIERPrecision;
float delta = 1.0f / n;
EERIE_3D lastpos, newpos;
EERIE_3D v;
lastpos.x = pathways[0].sx;
lastpos.y = pathways[0].sy;
lastpos.z = pathways[0].sz;
int arx_check_init = -1;
newpos.x = 0;
newpos.y = 0;
newpos.z = 0;
for (i = 0; i < 9; i++)
{
int kp = i;
int kpprec = (i > 0) ? kp - 1 : kp ;
int kpsuiv = kp + 1 ;
int kpsuivsuiv = (i < (9 - 2)) ? kpsuiv + 1 : kpsuiv;
for (int toto = 1; toto < n; toto++)
{
if (fTrail < i * n + toto) break;
float t = toto * delta;
float t1 = t;
float t2 = t1 * t1 ;
float t3 = t2 * t1 ;
float f0 = 2.f * t3 - 3.f * t2 + 1.f ;
float f1 = -2.f * t3 + 3.f * t2 ;
float f2 = t3 - 2.f * t2 + t1 ;
float f3 = t3 - t2 ;
float val = pathways[kpsuiv].sx;
float p0 = 0.5f * (val - pathways[kpprec].sx) ;
float p1 = 0.5f * (pathways[kpsuivsuiv].sx - pathways[kp].sx) ;
v.x = f0 * pathways[kp].sx + f1 * val + f2 * p0 + f3 * p1 ;
val = pathways[kpsuiv].sy ;
p0 = 0.5f * (val - pathways[kpprec].sy);
p1 = 0.5f * (pathways[kpsuivsuiv].sy - pathways[kp].sy) ;
v.y = f0 * pathways[kp].sy + f1 * val + f2 * p0 + f3 * p1 ;
val = pathways[kpsuiv].sz ;
p0 = 0.5f * (val - pathways[kpprec].sz) ;
p1 = 0.5f * (pathways[kpsuivsuiv].sz - pathways[kp].sz) ;
v.z = f0 * pathways[kp].sz + f1 * val + f2 * p0 + f3 * p1 ;
newpos.x = v.x;
newpos.y = v.y;
newpos.z = v.z;
if (!((fTrail - (i * n + toto)) > 70))
{
float c = 1.0f - ((fTrail - (i * n + toto)) / 70.0f);
c += frand2() * 0.1f;
if (c < 0) c = 0;
if (c > 1) c = 1;
}
float nx = lastpos.x;
float ny = lastpos.y;
float nz = lastpos.z;
lastpos.x = newpos.x;
lastpos.y = newpos.y;
lastpos.z = newpos.z;
newpos.x = nx;
newpos.y = ny;
newpos.z = nz;
++arx_check_init;
}
}
EERIE_3D stiteangle;
EERIE_3D stitepos;
EERIE_3D stitescale;
EERIE_RGB stitecolor;
EERIE_3D av;
ARX_CHECK_NOT_NEG(arx_check_init);
av.x = newpos.x - lastpos.x;
av.y = newpos.y - lastpos.y;
av.z = newpos.z - lastpos.z;
TRUEVector_Normalize(&av);
float bubu = GetAngle(av.x, av.z, 0, 0);
float bubu1 = GetAngle(av.x, av.y, 0, 0);
stitepos.x = lastpos.x;
stitepos.y = lastpos.y;
stitepos.z = lastpos.z;
stiteangle.b = -RAD2DEG(bubu);
stiteangle.a = 0;
stiteangle.g = -90 - RAD2DEG(bubu1);
stitecolor.r = 0.7f;
stitecolor.g = 0.7f;
stitecolor.b = 0.7f;
stitescale.x = 2;
stitescale.y = 2;
stitescale.z = 2;
eCurPos.x = lastpos.x;
eCurPos.y = lastpos.y;
eCurPos.z = lastpos.z;
if (fTrail >= (i * n))
{
LaunchPoisonExplosion(&lastpos);
}
SETCULL(m_pd3dDevice, D3DCULL_NONE);
SETZWRITE(m_pd3dDevice, FALSE);
SETALPHABLEND(m_pd3dDevice, TRUE);
return 1;
}
//-----------------------------------------------------------------------------
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 CMagicMissile::Render(LPDIRECT3DDEVICE7 m_pd3dDevice)
{
int i = 0;
EERIE_3D lastpos, newpos;
EERIE_3D v;
EERIE_3D stiteangle;
EERIE_3D stitepos;
EERIE_3D stitescale;
EERIE_RGB stitecolor;
EERIE_3D av;
if (ulCurrentTime >= ulDuration)
{
return 0.f;
}
// Set Appropriate Renderstates -------------------------------------------
SETCULL(m_pd3dDevice, D3DCULL_NONE);
SETZWRITE(m_pd3dDevice, FALSE);
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE);
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ONE);
SETALPHABLEND(m_pd3dDevice, TRUE);
// Set Texture ------------------------------------------------------------
if (tex_mm && tex_mm->m_pddsSurface)
{
if ((spells[spellinstance].caster == 0) && (cur_mr == 3))
SETTC(m_pd3dDevice, NULL);
else
SETTC(m_pd3dDevice, tex_mm);
}
// ------------------------------------------------------------------------
if (bMove)
{
fTrail = (ulCurrentTime * fOneOnDuration) * (iBezierPrecision + 2) * 5;
}
lastpos.x = pathways[0].sx;
lastpos.y = pathways[0].sy;
lastpos.z = pathways[0].sz;
Vector_Copy(&newpos, &lastpos);
for (i = 0; i < 5; i++)
{
int kp = i;
int kpprec = (i > 0) ? kp - 1 : kp ;
int kpsuiv = kp + 1 ;
int kpsuivsuiv = (i < (5 - 2)) ? kpsuiv + 1 : kpsuiv;
for (int toto = 1; toto < iBezierPrecision; toto++)
{
if (fTrail < i * iBezierPrecision + toto) break;
float t = toto * fOneOnBezierPrecision;
float t1 = t;
float t2 = t1 * t1 ;
float t3 = t2 * t1 ;
float f0 = 2.f * t3 - 3.f * t2 + 1.f ;
float f1 = -2.f * t3 + 3.f * t2 ;
float f2 = t3 - 2.f * t2 + t1 ;
float f3 = t3 - t2 ;
float val = pathways[kpsuiv].sx;
float p0 = 0.5f * (val - pathways[kpprec].sx) ;
float p1 = 0.5f * (pathways[kpsuivsuiv].sx - pathways[kp].sx) ;
v.x = f0 * pathways[kp].sx + f1 * val + f2 * p0 + f3 * p1 ;
val = pathways[kpsuiv].sy ;
p0 = 0.5f * (val - pathways[kpprec].sy) ;
p1 = 0.5f * (pathways[kpsuivsuiv].sy - pathways[kp].sy) ;
v.y = f0 * pathways[kp].sy + f1 * val + f2 * p0 + f3 * p1 ;
val = pathways[kpsuiv].sz ;
p0 = 0.5f * (val - pathways[kpprec].sz) ;
p1 = 0.5f * (pathways[kpsuivsuiv].sz - pathways[kp].sz) ;
v.z = f0 * pathways[kp].sz + f1 * val + f2 * p0 + f3 * p1 ;
Vector_Copy(&newpos, &v);
if (!((fTrail - (i * iBezierPrecision + toto)) > iLength))
{
float c;
if (fTrail < iLength)
{
c = 1.0f - ((fTrail - (i * iBezierPrecision + toto)) / fTrail);
}
else
{
c = 1.0f - ((fTrail - (i * iBezierPrecision + toto)) / (float)iLength);
}
float fsize = c;
float alpha = c - 0.2f;
if (alpha < 0.2f) alpha = 0.2f;
c += frand2() * 0.1f;
if (c < 0) c = 0;
else if (c > 1) c = 1;
int color = D3DRGB(c * fColor[0] * alpha, c * fColor[1] * alpha, c * fColor[2] * alpha);
if (fsize < 0.5f)
fsize = fsize * 2 * 3;
else
fsize = (1.0f - fsize + 0.5f) * 2 * (3 * 0.5f);
float fs = fsize * 6 + rnd() * 0.3f;
float fe = fsize * 6 + rnd() * 0.3f;
Draw3DLineTex(m_pd3dDevice, lastpos, newpos, color, fs, fe);
}
EERIE_3D temp_vector;
Vector_Copy(&temp_vector, &lastpos);
Vector_Copy(&lastpos, &newpos);
Vector_Copy(&newpos, &temp_vector);
}
}
av.x = newpos.x - lastpos.x;
av.y = newpos.y - lastpos.y;
av.z = newpos.z - lastpos.z;
float bubu = GetAngle(av.x, av.z, 0, 0);
float bubu1 = GetAngle(av.x, av.y, 0, 0);
Vector_Copy(&stitepos, &lastpos);
stiteangle.b = -RAD2DEG(bubu);
stiteangle.a = 0;
stiteangle.g = -(RAD2DEG(bubu1));
if (av.x < 0)
stiteangle.g -= 90;
if (av.x > 0)
stiteangle.g += 90;
if (stiteangle.g < 0)
stiteangle.g += 360.0f;
if ((spells[spellinstance].caster == 0) && (cur_mr == 3))
{
stitecolor.r = 1.f;
stitecolor.g = 0.f;
stitecolor.b = 0.2f;
}
else
{
stitecolor.r = 0.3f;
stitecolor.g = 0.3f;
stitecolor.b = 0.5f;
}
Vector_Init(&stitescale, 1, 1, 1);
{
if ((smissile))
DrawEERIEObjEx(m_pd3dDevice, smissile, &stiteangle, &stitepos, &stitescale, &stitecolor);
}
Vector_Copy(&eCurPos, &lastpos);
return 1 - 0.5f * rnd();
}
/******************************************************************************************************************
함수명 : SetBlendRenderState()
작성자 :
작성일 :
목적 : 렌더링스테이트를 셋팅한다.
입력 : LPDIRECT3DDEVICE7 pd3dDevice
BYTE bBlendFlag
D3DMATERIAL7 mtrlGetMtrl
출력 : void
[일자][수정자] : 수정내용
*******************************************************************************************************************/
void SetBlendRenderState(LPDIRECT3DDEVICE7 pd3dDevice, BYTE bBlendFlag, D3DMATERIAL7 mtrlGetMtrl)
{
pd3dDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, TRUE);
pd3dDevice->SetRenderState(D3DRENDERSTATE_COLORKEYENABLE, TRUE);
switch ( bBlendFlag )
{
case 0:
if ( mtrlGetMtrl.diffuse.a < 1.0f || mtrlGetMtrl.emissive.a < 1.0f )
{
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
pd3dDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE);
pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVSRCALPHA);
}
else
{
pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVSRCALPHA);
}
break;
case 1:
pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ONE);
break;
case 2:
pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVSRCCOLOR);
break;
case 3:
if( mtrlGetMtrl.diffuse.a < 1.0f || mtrlGetMtrl.emissive.a < 1.0f )
{
pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE | D3DTA_COMPLEMENT);
pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
pd3dDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE);
pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVSRCALPHA);
}
else
{
pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE | D3DTA_COMPLEMENT);
pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
pd3dDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_INVSRCALPHA);
pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ZERO);
}
break;
case 4:
pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE | D3DTA_COMPLEMENT);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE|D3DTA_COMPLEMENT);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVDESTCOLOR);
break;
case 5:
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE|D3DTA_COMPLEMENT);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE | D3DTA_COMPLEMENT);
pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVDESTCOLOR);
break;
}
}
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 );
}
//---------------------------------------------------------------------
float CControlTarget::Render(LPDIRECT3DDEVICE7 m_pd3dDevice)
{
int i = 0;
SETCULL(m_pd3dDevice, D3DCULL_NONE);
SETZWRITE(m_pd3dDevice, FALSE);
SETALPHABLEND(m_pd3dDevice, TRUE);
//----------------------------
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE);
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ONE);
SETALPHABLEND(m_pd3dDevice, TRUE);
if (tex_mm && tex_mm->m_pddsSurface)
{
SETTC(m_pd3dDevice, tex_mm);
}
// -------------------
fTrail += 1;
if (fTrail >= 300) fTrail = 0;
int n = BEZIERPrecision;
float delta = 1.0f / n;
fTrail = (ulCurrentTime * fOneOnDuration) * 9 * (n + 2);
EERIE_3D lastpos, newpos;
EERIE_3D v;
int arx_check_init = -1;
newpos.x = 0;
newpos.y = 0;
newpos.z = 0;
lastpos.x = pathways[0].sx;
lastpos.y = pathways[0].sy;
lastpos.z = pathways[0].sz;
for (i = 0; i < 9; i++)
{
int kp = i;
int kpprec = (i > 0) ? kp - 1 : kp ;
int kpsuiv = kp + 1 ;
int kpsuivsuiv = (i < (9 - 2)) ? kpsuiv + 1 : kpsuiv;
for (int toto = 1; toto < n; toto++)
{
if (fTrail < i * n + toto) break;
float t = toto * delta;
float t1 = t;
float t2 = t1 * t1 ;
float t3 = t2 * t1 ;
float f0 = 2.f * t3 - 3.f * t2 + 1.f ;
float f1 = -2.f * t3 + 3.f * t2 ;
float f2 = t3 - 2.f * t2 + t1 ;
float f3 = t3 - t2 ;
float val = pathways[kpsuiv].sx;
float p0 = 0.5f * (val - pathways[kpprec].sx) ;
float p1 = 0.5f * (pathways[kpsuivsuiv].sx - pathways[kp].sx) ;
v.x = f0 * pathways[kp].sx + f1 * val + f2 * p0 + f3 * p1 ;
val = pathways[kpsuiv].sy ;
p0 = 0.5f * (val - pathways[kpprec].sy) ;
p1 = 0.5f * (pathways[kpsuivsuiv].sy - pathways[kp].sy) ;
v.y = f0 * pathways[kp].sy + f1 * val + f2 * p0 + f3 * p1 ;
val = pathways[kpsuiv].sz ;
p0 = 0.5f * (val - pathways[kpprec].sz) ;
p1 = 0.5f * (pathways[kpsuivsuiv].sz - pathways[kp].sz) ;
v.z = f0 * pathways[kp].sz + f1 * val + f2 * p0 + f3 * p1 ;
newpos.x = v.x;
newpos.y = v.y;
newpos.z = v.z;
if (!((fTrail - (i * n + toto)) > 70))
{
float c = 1.0f - ((fTrail - (i * n + toto)) / 70.0f);
int j = ARX_PARTICLES_GetFree();
if ((j != -1) && (!ARXPausedTimer))
{
ParticleCount++;
particle[j].exist = 1;
particle[j].zdec = 0;
particle[j].ov.x = lastpos.x;
particle[j].ov.y = lastpos.y;
particle[j].ov.z = lastpos.z;
particle[j].move.x = 0;
particle[j].move.y = 0;
particle[j].move.z = 0;
particle[j].siz = 5 * c;
particle[j].tolive = 10 + (unsigned long)(float)(rnd() * 100.f);
particle[j].scale.x = 1;
particle[j].scale.y = 1;
particle[j].scale.z = 1;
particle[j].timcreation = lARXTime;
particle[j].tc = tex_mm;
particle[j].special = FADE_IN_AND_OUT | ROTATING | MODULATE_ROTATION | DISSIPATING;
particle[j].fparam = 0.0000001f;
particle[j].r = c;
particle[j].g = c;
particle[j].b = c;
}
}
float nx = lastpos.x;
float ny = lastpos.y;
float nz = lastpos.z;
lastpos.x = newpos.x;
lastpos.y = newpos.y;
lastpos.z = newpos.z;
newpos.x = nx;
newpos.y = ny;
newpos.z = nz;
++arx_check_init;
int j = ARX_PARTICLES_GetFree();
if ((j != -1) && (!ARXPausedTimer))
{
ParticleCount++;
particle[j].exist = 1;
particle[j].zdec = 0;
particle[j].ov.x = lastpos.x;
particle[j].ov.y = lastpos.y;
particle[j].ov.z = lastpos.z;
particle[j].move.x = 0;
particle[j].move.y = 0;
particle[j].move.z = 0;
particle[j].siz = 5;
particle[j].tolive = 10 + (unsigned long)(float)(rnd() * 100.f);
particle[j].scale.x = 1;
particle[j].scale.y = 1;
particle[j].scale.z = 1;
particle[j].timcreation = lARXTime;
particle[j].tc = tex_mm;
particle[j].special = FADE_IN_AND_OUT | ROTATING | MODULATE_ROTATION | DISSIPATING;
particle[j].fparam = 0.0000001f;
particle[j].r = 0.1f;
particle[j].g = 0.1f;
particle[j].b = 0.1f;
}
}
}
EERIE_3D stiteangle;
EERIE_3D stitepos;
EERIE_3D stitescale;
EERIE_RGB stitecolor;
EERIE_3D av;
ARX_CHECK_NOT_NEG(arx_check_init);
av.x = lastpos.x - newpos.x;
av.y = lastpos.y - newpos.y;
av.z = lastpos.z - newpos.z;
TRUEVector_Normalize(&av);
float bubu = GetAngle(av.x, av.z, 0, 0);
float bubu1 = GetAngle(av.x, av.y, 0, 0);
stitepos.x = lastpos.x;
stitepos.y = lastpos.y;
stitepos.z = lastpos.z;
stiteangle.b = 180 - RAD2DEG(bubu);
stiteangle.a = 0;
stiteangle.g = 90 - RAD2DEG(bubu1);
stitecolor.r = 0.7f;
stitecolor.g = 0.7f;
stitecolor.b = 0.7f;
stitescale.x = 1;
stitescale.y = 1;
stitescale.z = 1;
eCurPos.x = lastpos.x;
eCurPos.y = lastpos.y;
eCurPos.z = lastpos.z;
return 1;
}
//-----------------------------------------------------------------------------
void ARX_MINIMAP_Show(LPDIRECT3DDEVICE7 m_pd3dDevice, long SHOWLEVEL, long flag, long fl2)
{
float sstartx, sstarty;
if (!pTexDetect)
{
GetTextureFile("Graph\\particles\\flare.bmp");
char temp[256];
MakeDir(temp, "Graph\\particles\\flare.bmp");
pTexDetect = D3DTextr_GetSurfaceContainer(temp);
}
// SHOWLEVEL=8;
// First Load Minimap TC & DATA if needed
if (minimap[SHOWLEVEL].tc == NULL)
{
ARX_MINIMAP_GetData(SHOWLEVEL);
}
if ((minimap[SHOWLEVEL].tc) && (minimap[SHOWLEVEL].tc->m_pddsSurface))
{
float startx, starty, casex, casey, ratiooo;
float mod_x = (float)MAX_BKGX / (float)MINIMAP_MAX_X;
float mod_z = (float)MAX_BKGZ / (float)MINIMAP_MAX_Z;
if (flag == 1)
{
startx = 0;
starty = 0;
casex = (900) / ((float)MINIMAP_MAX_X);
casey = (900) / ((float)MINIMAP_MAX_Z);
ratiooo = 900.f / 250.f;
if (fl2)
{
casex = (600) / ((float)MINIMAP_MAX_X);
casey = (600) / ((float)MINIMAP_MAX_Z);
ratiooo = 600.f / 250.f;
}
}
else
{
startx = (140);
starty = (120);
casex = (250) / ((float)MINIMAP_MAX_X);
casey = (250) / ((float)MINIMAP_MAX_Z);
ratiooo = 1.f;
}
sstartx = startx;
sstarty = starty;
float ofx, ofx2, ofy, ofy2, px, py;
px = py = 0.f;
ofx = mini_offset_x[CURRENTLEVEL];
ofx2 = minimap[SHOWLEVEL].xratio;
ofy = mini_offset_y[CURRENTLEVEL];
ofy2 = minimap[SHOWLEVEL].yratio;
if ((SHOWLEVEL == ARX_LEVELS_GetRealNum(CURRENTLEVEL)) || (flag == 2))
{
// Computes playerpos
ofx = mini_offset_x[CURRENTLEVEL];
ofx2 = minimap[SHOWLEVEL].xratio;
ofy = mini_offset_y[CURRENTLEVEL];
ofy2 = minimap[SHOWLEVEL].yratio;
px = startx + ((player.pos.x + ofx - ofx2) * DIV100 * casex
+ mini_offset_x[CURRENTLEVEL] * ratiooo * mod_x) / mod_x ; //DIV100*2;
py = starty + ((mapmaxy[SHOWLEVEL] - ofy - ofy2) * DIV100 * casey
- (player.pos.z + ofy - ofy2) * DIV100 * casey + mini_offset_y[CURRENTLEVEL] * ratiooo * mod_z) / mod_z ; //DIV100*2;
if (flag == 1)
{
sstartx = startx;
sstarty = starty;
startx = 490.f - px;
starty = 220.f - py;
px += startx;
py += starty;
}
}
D3DTLVERTEX verts[4];
SETTC(m_pd3dDevice, minimap[SHOWLEVEL].tc);
for (long k = 0; k < 4; k++)
{
verts[k].color = 0xFFFFFFFF;
verts[k].rhw = 1;
verts[k].sz = 0.00001f;
}
float div = DIV25;
TextureContainer * tc = minimap[SHOWLEVEL].tc;
float dw = 1.f / (float)max(tc->m_dwDeviceWidth, tc->m_dwOriginalWidth);
float dh = 1.f / (float)max(tc->m_dwDeviceHeight, tc->m_dwOriginalHeight);
float vx2 = 4.f * dw * mod_x;
float vy2 = 4.f * dh * mod_z;
float _px;
RECT boundaries;
float MOD20, MOD20DIV, divXratio, divYratio;
boundaries.bottom = boundaries.left = boundaries.right = boundaries.top = 0;
MOD20 = MOD20DIV = divXratio = divYratio = 0.f;
if (flag != 2)
{
if (flag == 1)
{
MOD20 = 20.f * Xratio;
MOD20DIV = 1.f / (MOD20);
//@PERF do if(fl2){}else{} to make 4 and not 8 flot op if fl2.
ARX_CHECK_LONG((360 + MOD20)*Xratio);
ARX_CHECK_LONG((555 - MOD20)*Xratio);
ARX_CHECK_LONG((85 + MOD20)*Yratio);
ARX_CHECK_LONG((355 - MOD20)*Yratio);
//CAST
boundaries.left = ARX_CLEAN_WARN_CAST_LONG((360 + MOD20) * Xratio);
boundaries.right = ARX_CLEAN_WARN_CAST_LONG((555 - MOD20) * Xratio);
boundaries.top = ARX_CLEAN_WARN_CAST_LONG((85 + MOD20) * Yratio);
boundaries.bottom = ARX_CLEAN_WARN_CAST_LONG((355 - MOD20) * Yratio);
if (fl2)
{
//CHECK (DEBUG)
ARX_CHECK_LONG((390 + MOD20)*Xratio);
ARX_CHECK_LONG((590 - MOD20)*Xratio);
ARX_CHECK_LONG((135 + MOD20)*Yratio);
ARX_CHECK_LONG((295 - MOD20)*Yratio);
//CAST
boundaries.left = ARX_CLEAN_WARN_CAST_LONG((390 + MOD20) * Xratio);
boundaries.right = ARX_CLEAN_WARN_CAST_LONG((590 - MOD20) * Xratio);
boundaries.top = ARX_CLEAN_WARN_CAST_LONG((135 + MOD20) * Yratio);
boundaries.bottom = ARX_CLEAN_WARN_CAST_LONG((295 - MOD20) * Yratio);
}
}
SETALPHABLEND(m_pd3dDevice, TRUE);
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_ZERO);
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVSRCCOLOR);
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_ZFUNC, D3DCMP_ALWAYS);
SETTEXTUREWRAPMODE(m_pd3dDevice, D3DTADDRESS_CLAMP);
if (fl2)
{
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE);
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVSRCCOLOR);
}
}
else
{
divXratio = 1.f / Xratio;
divYratio = 1.f / Yratio;
}
for (long j = -2; j < MINIMAP_MAX_Z + 2; j++)
{
for (long i = -2; i < MINIMAP_MAX_X + 2; i++)
{
float vx, vy, vxx, vyy;
vxx = ((float)i * (float)ACTIVEBKG->Xdiv * mod_x);
vyy = ((float)j * (float)ACTIVEBKG->Zdiv * mod_z);
vx = (vxx * div) * dw;
vy = (vyy * div) * dh;
long okay = 1;
float posx = (startx + i * casex) * Xratio;
float posy = (starty + j * casey) * Yratio;
if (flag == 1)
{
if ((posx < 360 * Xratio)
|| (posx > 555 * Xratio)
|| (posy < 85 * Yratio)
|| (posy > 355 * Yratio))
okay = 0;
if (fl2)
{
okay = 1;
if ((posx < 390 * Xratio)
|| (posx > 590 * Xratio)
|| (posy < 135 * Yratio)
|| (posy > 295 * Yratio))
okay = 0;
}
}
else
{
if ((posx > 345 * Xratio)
|| (posy > 290 * Yratio))
okay = 0;
}
if (okay)
{
if ((flag == 2)
&& (i >= 0) && (i < MINIMAP_MAX_X)
&& (j >= 0) && (j < MINIMAP_MAX_Z))
{
float d = Distance2D(posx * divXratio + casex * DIV2, posy * divYratio /*-casey * 2 * Yratio*/, px, py);
if (d <= 6.f)
{
long r;
float vv = (6 - d) * DIV6;
if (vv >= 0.5f)
vv = 1.f;
else if (vv > 0.f)
vv = vv * 2.f;
else
vv = 0.f;
F2L((float)(vv * 255.f), &r);
long ucLevel = __max(r, minimap[SHOWLEVEL].revealed[i][j]);
ARX_CHECK_UCHAR(ucLevel);
minimap[SHOWLEVEL].revealed[i][j] = ARX_CLEAN_WARN_CAST_UCHAR(ucLevel);
}
}
if (!FOR_EXTERNAL_PEOPLE)
{
if ((i >= 0) && (i < MINIMAP_MAX_X)
&& (j >= 0) && (j < MINIMAP_MAX_Z))
{
minimap[SHOWLEVEL].revealed[i][j] = 255;
}
}
verts[3].sx = verts[0].sx = (posx);
verts[1].sy = verts[0].sy = (posy);
verts[2].sx = verts[1].sx = posx + (casex * Xratio);
verts[3].sy = verts[2].sy = posy + (casey * Yratio);
verts[3].tu = verts[0].tu = vx;
verts[1].tv = verts[0].tv = vy;
verts[2].tu = verts[1].tu = vx + vx2;
verts[3].tv = verts[2].tv = vy + vy2;
if (flag != 2)
{
float v;
float oo = 0.f;
if ((i < 0) || (i >= MINIMAP_MAX_X) || (j < 0) || (j >= MINIMAP_MAX_Z)) v = 0;
else v = ((float)minimap[SHOWLEVEL].revealed[i][j]) * DIV255;
if (flag == 1)
{
long vert = 0;
_px = verts[vert].sx - boundaries.left;
if (_px < 0.f) v = 0.f;
else if (_px < MOD20) v *= _px * MOD20DIV;
_px = boundaries.right - verts[vert].sx;
if (_px < 0.f) v = 0.f;
else if (_px < MOD20) v *= _px * MOD20DIV;
_px = verts[vert].sy - boundaries.top;
if (_px < 0.f) v = 0.f;
else if (_px < MOD20) v *= _px * MOD20DIV;
_px = boundaries.bottom - verts[vert].sy;
if (_px < 0.f) v = 0.f;
else if (_px < MOD20) v *= _px * MOD20DIV;
}
if (fl2) verts[0].color = D3DRGB(v * DIV2, v * DIV2, v * DIV2);
else
verts[0].color = D3DRGB(v, v, v);
oo += v;
if ((i + 1 < 0) || (i + 1 >= MINIMAP_MAX_X) || (j < 0) || (j >= MINIMAP_MAX_Z)) v = 0;
else v = ((float)minimap[SHOWLEVEL].revealed[__min(i+1, MINIMAP_MAX_X-1)][j]) * DIV255;
if (flag == 1)
{
long vert = 1;
_px = verts[vert].sx - boundaries.left;
if (_px < 0.f) v = 0.f;
else if (_px < MOD20) v *= _px * MOD20DIV;
_px = boundaries.right - verts[vert].sx;
if (_px < 0.f) v = 0.f;
else if (_px < MOD20) v *= _px * MOD20DIV;
_px = verts[vert].sy - boundaries.top;
if (_px < 0.f) v = 0.f;
else if (_px < MOD20) v *= _px * MOD20DIV;
_px = boundaries.bottom - verts[vert].sy;
if (_px < 0.f) v = 0.f;
else if (_px < MOD20) v *= _px * MOD20DIV;
}
if (fl2) verts[1].color = D3DRGB(v * DIV2, v * DIV2, v * DIV2);
else
verts[1].color = D3DRGB(v, v, v);
oo += v;
if ((i + 1 < 0) || (i + 1 >= MINIMAP_MAX_X) || (j + 1 < 0) || (j + 1 >= MINIMAP_MAX_Z)) v = 0;
else v = ((float)minimap[SHOWLEVEL].revealed[__min(i+1, MINIMAP_MAX_X-1)][__min(j+1, MINIMAP_MAX_Z-1)]) * DIV255;
if (flag == 1)
{
long vert = 2;
_px = verts[vert].sx - boundaries.left;
if (_px < 0.f) v = 0.f;
else if (_px < MOD20) v *= _px * MOD20DIV;
_px = boundaries.right - verts[vert].sx;
if (_px < 0.f) v = 0.f;
else if (_px < MOD20) v *= _px * MOD20DIV;
_px = verts[vert].sy - boundaries.top;
if (_px < 0.f) v = 0.f;
else if (_px < MOD20) v *= _px * MOD20DIV;
_px = boundaries.bottom - verts[vert].sy;
if (_px < 0.f) v = 0.f;
else if (_px < MOD20) v *= _px * MOD20DIV;
}
if (fl2) verts[2].color = D3DRGB(v * DIV2, v * DIV2, v * DIV2);
else
verts[2].color = D3DRGB(v, v, v);
oo += v;
if ((i < 0) || (i >= MINIMAP_MAX_X) || (j + 1 < 0) || (j + 1 >= MINIMAP_MAX_Z)) v = 0;
else v = ((float)minimap[SHOWLEVEL].revealed[i][__min(j+1, MINIMAP_MAX_Z-1)]) * DIV255;
if (flag == 1)
{
long vert = 3;
_px = verts[vert].sx - boundaries.left;
if (_px < 0.f) v = 0.f;
else if (_px < MOD20) v *= _px * MOD20DIV;
_px = boundaries.right - verts[vert].sx;
if (_px < 0.f) v = 0.f;
else if (_px < MOD20) v *= _px * MOD20DIV;
_px = verts[vert].sy - boundaries.top;
if (_px < 0.f) v = 0.f;
else if (_px < MOD20) v *= _px * MOD20DIV;
_px = boundaries.bottom - verts[vert].sy;
if (_px < 0.f) v = 0.f;
else if (_px < MOD20) v *= _px * MOD20DIV;
}
if (fl2) verts[3].color = D3DRGB(v * DIV2, v * DIV2, v * DIV2);
else
verts[3].color = D3DRGB(v, v, v);
oo += v;
if (oo > 0.f)
{
if (fl2)
{
verts[0].sx += DECALX * Xratio;
verts[0].sy += DECALY * Yratio;
verts[1].sx += DECALX * Xratio;
verts[1].sy += DECALY * Yratio;
verts[2].sx += DECALX * Xratio;
verts[2].sy += DECALY * Yratio;
verts[3].sx += DECALX * Xratio;
verts[3].sy += DECALY * Yratio;
}
EERIEDRAWPRIM(GDevice, D3DPT_TRIANGLEFAN, D3DFVF_TLVERTEX | D3DFVF_DIFFUSE, verts, 4, 0);
}
}
}
}
}
if (flag != 2)
{
m_pd3dDevice->SetTextureStageState(0, D3DTSS_ADDRESS , D3DTADDRESS_WRAP);
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_ZFUNC, D3DCMP_LESSEQUAL);
SETALPHABLEND(m_pd3dDevice, FALSE);
if ((SHOWLEVEL == ARX_LEVELS_GetRealNum(CURRENTLEVEL)))
{
// Now Draws Playerpos/angle
verts[0].color = 0xFFFF0000;
verts[1].color = 0xFFFF0000;
verts[2].color = 0xFFFF0000;
float val;
if (flag == 1) val = 6.f;
else val = 3.f;
float rx = 0.f;
float ry = -val * 1.8f;
float rx2 = -val * DIV2;
float ry2 = val;
float rx3 = val * DIV2;
float ry3 = val;
float angle = DEG2RAD(player.angle.b);
float ca = EEcos(angle);
float sa = EEsin(angle);
verts[0].sx = (px + rx2 * ca + ry2 * sa) * Xratio;
verts[0].sy = (py + ry2 * ca - rx2 * sa) * Yratio;
verts[1].sx = (px + rx * ca + ry * sa) * Xratio;
verts[1].sy = (py + ry * ca - rx * sa) * Yratio;
verts[2].sx = (px + rx3 * ca + ry3 * sa) * Xratio;
verts[2].sy = (py + ry3 * ca - rx3 * sa) * Yratio;
SETTC(GDevice, NULL);
if (fl2)
{
SETALPHABLEND(m_pd3dDevice, TRUE);
verts[0].sx += DECALX * Xratio;
verts[0].sy += DECALY * Yratio;
verts[1].sx += DECALX * Xratio;
verts[1].sy += DECALY * Yratio;
verts[2].sx += DECALX * Xratio;
verts[2].sy += DECALY * Yratio;
}
EERIEDRAWPRIM(GDevice, D3DPT_TRIANGLEFAN, D3DFVF_TLVERTEX | D3DFVF_DIFFUSE, verts, 3, 0);
if (fl2) SETALPHABLEND(m_pd3dDevice, FALSE);
}
}
// tsu
for (long lnpc = 1; lnpc < inter.nbmax; lnpc++)
{
if ((inter.iobj[lnpc] != NULL) && (inter.iobj[lnpc]->ioflags & IO_NPC))
{
if (inter.iobj[lnpc]->_npcdata->life > 0.f)
if (!((inter.iobj[lnpc]->GameFlags & GFLAG_MEGAHIDE) ||
(inter.iobj[lnpc]->show == SHOW_FLAG_MEGAHIDE))
&& (inter.iobj[lnpc]->show == SHOW_FLAG_IN_SCENE))
if (!(inter.iobj[lnpc]->show == SHOW_FLAG_HIDDEN))
if (inter.iobj[lnpc]->_npcdata->fDetect >= 0)
{
if (player.Full_Skill_Etheral_Link >= inter.iobj[lnpc]->_npcdata->fDetect)
{
float fpx;
float fpy;
fpx = sstartx + ((inter.iobj[lnpc]->pos.x - 100 + ofx - ofx2) * DIV100 * casex
+ mini_offset_x[CURRENTLEVEL] * ratiooo * mod_x) / mod_x;
fpy = sstarty + ((mapmaxy[SHOWLEVEL] - ofy - ofy2) * DIV100 * casey
- (inter.iobj[lnpc]->pos.z + 200 + ofy - ofy2) * DIV100 * casey + mini_offset_y[CURRENTLEVEL] * ratiooo * mod_z) / mod_z;
if (flag == 1)
{
fpx = startx + ((inter.iobj[lnpc]->pos.x - 100 + ofx - ofx2) * DIV100 * casex
+ mini_offset_x[CURRENTLEVEL] * ratiooo * mod_x) / mod_x;
fpy = starty + ((mapmaxy[SHOWLEVEL] - ofy - ofy2) * DIV100 * casey
- (inter.iobj[lnpc]->pos.z + 200 + ofy - ofy2) * DIV100 * casey + mini_offset_y[CURRENTLEVEL] * ratiooo * mod_z) / mod_z;
}
float d = Distance2D(player.pos.x, player.pos.z, inter.iobj[lnpc]->pos.x, inter.iobj[lnpc]->pos.z);
if ((d <= 800) && (fabs(inter.iobj[0]->pos.y - inter.iobj[lnpc]->pos.y) < 250.f))
{
float col = 1.f;
if (d > 600.f)
{
col = 1.f - (d - 600.f) * DIV200;
}
if (!fl2)
{
SETALPHABLEND(m_pd3dDevice, true);
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_ONE);
m_pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_ONE);
}
else
SETALPHABLEND(m_pd3dDevice, true);
if (fl2)
{
fpx += DECALX * Xratio;
fpy += (DECALY + 15) * Yratio;
}
fpx *= Xratio;
fpy *= Yratio;
EERIEDrawBitmap(GDevice, fpx, fpy,
5.f * ratiooo, 5.f * ratiooo, 0, pTexDetect, D3DRGB(col, 0, 0));
if (!fl2)
SETALPHABLEND(m_pd3dDevice, false);
}
}
}
}
}
if (flag == 0)
for (long i = 0; i < Nb_Mapmarkers; i++)
{
if (Mapmarkers[i].lvl == SHOWLEVEL + 1)
{
float pos_x = Mapmarkers[i].x * 8 * ratiooo * ACTIVEBKG->Xmul * casex + startx;
float pos_y = Mapmarkers[i].y * 8 * ratiooo * ACTIVEBKG->Zmul * casey + starty;
float size = 5.f * ratiooo;
verts[0].color = 0xFFFF0000;
verts[1].color = 0xFFFF0000;
verts[2].color = 0xFFFF0000;
verts[3].color = 0xFFFF0000;
verts[0].sx = (pos_x - size) * Xratio;
verts[0].sy = (pos_y - size) * Yratio;
verts[1].sx = (pos_x + size) * Xratio;
verts[1].sy = (pos_y - size) * Yratio;
verts[2].sx = (pos_x + size) * Xratio;
verts[2].sy = (pos_y + size) * Yratio;
verts[3].sx = (pos_x - size) * Xratio;
verts[3].sy = (pos_y + size) * Yratio;
verts[0].tu = 0.f;
verts[0].tv = 0.f;
verts[1].tu = 1.f;
verts[1].tv = 0.f;
verts[2].tu = 1.f;
verts[2].tv = 1.f;
verts[3].tu = 0.f;
verts[3].tv = 1.f;
if ((!fl2)
&& (MouseInRect(verts[0].sx, verts[0].sy, verts[2].sx, verts[2].sy)))
{
if (!Mapmarkers[i].tstring)
{
_TCHAR output[4096];
MakeLocalised(Mapmarkers[i].string, output, 4096, 0);
Mapmarkers[i].tstring = (_TCHAR *)malloc((_tcslen(output) + 1) * sizeof(_TCHAR));
ZeroMemory(Mapmarkers[i].tstring, (_tcslen(output) + 1)*sizeof(_TCHAR));
_tcscpy(Mapmarkers[i].tstring, output);
}
if (Mapmarkers[i].tstring)
{
RECT rRect, bRect;
SetRect(&bRect , (140), (290)
, (140 + 205), (358));
float fLeft = (bRect.left) * Xratio ;
float fRight = (bRect.right) * Xratio ;
float fTop = (bRect.top) * Yratio ;
float fBottom = (bRect.bottom) * Yratio ;
ARX_CHECK_INT(fLeft);
ARX_CHECK_INT(fRight);
ARX_CHECK_INT(fTop);
ARX_CHECK_INT(fBottom);
SetRect(&rRect
, ARX_CLEAN_WARN_CAST_INT(fLeft)
, ARX_CLEAN_WARN_CAST_INT(fTop)
, ARX_CLEAN_WARN_CAST_INT(fRight)
, ARX_CLEAN_WARN_CAST_INT(fBottom));
long lLengthDraw = ARX_UNICODE_ForceFormattingInRect(
hFontInGameNote, Mapmarkers[i].tstring, 0, rRect);
danaeApp.DANAEEndRender();
_TCHAR Page_Buffer[256];
_tcsncpy(Page_Buffer, Mapmarkers[i].tstring, lLengthDraw);
Page_Buffer[lLengthDraw] = _T('\0');
DrawBookTextInRect(ARX_CLEAN_WARN_CAST_FLOAT(bRect.left), ARX_CLEAN_WARN_CAST_FLOAT(bRect.top),
ARX_CLEAN_WARN_CAST_FLOAT(bRect.right), ARX_CLEAN_WARN_CAST_FLOAT(bRect.bottom),
Page_Buffer, 0, 0x00FF00FF,
hFontInGameNote);
danaeApp.DANAEStartRender();
}
}
if (MapMarkerTc == NULL)
{
MapMarkerTc = MakeTCFromFile("Graph\\interface\\icons\\mapmarker.bmp");
}
SETTC(GDevice, MapMarkerTc);
if (fl2)
{
verts[0].sx += DECALX * Xratio;
verts[0].sy += DECALY * Yratio;
verts[1].sx += DECALX * Xratio;
verts[1].sy += DECALY * Yratio;
verts[2].sx += DECALX * Xratio;
verts[2].sy += DECALY * Yratio;
verts[3].sx += DECALX * Xratio;
verts[3].sy += DECALY * Yratio;
}
EERIEDRAWPRIM(GDevice, D3DPT_TRIANGLEFAN, D3DFVF_TLVERTEX | D3DFVF_DIFFUSE, verts, 4, 0);
}
}
}
}
