void CFlashRender::Render()
{
CGraphic* pGraphic = CGraphic::GetInst();
pGraphic->ClearStack();
CMainWindowTarget::GetInst()->Clear();
if(m_pText)
{
VerText2D* pVB;
RenderState* pRS;
CMatrix* Matrix = pGraphic->GetRenderStack( RS_GUI, m_pText, NULL, PT_TRIANGLESTRIP,
4, 2, VerText2D::Format, sizeof(VerText2D), (void**)&pVB, NULL, (void**)&pRS );
pRS->m_Cull = 1;
pRS->m_AlphaBlendEnable = m_bAlphaBlend;
pRS->m_AlphaTestEnable = m_bAlphaTest;
pRS->m_ZTestEnable = FALSE;
Matrix->Identity();
pVB[0].x = m_fOffX; pVB[0].y = m_fOffY; pVB[0].z = 1.0f;
pVB[1].x = float(m_Width)+ m_fOffX; pVB[1].y = m_fOffY; pVB[1].z = 1.0f;
pVB[2].x = m_fOffX; pVB[2].y = float(m_Height) + m_fOffY; pVB[2].z = 1.0f;
pVB[3].x = float(m_Width)+ m_fOffX; pVB[3].y = float(m_Height) + m_fOffY; pVB[3].z = 1.0f;
pVB[0].w = 1.0; pVB[0].tu = 0.0; pVB[0].tv = 0.0;
pVB[1].w = 1.0; pVB[1].tu = 1.0; pVB[1].tv = 0.0;
pVB[2].w = 1.0; pVB[2].tu = 0.0; pVB[2].tv = 1.0;
pVB[3].w = 1.0; pVB[3].tu = 1.0; pVB[3].tv = 1.0;
if(m_bShowRect)
{
VerColor2D* pVBRenct;
RenderState* pLRS;
Matrix = pGraphic->GetRenderStack( RS_GUI, NULL, NULL, PT_TRIANGLESTRIP,
4, 2, VerColor2D::Format, sizeof(VerColor2D), (void**)&pVBRenct, NULL, (void**)&pLRS );
Matrix->Identity();
pLRS->m_Cull = 1;
pLRS->m_AlpOP_S1 = TOP_SELECTARG1;
pLRS->m_AlpArg1_S1 = TA_DIFFUSE;
pLRS->m_TexOP_S1 = TOP_BLENDDIFFUSEALPHA;
pLRS->m_TexArg1_S1 = TA_CURRENT;
pLRS->m_TexArg2_S1 = TA_DIFFUSE;
pLRS->m_AlphaBlendEnable = TRUE;
pLRS->m_AlphaTestEnable = FALSE;
pLRS->m_ZTestEnable = FALSE;
pVBRenct[0].x = m_fOffX + m_fRect.left; pVBRenct[0].y = m_fOffY + m_fRect.top; pVBRenct[0].z = 1.0f;
pVBRenct[1].x = m_fOffX + m_fRect.right; pVBRenct[1].y = m_fOffY + m_fRect.top; pVBRenct[1].z = 1.0f;
pVBRenct[2].x = m_fOffX + m_fRect.left; pVBRenct[2].y = m_fOffY + m_fRect.bottom; pVBRenct[2].z = 1.0f;
pVBRenct[3].x = m_fOffX + m_fRect.right; pVBRenct[3].y = m_fOffY + m_fRect.bottom; pVBRenct[3].z = 1.0f;
pVBRenct[0].w = 1.0f;
pVBRenct[1].w = 1.0f;
pVBRenct[2].w = 1.0f;
pVBRenct[3].w = 1.0f;
pVBRenct[0].diffuse = pVBRenct[1].diffuse = pVBRenct[2].diffuse = pVBRenct[3].diffuse = 0x800000FF;
}
}
}
void CEditDirctionLine::Render() const
{
if( m_vEnd.x == m_vStart.x )
return;
size_t PointNum = 2 + m_nWeight * 4 + 4;
VerColor3D* pVB;
RenderState* pRS;
CMatrix* pMatrix = CGraphic::GetInst()->GetRenderStack( RS_DEFAULT, NULL, NULL, PT_LINELIST,
PointNum, PointNum/2, VerColor3D::Format, sizeof(VerColor3D),
(void**)&pVB, NULL, (void**)&pRS );
pRS->m_LightEnable = FALSE;
pMatrix->Identity();
pVB[0].p = m_vStart;
pVB[1].p = m_vEnd;
pVB[0].diffuse = pVB[1].diffuse = m_dwColor;
int startIndex = 0;
for ( int m = 1; m <= m_nWeight; ++m )
{
CVector3f temp = CVector3f(0.0f, 0.0f, m * fStep);
pVB[startIndex].p = m_vStart + temp;
pVB[startIndex].diffuse = m_dwColor;
++startIndex;
pVB[startIndex].p = m_vEnd + temp;
pVB[startIndex].diffuse = m_dwColor;
++startIndex;
temp = CVector3f(0.0f, 0.0f, -m * fStep);
pVB[startIndex].p = m_vStart + temp;
pVB[startIndex].diffuse = m_dwColor;
++startIndex;
pVB[startIndex].p = m_vEnd + temp;
pVB[startIndex].diffuse = m_dwColor;
++startIndex;
}
pVB[startIndex].p = m_vStart;
pVB[startIndex+1].p = m_vEnd;
pVB[startIndex].diffuse = pVB[startIndex+1].diffuse = m_dwColor;
pVB[startIndex+2].p = m_vEnd;
pVB[startIndex+2].diffuse = m_dwColor;
pVB[startIndex+3].p = m_vEnd + CVector3f(-8.0f, 5.0f, 2.0f);
pVB[startIndex+3].diffuse = m_dwColor;
pVB[startIndex+4].p = m_vEnd;
pVB[startIndex+4].diffuse = m_dwColor;
pVB[startIndex+5].p = m_vEnd + CVector3f(-8.0f, -5.0f, 2.0f);
pVB[startIndex+5].diffuse = m_dwColor;
pMatrix->Identity();
}
void CFrameBufferObject::DrawTexture( CDrawContext * pDrawContext ) {
CMatrix< float > mat;
mat.Identity();
mat.Translate( 0.0f, m_Height, 0.0f );
DrawTexture( pDrawContext, &mat );
}
void CGraphic::Draw3DPlane(ITexture* pTexture, CVector3f *vec3d, DWORD Color, ERenderStyle RS, CVector2f *tex_uv)
{
if ( pTexture )
{
VerColorTex vs[4] =
{
VerColorTex( vec3d[0].x, vec3d[0].y, vec3d[0].z, Color, tex_uv[0].x, tex_uv[0].y),
VerColorTex( vec3d[1].x, vec3d[1].y, vec3d[1].z, Color, tex_uv[1].x, tex_uv[1].y),
VerColorTex( vec3d[2].x, vec3d[2].y, vec3d[2].z, Color, tex_uv[2].x, tex_uv[2].y),
VerColorTex( vec3d[3].x, vec3d[3].y, vec3d[3].z, Color, tex_uv[3].x, tex_uv[3].y),
};
VerColorTex* pVB;
RenderState * pRS;
CMatrix view;
CCamera *pCamera = m_pActiveTarget->GetCamera();
CMatrix matBillboard;
view = pCamera->getViewMatrix();
matBillboard.Identity();
matBillboard._11 = view._11;
matBillboard._12 = view._12;
matBillboard._13 = view._13;
matBillboard._21 = view._21;
matBillboard._22 = view._22;
matBillboard._23 = view._23;
matBillboard._31 = view._31;
matBillboard._32 = view._32;
matBillboard._33 = view._33;
matBillboard.Invert();
CMatrix *m_Mat = GetRenderStack( RS, pTexture, NULL, PT_TRIANGLESTRIP, 4, 2,
VerColorTex::Format , sizeof(VerColorTex), (void**)&pVB, NULL, (void**)&pRS );
m_Mat->Identity();
m_Mat->_11 = matBillboard._11;
m_Mat->_12 = matBillboard._12;
m_Mat->_13 = matBillboard._13;
m_Mat->_21 = matBillboard._21;
m_Mat->_22 = matBillboard._22;
m_Mat->_23 = matBillboard._23;
m_Mat->_31 = matBillboard._31;
m_Mat->_32 = matBillboard._32;
m_Mat->_33 = matBillboard._33;
m_Mat->_41 = vec3d[4].x;
m_Mat->_42 = vec3d[4].y;
m_Mat->_43 = vec3d[4].z;
pRS->m_TexOP_S0 = TOP_SELECTARG1;
pRS->m_TexArg1_S0 = TA_TEXTURE;
memcpy(pVB,vs,sizeof(vs));
}
}
void CEditEllipse::Render() const
{
size_t PointNum = m_spherePoints.size();
if( PointNum == 0 )
return;
VerColor3D* pVB;
RenderState* pRS;
CMatrix* pMatrix = CGraphic::GetInst()->GetRenderStack( RS_DEFAULT, NULL, NULL, PT_LINESTRIP,
PointNum, PointNum/2, VerColor3D::Format, sizeof(VerColor3D),
(void**)&pVB, NULL, (void**)&pRS );
pRS->m_LightEnable = FALSE;
pMatrix->Identity();
for ( size_t m = 0; m < PointNum; ++m )
{
pVB[m].p = m_spherePoints[m];
pVB[m].diffuse = m_dwColor;
}
pMatrix->Identity();
}
bool CPingPong::Draw(CRenderD3D* render)
{
LPDIRECT3DDEVICE8 d3dDevice = render->GetDevice();
D3DXMATRIX mProjection;
D3DXMatrixPerspectiveFovLH( &mProjection, DEGTORAD( 60.0f ), (f32)render->m_Width / (f32)render->m_Height, 0.1f, 2000.0f );
d3dDevice->SetTransform( D3DTS_PROJECTION, &mProjection );
// Fill in the vertex buffers with the quads
TRenderVertex* vert = NULL;
m_VertexBuffer->Lock( 0, 0, (BYTE**)&vert, 0);
vert = AddQuad(vert, m_Ball.m_Pos, m_Ball.m_Size, m_Ball.m_Col.RenderColor());
vert = AddQuad(vert, m_Paddle[0].m_Pos, m_Paddle[0].m_Size, m_Paddle[0].m_Col.RenderColor());
vert = AddQuad(vert, m_Paddle[1].m_Pos, m_Paddle[1].m_Size, m_Paddle[1].m_Col.RenderColor());
m_VertexBuffer->Unlock();
d3dSetRenderState(D3DRS_ZENABLE, FALSE);
d3dSetRenderState(D3DRS_LIGHTING, FALSE);
d3dSetRenderState(D3DRS_COLORVERTEX,TRUE);
d3dSetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID );
d3dSetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
d3dSetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
d3dSetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
d3dSetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
d3dSetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
d3dSetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
d3dDevice->SetTexture( 0, NULL );
d3dDevice->SetStreamSource( 0, m_VertexBuffer, sizeof(TRenderVertex) );
d3dDevice->SetVertexShader( TRenderVertex::FVF_Flags );
CMatrix m;
m.Identity();
d3dDevice->SetTransform(D3DTS_VIEW, (D3DXMATRIX*)&m);
m._43 = 70.0f;
d3dDevice->SetTransform(D3DTS_WORLD, (D3DXMATRIX*)&m);
for (int pnr=0; pnr<NUMQUADS; pnr++)
{
d3dDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, pnr*4, 2 );
}
return true;
}
void CEditDashed::Render() const
{
if( m_vEnd.x == m_vStart.x )
return;
VerColor3D* pVB;
RenderState* pRS;
float fDisX = m_vEnd.x - m_vStart.x;
int nStep = (int)(fabs(fDisX) / m_fDashedStep);
float tg = (m_vEnd.z - m_vStart.z) / (m_vEnd.x - m_vStart.x);
vector<CVector3f> points;
for ( int m = 0;m < nStep; )
{
CVector3f temp = m_vStart;
temp.x += m * m_fDashedStep;
temp.z = m_vStart.z + m * m_fDashedStep * tg;
points.push_back(temp);
temp.x += m_fDashedStep;
temp.z = m_vStart.z + (temp.x - m_vStart.x) * tg;
points.push_back(temp);
m += 2;
}
if( points.empty() )
return;
size_t PointNum = points.size();
size_t noWeightPointNum = PointNum;;
size_t startIndex = PointNum;
PointNum = PointNum + m_nWeight * PointNum * 2;
CMatrix* pMatrix = CGraphic::GetInst()->GetRenderStack( RS_DEFAULT, NULL, NULL, PT_LINELIST,
PointNum, PointNum/2, VerColor3D::Format, sizeof(VerColor3D),
(void**)&pVB, NULL, (void**)&pRS );
pRS->m_LightEnable = FALSE;
pMatrix->Identity();
for ( size_t m = 0; m < noWeightPointNum; ++m )
{
pVB[m].p = points[m];
pVB[m].diffuse = m_dwColor;
}
for ( int m = 1; m <= m_nWeight; ++m )
{
CVector3f ptemp = CVector3f(0.0f, 0.0f, m * fWeigthSetp);
CVector3f ntemp = CVector3f(0.0f, 0.0f, -m * fWeigthSetp);
for ( size_t m = 0; m < noWeightPointNum; )
{
CVector3f start = pVB[m].p;
CVector3f end = pVB[m+1].p;
pVB[startIndex].p = start + ptemp;
pVB[startIndex].diffuse = m_dwColor;
points.push_back(pVB[startIndex].p);
++startIndex;
pVB[startIndex].p = end + ptemp;
pVB[startIndex].diffuse = m_dwColor;
points.push_back(pVB[startIndex].p);
++startIndex;
pVB[startIndex].p = start + ntemp;
pVB[startIndex].diffuse = m_dwColor;
points.push_back(pVB[startIndex].p);
++startIndex;
pVB[startIndex].p = end + ntemp;
pVB[startIndex].diffuse = m_dwColor;
points.push_back(pVB[startIndex].p);
++startIndex;
m += 2;
}
}
size_t size = points.size();
Ast(size==PointNum);
}
