//----------------------------------------------------------------------------
void PdrPixelShader::Disable (Renderer* renderer, const PixelShader* pshader,
const ShaderParameters* parameters)
{
IDirect3DDevice9* device = renderer->mData->mDevice;
HRESULT hr;
WM5_UNUSED(hr);
#ifdef WM5_PDR_DEBUG
// Verify that the active shader is the one making the disable request.
IDirect3DPixelShader9* activePShader = 0;
hr = device->GetPixelShader(&activePShader);
assertion(hr == D3D_OK, "Failed to get pixel shader: %s\n",
DXGetErrorString(hr));
assertion(activePShader == mShader, "Mismatched pixel shaders\n");
activePShader->Release();
#endif
int profile = PixelShader::GetProfile();
DisableTextures(renderer, pshader, profile, parameters,
renderer->mData->mMaxPShaderImages, 0);
// Disable the shader by clearing the state.
hr = device->SetPixelShader(0);
assertion(hr == D3D_OK, "Failed to set pixel shader: %s\n",
DXGetErrorString(hr));
}
//----------------------------------------------------------------------------
void PdrPixelShader::Disable (Renderer* renderer, const PixelShader* pshader,
const ShaderParameters* parameters)
{
IDirect3DDevice9* device = renderer->mData->mDevice;
HRESULT hr;
PX2_UNUSED(hr);
#ifdef PX2_PDR_DEBUG
// 检测需要被取消激活的数据，是否匹配。
IDirect3DPixelShader9* activePShader = 0;
hr = device->GetPixelShader(&activePShader);
assertion(hr == D3D_OK, "Failed to get pixel shader: %s\n",
DXGetErrorString(hr));
assertion(activePShader == mShader, "Mismatched pixel shaders\n");
activePShader->Release();
#endif
int profile = PixelShader::GetProfile();
DisableTextures(renderer, pshader, profile, parameters,
renderer->mData->mMaxPShaderImages, 0);
// 取消激活着色器
hr = device->SetPixelShader(0);
assertion(hr == D3D_OK, "Failed to set pixel shader: %s\n",
DXGetErrorString(hr));
}
void MFShader_DestroyPlatformSpecific(MFShader *pShader)
{
switch(pShader->pTemplate->shaderType)
{
case MFST_VertexShader:
{
IDirect3DVertexShader9 *pVS = (IDirect3DVertexShader9*)pShader->pPlatformData;
pVS->Release();
break;
}
case MFST_PixelShader:
{
IDirect3DPixelShader9 *pPS = (IDirect3DPixelShader9*)pShader->pPlatformData;
pPS->Release();
break;
}
case MFST_GeometryShader:
case MFST_DomainShader:
case MFST_HullShader:
case MFST_ComputeShader:
MFDebug_Assert(false, "Not supported in D3D9!");
break;
default:
MFUNREACHABLE;
}
}
Burger::EffectDX9::~EffectDX9()
{
// Release the pixel and vertex shaders
IDirect3DPixelShader9 *pPixelShader = m_pPixelShader;
if (pPixelShader != NULL) {
pPixelShader->Release();
m_pPixelShader = NULL;
}
IDirect3DVertexShader9 *pVertexShader = m_pVertexShader;
if (pVertexShader != NULL) {
pVertexShader->Release();
m_pVertexShader = NULL;
}
}
void CState::Restore()
{
// viewport
m_D3DDev->SetViewport(&m_Vp);
// render states
m_D3DDev->SetRenderState(D3DRS_ZENABLE, m_Z);
m_D3DDev->SetRenderState(D3DRS_CULLMODE, m_CullMode);
m_D3DDev->SetRenderState(D3DRS_ALPHATESTENABLE, m_AlphaTest);
m_D3DDev->SetRenderState(D3DRS_ALPHABLENDENABLE, m_AlphaBlend);
m_D3DDev->SetRenderState(D3DRS_BLENDOP, m_BlendOp);
m_D3DDev->SetRenderState(D3DRS_SRCBLEND, m_SrcBlend);
m_D3DDev->SetRenderState(D3DRS_DESTBLEND, m_DstBlend);
m_D3DDev->SetRenderState(D3DRS_CLIPPLANEENABLE, m_ClipPlane);
m_D3DDev->SetRenderState(D3DRS_FILLMODE, m_FillMode);
m_D3DDev->SetRenderState(D3DRS_LASTPIXEL, m_LastPixel);
m_D3DDev->SetRenderState(D3DRS_FOGENABLE, m_Fog);
m_D3DDev->SetRenderState(D3DRS_STENCILENABLE, m_Stencil);
m_D3DDev->SetRenderState(D3DRS_COLORWRITEENABLE, m_ColorWrite);
m_D3DDev->SetRenderState(D3DRS_SCISSORTESTENABLE, m_Scissor);
if( m_Caps.PrimitiveMiscCaps & D3DPMISCCAPS_SEPARATEALPHABLEND )
m_D3DDev->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, m_SeparateAlphaBlend);
//if( m_Caps.LineCaps & D3DLINECAPS_ANTIALIAS )
m_D3DDev->SetRenderState(D3DRS_ANTIALIASEDLINEENABLE, m_AntiAliasedLine);
// primitive
m_D3DDev->SetFVF(m_FVF);
m_D3DDev->SetStreamSource(0, m_StreamData, m_StreamOffset, m_StreamStride);
if( m_StreamData )
m_StreamData->Release();
m_D3DDev->SetVertexShader(m_VertexShader);
if( m_VertexShader )
m_VertexShader->Release();
// texture
m_D3DDev->SetTexture(0, m_Tex);
if( m_Tex )
m_Tex->Release();
m_D3DDev->SetPixelShader(m_PixelShader);
if( m_PixelShader )
m_PixelShader->Release();
// texture stage states
m_D3DDev->SetTextureStageState(0, D3DTSS_COLOROP, m_ColorOp);
m_D3DDev->SetTextureStageState(0, D3DTSS_COLORARG1, m_ColorArg1);
m_D3DDev->SetTextureStageState(0, D3DTSS_COLORARG2, m_ColorArg2);
m_D3DDev->SetTextureStageState(0, D3DTSS_ALPHAOP, m_AlphaOp);
m_D3DDev->SetTextureStageState(0, D3DTSS_ALPHAARG1, m_AlphaArg1);
m_D3DDev->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, m_TexCoordIndex);
m_D3DDev->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, m_TexTransfFlags);
m_D3DDev->SetSamplerState(0, D3DSAMP_ADDRESSU, m_AddressU);
m_D3DDev->SetSamplerState(0, D3DSAMP_ADDRESSV, m_AddressV);
m_D3DDev->SetSamplerState(0, D3DSAMP_MAGFILTER, m_MagFilter);
m_D3DDev->SetSamplerState(0, D3DSAMP_MINFILTER, m_MinFilter);
m_D3DDev->SetSamplerState(0, D3DSAMP_MIPFILTER, m_MipFilter);
}
void Close()
{
if(effect)
effect->Release();
effect=null;
if(ps)
ps->Release();
ps=null;
if(vb)
vb->Release();
vb=null;
}
void CCampathDrawer::OnPostRenderAllTools()
{
// Actually we are often called twice per frame due to an engine bug(?), once after 3d skybox
// and once after world is drawn, maybe we will be even called more times,
// but we can not care about that for now.
if(!m_Draw)
return;
if(!m_VertexShader)
{
m_VertexShader = g_AfxShaders.GetVertexShader("afx_line_vs20.fxo");
}
IDirect3DVertexShader9 * vertexShader = m_VertexShader->GetVertexShader();
if(!m_PixelShader)
{
m_PixelShader = g_AfxShaders.GetPixelShader("afx_line_ps20.fxo");
}
IDirect3DPixelShader9 * pixelShader = m_PixelShader->GetPixelShader();
if(!(m_Device && vertexShader && m_PixelShader && g_VEngineClient))
{
static bool firstError = true;
if(firstError)
{
firstError = false;
Tier0_Msg(
"AFXERROR: CCampathDrawer::OnEndScene: Missing required dependencies:%s%s%s%s.\n",
!m_Device ? " m_Device" : "",
!vertexShader ? " vertexShader" : "",
!pixelShader ? " pixelShader" : "",
!g_VEngineClient ? " g_VEngineClient" : ""
);
}
return;
}
// Save device state:
IDirect3DPixelShader9 * oldPixelShader = 0;
m_Device->GetPixelShader(&oldPixelShader);
if(oldPixelShader) oldPixelShader->AddRef();
IDirect3DVertexShader9 * oldVertexShader = 0;
m_Device->GetVertexShader(&oldVertexShader);
if(oldVertexShader) oldVertexShader->AddRef();
IDirect3DVertexBuffer9 * oldVertexBuffer = 0;
UINT oldVertexBufferOffset;
UINT oldVertexBufferStride;
m_Device->GetStreamSource(0, &oldVertexBuffer, &oldVertexBufferOffset, &oldVertexBufferStride);
// this is done already according to doc: // if(oldVertexBuffer) oldVertexBuffer->AddRef();
IDirect3DIndexBuffer9 * oldIndexBuffer = 0;
m_Device->GetIndices(&oldIndexBuffer);
// this is done already according to doc: // if(oldIndexBuffer) oldIndexBuffer->AddRef();
IDirect3DVertexDeclaration9 * oldDeclaration;
m_Device->GetVertexDeclaration(&oldDeclaration);
if(oldDeclaration) oldDeclaration->AddRef();
DWORD oldFVF;
m_Device->GetFVF(&oldFVF);
FLOAT oldCViewProj[4][4];
m_Device->GetVertexShaderConstantF(8, oldCViewProj[0], 4);
FLOAT oldCScreenInfo[4];
m_Device->GetVertexShaderConstantF(48, oldCScreenInfo, 1);
FLOAT oldCPlane0[4];
m_Device->GetVertexShaderConstantF(49, oldCPlane0, 1);
FLOAT oldCPlaneN[4];
m_Device->GetVertexShaderConstantF(50, oldCPlaneN, 1);
DWORD oldSrgbWriteEnable;
m_Device->GetRenderState(D3DRS_SRGBWRITEENABLE, &oldSrgbWriteEnable);
DWORD oldColorWriteEnable;
m_Device->GetRenderState(D3DRS_COLORWRITEENABLE, &oldColorWriteEnable);
DWORD oldZEnable;
m_Device->GetRenderState(D3DRS_ZENABLE, &oldZEnable);
DWORD oldZWriteEnable;
m_Device->GetRenderState(D3DRS_ZWRITEENABLE, &oldZWriteEnable);
DWORD oldZFunc;
m_Device->GetRenderState(D3DRS_ZFUNC, &oldZFunc);
DWORD oldAlphaTestEnable;
m_Device->GetRenderState(D3DRS_ALPHATESTENABLE, &oldAlphaTestEnable);
DWORD oldSeparateAlphaBlendEnable;
m_Device->GetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, &oldSeparateAlphaBlendEnable);
DWORD oldAlphaBlendEnable;
m_Device->GetRenderState(D3DRS_ALPHABLENDENABLE, &oldAlphaBlendEnable);
DWORD oldBlendOp;
m_Device->GetRenderState(D3DRS_BLENDOP, &oldBlendOp);
DWORD oldSrcBlend;
m_Device->GetRenderState(D3DRS_SRCBLEND, &oldSrcBlend);
DWORD oldDestBlend;
m_Device->GetRenderState(D3DRS_DESTBLEND, &oldDestBlend);
DWORD oldCullMode;
m_Device->GetRenderState(D3DRS_CULLMODE, &oldCullMode);
// Draw:
{
//Vector3 vvForward, vvUp, vvRight, vvPos;
double curTime = g_Hook_VClient_RenderView.GetCurTime();
bool inCampath = 1 <= g_Hook_VClient_RenderView.m_CamPath.GetSize()
&& g_Hook_VClient_RenderView.m_CamPath.GetLowerBound() <= curTime
&& curTime <= g_Hook_VClient_RenderView.m_CamPath.GetUpperBound();
bool campathCanEval = g_Hook_VClient_RenderView.m_CamPath.CanEval();
bool campathEnabled = g_Hook_VClient_RenderView.m_CamPath.Enabled_get();
bool cameraMightBeSelected = false;
m_Device->SetRenderState(D3DRS_SRGBWRITEENABLE, FALSE);
m_Device->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_ALPHA|D3DCOLORWRITEENABLE_BLUE|D3DCOLORWRITEENABLE_GREEN|D3DCOLORWRITEENABLE_RED);
m_Device->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
m_Device->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
m_Device->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL);
m_Device->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
m_Device->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, FALSE);
m_Device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
m_Device->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
m_Device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
m_Device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
m_Device->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
m_Device->SetVertexShader(vertexShader);
m_WorldToScreenMatrix = g_VEngineClient->WorldToScreenMatrix();
m_Device->SetVertexShaderConstantF(8, m_WorldToScreenMatrix.m[0], 4);
// Provide view plane info for line clipping:
{
double plane0[4]={0,0,0,1};
double planeN[4]={1,0,0,1};
//double planeR[4]={0,-1,0,1};
//double planeU[4]={0,0,1,1};
unsigned char P[4];
unsigned char Q[4];
double L[4][4];
double U[4][4];
double M[4][4] = {
m_WorldToScreenMatrix.m[0][0], m_WorldToScreenMatrix.m[0][1], m_WorldToScreenMatrix.m[0][2], 0,
m_WorldToScreenMatrix.m[1][0], m_WorldToScreenMatrix.m[1][1], m_WorldToScreenMatrix.m[1][2], 0,
m_WorldToScreenMatrix.m[2][0], m_WorldToScreenMatrix.m[2][1], m_WorldToScreenMatrix.m[2][2], 0,
m_WorldToScreenMatrix.m[3][0], m_WorldToScreenMatrix.m[3][1], m_WorldToScreenMatrix.m[3][2], -1,
};
double b0[4] = {
0 -m_WorldToScreenMatrix.m[0][3],
0 -m_WorldToScreenMatrix.m[1][3],
0 -m_WorldToScreenMatrix.m[2][3],
-m_WorldToScreenMatrix.m[3][3],
};
double bN[4] = {
0 -m_WorldToScreenMatrix.m[0][3],
0 -m_WorldToScreenMatrix.m[1][3],
1 -m_WorldToScreenMatrix.m[2][3],
-m_WorldToScreenMatrix.m[3][3],
};
/*
double bR[4] = {
1 -m_WorldToScreenMatrix.m[0][3],
0 -m_WorldToScreenMatrix.m[1][3],
0 -m_WorldToScreenMatrix.m[2][3],
-m_WorldToScreenMatrix.m[3][3],
};
double bU[4] = {
0 -m_WorldToScreenMatrix.m[0][3],
1 -m_WorldToScreenMatrix.m[1][3],
0 -m_WorldToScreenMatrix.m[2][3],
-m_WorldToScreenMatrix.m[3][3],
};
*/
if(!LUdecomposition(M, P, Q, L, U))
{
Tier0_Warning("AFXERROR in CCampathDrawer::OnPostRenderAllTools: LUdecomposition failed\n");
}
else
{
SolveWithLU(L, U, P, Q, b0, plane0);
SolveWithLU(L, U, P, Q, bN, planeN);
//SolveWithLU(L, U, P, Q, bR, planeR);
//SolveWithLU(L, U, P, Q, bU, planeU);
}
/*
vvPos = Vector3(plane0[0], plane0[1], plane0[2]);
vvForward = Vector3(planeN[0] -vvPos.X, planeN[1] -vvPos.Y, planeN[2]-vvPos.Z);
vvForward.Normalize();
vvRight = Vector3(planeR[0] -vvPos.X, planeR[1] -vvPos.Y, planeR[2]-vvPos.Z);
vvRight.Normalize();
vvUp = Vector3(planeU[0] -vvPos.X, planeU[1] -vvPos.Y, planeU[2]-vvPos.Z);
vvUp.Normalize();
*/
/*
Tier0_Msg("CCampathDrawer::OnPostRenderAllTools: curTime = %f\n",curTime);
Tier0_Msg("M[0]=%f %f %f %f\nM[1]=%f %f %f %f\nM[2]=%f %f %f %f\nM[3]=%f %f %f %f\n", M[0][0],M[0][1],M[0][2],M[0][3], M[1][0],M[1][1],M[1][2],M[1][3], M[2][0],M[2][1],M[2][2],M[2][3], M[3][0],M[3][1],M[3][2],M[3][3]);
Tier0_Msg("b0[0]=%f %f %f %f\n", b0[0], b0[1], b0[2], b0[3]);
Tier0_Msg("bN[0]=%f %f %f %f\n", bN[0], bN[1], bN[2], bN[3]);
Tier0_Msg("plane0=%f %f %f %f\n", plane0[0], plane0[1], plane0[2], plane0[3]);
Tier0_Msg("planeN=%f %f %f %f\n", planeN[0], planeN[1], planeN[2], planeN[3]);
*/
FLOAT vPlane0[4] = {(float)plane0[0], (float)plane0[1], (float)plane0[2], 0.0f};
Vector3 planeNormal(planeN[0] -plane0[0], planeN[1] -plane0[1], planeN[2] -plane0[2]);
planeNormal.Normalize();
FLOAT vPlaneN[4] = {(float)planeNormal.X, (float)planeNormal.Y, (float)planeNormal.Z, 0.0f};
m_Device->SetVertexShaderConstantF(49, vPlane0, 1);
m_Device->SetVertexShaderConstantF(50, vPlaneN, 1);
}
m_Device->SetPixelShader(pixelShader);
m_Device->SetFVF(CCampathDrawer_VertexFVF);
int screenWidth, screenHeight;
g_VEngineClient->GetScreenSize(screenWidth, screenHeight);
FLOAT newCScreenInfo[4] = { 0 != screenWidth ? 1.0f / screenWidth : 0.0f, 0 != screenHeight ? 1.0f / screenHeight : 0.0f, 0.0, 0.0f};
// Draw trajectory:
if(2 <= g_Hook_VClient_RenderView.m_CamPath.GetSize() && campathCanEval)
{
if(m_RebuildDrawing)
{
// Rebuild trajectory points.
// This operation can be quite expensive (up to O(N^2)),
// so it should be done only when s.th.
// changed (which is what we do here).
m_TrajectoryPoints.clear();
CamPathIterator last = g_Hook_VClient_RenderView.m_CamPath.GetBegin();
CamPathIterator it = last;
TempPoint * pts = new TempPoint[c_CameraTrajectoryMaxPointsPerInterval];
for(++it; it != g_Hook_VClient_RenderView.m_CamPath.GetEnd(); ++it)
{
double delta = it.GetTime() -last.GetTime();
for(size_t i = 0; i<c_CameraTrajectoryMaxPointsPerInterval; i++)
{
double t = last.GetTime() + delta*((double)i/(c_CameraTrajectoryMaxPointsPerInterval-1));
CamPathValue cpv = g_Hook_VClient_RenderView.m_CamPath.Eval(t);
pts[i].t = t;
pts[i].y = Vector3(cpv.X, cpv.Y, cpv.Z);
pts[i].nextPt = i+1 <c_CameraTrajectoryMaxPointsPerInterval ? &(pts[i+1]) : 0;
}
RamerDouglasPeucker(&(pts[0]), &(pts[c_CameraTrajectoryMaxPointsPerInterval-1]), c_CameraTrajectoryEpsilon);
// add all points except the last one (to avoid duplicates):
for(TempPoint * pt = &(pts[0]); pt && pt->nextPt; pt = pt->nextPt)
{
m_TrajectoryPoints.push_back(pt->t);
}
last = it;
}
// add last point:
m_TrajectoryPoints.push_back(pts[c_CameraTrajectoryMaxPointsPerInterval-1].t);
delete pts;
m_RebuildDrawing = false;
}
newCScreenInfo[2] = c_CameraTrajectoryPixelWidth;
m_Device->SetVertexShaderConstantF(48, newCScreenInfo, 1);
AutoPolyLineStart();
std::list<double>::iterator itPts = m_TrajectoryPoints.begin();
CamPathIterator itKeysLast = g_Hook_VClient_RenderView.m_CamPath.GetBegin();
CamPathIterator itKeysNext = itKeysLast;
++itKeysNext;
bool hasLastPt = false;
bool hasNextPt = false;
bool hasCurPt = false;
double lastPtTime;
CamPathValue lastPtValue;
double curPtTime;
CamPathValue curPtValue;
double nextPtTime;
CamPathValue nextPtValue;
do
{
if(hasNextPt)
{
hasLastPt = true;
lastPtTime = curPtTime;
lastPtValue = curPtValue;
hasCurPt = true;
curPtTime = nextPtTime;
curPtValue = nextPtValue;
hasNextPt = false;
}
else
{
hasCurPt = true;
curPtTime = *itPts;
curPtValue = g_Hook_VClient_RenderView.m_CamPath.Eval(curPtTime);
++itPts;
}
while(itKeysNext.GetTime() < curPtTime)
{
itKeysLast = itKeysNext;
++itKeysNext;
}
if(itPts != m_TrajectoryPoints.end())
{
hasNextPt = true;
nextPtTime = *itPts;
nextPtValue = g_Hook_VClient_RenderView.m_CamPath.Eval(nextPtTime);
++itPts;
}
else
{
// current point is last point.
hasNextPt = false;
nextPtValue = curPtValue;
}
if(!hasLastPt)
{
// current point is first point.
lastPtValue = curPtValue;
}
// emit current point:
{
double deltaTime = abs(curTime -curPtTime);
DWORD colour;
// determine colour:
if(deltaTime < 1.0)
{
double t = (deltaTime -0.0)/1.0;
colour = D3DCOLOR_RGBA(
ValToUCCondInv(255.0*t, curPtValue.Selected),
ValToUCCondInv(255, curPtValue.Selected),
ValToUCCondInv(0, curPtValue.Selected),
(unsigned char)(127*(1.0-t))+128
);
}
else
if(deltaTime < 2.0)
{
double t = (deltaTime -1.0)/1.0;
colour = D3DCOLOR_RGBA(
ValToUCCondInv(255, curPtValue.Selected),
ValToUCCondInv(255.0*(1.0-t), curPtValue.Selected),
ValToUCCondInv(0, curPtValue.Selected),
(unsigned char)(64*(1.0-t))+64
);
}
else
{
colour = D3DCOLOR_RGBA(
ValToUCCondInv(255, curPtValue.Selected),
ValToUCCondInv(0, curPtValue.Selected),
ValToUCCondInv(0, curPtValue.Selected),
64
);
}
AutoPolyLinePoint(
Vector3(lastPtValue.X,lastPtValue.Y,lastPtValue.Z)
, Vector3(curPtValue.X,curPtValue.Y,curPtValue.Z)
, colour
, Vector3(nextPtValue.X,nextPtValue.Y,nextPtValue.Z));
}
}
while(hasNextPt);
AutoPolyLineFlush();
}
// Draw keyframes:
{
newCScreenInfo[2] = c_CampathCrossPixelWidth;
m_Device->SetVertexShaderConstantF(48, newCScreenInfo, 1);
bool lpSelected = false;
double lpTime;
/*if(0 < g_Hook_VClient_RenderView.m_CamPath.GetSize())
{
// Test for not too unlikely hard case:
CamPathValue cpv = g_Hook_VClient_RenderView.m_CamPath.GetBegin().GetValue();
Vector3 current(cpv.X+76, cpv.Y+76, cpv.Z+76);
Vector3 previous(current.X+76, current.Y-1*4, current.Z);
Vector3 next(current.X+76, current.Y+1*4, current.Z);
Vector3 next2(current.X, current.Y+2*4, current.Z);
Vector3 next3(current.X+76, current.Y+3*4, current.Z);
Vector3 next4(current.X, current.Y+4*4, current.Z);
Vector3 next5(current.X+76, current.Y+5*4, current.Z);
AutoPolyLineStart();
AutoPolyLinePoint(previous, previous, D3DCOLOR_RGBA(255,0,0,255), current);
AutoPolyLinePoint(previous, current, D3DCOLOR_RGBA(255,0,0,255), next);
AutoPolyLinePoint(current, next, D3DCOLOR_RGBA(255,0,0,255), next2);
AutoPolyLinePoint(next, next2, D3DCOLOR_RGBA(255,0,0,255), next3);
AutoPolyLinePoint(next2, next3, D3DCOLOR_RGBA(255,0,0,255), next4);
AutoPolyLinePoint(next3, next4, D3DCOLOR_RGBA(255,0,0,255), next5);
AutoPolyLinePoint(next4, next5, D3DCOLOR_RGBA(255,0,0,255), next5);
AutoPolyLineFlush();
}*/
/*if(0 < g_Hook_VClient_RenderView.m_CamPath.GetSize())
{
CamPathValue cpv = g_Hook_VClient_RenderView.m_CamPath.GetBegin().GetValue();
float x = cpv.X * m_WorldToScreenMatrix.m[0][0] + cpv.Y * m_WorldToScreenMatrix.m[0][1] + cpv.Z * m_WorldToScreenMatrix.m[0][2] +m_WorldToScreenMatrix.m[0][3];
float y = cpv.X * m_WorldToScreenMatrix.m[1][0] + cpv.Y * m_WorldToScreenMatrix.m[1][1] + cpv.Z * m_WorldToScreenMatrix.m[1][2] +m_WorldToScreenMatrix.m[1][3];
float z = cpv.X * m_WorldToScreenMatrix.m[2][0] + cpv.Y * m_WorldToScreenMatrix.m[2][1] + cpv.Z * m_WorldToScreenMatrix.m[2][2] +m_WorldToScreenMatrix.m[2][3];
float w = cpv.X * m_WorldToScreenMatrix.m[3][0] + cpv.Y * m_WorldToScreenMatrix.m[3][1] + cpv.Z * m_WorldToScreenMatrix.m[3][2] +m_WorldToScreenMatrix.m[3][3];
float iw = w ? 1/w : 0;
Tier0_Msg("pt: %f %f %f %f -> %f %f %f %f\n",x,y,z,w,x*iw,y*iw,z*iw,w*iw);
}*/
for(CamPathIterator it = g_Hook_VClient_RenderView.m_CamPath.GetBegin(); it != g_Hook_VClient_RenderView.m_CamPath.GetEnd(); ++it)
{
double cpT = it.GetTime();
CamPathValue cpv = it.GetValue();
cameraMightBeSelected = cameraMightBeSelected || lpSelected && cpv.Selected && lpTime <= curTime && curTime <= cpT;
lpSelected = cpv.Selected;
lpTime = cpT;
double deltaTime = abs(curTime -cpT);
bool selected = cpv.Selected;
DWORD colour;
// determine colour:
if(deltaTime < 1.0)
{
double t = (deltaTime -0.0)/1.0;
colour = D3DCOLOR_RGBA(
ValToUCCondInv(255.0*t, selected),
ValToUCCondInv(255, selected),
ValToUCCondInv(0, selected),
(unsigned char)(127*(1.0-t))+128
);
}
else
if(deltaTime < 2.0)
{
double t = (deltaTime -1.0)/1.0;
colour = D3DCOLOR_RGBA(
ValToUCCondInv(255, selected),
ValToUCCondInv(255.0*(1.0-t), selected),
ValToUCCondInv(0, selected),
(unsigned char)(64*(1.0-t))+64
);
}
else
{
colour = D3DCOLOR_RGBA(
ValToUCCondInv(255, selected),
ValToUCCondInv(0, selected),
ValToUCCondInv(0, selected),
64
);
}
// x / forward line:
AutoSingleLine(
Vector3(cpv.X -c_CampathCrossRadius, cpv.Y, cpv.Z),
colour,
Vector3(cpv.X +c_CampathCrossRadius, cpv.Y, cpv.Z),
colour
);
// y / left line:
AutoSingleLine(
Vector3(cpv.X, cpv.Y -c_CampathCrossRadius, cpv.Z),
colour,
Vector3(cpv.X, cpv.Y +c_CampathCrossRadius, cpv.Z),
colour
);
// z / up line:
AutoSingleLine(
Vector3(cpv.X, cpv.Y, cpv.Z -c_CampathCrossRadius),
colour,
Vector3(cpv.X, cpv.Y, cpv.Z +c_CampathCrossRadius),
colour
);
}
AutoSingleLineFlush();
}
// Draw wireframe camera:
if(inCampath && campathCanEval)
{
newCScreenInfo[2] = c_CameraPixelWidth;
m_Device->SetVertexShaderConstantF(48, newCScreenInfo, 1);
DWORD colourCam = campathEnabled
? D3DCOLOR_RGBA(
ValToUCCondInv(255,cameraMightBeSelected),
ValToUCCondInv(0,cameraMightBeSelected),
ValToUCCondInv(255,cameraMightBeSelected),
128)
: D3DCOLOR_RGBA(
ValToUCCondInv(255,cameraMightBeSelected),
ValToUCCondInv(255,cameraMightBeSelected),
ValToUCCondInv(255,cameraMightBeSelected),
128);
DWORD colourCamUp = campathEnabled
? D3DCOLOR_RGBA(
ValToUCCondInv(0,cameraMightBeSelected),
ValToUCCondInv(255,cameraMightBeSelected),
ValToUCCondInv(0,cameraMightBeSelected),
128)
: D3DCOLOR_RGBA(
ValToUCCondInv(0,cameraMightBeSelected),
ValToUCCondInv(0,cameraMightBeSelected),
ValToUCCondInv(0,cameraMightBeSelected),
128);
CamPathValue cpv = g_Hook_VClient_RenderView.m_CamPath.Eval(curTime);
// limit to values as RenderView hook:
cpv.Fov = max(1,cpv.Fov);
cpv.Fov = min(179,cpv.Fov);
double forward[3], right[3], up[3];
QEulerAngles ang = cpv.R.ToQREulerAngles().ToQEulerAngles();
MakeVectors(ang.Roll, ang.Pitch, ang.Yaw, forward, right, up);
Vector3 vCp(cpv.X, cpv.Y, cpv.Z);
Vector3 vForward(forward);
Vector3 vUp(up);
Vector3 vRight(right);
//Tier0_Msg("----------------",curTime);
//Tier0_Msg("currenTime = %f",curTime);
//Tier0_Msg("vCp = %f %f %f\n", vCp.X, vCp.Y, vCp.Z);
double a = sin(cpv.Fov * M_PI / 360.0) * c_CameraRadius;
double b = a;
int screenWidth, screenHeight;
g_VEngineClient->GetScreenSize(screenWidth, screenHeight);
double aspectRatio = screenWidth ? (double)screenHeight / (double)screenWidth : 1.0;
b *= aspectRatio;
Vector3 vLU = vCp +(double)c_CameraRadius * vForward -a * vRight +b * vUp;
Vector3 vRU = vCp +(double)c_CameraRadius * vForward +a * vRight +b * vUp;
Vector3 vLD = vCp +(double)c_CameraRadius * vForward -a * vRight -b * vUp;
Vector3 vRD = vCp +(double)c_CameraRadius * vForward +a * vRight -b * vUp;
Vector3 vMU = vLU +(vRU -vLU)/2;
Vector3 vMUU = vMU +(double)c_CameraRadius * vUp;
AutoSingleLine(vCp, colourCam, vLD, colourCam);
AutoSingleLine(vCp, colourCam, vRD, colourCam);
AutoSingleLine(vCp, colourCam, vLU, colourCam);
AutoSingleLine(vCp, colourCam, vRU, colourCam);
AutoSingleLine(vLD, colourCam, vRD, colourCam);
AutoSingleLine(vRD, colourCam, vRU, colourCam);
AutoSingleLine(vRU, colourCam, vLU, colourCam);
AutoSingleLine(vLU, colourCam, vLD, colourCam);
AutoSingleLine(vMU, colourCam, vMUU, colourCamUp);
AutoSingleLineFlush();
//
/*
colourCam = D3DCOLOR_RGBA(255, 0, 0, 255);
colourCamUp = D3DCOLOR_RGBA(255, 255, 0, 255);
vCp = vvPos;
vForward = vvForward;
vUp = vvUp;
vRight = vvRight;
//Tier0_Msg("vCp2 = %f %f %f\n", vCp.X, vCp.Y, vCp.Z);
vLU = vCp +(double)c_CameraRadius * vForward -a * vRight +b * vUp;
vRU = vCp +(double)c_CameraRadius * vForward +a * vRight +b * vUp;
vLD = vCp +(double)c_CameraRadius * vForward -a * vRight -b * vUp;
vRD = vCp +(double)c_CameraRadius * vForward +a * vRight -b * vUp;
vMU = vLU +(vRU -vLU)/2;
vMUU = vMU +(double)c_CameraRadius * vUp;
AutoSingleLine(vCp, colourCam, vLD, colourCam);
AutoSingleLine(vCp, colourCam, vRD, colourCam);
AutoSingleLine(vCp, colourCam, vLU, colourCam);
AutoSingleLine(vCp, colourCam, vRU, colourCam);
AutoSingleLine(vLD, colourCam, vRD, colourCam);
AutoSingleLine(vRD, colourCam, vRU, colourCam);
AutoSingleLine(vRU, colourCam, vLU, colourCam);
AutoSingleLine(vLU, colourCam, vLD, colourCam);
AutoSingleLine(vMU, colourCam, vMUU, colourCamUp);
AutoSingleLineFlush();
*/
}
}
// Restore device state:
m_Device->SetPixelShader(oldPixelShader);
if(oldPixelShader) oldPixelShader->Release();
m_Device->SetVertexShader(oldVertexShader);
if(oldVertexShader) oldVertexShader->Release();
m_Device->SetStreamSource(0, oldVertexBuffer, oldVertexBufferOffset, oldVertexBufferStride);
if(oldVertexBuffer) oldVertexBuffer->Release();
m_Device->SetIndices(oldIndexBuffer);
if(oldIndexBuffer) oldIndexBuffer->Release();
m_Device->SetFVF(oldFVF);
m_Device->SetVertexDeclaration(oldDeclaration);
if(oldDeclaration) oldDeclaration->Release();
m_Device->SetVertexShaderConstantF(8, oldCViewProj[0], 4);
m_Device->SetVertexShaderConstantF(48, oldCScreenInfo, 1);
m_Device->SetVertexShaderConstantF(49, oldCPlane0, 1);
m_Device->SetVertexShaderConstantF(50, oldCPlaneN, 1);
m_Device->SetRenderState(D3DRS_CULLMODE, oldCullMode);
m_Device->SetRenderState(D3DRS_DESTBLEND, oldDestBlend);
m_Device->SetRenderState(D3DRS_SRCBLEND, oldSrcBlend);
m_Device->SetRenderState(D3DRS_BLENDOP, oldBlendOp);
m_Device->SetRenderState(D3DRS_ALPHABLENDENABLE, oldAlphaBlendEnable);
m_Device->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, oldSeparateAlphaBlendEnable);
m_Device->SetRenderState(D3DRS_ALPHATESTENABLE, oldAlphaTestEnable);
m_Device->SetRenderState(D3DRS_ZFUNC, oldZFunc);
m_Device->SetRenderState(D3DRS_ZWRITEENABLE, oldZWriteEnable);
m_Device->SetRenderState(D3DRS_ZENABLE, oldZEnable);
m_Device->SetRenderState(D3DRS_COLORWRITEENABLE, oldColorWriteEnable);
m_Device->SetRenderState(D3DRS_SRGBWRITEENABLE, oldSrgbWriteEnable);
}