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);
}
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);
}
/// <summary>
/// <c>wSetTextureStageState</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="dwStage"></param>
/// <param name="dwState"></param>
/// <param name="dwValue"></param>
/// <returns></returns>
HRESULT __stdcall wSetTextureStageState(
LPDIRECT3DDEVICE7 d3dDevice7, ULONG dwStage, D3DTEXTURESTAGESTATETYPE dwState, ULONG dwValue)
{
PSTR pszStageSet;
PSTR pszErrorMessage;
HRESULT hResult;
++TotalRenderStateChanges;
pszStageSet = GetStageSet(dwState, dwValue);
InternalFunctionSpew("GameOS_Direct3D", "SetTextureStageState(%d,%s)", dwStage, pszStageSet);
hResult = d3dDevice7->SetTextureStageState(dwStage, dwState, dwValue);
if (FAILED(hResult))
{
if ( hResult != DDERR_SURFACELOST)
{
pszStageSet = GetStageSet(dwState, dwValue);
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - SetTextureStageState(%d,%s)",
hResult, pszErrorMessage, dwStage, pszStageSet) )
ENTER_DEBUGGER;
}
}
return hResult;
}
//-----------------------------------------------------------------------------
// 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);
}
/// <summary>
/// <c>wMultiplyTransform</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="dtstTransformStateType"></param>
/// <param name="lpD3DMatrix"></param>
/// <returns></returns>
HRESULT __stdcall wMultiplyTransform(
LPDIRECT3DDEVICE7 d3dDevice7, D3DTRANSFORMSTATETYPE dtstTransformStateType,
LPD3DMATRIX lpD3DMatrix)
{
PSTR pszTransformType;
PSTR pszErrorMessage;
HRESULT hResult;
pszTransformType = GetTransformType(dtstTransformStateType);
InternalFunctionSpew("GameOS_Direct3D", "MultiplyTransform(%s)", pszTransformType);
hResult =
d3dDevice7->MultiplyTransform(
dtstTransformStateType,
lpD3DMatrix);
if (FAILED(hResult))
{
pszTransformType = GetTransformType(dtstTransformStateType);
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - MultiplyTransform()",
hResult, pszErrorMessage, pszTransformType) )
ENTER_DEBUGGER;
}
return hResult;
}
//////////////////////////////////////////////////////////////////////////////
//CLEANUP
//////////////////////////////////////////////////////////////////////////////
void Prog_Done()
{
//release IDirect3DDevice
if(lpd3ddev)
{
lpd3ddev->Release();
lpd3ddev=NULL;
}
//release IDirect3D
if(lpd3d)
{
lpd3d->Release();
lpd3d=NULL;
}
//get rid of the texture.
LPDDS_Release(&lpddsTex);
//clean up primary surface(this will clean up the back buffer, also)
LPDDS_Release(&lpddsPrime);
//clean up the dd pointer
LPDD_Release(&lpdd);
}
void RenderSquareShadow(LPDIRECT3DDEVICE7 lpDevice,float x,float y,float z,float w,float h)
{
WORD wIndices[] = {
0,1,2,
3,2,1,
1,5,3,
3,5,7,
0,4,1,
1,4,5,
0,2,4,
4,2,6,
2,3,6,
6,3,7,
};
D3DLIGHT7 light;
lpDevice->GetLight(0,&light);
D3DVECTOR length=Normalize(light.dvDirection)*(-100);
D3DVERTEX v[8];
v[0] = D3DVERTEX( D3DVECTOR( x-w/2, y, z-h/2 ),D3DVECTOR(0,1,0), 0, 1 );
v[1] = D3DVERTEX( D3DVECTOR( x-w/2, y, z+h/2 ),D3DVECTOR(0,1,0), 0, 0 );
v[2] = D3DVERTEX( D3DVECTOR( x+w/2, y, z-h/2 ),D3DVECTOR(0,1,0), 1, 1 );
v[3] = D3DVERTEX( D3DVECTOR( x+w/2, y, z+h/2 ),D3DVECTOR(0,1,0), 1, 0 );
v[4] = D3DVERTEX( D3DVECTOR( x-w/2, y, z-h/2 )-length,D3DVECTOR(0,1,0), 0, 0 );
v[5] = D3DVERTEX( D3DVECTOR( x-w/2, y, z+h/2 )-length,D3DVECTOR(0,1,0), 0, 0 );
v[6] = D3DVERTEX( D3DVECTOR( x+w/2, y, z-h/2 )-length,D3DVECTOR(0,1,0), 0, 0 );
v[7] = D3DVERTEX( D3DVECTOR( x+w/2, y, z+h/2 )-length,D3DVECTOR(0,1,0), 0, 0 );
RenderShadow(lpDevice,v,8,wIndices,sizeof(wIndices)/sizeof(wIndices[0]));
}
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>wClear</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="dwCount"></param>
/// <param name="lpRects"></param>
/// <param name="dwFlags"></param>
/// <param name="dwColor"></param>
/// <param name="dvZ"></param>
/// <param name="dwStencil"></param>
/// <returns></returns>
HRESULT __stdcall wClear(
LPDIRECT3DDEVICE7 d3dDevice7, ULONG dwCount, LPD3DRECT lpRects, ULONG dwFlags,
ULONG dwColor, D3DVALUE dvZ, ULONG dwStencil)
{
PSTR pszClearArea;
PSTR pszErrorMessage;
HRESULT hResult;
pszClearArea = GetClearArea(dwCount, lpRects, dwFlags);
InternalFunctionSpew("GameOS_Direct3D", "Clear(%s)", pszClearArea);
hResult = d3dDevice7->Clear(
dwCount,
lpRects,
dwFlags,
dwColor,
dvZ,
dwStencil);
if (FAILED(hResult))
{
if ( hResult != DDERR_SURFACELOST)
{
pszClearArea = GetClearArea(dwCount, lpRects, dwFlags);
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - Clear(%s)", hResult, pszErrorMessage, pszClearArea) )
ENTER_DEBUGGER;
}
}
return hResult;
}
/// <summary>
/// <c>wLightEnable</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="dwLightIndex"></param>
/// <param name="Enable"></param>
/// <returns></returns>
HRESULT __stdcall wLightEnable(
LPDIRECT3DDEVICE7 d3dDevice7, ULONG dwLightIndex, bool Enable)
{
PSTR pszEnable;
PSTR pszErrorMessage;
HRESULT hResult;
if ( Enable )
pszEnable = "enable";
else
pszEnable = "disable";
InternalFunctionSpew("GameOS_Direct3D", "LightEnable(%d, %s)", dwLightIndex, pszEnable);
hResult = d3dDevice7->LightEnable(dwLightIndex, Enable);
if (FAILED(hResult))
{
if ( Enable )
pszEnable = "enable";
else
pszEnable = "disable";
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - LightEnable(%d, %s)", hResult, pszErrorMessage, dwLightIndex, pszEnable) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wDrawPrimitive</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="dptPrimitiveType"></param>
/// <param name="dvtVertexType"></param>
/// <param name="lpvVertices"></param>
/// <param name="dwVertexCount"></param>
/// <param name="dwFlags"></param>
/// <returns></returns>
HRESULT __stdcall wDrawPrimitive(
LPDIRECT3DDEVICE7 d3dDevice7, D3DPRIMITIVETYPE dptPrimitiveType,
ULONG dvtVertexType, PVOID lpvVertices, ULONG dwVertexCount, ULONG dwFlags)
{
PSTR pszPrimitiveData;
PSTR pszErrorMessage;
HRESULT hResult;
pszPrimitiveData = GetDrawPrimitiveData(
dptPrimitiveType, dvtVertexType, lpvVertices, dwVertexCount, dwFlags);
InternalFunctionSpew("GameOS_Direct3D", "DrawPrimitive( %s)", pszPrimitiveData);
hResult = d3dDevice7->DrawPrimitive(
dptPrimitiveType,
dvtVertexType,
lpvVertices,
dwVertexCount,
dwFlags);
if (FAILED(hResult))
{
if ( hResult != DDERR_SURFACELOST)
{
pszPrimitiveData = GetDrawPrimitiveData(
dptPrimitiveType, dvtVertexType, lpvVertices, dwVertexCount, dwFlags);
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - DrawPrimitive( %s)",
hResult, pszErrorMessage, pszPrimitiveData) )
ENTER_DEBUGGER;
}
}
return hResult;
}
/// <summary>
/// <c>wLoad</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="lpDestTex"></param>
/// <param name="lpDestPoint"></param>
/// <param name="lpSrcTex"></param>
/// <param name="lprcSrcRect"></param>
/// <param name="dwFlags"></param>
/// <returns></returns>
HRESULT __stdcall wLoad(
LPDIRECT3DDEVICE7 d3dDevice7, LPDIRECTDRAWSURFACE7 lpDestTex, LPPOINT lpDestPoint,
LPDIRECTDRAWSURFACE7 lpSrcTex, LPRECT lprcSrcRect, ULONG dwFlags)
{
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew("GameOS_Direct3D", "Load(0x%x with 0x%x)", lpDestTex, lpSrcTex);
hResult = d3dDevice7->Load(
lpDestTex,
lpDestPoint,
lpSrcTex,
lprcSrcRect,
dwFlags);
if (FAILED(hResult))
{
if ( hResult != DDERR_SURFACELOST)
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - Load(0x%x with 0x%x)",
hResult, pszErrorMessage, lpDestTex, lpSrcTex) )
ENTER_DEBUGGER;
}
}
return hResult;
}
/******************************************************************************************************************
함수명 : 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);
}
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;
}
//////////////////////////////////////////////////////////////////////////////
//MAIN GAME LOOP
//////////////////////////////////////////////////////////////////////////////
void Prog_Loop()
{
//set up the vertex positions
vert[0].sx=(float) (cos(angle)*240.0+320.0);
vert[0].sy=(float) (sin(angle)*240.0+240.0);
vert[0].sz=(float) (sin(angle)*240.0+240.0);
vert[1].sx=(float) (cos(angle+PI/2)*240.0+320.0);
vert[1].sy=(float) (sin(angle+PI/2)*240.0+240.0);
vert[1].sz=(float) (sin(angle+PI/2)*240.0+240.0);
vert[2].sx=(float) (cos(angle-PI/2)*240.0+320.0);
vert[2].sy=(float) (sin(angle-PI/2)*240.0+240.0);
vert[2].sz=(float) (sin(angle-PI/2)*240.0+240.0);
vert[3].sx=(float) (cos(angle-PI)*240.0+320.0);
vert[3].sy=(float) (sin(angle-PI)*240.0+240.0);
vert[3].sz=(float) (sin(angle-PI)*240.0+240.0);
//add to the angle for next time
angle+=PI/90;
//clear the viewport to black
lpd3ddev->Clear(0,NULL,D3DCLEAR_TARGET,0,0,0);
//start the scene
lpd3ddev->BeginScene();
//draw the triangle
lpd3ddev->DrawPrimitive(D3DPT_TRIANGLESTRIP,D3DFVF_TLVERTEX,vert,4,0);
//end the scene
lpd3ddev->EndScene();
//flip
lpddsPrime->Flip(NULL,DDFLIP_WAIT);
}
/// <summary>
/// <c>wEnumTextureFormats</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="lpd3dEnumPixelProc"></param>
/// <param name="lpArg"></param>
/// <returns></returns>
HRESULT __stdcall wEnumTextureFormats(
LPDIRECT3DDEVICE7 d3dDevice7, LPD3DENUMPIXELFORMATSCALLBACK lpd3dEnumPixelProc, PVOID lpArg)
{
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew("GameOS_Direct3D", "EnumTextureFormats()");
hResult = d3dDevice7->EnumTextureFormats(lpd3dEnumPixelProc, lpArg);
if (FAILED(hResult))
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - EnumTextureFormats()", hResult, pszErrorMessage) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wGetCaps</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="lpD3DHWDevDesc"></param>
/// <returns></returns>
HRESULT __stdcall wGetCaps(
LPDIRECT3DDEVICE7 d3dDevice7, LPD3DDEVICEDESC7 lpD3DHWDevDesc)
{
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew("GameOS_Direct3D", "GetCaps(0x%x)", d3dDevice7);
hResult = d3dDevice7->GetCaps(lpD3DHWDevDesc);
if (FAILED(hResult))
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - GetCaps(0x%x)", hResult, pszErrorMessage, d3dDevice7) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wSetViewport</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="lpViewport"></param>
/// <returns></returns>
HRESULT __stdcall wSetViewport(
LPDIRECT3DDEVICE7 d3dDevice7, LPD3DVIEWPORT7 lpViewport)
{
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew("GameOS_Direct3D", "SetViewport()");
hResult = d3dDevice7->SetViewport(lpViewport);
if (FAILED(hResult))
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - SetViewport()", hResult, pszErrorMessage) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wEndScene</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <returns></returns>
HRESULT __stdcall wEndScene(
LPDIRECT3DDEVICE7 d3dDevice7)
{
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew("GameOS_Direct3D", "EndScene()");
hResult = d3dDevice7->EndScene();
if (FAILED(hResult))
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - EndScene()", hResult, pszErrorMessage) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wDrawIndexedPrimitiveVB</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="d3dptPrimitiveType"></param>
/// <param name="lpd3dVertexBuffer"></param>
/// <param name="dwStartVertex"></param>
/// <param name="dwNumVertices"></param>
/// <param name="lpwIndices"></param>
/// <param name="dwIndexCount"></param>
/// <param name="dwFlags"></param>
/// <returns></returns>
HRESULT __stdcall wDrawIndexedPrimitiveVB(
LPDIRECT3DDEVICE7 d3dDevice7, D3DPRIMITIVETYPE d3dptPrimitiveType,
LPDIRECT3DVERTEXBUFFER7 lpd3dVertexBuffer, ULONG dwStartVertex,
ULONG dwNumVertices, PUSHORT lpwIndices, ULONG dwIndexCount, ULONG dwFlags)
{
LPDIRECT3DVERTEXBUFFER7 pd3dVertexBufferUsed;
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew("GameOS_Direct3D", "DrawIndexedPrimitiveVB(0x%x)", lpd3dVertexBuffer);
if (g_pGetDXVB)
{
pd3dVertexBufferUsed = g_pGetDXVB(lpd3dVertexBuffer, d3dDevice7);
}
else
{
pd3dVertexBufferUsed = lpd3dVertexBuffer;
}
hResult = d3dDevice7->DrawIndexedPrimitiveVB(
d3dptPrimitiveType,
pd3dVertexBufferUsed,
dwStartVertex,
dwNumVertices,
lpwIndices,
dwIndexCount,
dwFlags);
if (FAILED(hResult))
{
if ( hResult != DDERR_SURFACELOST)
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause(
"FAILED (0x%x - %s) - DrawIndexedPrimitiveVB(0x%x)",
hResult,
pszErrorMessage,
lpd3dVertexBuffer) )
ENTER_DEBUGGER;
}
}
return hResult;
}
/// <summary>
/// <c>wValidateDevice</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="pExtraPasses"></param>
/// <returns></returns>
HRESULT __stdcall wValidateDevice(
LPDIRECT3DDEVICE7 d3dDevice7, PULONG pExtraPasses)
{
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew("GameOS_Direct3D", "ValidateDevice()+");
hResult = d3dDevice7->ValidateDevice(pExtraPasses);
InternalFunctionSpew("GameOS_Direct3D", " -0x%x", *pExtraPasses);
if (FAILED(hResult))
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - ValidateDevice()",
hResult, pszErrorMessage) )
ENTER_DEBUGGER;
}
return hResult;
}
// Runden Schatten malen
void RenderRoundShadow(LPDIRECT3DDEVICE7 lpDevice,float x,float y,float z,float r)
{
#define EDGES 12
static D3DVERTEX v[(EDGES+1)*2];
D3DLIGHT7 light;
lpDevice->GetLight(0,&light);
D3DVECTOR length=Normalize(light.dvDirection)*(-100.0f);
for (int i=0;i<=EDGES;i++)
{
v[i]=v[i+EDGES+1]=D3DVERTEX(D3DVECTOR(x+sinf(float(i)/float(EDGES)*g_PI*2.0f)*r,y,z+cosf(float(i)/float(EDGES)*g_PI*2.0f)*r),D3DVECTOR(0,1,0),0,0);
v[i+EDGES+1].x-=length.x;
v[i+EDGES+1].y-=length.y;
v[i+EDGES+1].z-=length.z;
}
static WORD wIndices[(EDGES-2)*3+EDGES*6];
const PWORD Cap=&wIndices[0];
const PWORD Side=&wIndices[(EDGES-2)*3];
for (i=0;i<EDGES-2;i++)
{
Cap[i*3]=0;
Cap[i*3+1]=i+1;
Cap[i*3+2]=i+2;
}
for (i=0;i<EDGES;i++)
{
Side[i*6+0]=i;
Side[i*6+1]=i+EDGES+2;
Side[i*6+2]=i+1;
Side[i*6+3]=i;
Side[i*6+4]=i+EDGES+1;
Side[i*6+5]=i+EDGES+2;
}
RenderShadow(lpDevice,v,EDGES*2+2,wIndices,sizeof(wIndices)/sizeof(wIndices[0]));
// RenderShadow(lpDevice,v,8,wIndices,(EDGES-2)*3);
}
/// <summary>
/// <c>wSetLight</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="dwLightIndex"></param>
/// <param name="lpLight"></param>
/// <returns></returns>
HRESULT __stdcall wSetLight(
LPDIRECT3DDEVICE7 d3dDevice7, ULONG dwLightIndex, LPD3DLIGHT7 lpLight)
{
PSTR pszLightInfo;
PSTR pszErrorMessage;
HRESULT hResult;
pszLightInfo = GetLightInfo(lpLight);
InternalFunctionSpew("GameOS_Direct3D", "SetLight(%d, %s)", dwLightIndex, pszLightInfo);
hResult = d3dDevice7->SetLight(dwLightIndex, lpLight);
if (FAILED(hResult))
{
pszLightInfo = GetLightInfo(lpLight);
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - SetLight(%d, %s)",
hResult, pszErrorMessage, dwLightIndex, pszLightInfo) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wSetMaterial</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="pMaterial"></param>
/// <returns></returns>
HRESULT __stdcall wSetMaterial(
LPDIRECT3DDEVICE7 d3dDevice7, LPD3DMATERIAL7 pMaterial)
{
PSTR pszMaterialInfo;
PSTR pszErrorMessage;
HRESULT hResult;
pszMaterialInfo = GetMaterialInfo(pMaterial);
InternalFunctionSpew("GameOS_Direct3D", "SetMaterial(%s)", pszMaterialInfo);
hResult = d3dDevice7->SetMaterial(pMaterial);
if (FAILED(hResult))
{
pszMaterialInfo = GetMaterialInfo(pMaterial);
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - SetMaterial(%s)",
hResult, pszErrorMessage, pszMaterialInfo) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <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;
}
/// <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 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;
}
/******************************************************************************************************************
함수명 : 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 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);
}
}
//-----------------------------------------------------------------------------
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;
}
