//-----------------------------------------------------------------------------
// paint it!
//-----------------------------------------------------------------------------
void CMaterialViewPanel::Paint()
{
// Draw a background (translucent objects will appear that way)
// FIXME: Draw the outline of this panel?
if (!m_pMaterial)
return;
g_pMatSystemSurface->Begin3DPaint( 0, 0, m_iViewableWidth, m_iViewableHeight );
g_pMaterialSystem->MatrixMode( MATERIAL_PROJECTION );
g_pMaterialSystem->LoadIdentity();
g_pMaterialSystem->Scale( 1, -1, 1 );
g_pMaterialSystem->Ortho( 0, 0, m_iViewableWidth, m_iViewableHeight, 0, 1 );
g_pMaterialSystem->Bind( m_pMaterial );
IMesh *pMesh = g_pMaterialSystem->GetDynamicMesh();
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
if (!m_bUseActualSize)
{
DrawStretchedToPanel( meshBuilder );
}
else
{
DrawActualSize( meshBuilder );
}
meshBuilder.End();
pMesh->Draw();
g_pMatSystemSurface->End3DPaint( );
}
void DrawFastSphere( CMeshBuilder &meshBuilder, const Vector ¢er, float radius, int r, int g, int b )
{
int i;
int offset = meshBuilder.GetCurrentVertex();
Vector pos;
for (i = 0; i < 51; i++)
{
pos.x = g_FastSpherePosData[i][0] + center.x + g_FastSpherePosData[i][5] * radius;
pos.y = g_FastSpherePosData[i][1] + center.y + g_FastSpherePosData[i][6] * radius;
pos.z = g_FastSpherePosData[i][2] + center.z + g_FastSpherePosData[i][7] * radius;
meshBuilder.Position3fv( pos.Base() );
meshBuilder.Normal3fv( &g_FastSpherePosData[i][5] );
meshBuilder.TexCoord2fv( 0, &g_FastSpherePosData[i][3] );
meshBuilder.Color3ub( 255, 255, 255 );
meshBuilder.AdvanceVertex();
}
for (i = 0; i < 84; i++)
{
meshBuilder.FastIndex( g_FastSphereTriData[i][0] + offset );
meshBuilder.FastIndex( g_FastSphereTriData[i][1] + offset );
meshBuilder.FastIndex( g_FastSphereTriData[i][2] + offset );
}
}
//-----------------------------------------------------------------------------
// Purpose: Renders the connecting lines between the keyframes
// Input : pRender -
//-----------------------------------------------------------------------------
void CMapKeyFrame::Render3D( CRender3D *pRender )
{
if ( m_bRebuildPath )
{
if (GetAnimator() != NULL)
{
GetAnimator()->RebuildPath();
}
}
// only draw if we have a valid connection
if ( m_pNextKeyFrame && m_flSpeed > 0 )
{
// only draw if we haven't already been drawn this frame
if ( GetRenderFrame() != pRender->GetRenderFrame() )
{
pRender->PushRenderMode( RENDER_MODE_WIREFRAME );
SetRenderFrame( pRender->GetRenderFrame() );
Vector o1, o2;
GetOrigin( o1 );
m_pNextKeyFrame->GetOrigin( o2 );
CMeshBuilder meshBuilder;
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
IMesh *pMesh = pRenderContext->GetDynamicMesh();
// draw connecting line going from green to red
meshBuilder.Begin( pMesh, MATERIAL_LINE_STRIP, MAX_LINE_POINTS );
// start point
meshBuilder.Color3f( 0, 1.0f, 0 );
meshBuilder.Position3f( o1[0], o1[1], o1[2] );
meshBuilder.AdvanceVertex();
for ( int i = 0; i < MAX_LINE_POINTS; i++ )
{
float red = (float)(i+1) / (float)MAX_LINE_POINTS;
meshBuilder.Color3f( red, 1.0f - red, 0 );
meshBuilder.Position3f( m_LinePoints[i][0], m_LinePoints[i][1], m_LinePoints[i][2] );
meshBuilder.AdvanceVertex();
}
meshBuilder.End();
pMesh->Draw();
pRender->PopRenderMode();
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pRender -
//-----------------------------------------------------------------------------
void CMapLine::Render3D(CRender3D *pRender)
{
if ( (m_pStartEntity == NULL) || (m_pEndEntity == NULL) )
return;
pRender->BeginRenderHitTarget(this);
pRender->PushRenderMode(RENDER_MODE_WIREFRAME);
Vector Start, End;
m_pStartEntity->GetOrigin(Start);
m_pEndEntity->GetOrigin(End);
CMeshBuilder meshBuilder;
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
IMesh* pMesh = pRenderContext->GetDynamicMesh();
// FIXME: Can't do this...! glLineWidth(2);
meshBuilder.Begin( pMesh, MATERIAL_LINES, 1 );
unsigned char color[3];
if (IsSelected())
{
color[0] = SELECT_EDGE_RED;
color[1] = SELECT_EDGE_GREEN;
color[2] = SELECT_EDGE_BLUE;
}
else
{
color[0] = r;
color[1] = g;
color[2] = b;
}
meshBuilder.Color3ubv( color );
meshBuilder.Position3f(Start.x, Start.y, Start.z);
meshBuilder.AdvanceVertex();
meshBuilder.Color3ubv( color );
meshBuilder.Position3f(End.x, End.y, End.z);
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
pRender->EndRenderHitTarget();
pRender->PopRenderMode();
}
void R_DrawPortals()
{
// Draw the portals.
if( !r_DrawPortals.GetInt() )
return;
IMaterial *pMaterial = materialSystemInterface->FindMaterial( "debug\\debugportals", NULL );
IMesh *pMesh = materialSystemInterface->GetDynamicMesh( true, NULL, NULL, pMaterial );
brushdata_t *pBrush = &host_state.worldmodel->brush;
for( int i=0; i < pBrush->m_nAreaPortals; i++ )
{
dareaportal_t *pAreaPortal = &pBrush->m_pAreaPortals[i];
if( !R_IsAreaVisible( pAreaPortal->otherarea ) )
continue;
CMeshBuilder builder;
builder.Begin( pMesh, MATERIAL_LINES, pAreaPortal->m_nClipPortalVerts );
for( int j=0; j < pAreaPortal->m_nClipPortalVerts; j++ )
{
unsigned short iVert;
iVert = pAreaPortal->m_FirstClipPortalVert + j;
builder.Position3f( VectorExpand( pBrush->m_pClipPortalVerts[iVert] ) );
builder.Color4f( 0, 0, 0, 1 );
builder.AdvanceVertex();
iVert = pAreaPortal->m_FirstClipPortalVert + (j+1) % pAreaPortal->m_nClipPortalVerts;
builder.Position3f( VectorExpand( pBrush->m_pClipPortalVerts[iVert] ) );
builder.Color4f( 0, 0, 0, 1 );
builder.AdvanceVertex();
}
builder.End( false, true );
}
// Draw the clip rectangles.
for( i=0; i < g_PortalRects.Size(); i++ )
{
CPortalRect *pRect = &g_PortalRects[i];
R_DrawScreenRect( pRect->left, pRect->top, pRect->right, pRect->bottom );
}
g_PortalRects.Purge();
}
void CDispInfo::ApplyTerrainMod( ITerrainMod *pMod )
{
// New bbox.
Vector bbMin( 1e24, 1e24, 1e24 );
Vector bbMax( -1e24, -1e24, -1e24 );
int nVerts, nIndices;
CalcMaxNumVertsAndIndices( m_Power, &nVerts, &nIndices );
// Ok, it probably touches us. Lock our buffer and change the verts.
CMeshBuilder mb;
mb.BeginModify( m_pMesh->m_pMesh, m_iVertOffset, nVerts );
for( int iVert=0; iVert < nVerts; iVert++ )
{
if( m_AllowedVerts.Get( iVert ) )
{
Vector &vPos = m_Verts[iVert].m_vPos;
Vector &vOriginalPos = m_Verts[iVert].m_vOriginalPos;
if( pMod->ApplyMod( vPos, vOriginalPos ) )
mb.Position3f( VectorExpand( vPos ) );
VectorMin( vPos, bbMin, bbMin );
VectorMax( vPos, bbMax, bbMax );
}
mb.AdvanceVertex();
}
mb.EndModify();
// Set our new bounding box.
m_BBoxMin = bbMin;
m_BBoxMax = bbMax;
UpdateCenterAndRadius();
// Next time this displacement is seen, force it to rebuild and retesselate.
m_bForceRebuild = true;
}
int C_TestTraceline::DrawModel( int flags )
{
trace_t tr;
Vector forward, right, up, endpos, hitpos;
AngleVectors (GetAbsAngles(), &forward, &right, &up);
endpos = GetAbsOrigin() + forward * MAX_TRACE_LENGTH;
UTIL_TraceLine( GetAbsOrigin(), endpos, MASK_SOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &tr );
CMatRenderContextPtr pRenderContext( materials );
IMesh* pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, m_pWireframe );
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_LINES, 1 );
meshBuilder.Position3fv( GetAbsOrigin().Base() );
meshBuilder.Color3ub( 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( tr.endpos.Base() );
meshBuilder.Color3ub( 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
// Didn't hit anything
if ( tr.fraction != 1.0 )
{
unsigned char color[] = { 0, 255, 0 };
DrawCube( tr.endpos, color );
}
if ( (!tr.allsolid) && (tr.fractionleftsolid != 0.0) )
{
unsigned char color[] = { 255, 0, 0 };
DrawCube( tr.startpos, color );
}
return 1;
}
int CBulletManager::CBullet::DrawModel( int flags )
{
if (m_flCurrAlpha < 0)
return 0;
if (flags & STUDIO_SHADOWDEPTHTEXTURE)
return 0;
#ifdef __linux__
return 0;
#endif
if (!g_hBulletStreak.IsValid())
g_hBulletStreak.Init( "effects/tracer1.vmt", TEXTURE_GROUP_OTHER );
float flAlpha = 150.5f/255.0f * m_flCurrAlpha;
Vector vecRight = Vector(0, 0, 1).Cross(m_vecDirection).Normalized();
Vector vecCross1 = (Vector(0, 0, 1) + vecRight).Normalized();
Vector vecCross2 = (Vector(0, 0, 1) - vecRight).Normalized();
CMeshBuilder meshBuilder;
CMatRenderContextPtr pRenderContext( materials );
pRenderContext->Bind( g_hBulletStreak );
IMesh* pMesh = pRenderContext->GetDynamicMesh();
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
DrawCross(meshBuilder, GetRenderOrigin(), vecCross1, m_vecDirection, flAlpha);
DrawCross(meshBuilder, GetRenderOrigin(), vecCross2, m_vecDirection, flAlpha);
meshBuilder.End(false, true);
return 1;
}
//-----------------------------------------------------------------------------
// Purpose: Renders us in the 3D view.
// Input : pRender - Interface to use for rendering.
//-----------------------------------------------------------------------------
void CMapSideList::Render3D(CRender3D *pRender)
{
if (Parent->IsSelected())
{
//
// Draw lines from us to the center of all faces in the list.
//
pRender->SetRenderMode(RENDER_MODE_WIREFRAME);
CMeshBuilder meshBuilder;
IMesh *pMesh = MaterialSystemInterface()->GetDynamicMesh();
meshBuilder.Begin(pMesh, MATERIAL_LINES, m_Faces.Count());
for (int i = 0; i < m_Faces.Count(); i++)
{
CMapFace *pFace = m_Faces.Element(i);
Vector Center;
pFace->GetCenter(Center);
unsigned char color[3];
color[0] = SELECT_EDGE_RED;
color[1] = SELECT_EDGE_GREEN;
color[2] = SELECT_EDGE_BLUE;
meshBuilder.Color3ubv( color );
meshBuilder.Position3f(m_Origin.x, m_Origin.y, m_Origin.z);
meshBuilder.AdvanceVertex();
meshBuilder.Color3ubv( color );
meshBuilder.Position3f(Center.x, Center.y, Center.z);
meshBuilder.AdvanceVertex();
}
meshBuilder.End();
pMesh->Draw();
}
}
inline void CParticleEffectBinding::StartDrawMaterialParticles(
CEffectMaterial *pMaterial,
float flTimeDelta,
IMesh* &pMesh,
CMeshBuilder &builder,
ParticleDraw &particleDraw,
bool bWireframe )
{
// Setup the ParticleDraw and bind the material.
if( bWireframe )
{
IMaterial *pMaterial = m_pParticleMgr->m_pMaterialSystem->FindMaterial( "debug/debugparticlewireframe", TEXTURE_GROUP_OTHER );
m_pParticleMgr->m_pMaterialSystem->Bind( pMaterial, NULL );
}
else
{
m_pParticleMgr->m_pMaterialSystem->Bind( pMaterial->m_pGroup->m_pPageMaterial, m_pParticleMgr );
}
pMesh = m_pParticleMgr->m_pMaterialSystem->GetDynamicMesh( true );
builder.Begin( pMesh, MATERIAL_QUADS, NUM_PARTICLES_PER_BATCH * 4 );
particleDraw.Init( &builder, pMaterial->m_pGroup->m_pPageMaterial, flTimeDelta );
}
void R_DrawScreenRect( float left, float top, float right, float bottom )
{
float mat[16], proj[16];
materialSystemInterface->GetMatrix( MATERIAL_VIEW, mat );
materialSystemInterface->MatrixMode( MATERIAL_VIEW );
materialSystemInterface->LoadIdentity();
materialSystemInterface->GetMatrix( MATERIAL_PROJECTION, proj );
materialSystemInterface->MatrixMode( MATERIAL_PROJECTION );
materialSystemInterface->LoadIdentity();
IMaterial *pMaterial = materialSystemInterface->FindMaterial( "debug\\debugportals", NULL );
IMesh *pMesh = materialSystemInterface->GetDynamicMesh( true, NULL, NULL, pMaterial );
CMeshBuilder builder;
builder.Begin( pMesh, MATERIAL_LINE_LOOP, 4 );
Vector v1( left, bottom, 0.5 );
Vector v2( left, top, 0.5 );
Vector v3( right, top, 0.5 );
Vector v4( right, bottom, 0.5 );
builder.Position3fv( v1.Base() ); builder.AdvanceVertex();
builder.Position3fv( v2.Base() ); builder.AdvanceVertex();
builder.Position3fv( v3.Base() ); builder.AdvanceVertex();
builder.Position3fv( v4.Base() ); builder.AdvanceVertex();
builder.End( false, true );
materialSystemInterface->MatrixMode( MATERIAL_VIEW );
materialSystemInterface->LoadIdentity();
materialSystemInterface->MultMatrix( mat );
materialSystemInterface->MatrixMode( MATERIAL_PROJECTION );
materialSystemInterface->LoadIdentity();
materialSystemInterface->MultMatrix( proj );
}
//-----------------------------------------------------------------------------
// Debugging aid to display title safe areas.
// Title Safe critical insets are SD:32x24 or HD:64x48
//-----------------------------------------------------------------------------
static void OverlayTitleSafe()
{
IMaterial *pMaterial;
pMaterial = materials->FindMaterial( "vgui/white", TEXTURE_GROUP_OTHER, true );
int backBufferWidth, backBufferHeight;
materials->GetBackBufferDimensions( backBufferWidth, backBufferHeight );
CMatRenderContextPtr pRenderContext( materials );
pRenderContext->Bind( pMaterial );
IMesh* pMesh = pRenderContext->GetDynamicMesh( true );
CMeshBuilder meshBuilder;
// Required Title safe is TCR documented at inner 90% (RED)
int insetX = 0.05f * backBufferWidth;
int insetY = 0.05f * backBufferHeight;
meshBuilder.Begin( pMesh, MATERIAL_LINE_LOOP, 4 );
meshBuilder.Position3f( insetX, insetY, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.Color4f( 1, 0, 0, 1 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( backBufferWidth-insetX, insetY, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.Color4f( 1, 0, 0, 1 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( backBufferWidth-insetX, backBufferHeight-insetY, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.Color4f( 1, 0, 0, 1 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( insetX, backBufferHeight-insetY, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.Color4f( 1, 0, 0, 1 );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
// Suggested Title Safe is TCR documented at inner 85% (YELLOW)
insetX = 0.075f * backBufferWidth;
insetY = 0.075f * backBufferHeight;
meshBuilder.Begin( pMesh, MATERIAL_LINE_LOOP, 4 );
meshBuilder.Position3f( insetX, insetY, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.Color4f( 1, 1, 0, 1 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( backBufferWidth-insetX, insetY, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.Color4f( 1, 1, 0, 1 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( backBufferWidth-insetX, backBufferHeight-insetY, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.Color4f( 1, 1, 0, 1 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( insetX, backBufferHeight-insetY, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.Color4f( 1, 1, 0, 1 );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
}
static void DispInfo_DrawChainNormals( IDispInfo *pHead )
{
#ifndef SWDS
#ifdef _DEBUG
// Only do it in debug because we're only storing the info then
Vector p;
materialSystemInterface->Bind( g_pMaterialWireframeVertexColor );
for( IDispInfo *pCur=pHead; pCur; pCur = pCur->GetNextInRenderChain() )
{
CDispInfo *pDisp = static_cast<CDispInfo*>( pCur );
int nVerts = pDisp->NumVerts();
IMesh *pMesh = materialSystemInterface->GetDynamicMesh( );
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_LINES, nVerts * 3 );
for( int iVert=0; iVert < nVerts; iVert++ )
{
CDispRenderVert* pVert = pDisp->GetVertex(iVert);
meshBuilder.Position3fv( pVert->m_vPos.Base() );
meshBuilder.Color3ub( 255, 0, 0 );
meshBuilder.AdvanceVertex();
VectorMA( pVert->m_vPos, 5.0f, pVert->m_vNormal, p );
meshBuilder.Position3fv( p.Base() );
meshBuilder.Color3ub( 255, 0, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( pVert->m_vPos.Base() );
meshBuilder.Color3ub( 0, 255, 0 );
meshBuilder.AdvanceVertex();
VectorMA( pVert->m_vPos, 5.0f, pVert->m_vSVector, p );
meshBuilder.Position3fv( p.Base() );
meshBuilder.Color3ub( 0, 255, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( pVert->m_vPos.Base() );
meshBuilder.Color3ub( 0, 0, 255 );
meshBuilder.AdvanceVertex();
VectorMA( pVert->m_vPos, 5.0f, pVert->m_vTVector, p );
meshBuilder.Position3fv( p.Base() );
meshBuilder.Color3ub( 0, 0, 255 );
meshBuilder.AdvanceVertex();
}
meshBuilder.End();
pMesh->Draw();
}
#endif
#endif
}
//-----------------------------------------------------------------------------
// a pass to set the z buffer...
//-----------------------------------------------------------------------------
void C_VGuiScreen::DrawScreenOverlay()
{
materials->MatrixMode( MATERIAL_MODEL );
materials->PushMatrix();
materials->LoadMatrix( m_PanelToWorld );
unsigned char pColor[4] = {255, 255, 255, 255};
CMeshBuilder meshBuilder;
IMesh *pMesh = materials->GetDynamicMesh( true, NULL, NULL, m_OverlayMaterial );
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
meshBuilder.Position3f( 0.0f, 0.0f, 0 );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.Color4ubv( pColor );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( m_flWidth, 0.0f, 0 );
meshBuilder.TexCoord2f( 0, 1.0f, 0.0f );
meshBuilder.Color4ubv( pColor );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( m_flWidth, -m_flHeight, 0 );
meshBuilder.TexCoord2f( 0, 1.0f, 1.0f );
meshBuilder.Color4ubv( pColor );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( 0.0f, -m_flHeight, 0 );
meshBuilder.TexCoord2f( 0, 0.0f, 1.0f );
meshBuilder.Color4ubv( pColor );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
materials->PopMatrix();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CControlPointIconCapArrow::Paint( void )
{
if ( !m_pArrowMaterial || !m_pAttachedToIcon )
return;
int x = 0;
int y = 0;
ipanel()->GetAbsPos(GetVPanel(), x,y );
int iWidth = GetWide();
int iHeight = GetTall();
// Position the arrow based on the cap percentage
float flXa = 0;
float flXb = 1.0;
float flYa = 0;
float flYb = 1.0;
int iCappingTeam = ObjectiveResource()->GetCappingTeam( m_pAttachedToIcon->GetCapIndex() );
float flCapPercentage = ObjectiveResource()->GetCPCapPercentage( m_pAttachedToIcon->GetCapIndex() );
// The image needs to be remapped to the width of the underlying box,
// because we want the arrow head to move off the box at the exact time the cap ends.
float flArrowHeadPixelWidth = 15.0;
float flArrowBodyPixelWidth = 54.0;
float flBoxSize = 33.0;
// HACK: The arrow has an arrowhead portion that looks like this: >
// We want to start with the arrow entering the image, but we want to keep
// going until the arrow is fully off the edge. So we include extra width for it.
float flImageSize = (flArrowHeadPixelWidth+flArrowBodyPixelWidth);
float flMovementInTextureSpace = ( (flBoxSize+flArrowHeadPixelWidth) / flImageSize );
float flArrowSizeInTextureSpace = ( flArrowHeadPixelWidth / flImageSize );
// To help players spot the start & end of a cap, we indent a little on either side.
float flIndent = 0.07;
if ( m_pAttachedToIcon->ShouldSwipeUp() )
{
flYa = RemapVal( flCapPercentage, 0.0, 1.0, -flMovementInTextureSpace - flIndent, flArrowSizeInTextureSpace - flIndent );
flYb = RemapVal( flCapPercentage, 0.0, 1.0, flIndent, flMovementInTextureSpace - flIndent );
}
else
{
flIndent = 0.1;
float flStart = 1.0 - flIndent;
float flEnd = 1.0 + flIndent;
bool bSwipeLeftToRight = ( iCappingTeam % 2 ) ? false : true;
if ( bSwipeLeftToRight )
{
flXa = RemapVal( flCapPercentage, 0.0, 1.0, flStart + flMovementInTextureSpace, flEnd - flArrowSizeInTextureSpace );
flXb = RemapVal( flCapPercentage, 0.0, 1.0, flStart, 0.0 );
}
else
{
flXa = RemapVal( flCapPercentage, 0.0, 1.0, flStart, 0.0 );
flXb = RemapVal( flCapPercentage, 0.0, 1.0, flStart + flMovementInTextureSpace, flEnd - flArrowSizeInTextureSpace );
}
}
CMatRenderContextPtr pRenderContext( materials );
pRenderContext->Bind( m_pArrowMaterial );
IMesh* pMesh = pRenderContext->GetDynamicMesh( true );
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
meshBuilder.Position3f( x, y, 0.0f );
meshBuilder.TexCoord2f( 0, flXa, flYa );
meshBuilder.TexCoord2f( 1, 0.0f, 0.0f );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( x + iWidth, y, 0.0f );
meshBuilder.TexCoord2f( 0, flXb, flYa );
meshBuilder.TexCoord2f( 1, 1.0f, 0.0f );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( x + iWidth, y + iHeight, 0.0f );
meshBuilder.TexCoord2f( 0, flXb, flYb );
meshBuilder.TexCoord2f( 1, 1.0f, 1.0f );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( x, y + iHeight, 0.0f );
meshBuilder.TexCoord2f( 0, flXa, flYb );
meshBuilder.TexCoord2f( 1, 0.0f, 1.0f );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
}
void DrawLightmapPage( int lightmapPageID )
{
// assumes that we are already in ortho mode.
int lightmapPageWidth, lightmapPageHeight;
IMesh* pMesh = materialSystemInterface->GetDynamicMesh( true, NULL, NULL, g_materialDebugLightmap );
// materialSystemInterface->Bind( g_materialWireframe );
// IMesh* pMesh = materialSystemInterface->GetDynamicMesh( g_materialWireframe );
materialSystemInterface->GetLightmapPageSize( lightmapPageID, &lightmapPageWidth, &lightmapPageHeight );
materialSystemInterface->BindLightmapPage( lightmapPageID );
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
// texcoord 1 is lightmaptexcoord for fixed function.
meshBuilder.TexCoord2f( 1, 0.0f, 0.0f );
meshBuilder.Position3f( 0.0f, 0.0f, 0.0f );
meshBuilder.AdvanceVertex();
meshBuilder.TexCoord2f( 1, 1.0f, 0.0f );
meshBuilder.Position3f( lightmapPageWidth, 0.0f, 0.0f );
meshBuilder.AdvanceVertex();
meshBuilder.TexCoord2f( 1, 1.0f, 1.0f );
meshBuilder.Position3f( lightmapPageWidth, lightmapPageHeight, 0.0f );
meshBuilder.AdvanceVertex();
meshBuilder.TexCoord2f( 1, 0.0f, 1.0f );
meshBuilder.Position3f( 0.0f, lightmapPageHeight, 0.0f );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
}
// ----------------------------------------------------------------------------- //
// Adds shadow rendering data to a particular mesh builder
// ----------------------------------------------------------------------------- //
int DispInfo_AddShadowsToMeshBuilder( CMeshBuilder& meshBuilder,
DispShadowHandle_t h, int baseIndex )
{
#ifndef SWDS
if ( !r_DrawDisp.GetBool() )
{
return baseIndex;
}
CDispShadowDecal* pShadowDecal = &s_DispShadowDecals[h];
int shadow = pShadowDecal->m_Shadow;
ShadowInfo_t const& info = g_pShadowMgr->GetInfo( shadow );
// It had better be computed by now...
Assert( pShadowDecal->m_Flags & CDispDecalBase::FRAGMENTS_COMPUTED );
#ifdef _DEBUG
int triCount = 0;
int vertCount = 0;
#endif
DispShadowFragmentHandle_t f = pShadowDecal->m_FirstFragment;
while ( f != DISP_SHADOW_FRAGMENT_HANDLE_INVALID )
{
CDispShadowFragment& fragment = s_DispShadowFragments[f];
// Add in the vertices + indices, use two loops to minimize tests...
int i;
for ( i = 0; i < fragment.m_nVerts - 2; ++i )
{
meshBuilder.Position3fv( fragment.m_Verts[i].Base() );
// Transform + offset the texture coords
Vector2D texCoord;
Vector2DMultiply( fragment.m_TCoords[i].AsVector2D(), info.m_TexSize, texCoord );
texCoord += info.m_TexOrigin;
meshBuilder.TexCoord2fv( 0, texCoord.Base() );
unsigned char c = g_pShadowMgr->ComputeDarkness( fragment.m_TCoords[i].z, info );
meshBuilder.Color4ub( c, c, c, c );
meshBuilder.AdvanceVertex();
meshBuilder.Index( baseIndex );
meshBuilder.AdvanceIndex();
meshBuilder.Index( i + baseIndex + 1 );
meshBuilder.AdvanceIndex();
meshBuilder.Index( i + baseIndex + 2 );
meshBuilder.AdvanceIndex();
#ifdef _DEBUG
++triCount;
++vertCount;
#endif
}
for ( ; i < fragment.m_nVerts; ++i )
{
meshBuilder.Position3fv( fragment.m_Verts[i].Base() );
// Transform + offset the texture coords
Vector2D texCoord;
Vector2DMultiply( fragment.m_TCoords[i].AsVector2D(), info.m_TexSize, texCoord );
texCoord += info.m_TexOrigin;
meshBuilder.TexCoord2fv( 0, texCoord.Base() );
unsigned char c = g_pShadowMgr->ComputeDarkness( fragment.m_TCoords[i].z, info );
meshBuilder.Color4ub( c, c, c, c );
meshBuilder.AdvanceVertex();
#ifdef _DEBUG
++vertCount;
#endif
}
baseIndex += fragment.m_nVerts;
f = s_DispShadowFragments.Next(f);
}
#ifdef _DEBUG
Assert( triCount == pShadowDecal->m_nTris );
Assert( vertCount == pShadowDecal->m_nVerts );
#endif
return baseIndex;
#else
return 0;
#endif
}
//-----------------------------------------------------------------------------
// Renders a material orthographically to screen...
//-----------------------------------------------------------------------------
static void RenderMaterial( const char *pMaterialName )
{
// So it's not in the very top left
float x = 100.0f, y = 100.0f;
// float x = 0.0f, y = 0.0f;
IMaterial *pMaterial = materials->FindMaterial( pMaterialName, TEXTURE_GROUP_OTHER, false );
if ( !IsErrorMaterial( pMaterial ) )
{
CMatRenderContextPtr pRenderContext( materials );
pRenderContext->Bind( pMaterial );
IMesh* pMesh = pRenderContext->GetDynamicMesh( true );
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
meshBuilder.Position3f( x, y, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( x + pMaterial->GetMappingWidth(), y, 0.0f );
meshBuilder.TexCoord2f( 0, 1.0f, 0.0f );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( x + pMaterial->GetMappingWidth(), y + pMaterial->GetMappingHeight(), 0.0f );
meshBuilder.TexCoord2f( 0, 1.0f, 1.0f );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( x, y + pMaterial->GetMappingHeight(), 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 1.0f );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
}
}
void C_TestTraceline::DrawCube( Vector& center, unsigned char* pColor )
{
Vector facePoints[8];
Vector bmins, bmaxs;
bmins[0] = center[0] - CUBE_SIZE;
bmins[1] = center[1] - CUBE_SIZE;
bmins[2] = center[2] - CUBE_SIZE;
bmaxs[0] = center[0] + CUBE_SIZE;
bmaxs[1] = center[1] + CUBE_SIZE;
bmaxs[2] = center[2] + CUBE_SIZE;
facePoints[0][0] = bmins[0];
facePoints[0][1] = bmins[1];
facePoints[0][2] = bmins[2];
facePoints[1][0] = bmins[0];
facePoints[1][1] = bmins[1];
facePoints[1][2] = bmaxs[2];
facePoints[2][0] = bmins[0];
facePoints[2][1] = bmaxs[1];
facePoints[2][2] = bmins[2];
facePoints[3][0] = bmins[0];
facePoints[3][1] = bmaxs[1];
facePoints[3][2] = bmaxs[2];
facePoints[4][0] = bmaxs[0];
facePoints[4][1] = bmins[1];
facePoints[4][2] = bmins[2];
facePoints[5][0] = bmaxs[0];
facePoints[5][1] = bmins[1];
facePoints[5][2] = bmaxs[2];
facePoints[6][0] = bmaxs[0];
facePoints[6][1] = bmaxs[1];
facePoints[6][2] = bmins[2];
facePoints[7][0] = bmaxs[0];
facePoints[7][1] = bmaxs[1];
facePoints[7][2] = bmaxs[2];
int nFaces[6][4] =
{
{ 0, 2, 3, 1 },
{ 0, 1, 5, 4 },
{ 4, 5, 7, 6 },
{ 2, 6, 7, 3 },
{ 1, 3, 7, 5 },
{ 0, 4, 6, 2 }
};
for (int nFace = 0; nFace < 6; nFace++)
{
int nP1, nP2, nP3, nP4;
nP1 = nFaces[nFace][0];
nP2 = nFaces[nFace][1];
nP3 = nFaces[nFace][2];
nP4 = nFaces[nFace][3];
// Draw the face.
CMeshBuilder meshBuilder;
IMesh* pMesh = materials->GetDynamicMesh();
meshBuilder.DrawQuad( pMesh, facePoints[nP1].Base(), facePoints[nP2].Base(),
facePoints[nP3].Base(), facePoints[nP4].Base(), pColor, true );
}
}
void DrawSpriteModel( IClientEntity *baseentity, CEngineSprite *psprite, const Vector &origin, float fscale, float frame,
int rendermode, int r, int g, int b, int a, const Vector& forward, const Vector& right, const Vector& up, float flHDRColorScale )
{
float scale;
IMaterial *material;
// don't even bother culling, because it's just a single
// polygon without a surface cache
if ( fscale > 0 )
scale = fscale;
else
scale = 1.0f;
if ( rendermode == kRenderNormal )
{
render->SetBlend( 1.0f );
}
material = psprite->GetMaterial( (RenderMode_t)rendermode, frame );
if ( !material )
return;
CMatRenderContextPtr pRenderContext( materials );
if ( ShouldDrawInWireFrameMode() || r_drawsprites.GetInt() == 2 )
{
IMaterial *pMaterial = materials->FindMaterial( "debug/debugspritewireframe", TEXTURE_GROUP_OTHER );
pRenderContext->Bind( pMaterial, NULL );
}
else
{
pRenderContext->Bind( material, (IClientRenderable*)baseentity );
}
unsigned char color[4];
color[0] = r;
color[1] = g;
color[2] = b;
color[3] = a;
IMaterialVar *pHDRColorScaleVar = material->FindVarFast( "$HDRCOLORSCALE", &s_nHDRColorScaleCache );
if( pHDRColorScaleVar )
{
pHDRColorScaleVar->SetVecValue( flHDRColorScale, flHDRColorScale, flHDRColorScale );
}
Vector point;
IMesh* pMesh = pRenderContext->GetDynamicMesh();
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
Vector vec_a;
Vector vec_b;
Vector vec_c;
Vector vec_d;
// isolate common terms
VectorMA( origin, psprite->GetDown() * scale, up, vec_a );
VectorScale( right, psprite->GetLeft() * scale, vec_b );
VectorMA( origin, psprite->GetUp() * scale, up, vec_c );
VectorScale( right, psprite->GetRight() * scale, vec_d );
float flMinU, flMinV, flMaxU, flMaxV;
psprite->GetTexCoordRange( &flMinU, &flMinV, &flMaxU, &flMaxV );
meshBuilder.Color4ubv( color );
meshBuilder.TexCoord2f( 0, flMinU, flMaxV );
VectorAdd( vec_a, vec_b, point );
meshBuilder.Position3fv( point.Base() );
meshBuilder.AdvanceVertex();
meshBuilder.Color4ubv( color );
meshBuilder.TexCoord2f( 0, flMinU, flMinV );
VectorAdd( vec_c, vec_b, point );
meshBuilder.Position3fv( point.Base() );
meshBuilder.AdvanceVertex();
meshBuilder.Color4ubv( color );
meshBuilder.TexCoord2f( 0, flMaxU, flMinV );
VectorAdd( vec_c, vec_d, point );
meshBuilder.Position3fv( point.Base() );
meshBuilder.AdvanceVertex();
meshBuilder.Color4ubv( color );
meshBuilder.TexCoord2f( 0, flMaxU, flMaxV );
VectorAdd( vec_a, vec_d, point );
meshBuilder.Position3fv( point.Base() );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
}
//-----------------------------------------------------------------------------
// Draws the grid under the MDL
//-----------------------------------------------------------------------------
void CMDLPanel::DrawGrid()
{
matrix3x4_t transform;
SetIdentityMatrix( transform );
CMatRenderContextPtr pRenderContext( MaterialSystem() );
pRenderContext->MatrixMode( MATERIAL_MODEL );
pRenderContext->LoadMatrix( transform );
pRenderContext->Bind( m_Wireframe );
IMesh *pMesh = pRenderContext->GetDynamicMesh();
int nGridDim = 10;
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_LINES, 2 * nGridDim + 2 );
float bounds = 100.0f;
float delta = 2 * bounds / nGridDim;
for ( int i = 0; i < nGridDim + 1; ++i )
{
float xy = -bounds + delta * i;
meshBuilder.Position3f( xy, -bounds, 0 );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( xy, bounds, 0 );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( -bounds, xy, 0 );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( bounds, xy, 0 );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.AdvanceVertex();
}
meshBuilder.End();
pMesh->Draw();
}
void CMDLPanel::DrawCollisionModel()
{
vcollide_t *pCollide = MDLCache()->GetVCollide( m_hMDL->GetMDL() );
if ( !pCollide || pCollide->solidCount <= 0 )
return;
static color32 color = {255,0,0,0};
IVPhysicsKeyParser *pParser = g_pPhysicsCollision->VPhysicsKeyParserCreate( pCollide->pKeyValues );
CStudioHdr studioHdr( g_pMDLCache->GetStudioHdr( m_hMDL->GetMDL() ), g_pMDLCache );
matrix3x4_t pBoneToWorld[MAXSTUDIOBONES];
matrix3x4_t shapeToWorld;
m_pDag->GetTransform()->GetTransform( shapeToWorld );
m_hMDL->SetUpBones( shapeToWorld, MAXSTUDIOBONES, pBoneToWorld );
// PERFORMANCE: Just parse the script each frame. It's fast enough for tools. If you need
// this to go faster then cache off the bone index mapping in an array like HLMV does
while ( !pParser->Finished() )
{
const char *pBlock = pParser->GetCurrentBlockName();
if ( !stricmp( pBlock, "solid" ) )
{
solid_t solid;
pParser->ParseSolid( &solid, NULL );
int boneIndex = Studio_BoneIndexByName( &studioHdr, solid.name );
Vector *outVerts;
int vertCount = g_pPhysicsCollision->CreateDebugMesh( pCollide->solids[solid.index], &outVerts );
if ( vertCount )
{
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
pRenderContext->CullMode( MATERIAL_CULLMODE_CCW );
// NOTE: assumes these have been set up already by the model render code
// So this is a little bit of a back door to a cache of the bones
// this code wouldn't work unless you draw the model this frame before calling
// this routine. CMDLPanel always does this, but it's worth noting.
// A better solution would be to move the ragdoll visulization into the CDmeMdl
// and either draw it there or make it queryable and query/draw here.
matrix3x4_t xform;
SetIdentityMatrix( xform );
if ( boneIndex >= 0 )
{
MatrixCopy( pBoneToWorld[ boneIndex ], xform );
}
IMesh *pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, m_Wireframe );
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, vertCount/3 );
for ( int j = 0; j < vertCount; j++ )
{
Vector out;
VectorTransform( outVerts[j].Base(), xform, out.Base() );
meshBuilder.Position3fv( out.Base() );
meshBuilder.Color4ub( color.r, color.g, color.b, color.a );
meshBuilder.TexCoord2f( 0, 0, 0 );
meshBuilder.AdvanceVertex();
}
meshBuilder.End();
pMesh->Draw();
}
g_pPhysicsCollision->DestroyDebugMesh( vertCount, outVerts );
}
else
{
pParser->SkipBlock();
}
}
g_pPhysicsCollision->VPhysicsKeyParserDestroy( pParser );
}
void DispInfo_DrawPrimLists()
{
#ifndef SWDS
VPROF("DispInfo_DrawPrimLists");
int nDispGroupsSize = g_DispGroups.Size();
for( int iGroup=0; iGroup < nDispGroupsSize; iGroup++ )
{
CDispGroup *pGroup = g_DispGroups[iGroup];
if( pGroup->m_nVisible == 0 )
continue;
int numPasses = pGroup->m_pMaterial->GetNumPasses();
materialSystemInterface->Bind( pGroup->m_pMaterial );
materialSystemInterface->BindLightmapPage( pGroup->m_LightmapPageID );
int nMeshesSize = pGroup->m_Meshes.Size();
if ( r_DispUseStaticMeshes.GetInt() )
{
for( int iMesh=0; iMesh < nMeshesSize; iMesh++ )
{
CGroupMesh *pMesh = pGroup->m_Meshes[iMesh];
if( pMesh->m_nVisible == 0 )
continue;
int numTris = 0;
for ( int iIteration=0; iIteration < disp_numiterations.GetInt(); iIteration++ )
{
if ( disp_dynamic.GetInt() )
{
for ( int iVisible=0; iVisible < pMesh->m_nVisible; iVisible++ )
{
pMesh->m_VisibleDisps[iVisible]->SpecifyDynamicMesh();
}
}
else
{
pMesh->m_pMesh->Draw( pMesh->m_Visible.Base(), pMesh->m_nVisible );
}
int i;
for( i = 0; i < pMesh->m_nVisible; i++ )
{
numTris += pMesh->m_Visible[i].m_NumIndices / 3;
}
}
g_EngineStats.IncrementCountedStat( ENGINE_STATS_NUM_DISP_TRIANGLES, numPasses * numTris );
pMesh->m_nVisible = 0;
}
}
else
{
// First, calculate totals.
int nTotalVerts = 0, nTotalIndices = 0;
for( int iMesh=0; iMesh < nMeshesSize; iMesh++ )
{
CGroupMesh *pMesh = pGroup->m_Meshes[iMesh];
if( pMesh->m_nVisible == 0 )
continue;
for ( int iVisible=0; iVisible < pMesh->m_nVisible; iVisible++ )
{
nTotalVerts += pMesh->m_VisibleDisps[iVisible]->NumVerts();
nTotalIndices += pMesh->m_VisibleDisps[iVisible]->m_nIndices;
}
}
// Now lock the dynamic mesh and specify the indices.
IMesh *pMesh = materialSystemInterface->GetDynamicMesh( true );
CMeshBuilder builder;
builder.Begin( pMesh, MATERIAL_TRIANGLES, nTotalVerts, nTotalIndices );
int indexOffset = 0;
for( iMesh=0; iMesh < nMeshesSize; iMesh++ )
{
CGroupMesh *pMesh = pGroup->m_Meshes[iMesh];
if( pMesh->m_nVisible == 0 )
continue;
for ( int iVisible=0; iVisible < pMesh->m_nVisible; iVisible++ )
{
CDispInfo *pDisp = pMesh->m_VisibleDisps[iVisible];
pMesh->m_pMesh->CopyToMeshBuilder(
pDisp->m_iVertOffset,
pDisp->NumVerts(),
pDisp->m_iIndexOffset,
pDisp->m_nIndices,
indexOffset,
builder );
indexOffset += pDisp->NumVerts();
}
pMesh->m_nVisible = 0;
}
builder.End( false, true );
}
pGroup->m_nVisible = 0;
}
#endif
}
float PixelVisibility_DrawProxy( IMatRenderContext *pRenderContext, OcclusionQueryObjectHandle_t queryHandle, Vector origin, float scale, float proxyAspect, IMaterial *pMaterial, bool screenspace )
{
Vector point;
// don't expand this with distance to fit pixels or the sprite will poke through
// only expand the parts perpendicular to the view
float forwardScale = scale;
// draw a pyramid of points touching a sphere of radius "scale" at origin
float pixelsPerUnit = pRenderContext->ComputePixelDiameterOfSphere( origin, 1.0f );
pixelsPerUnit = MAX( pixelsPerUnit, 1e-4f );
if ( screenspace )
{
// Force this to be the size of a sphere of diameter "scale" at some reference distance (1.0 unit)
float pixelsPerUnit2 = pRenderContext->ComputePixelDiameterOfSphere( CurrentViewOrigin() + CurrentViewForward()*1.0f, scale*0.5f );
// force drawing of "scale" pixels
scale = pixelsPerUnit2 / pixelsPerUnit;
}
else
{
float pixels = scale * pixelsPerUnit;
// make the radius larger to ensure a minimum screen space size of the proxy geometry
if ( pixels < MIN_PROXY_PIXELS )
{
scale = MIN_PROXY_PIXELS / pixelsPerUnit;
}
}
// collapses the pyramid to a plane - so this could be a quad instead
Vector dir = origin - CurrentViewOrigin();
VectorNormalize(dir);
origin -= dir * forwardScale;
forwardScale = 0.0f;
//
Vector verts[5];
const float sqrt2 = 0.707106781f; // sqrt(2) - keeps all vectors the same length from origin
scale *= sqrt2;
float scale45x = scale;
float scale45y = scale / proxyAspect;
verts[0] = origin - CurrentViewForward() * forwardScale; // the apex of the pyramid
verts[1] = origin + CurrentViewUp() * scale45y - CurrentViewRight() * scale45x; // these four form the base
verts[2] = origin + CurrentViewUp() * scale45y + CurrentViewRight() * scale45x; // the pyramid is a sprite with a point that
verts[3] = origin - CurrentViewUp() * scale45y + CurrentViewRight() * scale45x; // pokes back toward the camera through any nearby
verts[4] = origin - CurrentViewUp() * scale45y - CurrentViewRight() * scale45x; // geometry
// get screen coords of edges
Vector screen[4];
for ( int i = 0; i < 4; i++ )
{
extern int ScreenTransform( const Vector& point, Vector& screen );
if ( ScreenTransform( verts[i+1], screen[i] ) )
return -1;
}
// compute area and screen-clipped area
float w = screen[1].x - screen[0].x;
float h = screen[0].y - screen[3].y;
float ws = MIN(1.0f, screen[1].x) - MAX(-1.0f, screen[0].x);
float hs = MIN(1.0f, screen[0].y) - MAX(-1.0f, screen[3].y);
float area = w*h; // area can be zero when we ALT-TAB
float areaClipped = ws*hs;
float ratio = 0.0f;
if ( area != 0 )
{
// compute the ratio of the area not clipped by the frustum to total area
ratio = areaClipped / area;
ratio = clamp(ratio, 0.0f, 1.0f);
}
pRenderContext->BeginOcclusionQueryDrawing( queryHandle );
CMeshBuilder meshBuilder;
IMesh* pMesh = pRenderContext->GetDynamicMesh( false, NULL, NULL, pMaterial );
meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, 4 );
// draw a pyramid
for ( int i = 0; i < 4; i++ )
{
int a = i+1;
int b = (a%4)+1;
meshBuilder.Position3fv( verts[0].Base() );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( verts[a].Base() );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( verts[b].Base() );
meshBuilder.AdvanceVertex();
}
meshBuilder.End();
pMesh->Draw();
// sprite/quad proxy
#if 0
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
VectorMA (origin, -scale, CurrentViewUp(), point);
VectorMA (point, -scale, CurrentViewRight(), point);
meshBuilder.Position3fv (point.Base());
meshBuilder.AdvanceVertex();
VectorMA (origin, scale, CurrentViewUp(), point);
VectorMA (point, -scale, CurrentViewRight(), point);
meshBuilder.Position3fv (point.Base());
meshBuilder.AdvanceVertex();
VectorMA (origin, scale, CurrentViewUp(), point);
VectorMA (point, scale, CurrentViewRight(), point);
meshBuilder.Position3fv (point.Base());
meshBuilder.AdvanceVertex();
VectorMA (origin, -scale, CurrentViewUp(), point);
VectorMA (point, scale, CurrentViewRight(), point);
meshBuilder.Position3fv (point.Base());
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
#endif
pRenderContext->EndOcclusionQueryDrawing( queryHandle );
// fraction clipped by frustum
return ratio;
}
void DispInfo_DrawDecals( CDispInfo *visibleDisps[MAX_MAP_DISPINFO], int nVisibleDisps )
{
#ifndef SWDS
VPROF("DispInfo_DrawDecals");
if( !nVisibleDisps )
return;
int nTrisDrawn = 0;
// FIXME: We should bucket all decals (displacement + otherwise)
// and sort them by material enum id + lightmap
// To do this, we need to associate a sort index from 0-n for all
// decals we've seen this level. Then we add those decals to the
// appropriate search list, (sorted by lightmap id)?
for( int i=0; i < nVisibleDisps; i++ )
{
CDispInfo *pDisp = visibleDisps[i];
// Don't bother if there's no decals
if( pDisp->m_FirstDecal == DISP_DECAL_HANDLE_INVALID )
continue;
materialSystemInterface->BindLightmapPage( pDisp->m_pMesh->m_pGroup->m_LightmapPageID );
// At the moment, all decals in a single displacement are sorted by material
// so we get a little batching at least
DispDecalHandle_t d = pDisp->m_FirstDecal;
while( d != DISP_DECAL_HANDLE_INVALID )
{
CDispDecal& decal = s_DispDecals[d];
// Compute decal fragments if we haven't already....
if ((decal.m_Flags & CDispDecalBase::FRAGMENTS_COMPUTED) == 0)
{
pDisp->GenerateDecalFragments( pDisp->m_pPowerInfo->m_RootNode, 0, d, &decal );
}
// Don't draw if there's no triangles
if (decal.m_nTris == 0)
{
d = s_DispDecals.Next(d);
continue;
}
// Now draw all the fragments with this material.
IMaterial* pMaterial = decal.m_pDecal->material;
IMesh *pMesh = materialSystemInterface->GetDynamicMesh( true, NULL, NULL, pMaterial );
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, decal.m_nVerts, decal.m_nTris * 3 );
int baseIndex = 0;
DispDecalFragmentHandle_t f = decal.m_FirstFragment;
while (f != DISP_DECAL_FRAGMENT_HANDLE_INVALID)
{
CDispDecalFragment& fragment = s_DispDecalFragments[f];
int v;
for ( v = 0; v < fragment.m_nVerts - 2; ++v)
{
meshBuilder.Position3fv( fragment.m_pVerts[v].m_vPos.Base() );
meshBuilder.TexCoord2fv( 0, fragment.m_pVerts[v].m_tCoords.Base() );
meshBuilder.TexCoord2fv( 1, fragment.m_pVerts[v].m_LMCoords.Base() );
meshBuilder.AdvanceVertex();
meshBuilder.Index( baseIndex );
meshBuilder.AdvanceIndex();
meshBuilder.Index( v + baseIndex + 1 );
meshBuilder.AdvanceIndex();
meshBuilder.Index( v + baseIndex + 2 );
meshBuilder.AdvanceIndex();
}
meshBuilder.Position3fv( fragment.m_pVerts[v].m_vPos.Base() );
meshBuilder.TexCoord2fv( 0, fragment.m_pVerts[v].m_tCoords.Base() );
meshBuilder.TexCoord2fv( 1, fragment.m_pVerts[v].m_LMCoords.Base() );
meshBuilder.AdvanceVertex();
++v;
meshBuilder.Position3fv( fragment.m_pVerts[v].m_vPos.Base() );
meshBuilder.TexCoord2fv( 0, fragment.m_pVerts[v].m_tCoords.Base() );
meshBuilder.TexCoord2fv( 1, fragment.m_pVerts[v].m_LMCoords.Base() );
meshBuilder.AdvanceVertex();
baseIndex += fragment.m_nVerts;
f = s_DispDecalFragments.Next(f);
}
meshBuilder.End( false, true );
nTrisDrawn += decal.m_nTris * pMaterial->GetNumPasses();
d = s_DispDecals.Next(d);
}
}
g_EngineStats.IncrementCountedStat( ENGINE_STATS_DECAL_TRIANGLES, nTrisDrawn );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : frame -
// x -
// y -
// *prcSubRect -
//-----------------------------------------------------------------------------
void CEngineSprite::DrawFrameOfSize( int frame, int x, int y, int iWidth, int iHeight, const wrect_t *prcSubRect )
{
// FIXME: If we ever call this with AVIs, need to have it call GetTexCoordRange and make that work
Assert( !IsAVI() && !IsBIK() );
float fLeft = 0;
float fRight = 1;
float fTop = 0;
float fBottom = 1;
if ( prcSubRect )
{
AdjustSubRect( this, frame, &fLeft, &fRight, &fTop, &fBottom, &iWidth, &iHeight, prcSubRect );
}
if ( giScissorTest && !Scissor( x, y, iWidth, iHeight, fLeft, fTop, fRight, fBottom ) )
return;
SetFrame( frame );
CMatRenderContextPtr pRenderContext( materials );
IMesh* pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, GetMaterial() );
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
float color[3];
GetHUDSpriteColor( color );
meshBuilder.Color3fv( color );
meshBuilder.TexCoord2f( 0, fLeft, fTop );
meshBuilder.Position3f( x, y, 0.0f );
meshBuilder.AdvanceVertex();
meshBuilder.Color3fv( color );
meshBuilder.TexCoord2f( 0, fRight, fTop );
meshBuilder.Position3f( x + iWidth, y, 0.0f );
meshBuilder.AdvanceVertex();
meshBuilder.Color3fv( color );
meshBuilder.TexCoord2f( 0, fRight, fBottom );
meshBuilder.Position3f( x + iWidth, y + iHeight, 0.0f );
meshBuilder.AdvanceVertex();
meshBuilder.Color3fv( color );
meshBuilder.TexCoord2f( 0, fLeft, fBottom );
meshBuilder.Position3f( x, y + iHeight, 0.0f );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
}
//-----------------------------------------------------------------------------
// 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 CRender::ViewDrawFade( byte *color, IMaterial* pFadeMaterial )
{
if ( !color || !color[3] )
return;
if( !pFadeMaterial )
return;
materialSystemInterface->Bind( pFadeMaterial );
pFadeMaterial->AlphaModulate( color[3] * ( 1.0f / 255.0f ) );
pFadeMaterial->ColorModulate( color[0] * ( 1.0f / 255.0f ),
color[1] * ( 1.0f / 255.0f ),
color[2] * ( 1.0f / 255.0f ) );
pFadeMaterial->SetMaterialVarFlag( MATERIAL_VAR_IGNOREZ, true );
int nTexWidth, nTexHeight;
nTexWidth = pFadeMaterial->GetMappingWidth();
nTexHeight = pFadeMaterial->GetMappingHeight();
float flUOffset = 0.5f / nTexWidth;
float flVOffset = 0.5f / nTexHeight;
int width, height;
materialSystemInterface->GetRenderTargetDimensions( width, height );
materialSystemInterface->Viewport( 0, 0, width, height );
materialSystemInterface->MatrixMode( MATERIAL_PROJECTION );
materialSystemInterface->PushMatrix();
materialSystemInterface->LoadIdentity();
materialSystemInterface->Scale( 1, -1, 1 );
materialSystemInterface->Ortho( 0, 0, width, height, -99999, 99999 );
materialSystemInterface->MatrixMode( MATERIAL_MODEL );
materialSystemInterface->PushMatrix();
materialSystemInterface->LoadIdentity();
materialSystemInterface->MatrixMode( MATERIAL_VIEW );
materialSystemInterface->PushMatrix();
materialSystemInterface->LoadIdentity();
IMesh* pMesh = materialSystemInterface->GetDynamicMesh();
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
meshBuilder.Position3f( m_view.x, m_view.y, 0.0f );
meshBuilder.TexCoord2f( 0, flUOffset, flVOffset );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( m_view.x + m_view.width, m_view.y, 0.0f );
meshBuilder.TexCoord2f( 0, 1.0f - flUOffset, flVOffset );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( m_view.x + m_view.width, m_view.y + m_view.height, 0.0f );
meshBuilder.TexCoord2f( 0, 1.0f - flUOffset, 1.0f - flVOffset );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( m_view.x, m_view.y + m_view.height, 0.0f );
meshBuilder.TexCoord2f( 0, flUOffset, 1.0f - flVOffset );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
materialSystemInterface->MatrixMode( MATERIAL_MODEL );
materialSystemInterface->PopMatrix();
materialSystemInterface->MatrixMode( MATERIAL_VIEW );
materialSystemInterface->PopMatrix();
materialSystemInterface->MatrixMode( MATERIAL_PROJECTION );
materialSystemInterface->PopMatrix();
}
void CVoiceStatus::DrawHeadLabels()
{
if ( m_bHeadLabelsDisabled )
return;
if( !m_pHeadLabelMaterial )
return;
CMatRenderContextPtr pRenderContext( materials );
for(int i=0; i < VOICE_MAX_PLAYERS; i++)
{
if ( !m_VoicePlayers[i] )
continue;
IClientNetworkable *pClient = cl_entitylist->GetClientEntity( i+1 );
// Don't show an icon if the player is not in our PVS.
if ( !pClient || pClient->IsDormant() )
continue;
C_BasePlayer *pPlayer = dynamic_cast<C_BasePlayer*>(pClient);
if( !pPlayer )
continue;
// Don't show an icon for dead or spectating players (ie: invisible entities).
if( pPlayer->IsPlayerDead() )
continue;
// Place it 20 units above his head.
Vector vOrigin = pPlayer->WorldSpaceCenter();
vOrigin.z += g_flHeadOffset;
// Align it so it never points up or down.
Vector vUp( 0, 0, 1 );
Vector vRight = CurrentViewRight();
if ( fabs( vRight.z ) > 0.95 ) // don't draw it edge-on
continue;
vRight.z = 0;
VectorNormalize( vRight );
float flSize = g_flHeadIconSize;
pRenderContext->Bind( pPlayer->GetHeadLabelMaterial() );
IMesh *pMesh = pRenderContext->GetDynamicMesh();
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
meshBuilder.Color3f( 1.0, 1.0, 1.0 );
meshBuilder.TexCoord2f( 0,0,0 );
meshBuilder.Position3fv( (vOrigin + (vRight * -flSize) + (vUp * flSize)).Base() );
meshBuilder.AdvanceVertex();
meshBuilder.Color3f( 1.0, 1.0, 1.0 );
meshBuilder.TexCoord2f( 0,1,0 );
meshBuilder.Position3fv( (vOrigin + (vRight * flSize) + (vUp * flSize)).Base() );
meshBuilder.AdvanceVertex();
meshBuilder.Color3f( 1.0, 1.0, 1.0 );
meshBuilder.TexCoord2f( 0,1,1 );
meshBuilder.Position3fv( (vOrigin + (vRight * flSize) + (vUp * -flSize)).Base() );
meshBuilder.AdvanceVertex();
meshBuilder.Color3f( 1.0, 1.0, 1.0 );
meshBuilder.TexCoord2f( 0,0,1 );
meshBuilder.Position3fv( (vOrigin + (vRight * -flSize) + (vUp * -flSize)).Base() );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
}
}
void CGlowOverlay::Draw( bool bCacheFullSceneState )
{
extern ConVar r_drawsprites;
if( !r_drawsprites.GetBool() )
return;
// Get the vector to the sun.
Vector vToGlow;
if( m_bDirectional )
vToGlow = m_vDirection;
else
vToGlow = m_vPos - CurrentViewOrigin();
VectorNormalize( vToGlow );
float flDot = vToGlow.Dot( CurrentViewForward() );
UpdateGlowObstruction( vToGlow, bCacheFullSceneState );
if( m_flGlowObstructionScale == 0 )
return;
bool bWireframe = ShouldDrawInWireFrameMode() || (r_drawsprites.GetInt() == 2);
CMatRenderContextPtr pRenderContext( materials );
for( int iSprite=0; iSprite < m_nSprites; iSprite++ )
{
CGlowSprite *pSprite = &m_Sprites[iSprite];
// Figure out the color and size to draw it.
float flHorzSize, flVertSize;
Vector vColor;
CalcSpriteColorAndSize( flDot, pSprite, &flHorzSize, &flVertSize, &vColor );
// If we're alpha'd out, then don't bother
if ( vColor.LengthSqr() < 0.00001f )
continue;
// Setup the basis to draw the sprite.
Vector vBasePt, vUp, vRight;
CalcBasis( vToGlow, flHorzSize, flVertSize, vBasePt, vUp, vRight );
//Get our diagonal radius
float radius = (vRight+vUp).Length();
if ( R_CullSphere( view->GetFrustum(), 5, &vBasePt, radius ) )
continue;
// Get our material (deferred default load)
if ( m_Sprites[iSprite].m_pMaterial == NULL )
{
m_Sprites[iSprite].m_pMaterial = materials->FindMaterial( "sprites/light_glow02_add_noz", TEXTURE_GROUP_CLIENT_EFFECTS );
}
Assert( m_Sprites[iSprite].m_pMaterial );
static unsigned int nHDRColorScaleCache = 0;
IMaterialVar *pHDRColorScaleVar = m_Sprites[iSprite].m_pMaterial->FindVarFast( "$hdrcolorscale", &nHDRColorScaleCache );
if( pHDRColorScaleVar )
{
pHDRColorScaleVar->SetFloatValue( m_flHDRColorScale );
}
// Draw the sprite.
IMesh *pMesh = pRenderContext->GetDynamicMesh( false, 0, 0, m_Sprites[iSprite].m_pMaterial );
CMeshBuilder builder;
builder.Begin( pMesh, MATERIAL_QUADS, 1 );
Vector vPt;
vPt = vBasePt - vRight + vUp;
builder.Position3fv( vPt.Base() );
builder.Color4f( VectorExpand(vColor), 1 );
builder.TexCoord2f( 0, 0, 1 );
builder.AdvanceVertex();
vPt = vBasePt + vRight + vUp;
builder.Position3fv( vPt.Base() );
builder.Color4f( VectorExpand(vColor), 1 );
builder.TexCoord2f( 0, 1, 1 );
builder.AdvanceVertex();
vPt = vBasePt + vRight - vUp;
builder.Position3fv( vPt.Base() );
builder.Color4f( VectorExpand(vColor), 1 );
builder.TexCoord2f( 0, 1, 0 );
builder.AdvanceVertex();
vPt = vBasePt - vRight - vUp;
builder.Position3fv( vPt.Base() );
builder.Color4f( VectorExpand(vColor), 1 );
builder.TexCoord2f( 0, 0, 0 );
builder.AdvanceVertex();
builder.End( false, true );
if( bWireframe )
{
IMaterial *pWireframeMaterial = materials->FindMaterial( "debug/debugwireframevertexcolor", TEXTURE_GROUP_OTHER );
pRenderContext->Bind( pWireframeMaterial );
// Draw the sprite.
IMesh *pMesh = pRenderContext->GetDynamicMesh( false, 0, 0, pWireframeMaterial );
CMeshBuilder builder;
builder.Begin( pMesh, MATERIAL_QUADS, 1 );
Vector vPt;
vPt = vBasePt - vRight + vUp;
builder.Position3fv( vPt.Base() );
builder.Color3f( 1.0f, 0.0f, 0.0f );
builder.AdvanceVertex();
vPt = vBasePt + vRight + vUp;
builder.Position3fv( vPt.Base() );
builder.Color3f( 1.0f, 0.0f, 0.0f );
builder.AdvanceVertex();
vPt = vBasePt + vRight - vUp;
builder.Position3fv( vPt.Base() );
builder.Color3f( 1.0f, 0.0f, 0.0f );
builder.AdvanceVertex();
vPt = vBasePt - vRight - vUp;
builder.Position3fv( vPt.Base() );
builder.Color3f( 1.0f, 0.0f, 0.0f );
builder.AdvanceVertex();
builder.End( false, true );
}
}
}
