//----------------------------------------------------------------------------- // 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(); }