//-----------------------------------------------------------------------------
// Draw sprite-card based materials
//-----------------------------------------------------------------------------
void CVMTPreviewPanel::RenderSpriteCard( const Vector &vCenter, float flRadius )
{
CMatRenderContextPtr pRenderContext( MaterialSystem() );
IMesh *pMesh = pRenderContext->GetDynamicMesh();
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
// Draw a polygon the size of the panel
meshBuilder.Position3fv( vCenter.Base() );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.TexCoord4f( 0, 0.0f, 0.0f, 1.0f, 1.0f );
meshBuilder.TexCoord4f( 1, 0.0f, 0.0f, 1.0f, 1.0f );
meshBuilder.TexCoord4f( 2, 0.0f, 0.0f, flRadius, 0.0f );
meshBuilder.TexCoord2f( 3, 0, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( vCenter.Base() );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.TexCoord4f( 0, 0.0f, 0.0f, 1.0f, 1.0f );
meshBuilder.TexCoord4f( 1, 0.0f, 0.0f, 1.0f, 1.0f );
meshBuilder.TexCoord4f( 2, 0.0f, 0.0f, flRadius, 0.0f );
meshBuilder.TexCoord2f( 3, 0, 1 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( vCenter.Base() );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.TexCoord4f( 0, 0.0f, 0.0f, 1.0f, 1.0f );
meshBuilder.TexCoord4f( 1, 0.0f, 0.0f, 1.0f, 1.0f );
meshBuilder.TexCoord4f( 2, 0.0f, 0.0f, flRadius, 0.0f );
meshBuilder.TexCoord2f( 3, 1, 1 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( vCenter.Base() );
meshBuilder.Color4ub( 255, 255, 255, 255 );
meshBuilder.TexCoord4f( 0, 0.0f, 0.0f, 1.0f, 1.0f );
meshBuilder.TexCoord4f( 1, 0.0f, 0.0f, 1.0f, 1.0f );
meshBuilder.TexCoord4f( 2, 0.0f, 0.0f, flRadius, 0.0f );
meshBuilder.TexCoord2f( 3, 1, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
}
static void OverlayWaterTexture( IMaterial *pMaterial, int xOffset, int yOffset, bool bFlip )
{
// screen safe
float xBaseOffset = IsPC() ? 0 : 32;
float yBaseOffset = IsPC() ? 0 : 32;
float offsetS = ( 0.5f / 256.0f );
float offsetT = ( 0.5f / 256.0f );
float fFlip0 = bFlip ? 1.0f : 0.0f;
float fFlip1 = bFlip ? 0.0f : 1.0f;
if( !IsErrorMaterial( pMaterial ) )
{
CMatRenderContextPtr pRenderContext( materials );
pRenderContext->Bind( pMaterial );
IMesh* pMesh = pRenderContext->GetDynamicMesh( true );
float w = mat_wateroverlaysize.GetFloat();
float h = mat_wateroverlaysize.GetFloat();
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
meshBuilder.Position3f( xBaseOffset + xOffset * w, yBaseOffset + yOffset * h, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f + offsetS, fFlip1 + offsetT );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( xBaseOffset + ( xOffset + 1 ) * w, yBaseOffset + yOffset * h, 0.0f );
meshBuilder.TexCoord2f( 0, 1.0f + offsetS, fFlip1 + offsetT );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( xBaseOffset + ( xOffset + 1 ) * w, yBaseOffset + ( yOffset + 1 ) * h, 0.0f );
meshBuilder.TexCoord2f( 0, 1.0f + offsetS, fFlip0 + offsetT );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( xBaseOffset + xOffset * w, yBaseOffset + ( yOffset + 1 ) * h, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f + offsetS, fFlip0 + offsetT );
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 C_EnergyWave::DrawWireframeModel( )
{
IMesh* pMesh = materials->GetDynamicMesh( true, NULL, NULL, m_pWireframe );
int numLines = (EWAVE_NUM_VERTICAL_POINTS - 1) * EWAVE_NUM_HORIZONTAL_POINTS +
EWAVE_NUM_VERTICAL_POINTS * (EWAVE_NUM_HORIZONTAL_POINTS - 1);
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_LINES, numLines );
Vector tmp;
for (int i = 0; i < EWAVE_NUM_VERTICAL_POINTS; ++i)
{
for (int j = 0; j < EWAVE_NUM_HORIZONTAL_POINTS; ++j)
{
if ( i > 0 )
{
meshBuilder.Position3fv( m_EWaveEffect.GetPoint( j, i ).Base() );
meshBuilder.Color4ub( 255, 255, 255, 128 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( m_EWaveEffect.GetPoint( j, i - 1 ).Base() );
meshBuilder.Color4ub( 255, 255, 255, 128 );
meshBuilder.AdvanceVertex();
}
if (j > 0)
{
meshBuilder.Position3fv( m_EWaveEffect.GetPoint( j, i ).Base() );
meshBuilder.Color4ub( 255, 255, 255, 128 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( m_EWaveEffect.GetPoint( j - 1, i ).Base() );
meshBuilder.Color4ub( 255, 255, 255, 128 );
meshBuilder.AdvanceVertex();
}
}
}
meshBuilder.End();
pMesh->Draw();
}
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;
}
static void OverlayFrameBufferTexture( int nFrameBufferIndex )
{
float offsetS = ( 0.5f / 256.0f );
float offsetT = ( 0.5f / 256.0f );
IMaterial *pMaterial;
char buf[MAX_PATH];
Q_snprintf( buf, MAX_PATH, "debug/debugfbtexture%d", nFrameBufferIndex );
pMaterial = materials->FindMaterial( buf, TEXTURE_GROUP_OTHER, true );
if( !IsErrorMaterial( pMaterial ) )
{
CMatRenderContextPtr pRenderContext( materials );
pRenderContext->Bind( pMaterial );
IMesh* pMesh = pRenderContext->GetDynamicMesh( true );
float w = mat_framebuffercopyoverlaysize.GetFloat();
float h = mat_framebuffercopyoverlaysize.GetFloat();
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
meshBuilder.Position3f( w * nFrameBufferIndex, 0.0f, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f + offsetS, 0.0f + offsetT );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( w * ( nFrameBufferIndex + 1 ), 0.0f, 0.0f );
meshBuilder.TexCoord2f( 0, 1.0f + offsetS, 0.0f + offsetT );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( w * ( nFrameBufferIndex + 1 ), h, 0.0f );
meshBuilder.TexCoord2f( 0, 1.0f + offsetS, 1.0f + offsetT );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( w * nFrameBufferIndex, h, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f + offsetS, 1.0f + offsetT );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
}
}
//-----------------------------------------------------------------------------
// 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();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNetGraphPanel::DrawLineSegments()
{
int c = m_Rects.Count();
if ( c <= 0 )
return;
int start = 0;
while ( start < c )
{
int consume = MIN( 5000, c - start );
CMatRenderContextPtr pRenderContext( materials );
IMesh* m_pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, m_WhiteMaterial );
CMeshBuilder meshBuilder;
meshBuilder.Begin( m_pMesh, MATERIAL_LINES, c );
int i;
for ( i = start ; i < start + consume; i++ )
{
CLineSegment *seg = &m_Rects[ i ];
meshBuilder.Color4ubv( seg->color );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.Position3f( seg->x1, seg->y1, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Color4ubv( seg->color2 );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.Position3f( seg->x2, seg->y2, 0 );
meshBuilder.AdvanceVertex();
}
meshBuilder.End();
m_pMesh->Draw();
start += consume;
}
}
//-----------------------------------------------------------------------------
// 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();
}
}
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 );
}
//-----------------------------------------------------------------------------
// a pass to set the z buffer...
//-----------------------------------------------------------------------------
void C_VGuiScreen::DrawScreenOverlay()
{
CMatRenderContextPtr pRenderContext( materials );
pRenderContext->MatrixMode( MATERIAL_MODEL );
pRenderContext->PushMatrix();
pRenderContext->LoadMatrix( m_PanelToWorld );
unsigned char pColor[4] = {255, 255, 255, 255};
CMeshBuilder meshBuilder;
IMesh *pMesh = pRenderContext->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();
pRenderContext->PopMatrix();
}
static void ForceTextureIntoHardware( ITexture *pTexture, IMaterial *pMaterial, IMaterialVar *pBaseTextureVar )
{
if ( IsX360() )
return;
pBaseTextureVar->SetTextureValue( pTexture );
CMatRenderContextPtr pRenderContext( MaterialSystem()->GetRenderContext() );
pRenderContext->Bind( pMaterial );
IMesh* pMesh = pRenderContext->GetDynamicMesh( true );
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, 1 );
meshBuilder.Position3f( 0.0f, 0.0f, 0.0f );
meshBuilder.TangentS3f( 0.0f, 1.0f, 0.0f );
meshBuilder.TangentT3f( 1.0f, 0.0f, 0.0f );
meshBuilder.Normal3f( 0.0f, 0.0f, 1.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( 0.0f, 0.0f, 0.0f );
meshBuilder.TangentS3f( 0.0f, 1.0f, 0.0f );
meshBuilder.TangentT3f( 1.0f, 0.0f, 0.0f );
meshBuilder.Normal3f( 0.0f, 0.0f, 1.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( 0.0f, 0.0f, 0.0f );
meshBuilder.TangentS3f( 0.0f, 1.0f, 0.0f );
meshBuilder.TangentT3f( 1.0f, 0.0f, 0.0f );
meshBuilder.Normal3f( 0.0f, 0.0f, 1.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
}
void RenderFullScreenQuad( IMaterial *pMat )
{
CMatRenderContextPtr pRenderContext( materials );
CMeshBuilder pMeshBuilder;
IMesh *pMesh = pRenderContext->GetDynamicMesh( true, 0, 0, pMat );
pMeshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
pMeshBuilder.Position3f( -1, 1, 1 );
pMeshBuilder.TexCoord2f( 0, 0, 0 );
pMeshBuilder.AdvanceVertex();
pMeshBuilder.Position3f( 1, 1, 1 );
pMeshBuilder.TexCoord2f( 0, 1, 0 );
pMeshBuilder.AdvanceVertex();
pMeshBuilder.Position3f( 1, -1, 1 );
pMeshBuilder.TexCoord2f( 0, 1, 1 );
pMeshBuilder.AdvanceVertex();
pMeshBuilder.Position3f( -1, -1, 1 );
pMeshBuilder.TexCoord2f( 0, 0, 1 );
pMeshBuilder.AdvanceVertex();
pMeshBuilder.End();
pMesh->Draw();
}
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;
}
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 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
}
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
}
//-----------------------------------------------------------------------------
// 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();
}
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 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 );
}
}
}
//-----------------------------------------------------------------------------
// 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();
}
//-----------------------------------------------------------------------------
// Draws shield decals
//-----------------------------------------------------------------------------
void C_Shield::DrawShieldDecals( Vector* pt, bool hitDecals )
{
if (m_Decals.Size() == 0)
return;
// Compute ripples:
for ( int r = m_Decals.Size(); --r >= 0; )
{
// At the moment, nothing passes!
bool passDecal = false;
if ((!hitDecals) && (passDecal == hitDecals))
continue;
SetCurrentDecal( r );
// We have to force a flush here because we're changing the proxy state
if (!hitDecals)
materials->Bind( m_pPassDecal, (IClientRenderable*)this );
else
materials->Bind( passDecal ? m_pPassDecal2 : m_pHitDecal, (IClientRenderable*)this );
float dtime = gpGlobals->curtime - m_Decals[r].m_StartTime;
float decay = exp( -( 2 * dtime) );
// Retire the animation if it wraps
// This gets set by TextureAnimatedWrapped above
if ((m_Decals[r].m_StartTime < 0.0f) || (decay < 1e-3))
{
m_Decals.Remove(r);
continue;
}
IMesh* pMesh = materials->GetDynamicMesh();
// Figure out the quads we must mod2x....
float u0 = m_Decals[r].m_RippleU - m_Decals[r].m_Radius;
float u1 = m_Decals[r].m_RippleU + m_Decals[r].m_Radius;
float v0 = m_Decals[r].m_RippleV - m_Decals[r].m_Radius;
float v1 = m_Decals[r].m_RippleV + m_Decals[r].m_Radius;
float du = u1 - u0;
float dv = v1 - v0;
int i0 = Floor2Int( v0 * (m_SubdivisionCount - 1) );
int i1 = Ceil2Int( v1 * (m_SubdivisionCount - 1) );
int j0 = Floor2Int( u0 * (m_SubdivisionCount - 1) );
int j1 = Ceil2Int( u1 * (m_SubdivisionCount - 1) );
if (i0 < 0)
i0 = 0;
if (i1 >= m_SubdivisionCount)
i1 = m_SubdivisionCount - 1;
if (j0 < 0)
j0 = 0;
if (j1 >= m_SubdivisionCount)
j1 = m_SubdivisionCount - 1;
int numTriangles = (i1 - i0) * (j1 - j0) * 2;
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, numTriangles );
float decalDu = m_InvSubdivisionCount / du;
float decalDv = m_InvSubdivisionCount / dv;
unsigned char color[3];
color[0] = s_ImpactDecalColor[0] * decay;
color[1] = s_ImpactDecalColor[1] * decay;
color[2] = s_ImpactDecalColor[2] * decay;
for ( int i = i0; i < i1; ++i)
{
float t = (float)i * m_InvSubdivisionCount;
for (int j = j0; j < j1; ++j)
{
float s = (float)j * m_InvSubdivisionCount;
int idx = i * m_SubdivisionCount + j;
// Compute (u,v) into the decal
float decalU = (s - u0) / du;
float decalV = (t - v0) / dv;
meshBuilder.Position3fv( pt[idx].Base() );
meshBuilder.Color3ubv( color );
meshBuilder.TexCoord2f( 0, decalU, decalV );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( pt[idx + m_SubdivisionCount].Base() );
meshBuilder.Color3ubv( color );
meshBuilder.TexCoord2f( 0, decalU, decalV + decalDv );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( pt[idx + 1].Base() );
meshBuilder.Color3ubv( color );
meshBuilder.TexCoord2f( 0, decalU + decalDu, decalV );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( pt[idx + 1].Base() );
meshBuilder.Color3ubv( color );
meshBuilder.TexCoord2f( 0, decalU + decalDu, decalV );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( pt[idx + m_SubdivisionCount].Base() );
meshBuilder.Color3ubv( color );
meshBuilder.TexCoord2f( 0, decalU, decalV + decalDv );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( pt[idx + m_SubdivisionCount + 1].Base() );
meshBuilder.Color3ubv( color );
meshBuilder.TexCoord2f( 0, decalU + decalDu, decalV + decalDv );
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 FX_DrawLineFade( const Vector &start, const Vector &end, float scale, IMaterial *pMaterial, const color32 &color, float fadeDist )
{
Vector lineDir, viewDir;
//Get the proper orientation for the line
VectorSubtract( end, start, lineDir );
VectorSubtract( end, CurrentViewOrigin(), viewDir );
float lineLength = lineDir.Length();
float t0 = 0.25f;
float t1 = 0.75f;
if ( lineLength > 0 )
{
t0 = fadeDist / lineLength;
t0 = clamp( t0, 0.0f, 0.25f );
t1 = 1.0f - t0;
}
Vector cross = lineDir.Cross( viewDir );
VectorNormalize( cross );
CMatRenderContextPtr pRenderContext( materials );
//Bind the material
IMesh* pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, pMaterial );
CMeshBuilder meshBuilder;
Vector tmp;
meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, 8, 24 );
// 2 5
// 0 1 4 7
// 3 6
// 0,2,1 - 0,1,3 - 7,4,5 - 7,6,4 - 1,4,6, 1,6,3 - 1,5,4 - 1,2,5
// v0
meshBuilder.Position3fv( start.Base() );
meshBuilder.TexCoord2f( 0, 0.5f, 0.0f );
meshBuilder.Color4ub( 0, 0, 0, 0 );
meshBuilder.Normal3fv( cross.Base() );
meshBuilder.AdvanceVertex();
// v1
Vector v1 = start + t0 * lineDir;
meshBuilder.Position3fv( v1.Base() );
meshBuilder.TexCoord2f( 0, 0.5f, t0 );
meshBuilder.Color4ub( color.r, color.g, color.b, color.a );
meshBuilder.Normal3fv( cross.Base() );
meshBuilder.AdvanceVertex();
// v2
tmp = v1 - scale*cross;
meshBuilder.Position3fv( tmp.Base() );
meshBuilder.TexCoord2f( 0, 1.0f, t0 );
meshBuilder.Color4ub( color.r, color.g, color.b, color.a );
meshBuilder.Normal3fv( cross.Base() );
meshBuilder.AdvanceVertex();
// v3
tmp = v1 + scale*cross;
meshBuilder.Position3fv( tmp.Base() );
meshBuilder.TexCoord2f( 0, 0.0f, t0 );
meshBuilder.Color4ub( color.r, color.g, color.b, color.a );
meshBuilder.Normal3fv( cross.Base() );
meshBuilder.AdvanceVertex();
// v4
Vector v4 = start + t1 * lineDir;
meshBuilder.Position3fv( v4.Base() );
meshBuilder.TexCoord2f( 0, 0.5f, t1 );
meshBuilder.Color4ub( color.r, color.g, color.b, color.a );
meshBuilder.Normal3fv( cross.Base() );
meshBuilder.AdvanceVertex();
// v5
tmp = v4 - scale*cross;
meshBuilder.Position3fv( tmp.Base() );
meshBuilder.TexCoord2f( 0, 1.0f, t1 );
meshBuilder.Color4ub( color.r, color.g, color.b, color.a );
meshBuilder.Normal3fv( cross.Base() );
meshBuilder.AdvanceVertex();
// v6
tmp = v4 + scale*cross;
meshBuilder.Position3fv( tmp.Base() );
meshBuilder.TexCoord2f( 0, 0.0f, t1 );
meshBuilder.Color4ub( color.r, color.g, color.b, color.a );
meshBuilder.Normal3fv( cross.Base() );
meshBuilder.AdvanceVertex();
// v7
meshBuilder.Position3fv( end.Base() );
meshBuilder.TexCoord2f( 0, 0.5f, 1.0f );
meshBuilder.Color4ub( 0, 0, 0, 0 );
meshBuilder.Normal3fv( cross.Base() );
meshBuilder.AdvanceVertex();
// triangles - 0,2,1 - 0,1,3 - 7,4,5 - 7,6,4 - 1,4,6, 1,6,3 - 1,5,4 - 1,2,5
meshBuilder.FastIndex( 0 );
meshBuilder.FastIndex( 2 );
meshBuilder.FastIndex( 1 );
meshBuilder.FastIndex( 0 );
meshBuilder.FastIndex( 1 );
meshBuilder.FastIndex( 3 );
meshBuilder.FastIndex( 7 );
meshBuilder.FastIndex( 4 );
meshBuilder.FastIndex( 5 );
meshBuilder.FastIndex( 7 );
meshBuilder.FastIndex( 6 );
meshBuilder.FastIndex( 4 );
meshBuilder.FastIndex( 1 );
meshBuilder.FastIndex( 4 );
meshBuilder.FastIndex( 6 );
meshBuilder.FastIndex( 1 );
meshBuilder.FastIndex( 6 );
meshBuilder.FastIndex( 3 );
meshBuilder.FastIndex( 1 );
meshBuilder.FastIndex( 5 );
meshBuilder.FastIndex( 4 );
meshBuilder.FastIndex( 1 );
meshBuilder.FastIndex( 2 );
meshBuilder.FastIndex( 5 );
meshBuilder.End();
pMesh->Draw();
}
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();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : frametime -
//-----------------------------------------------------------------------------
void CFXLine::Draw( double frametime )
{
// Update the effect
Update( frametime );
Vector lineDir, viewDir;
//Get the proper orientation for the line
VectorSubtract( m_FXData.m_vecStart, m_FXData.m_vecEnd, lineDir );
VectorSubtract( m_FXData.m_vecEnd, CurrentViewOrigin(), viewDir );
Vector cross = lineDir.Cross( viewDir );
VectorNormalize( cross );
CMatRenderContextPtr pRenderContext( materials );
//Bind the material
IMesh* pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, m_FXData.m_pMaterial );
CMeshBuilder meshBuilder;
Vector tmp;
meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
float scaleTimePerc = ( m_FXData.m_flLifeTime / m_FXData.m_flDieTime );
float scale = m_FXData.m_flStartScale + ( ( m_FXData.m_flEndScale - m_FXData.m_flStartScale ) * scaleTimePerc );
color32 color = {255,255,255,255};
float alpha = m_FXData.m_flStartAlpha + ( ( m_FXData.m_flEndAlpha - m_FXData.m_flStartAlpha ) * scaleTimePerc );
alpha = clamp( alpha, 0.0f, 1.0f );
color.a *= alpha;
// Start
VectorMA( m_FXData.m_vecStart, -scale, cross, tmp );
meshBuilder.Position3fv( tmp.Base() );
meshBuilder.TexCoord2f( 0, 1.0f, 1.0f );
meshBuilder.Color4ub( color.r, color.g, color.b, color.a );
meshBuilder.Normal3fv( cross.Base() );
meshBuilder.AdvanceVertex();
VectorMA( m_FXData.m_vecStart, scale, cross, tmp );
meshBuilder.Position3fv( tmp.Base() );
meshBuilder.TexCoord2f( 0, 0.0f, 1.0f );
meshBuilder.Color4ub( color.r, color.g, color.b, color.a );
meshBuilder.Normal3fv( cross.Base() );
meshBuilder.AdvanceVertex();
// End
VectorMA( m_FXData.m_vecEnd, scale, cross, tmp );
meshBuilder.Position3fv( tmp.Base() );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.Color4ub( color.r, color.g, color.b, color.a );
meshBuilder.Normal3fv( cross.Base() );
meshBuilder.AdvanceVertex();
VectorMA( m_FXData.m_vecEnd, -scale, cross, tmp );
meshBuilder.Position3fv( tmp.Base() );
meshBuilder.TexCoord2f( 0, 1.0f, 0.0f );
meshBuilder.Color4ub( color.r, color.g, color.b, color.a );
meshBuilder.Normal3fv( cross.Base() );
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 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();
}
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();
}
}
static void OverlayColorRamp( bool bHalfSpace )
{
IMaterial *pMaterial;
float x, y, w, h;
pMaterial = materials->FindMaterial( "vgui/white", TEXTURE_GROUP_OTHER, true );
int backBufferWidth, backBufferHeight;
materials->GetBackBufferDimensions( backBufferWidth, backBufferHeight );
w = ( backBufferWidth == 1280 ) ? 1024 : 512;
h = 80;
x = ( backBufferWidth - w )/2;
y = ( backBufferHeight - 4*h )/2;
int numBands = 32;
int color0 = 0;
int color1 = bHalfSpace ? 127 : 255;
int colorStep = (color1 - color0 + 1)/numBands;
CMatRenderContextPtr pRenderContext( materials );
pRenderContext->Bind( pMaterial );
IMesh* pMesh = pRenderContext->GetDynamicMesh( true );
CMeshBuilder meshBuilder;
// draw ticks
int xx = x;
meshBuilder.Begin( pMesh, MATERIAL_LINES, numBands+1 );
for ( int i=0; i<numBands+1; i++ )
{
meshBuilder.Position3f( xx, y-10, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.Color3ub( 255, 255, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( xx, y, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.Color3ub( 255, 255, 0 );
meshBuilder.AdvanceVertex();
xx += w/numBands;
}
meshBuilder.End();
pMesh->Draw();
// black to white band
xx = x;
int color = color0;
meshBuilder.Begin( pMesh, MATERIAL_QUADS, numBands );
for ( int i=0; i<numBands+1; i++ )
{
meshBuilder.Position3f( xx, y, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.Color3ub( color, color, color );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( xx+w/numBands, y, 0.0f );
meshBuilder.TexCoord2f( 0, 1.0f, 0.0f );
meshBuilder.Color3ub( color, color, color );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( xx+w/numBands, y+h, 0.0f );
meshBuilder.TexCoord2f( 0, 1.0f, 1.0f );
meshBuilder.Color3ub( color, color, color );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( xx, y+h, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 1.0f );
meshBuilder.Color3ub( color, color, color );
meshBuilder.AdvanceVertex();
color += colorStep;
if ( color > 255 )
color = 255;
xx += w/numBands;
}
meshBuilder.End();
pMesh->Draw();
// white to black band
color = color1;
y += h;
xx = x;
meshBuilder.Begin( pMesh, MATERIAL_QUADS, numBands );
for ( int i=0; i<numBands+1; i++ )
{
meshBuilder.Position3f( xx, y, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.Color3ub( color, color, color );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( xx+w/numBands, y, 0.0f );
meshBuilder.TexCoord2f( 0, 1.0f, 0.0f );
meshBuilder.Color3ub( color, color, color );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( xx+w/numBands, y+h, 0.0f );
meshBuilder.TexCoord2f( 0, 1.0f, 1.0f );
meshBuilder.Color3ub( color, color, color );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( xx, y+h, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 1.0f );
meshBuilder.Color3ub( color, color, color );
meshBuilder.AdvanceVertex();
color -= colorStep;
if ( color < 0 )
color = 0;
xx += w/numBands;
}
meshBuilder.End();
pMesh->Draw();
// red band
color = color1;
y += h;
xx = x;
meshBuilder.Begin( pMesh, MATERIAL_QUADS, numBands );
for ( int i=0; i<numBands+1; i++ )
{
meshBuilder.Position3f( xx, y, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.Color3ub( color, 0, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( xx+w/numBands, y, 0.0f );
meshBuilder.TexCoord2f( 0, 1.0f, 0.0f );
meshBuilder.Color3ub( color, 0, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( xx+w/numBands, y+h, 0.0f );
meshBuilder.TexCoord2f( 0, 1.0f, 1.0f );
meshBuilder.Color3ub( color, 0, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( xx, y+h, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 1.0f );
meshBuilder.Color3ub( color, 0, 0 );
meshBuilder.AdvanceVertex();
color -= colorStep;
if ( color < 0 )
color = 0;
xx += w/numBands;
}
meshBuilder.End();
pMesh->Draw();
// green band
color = color1;
y += h;
xx = x;
meshBuilder.Begin( pMesh, MATERIAL_QUADS, numBands );
for ( int i=0; i<numBands+1; i++ )
{
meshBuilder.Position3f( xx, y, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.Color3ub( 0, color, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( xx+w/numBands, y, 0.0f );
meshBuilder.TexCoord2f( 0, 1.0f, 0.0f );
meshBuilder.Color3ub( 0, color, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( xx+w/numBands, y+h, 0.0f );
meshBuilder.TexCoord2f( 0, 1.0f, 1.0f );
meshBuilder.Color3ub( 0, color, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( xx, y+h, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 1.0f );
meshBuilder.Color3ub( 0, color, 0 );
meshBuilder.AdvanceVertex();
color -= colorStep;
if ( color < 0 )
color = 0;
xx += w/numBands;
}
meshBuilder.End();
pMesh->Draw();
// blue band
color = color1;
y += h;
xx = x;
meshBuilder.Begin( pMesh, MATERIAL_QUADS, numBands );
for ( int i=0; i<numBands+1; i++ )
{
meshBuilder.Position3f( xx, y, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.Color3ub( 0, 0, color );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( xx+w/numBands, y, 0.0f );
meshBuilder.TexCoord2f( 0, 1.0f, 0.0f );
meshBuilder.Color3ub( 0, 0, color );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( xx+w/numBands, y+h, 0.0f );
meshBuilder.TexCoord2f( 0, 1.0f, 1.0f );
meshBuilder.Color3ub( 0, 0, color );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( xx, y+h, 0.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 1.0f );
meshBuilder.Color3ub( 0, 0, color );
meshBuilder.AdvanceVertex();
color -= colorStep;
if ( color < 0 )
color = 0;
xx += w/numBands;
}
meshBuilder.End();
pMesh->Draw();
}
