void MatrixBuildPerspective( VMatrix &dst, float fovX, float fovY, float zNear, float zFar )
{
// FIXME: collapse all of this into one matrix after we figure out what all should be in here.
float width = 2 * zNear * tan( fovX * ( M_PI/180.0f ) * 0.5f );
float height = 2 * zNear * tan( fovY * ( M_PI/180.0f ) * 0.5f );
memset( dst.Base(), 0, sizeof( dst ) );
dst[0][0] = 2.0F * zNear / width;
dst[1][1] = 2.0F * zNear / height;
dst[2][2] = -zFar / ( zNear - zFar );
dst[3][2] = 1.0f;
dst[2][3] = zNear * zFar / ( zNear - zFar );
// negate X and Y so that X points right, and Y points up.
VMatrix negateXY;
negateXY.Identity();
negateXY[0][0] = -1.0f;
negateXY[1][1] = -1.0f;
MatrixMultiply( negateXY, dst, dst );
VMatrix addW;
addW.Identity();
addW[0][3] = 1.0f;
addW[1][3] = 1.0f;
addW[2][3] = 0.0f;
MatrixMultiply( addW, dst, dst );
VMatrix scaleHalf;
scaleHalf.Identity();
scaleHalf[0][0] = 0.5f;
scaleHalf[1][1] = 0.5f;
MatrixMultiply( scaleHalf, dst, dst );
}
//-----------------------------------------------------------------------------
// Purpose: Generates a view matrix based on our current yaw, pitch, and roll.
// The view matrix does not consider FOV or clip plane distances.
//-----------------------------------------------------------------------------
void CCamera::BuildViewMatrix()
{
// The camera transformation is produced by multiplying roll * yaw * pitch.
// This will transform a point from world space into quake camera space,
// which is exactly what we want for our view matrix. However, quake
// camera space isn't the same as material system camera space, so
// we're going to have to apply a transformation that goes from quake
// camera space to material system camera space.
CameraIdentityMatrix( m_ViewMatrix );
RotateAroundAxis(m_ViewMatrix, m_fPitch, 0 );
RotateAroundAxis(m_ViewMatrix, m_fRoll, 1);
RotateAroundAxis(m_ViewMatrix, m_fYaw, 2);
// Translate the viewpoint to the world origin.
VMatrix TempMatrix;
TempMatrix.Identity();
TempMatrix.SetTranslation( -m_ViewPoint );
m_ViewMatrix = m_ViewMatrix * TempMatrix;
m_ViewProjMatrix = m_ProjMatrix * m_ViewMatrix;
m_ViewProjMatrix.InverseGeneral( m_InvViewProjMatrix );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFArrowPanel::Paint()
{
if ( !m_hEntity.Get() )
return;
C_BaseEntity *pEnt = m_hEntity.Get();
IMaterial *pMaterial = m_NeutralMaterial;
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
// figure out what material we need to use
if ( pEnt->GetTeamNumber() == TF_TEAM_RED )
{
pMaterial = m_RedMaterial;
if ( pLocalPlayer && ( pLocalPlayer->GetObserverMode() == OBS_MODE_IN_EYE ) )
{
// is our target a player?
C_BaseEntity *pTargetEnt = pLocalPlayer->GetObserverTarget();
if ( pTargetEnt && pTargetEnt->IsPlayer() )
{
// does our target have the flag and are they carrying the flag we're currently drawing?
C_TFPlayer *pTarget = static_cast< C_TFPlayer* >( pTargetEnt );
if ( pTarget->HasTheFlag() && ( pTarget->GetItem() == pEnt ) )
{
pMaterial = m_RedMaterialNoArrow;
}
}
}
}
else if ( pEnt->GetTeamNumber() == TF_TEAM_BLUE )
{
pMaterial = m_BlueMaterial;
if ( pLocalPlayer && ( pLocalPlayer->GetObserverMode() == OBS_MODE_IN_EYE ) )
{
// is our target a player?
C_BaseEntity *pTargetEnt = pLocalPlayer->GetObserverTarget();
if ( pTargetEnt && pTargetEnt->IsPlayer() )
{
// does our target have the flag and are they carrying the flag we're currently drawing?
C_TFPlayer *pTarget = static_cast< C_TFPlayer* >( pTargetEnt );
if ( pTarget->HasTheFlag() && ( pTarget->GetItem() == pEnt ) )
{
pMaterial = m_BlueMaterialNoArrow;
}
}
}
}
else if (pEnt->GetTeamNumber() == TF_TEAM_GREEN)
{
pMaterial = m_GreenMaterial;
if (pLocalPlayer && (pLocalPlayer->GetObserverMode() == OBS_MODE_IN_EYE))
{
// is our target a player?
C_BaseEntity *pTargetEnt = pLocalPlayer->GetObserverTarget();
if (pTargetEnt && pTargetEnt->IsPlayer())
{
// does our target have the flag and are they carrying the flag we're currently drawing?
C_TFPlayer *pTarget = static_cast< C_TFPlayer* >(pTargetEnt);
if (pTarget->HasTheFlag() && (pTarget->GetItem() == pEnt))
{
pMaterial = m_GreenMaterialNoArrow;
}
}
}
}
else if (pEnt->GetTeamNumber() == TF_TEAM_YELLOW)
{
pMaterial = m_YellowMaterial;
if (pLocalPlayer && (pLocalPlayer->GetObserverMode() == OBS_MODE_IN_EYE))
{
// is our target a player?
C_BaseEntity *pTargetEnt = pLocalPlayer->GetObserverTarget();
if (pTargetEnt && pTargetEnt->IsPlayer())
{
// does our target have the flag and are they carrying the flag we're currently drawing?
C_TFPlayer *pTarget = static_cast< C_TFPlayer* >(pTargetEnt);
if (pTarget->HasTheFlag() && (pTarget->GetItem() == pEnt))
{
pMaterial = m_YellowMaterialNoArrow;
}
}
}
}
int x = 0;
int y = 0;
ipanel()->GetAbsPos( GetVPanel(), x, y );
int nWidth = GetWide();
int nHeight = GetTall();
CMatRenderContextPtr pRenderContext( materials );
pRenderContext->MatrixMode( MATERIAL_MODEL );
pRenderContext->PushMatrix();
VMatrix panelRotation;
panelRotation.Identity();
MatrixBuildRotationAboutAxis( panelRotation, Vector( 0, 0, 1 ), GetAngleRotation() );
// MatrixRotate( panelRotation, Vector( 1, 0, 0 ), 5 );
panelRotation.SetTranslation( Vector( x + nWidth/2, y + nHeight/2, 0 ) );
pRenderContext->LoadMatrix( panelRotation );
IMesh *pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, pMaterial );
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
meshBuilder.TexCoord2f( 0, 0, 0 );
meshBuilder.Position3f( -nWidth/2, -nHeight/2, 0 );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.TexCoord2f( 0, 1, 0 );
meshBuilder.Position3f( nWidth/2, -nHeight/2, 0 );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.TexCoord2f( 0, 1, 1 );
meshBuilder.Position3f( nWidth/2, nHeight/2, 0 );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.TexCoord2f( 0, 0, 1 );
meshBuilder.Position3f( -nWidth/2, nHeight/2, 0 );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
pRenderContext->PopMatrix();
}
void EmitClipPortalGeometry( node_t *pHeadNode, portal_t *pPortal, int iSrcArea, dareaportal_t *dp )
{
// Build a list of all the points in portals from the same original face.
CUtlVector<portal_t*> portals;
FindPortalsLeadingToArea_R(
pHeadNode,
iSrcArea,
dp->otherarea,
&pPortal->plane,
portals );
CUtlVector<Vector> points;
for( int iPortal=0; iPortal < portals.Size(); iPortal++ )
{
portal_t *pPointPortal = portals[iPortal];
winding_t *pWinding = pPointPortal->winding;
for( int i=0; i < pWinding->numpoints; i++ )
{
points.AddToTail( pWinding->p[i] );
}
}
// Get the 2D convex hull.
//// First transform them into a plane.
QAngle vAngles;
Vector vecs[3];
VectorAngles( pPortal->plane.normal, vAngles );
AngleVectors( vAngles, &vecs[0], &vecs[1], &vecs[2] );
VMatrix mTransform;
mTransform.Identity();
mTransform.SetBasisVectors( vecs[0], vecs[1], vecs[2] );
VMatrix mInvTransform = mTransform.Transpose();
int i;
CUtlVector<Vector2D> points2D;
for( i=0; i < points.Size(); i++ )
{
Vector vTest = mTransform * points[i];
points2D.AddToTail( Vector2D( vTest.y, vTest.z ) );
}
// Build the hull.
int indices[512];
int nIndices = Convex2D( points2D.Base(), points2D.Size(), indices, 512 );
// Output the hull.
dp->m_FirstClipPortalVert = g_nClipPortalVerts;
dp->m_nClipPortalVerts = nIndices;
if ( nIndices >= 32 )
{
Warning( "Warning: area portal has %d verts. Could be a vbsp bug.\n", nIndices );
}
if( dp->m_FirstClipPortalVert + dp->m_nClipPortalVerts >= MAX_MAP_PORTALVERTS )
{
Vector *p = pPortal->winding->p;
Error( "MAX_MAP_PORTALVERTS (probably a broken areaportal near %.1f %.1f %.1f ", p->x, p->y, p->z );
}
for( i=0; i < nIndices; i++ )
{
g_ClipPortalVerts[g_nClipPortalVerts] = points[ indices[i] ];
++g_nClipPortalVerts;
}
}
//ConMsg("Angle = %f\n", angle);
pRenderContext->Rotate(angle, 0.0f, 0.0f, 1.0f);
//VMatrix rotationMatrix2 = SetupMatrixAngles(view->GetViewSetup()->angles);
//pRenderContext->MultMatrix(rotationMatrix2);
//VMatrix rotationMatrix = rotationMatrix2.InverseTR(); //SetupMatrixAngles(-(view->GetViewSetup()->angles));
rotationMatrix = SetupMatrixAxisRot(Vector(0.0f, 0.0f, 1.0f), -angle);
invRotationMatrix = SetupMatrixAxisRot(Vector(0.0f, 0.0f, 1.0f), angle);
Vector eye = view->GetViewSetup()->origin;
transformedEye = (eye-center)*(1.0f/m_flRadius);
transformedEye = rotationMatrix.ApplyRotation(transformedEye);
}
else
{
rotationMatrix.Identity();
invRotationMatrix.Identity();
transformedEye.Init();
angle = 0.0f;
}
if(sv_surface_use_tiler.GetBool())
{
tiler->beginFrame(Point3D(0.0f, 0.0f, 0.0f), (void*)&pRenderContext, !(sv_surface_draw_margin.GetBool()));
}
else
{
sweepRenderer->beginFrame(!(sv_surface_draw_margin.GetBool()), (void*)&pRenderContext);
sweepRenderer->setOffset(Point3D(0.0f, 0.0f, 0.0f));
//sweepRenderer->beginTile();
}
