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