//----------------------------------------------------------------------------
void PdrVertexFormat::Disable (Renderer* renderer)
{
IDirect3DDevice9* device = renderer->mData->mDevice;
PX2_UNUSED(device);
HRESULT hr;
PX2_UNUSED(hr);
#ifdef PX2_PDR_DEBUG
IDirect3DVertexDeclaration9* activeDeclaration = 0;
hr = device->GetVertexDeclaration(&activeDeclaration);
assertion(hr == D3D_OK, "Failed to get vertex declaration: %s\n",
DXGetErrorString(hr));
assertion(activeDeclaration == mDeclaration,
"Mismatched vertex declarations\n");
activeDeclaration->Release();
#endif
hr = device->SetVertexDeclaration(0);
assertion(hr == D3D_OK, "Failed to set vertex declaration: %s\n",
DXGetErrorString(hr));
}
GLenum Dx9BackEnd::setupAttributesPreDraw(const TranslatedAttribute *attributes)
{
HRESULT hr;
D3DVERTEXELEMENT9 elements[MAX_VERTEX_ATTRIBS+1];
D3DVERTEXELEMENT9 *nextElement = &elements[0];
for (BYTE i = 0; i < MAX_VERTEX_ATTRIBS; i++)
{
if (attributes[i].enabled)
{
nextElement->Stream = i + 1; // Stream 0 is skipped because D3D does not permit it to be an instanced stream.
nextElement->Offset = 0;
nextElement->Type = static_cast<BYTE>(mapAttributeType(attributes[i].type, attributes[i].size, attributes[i].normalized));
nextElement->Method = D3DDECLMETHOD_DEFAULT;
nextElement->Usage = D3DDECLUSAGE_TEXCOORD;
nextElement->UsageIndex = attributes[i].semanticIndex;
nextElement++;
}
}
static const D3DVERTEXELEMENT9 end = D3DDECL_END();
*nextElement = end;
IDirect3DVertexDeclaration9* vertexDeclaration;
hr = mDevice->CreateVertexDeclaration(elements, &vertexDeclaration);
mDevice->SetVertexDeclaration(vertexDeclaration);
vertexDeclaration->Release();
mDevice->SetStreamSource(0, NULL, 0, 0);
bool nonArrayAttributes = false;
for (size_t i = 0; i < MAX_VERTEX_ATTRIBS; i++)
{
if (attributes[i].enabled)
{
if (attributes[i].nonArray) nonArrayAttributes = true;
mDevice->SetStreamSource(i + 1, getDxBuffer(attributes[i].buffer), attributes[i].offset, attributes[i].stride);
if (!mAppliedAttribEnabled[i])
{
mAppliedAttribEnabled[i] = true;
}
}
else
{
if (mAppliedAttribEnabled[i])
{
mDevice->SetStreamSource(i + 1, 0, 0, 0);
mAppliedAttribEnabled[i] = false;
}
}
}
if (mUseInstancingForStrideZero)
{
// When there are no stride zero attributes, we disable instancing so that DrawPrimitive can be used.
if (nonArrayAttributes)
{
if (mStreamFrequency[0] != STREAM_FREQUENCY_INDEXED)
{
mStreamFrequency[0] = STREAM_FREQUENCY_INDEXED;
mDevice->SetStreamSourceFreq(0, D3DSTREAMSOURCE_INDEXEDDATA | 1);
}
for (size_t i = 0; i < MAX_VERTEX_ATTRIBS; i++)
{
if (attributes[i].enabled)
{
if (attributes[i].nonArray)
{
if (mStreamFrequency[i+1] != STREAM_FREQUENCY_INSTANCED)
{
mStreamFrequency[i+1] = STREAM_FREQUENCY_INSTANCED;
mDevice->SetStreamSourceFreq(i + 1, D3DSTREAMSOURCE_INSTANCEDATA | 1);
}
}
else
{
if (mStreamFrequency[i+1] != STREAM_FREQUENCY_INDEXED)
{
mStreamFrequency[i+1] = STREAM_FREQUENCY_INDEXED;
mDevice->SetStreamSourceFreq(i + 1, D3DSTREAMSOURCE_INDEXEDDATA | 1);
}
}
}
}
}
else
{
for (size_t i = 0; i < MAX_VERTEX_ATTRIBS + 1; i++)
{
if (mStreamFrequency[i] != STREAM_FREQUENCY_UNINSTANCED)
{
mStreamFrequency[i] = STREAM_FREQUENCY_UNINSTANCED;
// This should not be needed, but otherwise there is a buggy driver that will leave instancing
// enabled for the first draw after it has been turned off.
mDevice->SetStreamSourceFreq(i, D3DSTREAMSOURCE_INDEXEDDATA | 1);
mDevice->SetStreamSourceFreq(i, 1);
}
}
}
}
return GL_NO_ERROR;
}
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);
}
void MFVertex_DestroyVertexDeclarationPlatformSpecific(MFVertexDeclaration *pDeclaration)
{
IDirect3DVertexDeclaration9 *pDecl = (IDirect3DVertexDeclaration9*)pDeclaration->pPlatformData;
pDecl->Release();
}
bool Engine::init(int width, int height, HINSTANCE hInstance)
{
WNDCLASSEX wc = {sizeof(WNDCLASSEX), CS_CLASSDC, ::WindowProc, 0, 0, hInstance, 0, 0, 0, 0, "CG Task3", 0};
if (0 == RegisterClassEx(&wc))
{
return false;
}
m_window = CreateWindow("CG Task3", "CG Task3: Cylinder", (WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX), 0, 0, width, height, GetDesktopWindow(), 0, hInstance, 0);
if(NULL == m_window)
{
return false;
}
m_d3d = Direct3DCreate9(D3D_SDK_VERSION);
if(!m_d3d)
{
return false;
}
D3DPRESENT_PARAMETERS d3dpp = {0};
d3dpp.Windowed = TRUE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
d3dpp.EnableAutoDepthStencil = TRUE;
d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
HRESULT hr = m_d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_window,
D3DCREATE_HARDWARE_VERTEXPROCESSING, &d3dpp, &m_d3dDevice);
if(FAILED(hr) || !m_d3dDevice)
{
return false;
}
m_d3dDevice->SetRenderState(D3DRS_AMBIENT, AMBIENT_COLOR);
m_d3dDevice->SetRenderState(D3DRS_LIGHTING, false);
m_d3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
m_d3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
m_d3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
m_d3dDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
//m_d3dDevice->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
D3DVERTEXELEMENT9 vertexDeclaration[] = {
{0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
{0, 3 * sizeof(float), D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
D3DDECL_END()};
IDirect3DVertexDeclaration9 *decl;
if(FAILED(m_d3dDevice->CreateVertexDeclaration(vertexDeclaration, &decl)))
{
return false;
}
if(FAILED(m_d3dDevice->SetVertexDeclaration(decl)))
{
return false;
}
decl->Release();
Vertex *vertices;
uint16_t *indices;
generateCylinder(CYLINDER_STACKS, CYLINDER_SLICES, CYLINDER_RADIUS, CYLINDER_HEIGHT, 0x80000000, true, &indices, &vertices, m_indexCount, m_vertexCount);
if((0 == vertices) || (0 == indices))
{
return false;
}
if(FAILED(m_d3dDevice->CreateVertexBuffer(m_vertexCount * sizeof(Vertex), D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, &m_vertexBuffer, 0)))
{
return false;
}
void *vertexPointer;
if(FAILED(m_vertexBuffer->Lock(0, m_vertexCount * sizeof(Vertex), (void**)&vertexPointer, 0)))
{
return false;
}
memcpy(vertexPointer, vertices, m_vertexCount * sizeof(Vertex));
if(FAILED(m_vertexBuffer->Unlock()))
{
return false;
}
if(FAILED(m_d3dDevice->CreateIndexBuffer(m_indexCount * sizeof(uint16_t), D3DUSAGE_WRITEONLY, D3DFMT_INDEX16, D3DPOOL_DEFAULT, &m_indexBuffer, 0)))
{
return false;
}
void *indexPointer;
if(FAILED(m_indexBuffer->Lock(0, m_indexCount * sizeof(uint16_t), (void**)&indexPointer, 0)))
{
return false;
}
memcpy(indexPointer, indices, m_indexCount * sizeof(uint16_t));
if(FAILED(m_indexBuffer->Unlock()))
{
return false;
}
#include "shader.h"
if (FAILED(m_d3dDevice->CreateVertexShader(g_vs11_main, &m_shader)))
{
return false;
}
m_mainCamera.setDirection(DEFAULT_CAMERA_LOOK, DEFAULT_CAMERA_UP);
D3DXVECTOR3 look = m_mainCamera.look();
m_mainCamera.setPosition(*D3DXVec3Scale(&look, &look, -m_radius));
D3DXMatrixIdentity(&m_worldMatrix);
resize(width, height);
m_bones = new D3DXMATRIX[2];
D3DXMatrixIdentity(&m_bones[0]);
D3DXMatrixIdentity(&m_bones[1]);
D3DXMatrixTranspose(&m_bones[0], &m_bones[0]);
D3DXMatrixTranspose(&m_bones[1], &m_bones[1]);
m_d3dDevice->SetVertexShader(m_shader);
if(FAILED(m_d3dDevice->SetVertexShaderConstantF(4, &(m_bones[0].m[0][0]), 4)))
{
return false;
}
if(FAILED(m_d3dDevice->SetVertexShaderConstantF(8, &(m_bones[1].m[0][0]), 4)))
{
return false;
}
float sizeConst[4];
sizeConst[0] = 1 / CYLINDER_HEIGHT;
if(FAILED(m_d3dDevice->SetVertexShaderConstantF(12, sizeConst, 1)))
{
return false;
}
updateMatrices();
return true;
}
