void C_QUA_Strider::DrawHudElements( ) { CHudTexture *pIcon; //int iIconX, iIconY; // draw crosshairs for vehicle gun pIcon = gHUD.GetIcon( "gunhair" ); if ( pIcon != NULL ) { float x, y; Vector screen; x = ScreenWidth()/2; y = ScreenHeight()/2; ScreenTransform( m_vecGunCrosshair, screen ); x += 0.5 * screen[0] * ScreenWidth() + 0.5; y -= 0.5 * screen[1] * ScreenHeight() + 0.5; x -= pIcon->Width() / 2; y -= pIcon->Height() / 2; bool unable; unable=false; Color clr = ( unable ) ? gHUD.m_clrCaution : gHUD.m_clrNormal; pIcon->DrawSelf( x, y, clr ); } // Aqui pondremos el crosshair }
//----------------------------------------------------------------------------- // Purpose: Get the x & y positions of a world position in screenspace // Returns true if it's onscreen //----------------------------------------------------------------------------- bool GetVectorInScreenSpace( Vector pos, int& iX, int& iY, Vector *vecOffset ) { Vector screen; // Apply the offset, if one was specified if ( vecOffset != NULL ) pos += *vecOffset; // Transform to screen space int iFacing = ScreenTransform( pos, screen ); iX = 0.5 * screen[0] * ScreenWidth(); iY = -0.5 * screen[1] * ScreenHeight(); iX += 0.5 * ScreenWidth(); iY += 0.5 * ScreenHeight(); // Make sure the player's facing it if ( iFacing ) { // We're actually facing away from the Target. Stomp the screen position. iX = -640; iY = -640; return false; } return true; }
//----------------------------------------------------------------------------- // Purpose: // Input : pMaterial - // source - // color - //----------------------------------------------------------------------------- void DrawHaloOriented( const Vector& source, float scale, float const *color, float roll ) { Vector point, screen; CMatRenderContextPtr pRenderContext( materials ); IMesh* pMesh = pRenderContext->GetDynamicMesh(); CMeshBuilder meshBuilder; meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 ); // Transform source into screen space ScreenTransform( source, screen ); Vector right, up; float sr, cr; SinCos( roll, &sr, &cr ); for ( int i = 0; i < 3; i++ ) { right[i] = CurrentViewRight()[i] * cr + CurrentViewUp()[i] * sr; up[i] = CurrentViewRight()[i] * -sr + CurrentViewUp()[i] * cr; } meshBuilder.Color3fv (color); meshBuilder.TexCoord2f (0, 0, 1); VectorMA (source, -scale, up, point); VectorMA (point, -scale, right, point); meshBuilder.Position3fv (point.Base()); meshBuilder.AdvanceVertex(); meshBuilder.Color3fv (color); meshBuilder.TexCoord2f (0, 0, 0); VectorMA (source, scale, up, point); VectorMA (point, -scale, right, point); meshBuilder.Position3fv (point.Base()); meshBuilder.AdvanceVertex(); meshBuilder.Color3fv (color); meshBuilder.TexCoord2f (0, 1, 0); VectorMA (source, scale, up, point); VectorMA (point, scale, right, point); meshBuilder.Position3fv (point.Base()); meshBuilder.AdvanceVertex(); meshBuilder.Color3fv (color); meshBuilder.TexCoord2f (0, 1, 1); VectorMA (source, -scale, up, point); VectorMA (point, scale, right, point); meshBuilder.Position3fv (point.Base()); meshBuilder.AdvanceVertex(); meshBuilder.End(); pMesh->Draw(); }
//----------------------------------------------------------------------------- // Purpose: // Input : pMaterial - // source - // color - //----------------------------------------------------------------------------- void DrawHalo(IMaterial* pMaterial, const Vector& source, float scale, float const* color, float flHDRColorScale ) { static unsigned int nHDRColorScaleCache = 0; Vector point, screen; if( pMaterial ) { IMaterialVar *pHDRColorScaleVar = pMaterial->FindVarFast( "$hdrcolorscale", &nHDRColorScaleCache ); if( pHDRColorScaleVar ) { pHDRColorScaleVar->SetFloatValue( flHDRColorScale ); } } CMatRenderContextPtr pRenderContext( materials ); IMesh* pMesh = pRenderContext->GetDynamicMesh( ); CMeshBuilder meshBuilder; meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 ); // Transform source into screen space ScreenTransform( source, screen ); meshBuilder.Color3fv (color); meshBuilder.TexCoord2f (0, 0, 1); VectorMA (source, -scale, CurrentViewUp(), point); VectorMA (point, -scale, CurrentViewRight(), point); meshBuilder.Position3fv (point.Base()); meshBuilder.AdvanceVertex(); meshBuilder.Color3fv (color); meshBuilder.TexCoord2f (0, 0, 0); VectorMA (source, scale, CurrentViewUp(), point); VectorMA (point, -scale, CurrentViewRight(), point); meshBuilder.Position3fv (point.Base()); meshBuilder.AdvanceVertex(); meshBuilder.Color3fv (color); meshBuilder.TexCoord2f (0, 1, 0); VectorMA (source, scale, CurrentViewUp(), point); VectorMA (point, scale, CurrentViewRight(), point); meshBuilder.Position3fv (point.Base()); meshBuilder.AdvanceVertex(); meshBuilder.Color3fv (color); meshBuilder.TexCoord2f (0, 1, 1); VectorMA (source, -scale, CurrentViewUp(), point); VectorMA (point, scale, CurrentViewRight(), point); meshBuilder.Position3fv (point.Base()); meshBuilder.AdvanceVertex(); meshBuilder.End(); pMesh->Draw(); }
bool CNeeded::WorldToScreen( const Vector &vOrigin, Vector &vScreen ) { if( ScreenTransform(vOrigin , vScreen) == false ){ int iScreenWidth, iScreenHeight; g_pEngine->GetScreenSize( iScreenWidth, iScreenHeight ); float x = iScreenWidth / 2; float y = iScreenHeight / 2; x += 0.5 * vScreen.x * iScreenWidth + 0.5; y -= 0.5 * vScreen.y * iScreenHeight + 0.5; vScreen.x = x; vScreen.y = y; return true; } return false; }
bool CNeeded::TransformVector( Vector v, Vector &s ) { if( ScreenTransform( v, s ) == false ){ int sw, sh; g_pEngine->GetScreenSize( sw, sh ); float x = sw / 2; float y = sh / 2; x += 0.5 * s.x * sw + 0.5; y -= 0.5 * s.y * sh + 0.5; s.x = x; s.y = y; return true; } return false; }
void vParticleOperator_GravityWorld::Simulate( vParticle *parent ) { float dot_z = DotProduct( MainViewForward(), Vector( 0, 0, -1 ) ); float rotation_dir = Sign( dot_z ); int vx, vy, w, t; vgui::surface()->GetFullscreenViewport( vx, vy, w, t ); Vector screen; if ( ScreenTransform( MainViewOrigin() + Vector( 0, 0, 100 ), screen ) ) ScreenTransform( MainViewOrigin() - Vector( 0, 0, 100 ), screen ); screen *= Vector( 0.5f, -0.5f, 0 ); screen += Vector( 0.5f, 0.5f, 0 ); Vector2D gravity_center( w * screen.x, t * screen.y ); Vector2D delta = parent->vecPos - gravity_center; float screenLength = delta.NormalizeInPlace(); delta *= rotation_dir * -1.0f; Vector2D accel = delta * vParticle::GetRelativeScale() * GetImpulse( parent ) * amt; float speedMult = 1.0f; if ( rotation_dir > 0 ) { float drag = RemapValClamped( rotation_dir, 0.5f, 1, 1, 0.00001f ); ScaleByFrametime( drag ); speedMult = RemapValClamped( (screenLength/vParticle::GetRelativeScale()), 0, 1000, 0, 1 ) * (1.0f - drag) + drag; } parent->vecVelocity += accel; parent->vecVelocity *= speedMult; }
SDK::Vector WorldToScreen( const SDK::Vector &origin ) { SDK::Vector screen; if(!ScreenTransform( origin, screen )) { int iScreenWidth, iScreenHeight; SDK::Interfaces::g_pEngine->GetScreenSize( iScreenWidth, iScreenHeight ); float fScreenX = iScreenWidth / 2.0f; float fScreenY = iScreenHeight / 2.0f; fScreenX += 0.5f * screen.x * iScreenWidth + 0.5f; fScreenY -= 0.5f * screen.y * iScreenHeight + 0.5f; screen.x = fScreenX; screen.y = fScreenY; } return screen; }
bool CGodRaysEffect::SetMaterialParms( const Vector& vLightPos ) { int nSunX, nSunY; bool bOnScreen = GetVectorInHudSpace( vLightPos, nSunX, nSunY ); if( bOnScreen ) { // Set the material parameters. m_pGrDecayVar->SetFloatValue( gfx_gr_decay.GetFloat() ); m_pGrDensityVar->SetFloatValue( gfx_gr_density.GetFloat() ); m_pGrExposureVar->SetFloatValue( gfx_gr_exposure.GetFloat() ); m_pGrWeightVar->SetFloatValue( gfx_gr_weight.GetFloat() ); // Set the sun position. float flSunX = float( nSunX ) / float( ScreenWidth() ); float flSunY = float( nSunY ) / float( ScreenHeight() ); m_pGrSunPosVar->SetVecValue(flSunX, flSunY); } return bOnScreen; #if 0 // Convert from 3d to 2d. Vector vLightPos2d; int behind = ScreenTransform( vLightPos, vLightPos2d ); if( behind == 0 ) { m_pGrDecayVar->SetFloatValue( gfx_gr_decay.GetFloat() ); m_pGrDensityVar->SetFloatValue( gfx_gr_density.GetFloat() ); m_pGrExposureVar->SetFloatValue( gfx_gr_exposure.GetFloat() ); m_pGrWeightVar->SetFloatValue( gfx_gr_weight.GetFloat() ); int sunX, sunY; GetVectorInScreenSpace( vLightPos, sunX, sunY ); m_pGrSunPosVar->SetVecValue( sunX / ScreenWidth(), sunY / ScreenHeight() ); return true; } return false; #endif }
bool WorldToScreen(const Vector &origin, Vector &screen) { bool ret = false; if (!ScreenTransform(origin, screen)) { int width, height; structs.engine->GetScreenSize(&width, &height); fScreenX = int(width / 2); fScreenY = int(height / 2); fScreenX += 0.5f * screen.x * width + 0.5f; fScreenY -= 0.5f * screen.y * height + 0.5f; screen.x = fScreenX; screen.y = fScreenY; ret = true; } return ret; }
void PointerMotionAction(Graph *graph, XPointerMovedEvent *motionevent) { int sx2, sy2; int sx1, sy1; int button; float x1, y1; float x2, y2; float x, y; /* * get the location of the cursor */ sx2 = motionevent->x; sy2 = motionevent->y; /* * get the button pressed */ button = (motionevent->state & 0xFF00) >> 8; switch (ButtonMode()) { case PINCHMODE: /* * pinch at the cursor location */ WorldTransform(graph, sx2, sy2, &x2, &y2); NBShowCoords((BasicWindow *)graph->frame->text, 0, graph->fontheight, x2, y2); break; case TEXTMODE: /* * if its in text mode then read out the cursor location */ ShowCursorCoords((BasicWindow *)graph->frame->text, 0, graph->fontheight, sx2, sy2); break; case DRAWMODE: /* * If it's in screen coord mode then read out the cursor location. */ switch (button) { case 1: /* draw line */ if (graph->dragx1 != -1) { if (graph->dragx2 != -1) { /* * erase the old drag line from the starting drag * coordinates drag->x1, y1 to the previous end * coordinates drag->x2, y2. */ EraseSuperLine((BasicWindow *)graph, graph->dragx1, graph->dragy1, graph->dragx2, graph->dragy2); } /* * get the world coordinates of the initial drag point */ x1 = graph->dragwx1; y1 = graph->dragwy1; /* * get the world coordinates of the current cursor * location */ WorldTransform(graph, sx2, sy2, &x2, &y2); /* * update the drag coordinates to the current location */ graph->dragx2 = sx2; graph->dragy2 = sy2; /* * display data about the line between the points in the * text window */ ShowSlopeCoords((BasicWindow *)graph->frame->text, 0, graph->fontheight, x1, y1, x2, y2); /* * draw the new drag line */ DrawSuperLine((BasicWindow *)graph, graph->dragx1, graph->dragy1, graph->dragx2, graph->dragy2); } break; } break; case DATAMODE: switch (button) { case 1: /* zoom box */ if (graph->dragx1 != -1) { if (graph->dragx2 != -1) { /* * erase the old drag rectangle */ EraseSuperBox((BasicWindow *)graph, graph->dragx1, graph->dragy1, graph->dragx2, graph->dragy2); } graph->dragx2 = sx2; graph->dragy2 = sy2; /* * draw the new drag rectangle */ DrawSuperBox((BasicWindow *)graph, graph->dragx1, graph->dragy1, graph->dragx2, graph->dragy2); } break; case 2: /* ruler line */ if (graph->dragx1 != -1) { if (graph->dragx2 != -1) { /* * erase the old drag line from the starting drag * coordinates drag->x1, y1 to the previous end * coordinates drag->x2, y2. */ EraseSuperLine((BasicWindow *)graph, graph->dragx1, graph->dragy1, graph->dragx2, graph->dragy2); } /* * get the world coordinates of the initial drag point */ x1 = graph->dragwx1; y1 = graph->dragwy1; if (snapmode) { /* * get the data coordinates closest to the current cursor * location */ Snap(graph, sx2, sy2, &x2, &y2); /* * compute the screen coordinate of the data point */ ScreenTransform(graph, x2, y2, &sx1, &sy1); /* * update the drag coordinates to the current location */ graph->dragx2 = sx1; graph->dragy2 = sy1; } else { /* * get the world coordinates of the current cursor * location */ WorldTransform(graph, sx2, sy2, &x2, &y2); /* * update the drag coordinates to the current location */ graph->dragx2 = sx2; graph->dragy2 = sy2; } /* * display data about the line between the points in the * text window */ ShowSlopeCoords((BasicWindow *)graph->frame->text, 0, graph->fontheight, x1, y1, x2, y2); /* * draw the new drag line */ DrawSuperLine((BasicWindow *)graph, graph->dragx1, graph->dragy1, graph->dragx2, graph->dragy2); } break; case 4: /* * get the data point whose screen x coordinate is closest to the * current cursor location */ Snap(graph, sx2, sy2, &x, &y); /* * compute the screen coordinate of the data point */ ScreenTransform(graph, x, y, &sx1, &sy1); /* * erase the previous line */ EraseSuperLine((BasicWindow *)graph, graph->dragx2, graph->dragy2, graph->dragx2, graph->dragy1); /* * and draw a new line using the x coordinate of the data point * and the y coordinates of the cursor and the data point */ graph->dragx1 = sx2; graph->dragy1 = sy2; graph->dragx2 = sx1; graph->dragy2 = sy1; DrawSuperLine((BasicWindow *)graph, sx1, sy1, sx1, sy2); /* * display the data coordinates in the text window */ NBShowCoords((BasicWindow *)graph->frame->text, 0, graph->fontheight, x, y); break; } break; } }
void ButtonReleaseAction(Graph *graph, XButtonReleasedEvent *buttonevent) { int button; int sx2, sy2; int sx1, sy1; float x1, y1, x2, y2; button = buttonevent->button; sx2 = buttonevent->x; sy2 = buttonevent->y; switch (ButtonMode()) { case DATAMODE: switch (button) { case 1: /* zoom box */ /* * mark the end of the drag and zoom */ graph->dragx2 = sx2; graph->dragy2 = sy2; WorldTransform(graph, graph->dragx1, graph->dragy1, &x1, &y1); WorldTransform(graph, graph->dragx2, graph->dragy2, &x2, &y2); /* * Don't perform a zero scale action. */ if (x2 == x1 || y2 == y1) return; if (x2 > x1) { graph->wxmin = x1; graph->wxmax = x2; } else { graph->wxmin = x2; graph->wxmax = x1; } if (y2 > y1) { graph->wymin = y1; graph->wymax = y2; } else { graph->wymin = y2; graph->wymax = y1; } ScaleAndRefreshGraph(graph); /* * set the drag coords back to the invalid state */ graph->dragx1 = -1; graph->dragx2 = -1; break; case 2: /* ruler line */ /* * get the world coordinates of the starting point */ x1 = graph->dragwx1; y1 = graph->dragwy1; if (sx2 != graph->dragx1 || sy2 != graph->dragy1) { if (snapmode) { /* * display the final coords */ Snap(graph, sx2, sy2, &x2, &y2); /* * compute the screen coordinate of the data point */ ScreenTransform(graph, x2, y2, &sx1, &sy1); ShowCoords((BasicWindow *)graph, sx1, sy1, x2, y2); } else { /* * display the final coords */ WorldTransform(graph, sx2, sy2, &x2, &y2); ShowCoords((BasicWindow *)graph, sx2, sy2, x2, y2); } ClearWindow((BasicWindow *)graph->frame->text); ShowSlope((BasicWindow *)graph->frame->text, 0, graph->fontheight, x1, y1, x2, y2); AddLabelLine((BasicWindow *)graph, 0, 0, 0, 0, x1, y1, x2, y2, WORLD_LBL, TEMPORARY_LBL); } /* * set the drag coords back to the invalid state */ graph->dragx1 = -1; graph->dragx2 = -1; break; case 3: /* drag line */ /* * erase the old line */ EraseSuperLine((BasicWindow *)graph, graph->dragx2, graph->dragy1, graph->dragx2, graph->dragy2); /* * get the coords */ Snap(graph, sx2, sy2, &x2, &y2); ShowCoords((BasicWindow *)graph, graph->dragx2, graph->dragy2, x2, y2); graph->dragx1 = -1; graph->dragx2 = -1; break; } break; case DRAWMODE: switch (button) { case 1: /* draw line */ /* * mark the end of the drag and zoom */ graph->dragx2 = sx2; graph->dragy2 = sy2; WorldTransform(graph, graph->dragx1, graph->dragy1, &x1, &y1); WorldTransform(graph, graph->dragx2, graph->dragy2, &x2, &y2); /* * draw a line between the points */ AddLabelLine((BasicWindow *)graph, 0, 0, 0, 0, x1, y1, x2, y2, WORLD_LBL, TEMPORARY_LBL); /* * set the drag coords back to the invalid state */ graph->dragx1 = -1; graph->dragx2 = -1; break; } break; } }
void ButtonPressAction(Graph *graph, XButtonPressedEvent *buttonevent) { float x, y; int sx1, sy1; int sx2, sy2; int button; sx1 = buttonevent->x; sy1 = buttonevent->y; button = buttonevent->button; switch (ButtonMode()) { case DATAMODE: switch (button) { case 1: /* * mark the start of the drag location */ graph->dragx1 = sx1; graph->dragy1 = sy1; break; case 2: ClearWindow((BasicWindow *)graph->frame->text); if (snapmode) { /* * world coord xy readout of data */ Snap(graph, sx1, sy1, &x, &y); /* * get the screen coords of the data point */ ScreenTransform(graph, x, y, &sx2, &sy2); ShowCoords((BasicWindow *)graph, sx2, sy2, x, y); /* * mark the start of the drag location */ graph->dragx1 = sx2; graph->dragy1 = sy2; } else { /* * world coord xy readout of cursor location */ WorldTransform(graph, sx1, sy1, &x, &y); ShowCoords((BasicWindow *)graph, sx1, sy1, x, y); /* * mark the start of the drag location */ graph->dragx1 = sx1; graph->dragy1 = sy1; } graph->dragwx1 = x; graph->dragwy1 = y; break; case 3: /* * world coord xy readout closest above point */ Snap(graph, sx1, sy1, &x, &y); /* * draw a line to the point on the plot (sx2, sy2) */ ScreenTransform(graph, x, y, &sx2, &sy2); /* avoid writing on the last pixel */ if (sy2 > sy1) { sy2 -= 1; } else { sy2 += 1; } graph->dragx1 = sx1; graph->dragy1 = sy1; graph->dragx2 = sx2; graph->dragy2 = sy2; DrawSuperLine((BasicWindow *)graph, sx2, sy1, sx2, sy2); ClearWindow((BasicWindow *)graph->frame->text); NBShowCoords((BasicWindow *)graph->frame->text, 0, graph->fontheight, x, y); } break; case DRAWMODE: switch (button) { case 1: /* * mark the start of the line */ graph->dragx1 = sx1; graph->dragy1 = sy1; WorldTransform(graph, sx1, sy1, &x, &y); graph->dragwx1 = x; graph->dragwy1 = y; break; } break; case ZAPMODE: switch (button) { case 1: /* * delete the label */ ZapLabel(graph, (XKeyEvent *)buttonevent); break; } break; case PINCHMODE: switch (button) { case 1: /* * offset the plots */ OffsetPlotGraphically(graph, buttonevent->x, buttonevent->y, 0); break; } break; } }
void DrawXTicks(Graph *graph) { int sx1, sy1; int sx2, sy2; int i; float yint; float val; float scale; int tmp; int axisx; int j; if (graph->xaxis_desired_nticks == 0) { graph->xaxis_nticks = 1; return; } /* * Get the screen coordinates of the axis. */ SetColor(graph->foreground); yint = graph->xaxis_yintcpt; ScreenTransform(graph, graph->wxmin, yint, &sx1, &sy1); ScreenTransform(graph, graph->wxmax, yint, &sx2, &sy2); scale = 1.0 / pow((double) 10.0, (double) graph->xaxis_exponent); ScreenTransform(graph, graph->yaxis_xintcpt, 0.0, &axisx, &tmp); for (i = 0; i < graph->xaxis_nticks; i++) { for (j = 0; j < graph->xaxis_nsubticks + 1; j++) { val = i * graph->xaxis_tickinc + graph->xaxis_tickstart + j * graph->xaxis_tickinc / (graph->xaxis_nsubticks + 1); ScreenTransform(graph, val, graph->xaxis_yintcpt, &sx1, &sy1); /* * Either draw a grid or just tick marks at the tick intervals. */ if (graph->show_xgrid) { SetColor(graph->gridcolor); SetLinestyle((BasicWindow *)graph, 1); DrawLine(sx1, 0, sx1, graph->wheight); SetLinestyle((BasicWindow *)graph, 0); SetColor(graph->foreground); } if (!(graph->quadrants & 0x1) && !(graph->quadrants & 0x4)) continue; /* * Check for quadrants I. */ if (!(graph->quadrants & 0x1) && sx1 > axisx) continue; /* * Check for quadrants III. */ if (!(graph->quadrants & 0x4) && sx1 < axisx) continue; if (j == 0) { DrawLine(sx1, sy1 - graph->ticksize, sx1, sy2 + graph->ticksize); /* * label the ticks */ if (graph->show_xlabels) { DrawXTickLabel(graph, sx1, sy1, val, scale, graph->xaxis_leftdp, graph->xaxis_rightdp); } } else { DrawLine(sx1, sy1 - (int) (0.5 * graph->ticksize), sx1, sy2 + (int) (0.5 * graph->ticksize)); } } } }
void DrawYTicks(Graph *graph) { int sx1, sy1; int sx2, sy2; int i; float xint; float val; float scale; int tmp; int axisy; int j; if (graph->yaxis_desired_nticks == 0) { graph->yaxis_nticks = 1; return; } /* * Get the screen coordinates of the axis. */ SetColor(graph->foreground); xint = graph->yaxis_xintcpt; ScreenTransform(graph, xint, graph->wymin, &sx1, &sy1); ScreenTransform(graph, xint, graph->wymax, &sx2, &sy2); /* * Get the axis exponent. */ scale = 1.0 / pow((double) 10.0, (double) graph->yaxis_exponent); ScreenTransform(graph, 0.0, graph->xaxis_yintcpt, &tmp, &axisy); /* * Loop over all the tick marks. */ for (i = 0; i < graph->yaxis_nticks; i++) { for (j = 0; j < graph->yaxis_nsubticks + 1; j++) { /* * Get the actual value of the tick. */ val = i * graph->yaxis_tickinc + graph->yaxis_tickstart + j * graph->yaxis_tickinc / (graph->yaxis_nsubticks + 1); /* * Locate its screen position in the window. */ ScreenTransform(graph, graph->yaxis_xintcpt, val, &sx1, &sy1); /* * Either draw a grid or just tick marks at the tick intervals. */ if (graph->show_ygrid) { SetColor(graph->gridcolor); SetLinestyle((BasicWindow *)graph, 1); DrawLine(0, sy1, graph->wwidth, sy1); SetLinestyle((BasicWindow *)graph, 0); SetColor(graph->foreground); } if (!(graph->quadrants & 0x2) && !(graph->quadrants & 0x8)) continue; /* * Check for quadrants II. */ if (!(graph->quadrants & 0x2) && sy1 < axisy) continue; /* * Check for quadrants IV. */ if (!(graph->quadrants & 0x8) && sy1 > axisy) continue; if (j == 0) { DrawLine(sx1 - graph->ticksize, sy1, sx2 + graph->ticksize, sy1); /* * Label the ticks. */ if (graph->show_ylabels) { DrawYTickLabel(graph, sx1, sy1, val, scale, graph->yaxis_leftdp, graph->yaxis_rightdp); } } else { DrawLine(sx1 - (int) (0.5 * graph->ticksize), sy1, sx2 + (int) (0.5 * graph->ticksize), sy1); } } } }
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 C_PropVehicleDriveable::DrawHudElements( ) { CHudTexture *pIcon; int iIconX, iIconY; if (m_bHasGun) { // draw crosshairs for vehicle gun pIcon = gHUD.GetIcon( "gunhair" ); if ( pIcon != NULL ) { float x, y; if( UseVR() ) { C_BasePlayer *pPlayer = (C_BasePlayer *)GetPassenger( VEHICLE_ROLE_DRIVER ); Vector vecStart, vecDirection; pPlayer->EyePositionAndVectors( &vecStart, &vecDirection, NULL, NULL ); Vector vecEnd = vecStart + vecDirection * MAX_TRACE_LENGTH; trace_t tr; UTIL_TraceLine( vecStart, vecEnd, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr ); Vector screen; screen.Init(); ScreenTransform(tr.endpos, screen); int vx, vy, vw, vh; vgui::surface()->GetFullscreenViewport( vx, vy, vw, vh ); float screenWidth = vw; float screenHeight = vh; x = 0.5f * ( 1.0f + screen[0] ) * screenWidth + 0.5f; y = 0.5f * ( 1.0f - screen[1] ) * screenHeight + 0.5f; } else { Vector screen; x = ScreenWidth()/2; y = ScreenHeight()/2; #if TRIANGULATED_CROSSHAIR ScreenTransform( m_vecGunCrosshair, screen ); x += 0.5 * screen[0] * ScreenWidth() + 0.5; y -= 0.5 * screen[1] * ScreenHeight() + 0.5; #endif } x -= pIcon->Width() / 2; y -= pIcon->Height() / 2; Color clr = ( m_bUnableToFire ) ? gHUD.m_clrCaution : gHUD.m_clrNormal; pIcon->DrawSelf( x, y, clr ); } if ( m_nScannerDisabledWeapons ) { // Draw icons for scanners "weps disabled" pIcon = gHUD.GetIcon( "dmg_bio" ); if ( pIcon ) { iIconY = 467 - pIcon->Height() / 2; iIconX = 385; if ( !m_bScannerWepIcon ) { pIcon->DrawSelf( XRES(iIconX), YRES(iIconY), Color( 0, 0, 255, 255 ) ); m_bScannerWepIcon = true; m_iScannerWepFlashTimer = 0; m_bScannerWepDim = true; } else { pIcon->DrawSelf( XRES(iIconX), YRES(iIconY), Color( 0, 0, GetFlashColorIntensity(55, 255, m_bScannerWepDim, 10, m_iScannerWepFlashTimer), 255 ) ); m_iScannerWepFlashTimer++; m_iScannerWepFlashTimer %= 20; if(!m_iScannerWepFlashTimer) m_bScannerWepDim ^= 1; } } } } if ( m_nScannerDisabledVehicle ) { // Draw icons for scanners "vehicle disabled" pIcon = gHUD.GetIcon( "dmg_bio" ); if ( pIcon ) { iIconY = 467 - pIcon->Height() / 2; iIconX = 410; if ( !m_bScannerVehicleIcon ) { pIcon->DrawSelf( XRES(iIconX), YRES(iIconY), Color( 0, 0, 255, 255 ) ); m_bScannerVehicleIcon = true; m_iScannerVehicleFlashTimer = 0; m_bScannerVehicleDim = true; } else { pIcon->DrawSelf( XRES(iIconX), YRES(iIconY), Color( 0, 0, GetFlashColorIntensity(55, 255, m_bScannerVehicleDim, 10, m_iScannerVehicleFlashTimer), 255 ) ); m_iScannerVehicleFlashTimer++; m_iScannerVehicleFlashTimer %= 20; if(!m_iScannerVehicleFlashTimer) m_bScannerVehicleDim ^= 1; } } } }