void AvHSpriteDrawTiles(int spriteHandle, int numXFrames, int numYFrames, float x1, float y1, float x2, float y2, float u1, float v1, float u2, float v2) { float dx = x2 - x1; float dy = y2 - y1; float oldDepth = gDepth; for (int frameY = 0; frameY < numYFrames; ++frameY) { for (int frameX = 0; frameX < numXFrames; ++frameX) { int frame = frameX + frameY * numXFrames; float pw = SPR_Width(spriteHandle, frame); float ph = SPR_Height(spriteHandle, frame); float fx1 = ((float)(frameX)) / numXFrames; float fy1 = ((float)(frameY)) / numYFrames; float fx2 = ((float)(frameX + 1)) / numXFrames; float fy2 = ((float)(frameY + 1)) / numYFrames; gDepth = oldDepth; AvHSpriteDraw(spriteHandle, frame, x1 + dx * fx1, y1 + dy * fy1, x1 + dx * fx2, y1 + dy * fy2, 0, 0, 1, 1); } } }
void UIDrawVariableBarSpriteHoles(int inSprite, int inX, int inY, float inPercentage) { // Assumes that frame 0 is the empty sprite, frame 1 is full sprite const int kEmptyFrame = 0; const int kFullFrame = 1; int theSpriteWidth = SPR_Width(inSprite, kFullFrame); int theSpriteHeight = SPR_Height(inSprite, kFullFrame); int theColorComponent = 255; // Draw empty sprite SPR_Set(inSprite, theColorComponent, theColorComponent, theColorComponent); SPR_DrawHoles(kEmptyFrame, inX, inY, NULL); // Draw secondary level if specified, at half brightness int theFilledHeight = theSpriteHeight*inPercentage; theFilledHeight = theSpriteHeight*inPercentage; // Draw partially full sprite. Enable scissor so it's not all drawn. SPR_EnableScissor(inX, inY + (theSpriteHeight - theFilledHeight), theSpriteWidth, theFilledHeight); SPR_Set(inSprite, theColorComponent, theColorComponent, theColorComponent); SPR_DrawHoles(kFullFrame, inX, inY, NULL); SPR_DisableScissor(); }
// Redraw // step through the local data, placing the appropriate graphics & text as appropriate // returns 1 if they've changed, 0 otherwise int CHud :: Redraw( float flTime, int intermission ) { m_fOldTime = m_flTime; // save time of previous redraw m_flTime = flTime; m_flTimeDelta = (double)m_flTime - m_fOldTime; // Clock was reset, reset delta if ( m_flTimeDelta < 0 ) m_flTimeDelta = 0; m_iIntermission = intermission; // if no redrawing is necessary // return 0; HUDLIST *pList = m_pHudList; while (pList) { if ( !intermission ) { if ((pList->p->m_iFlags & HUD_ACTIVE) && !(m_iHideHUDDisplay & HIDEHUD_ALL)) pList->p->Draw(flTime); } else { // it's an intermission, so only draw hud elements that are set to draw during intermissions if ( pList->p->m_iFlags & HUD_INTERMISSION ) pList->p->Draw( flTime ); } pList = pList->pNext; } // are we in demo mode? do we need to draw the logo in the top corner? if (m_iLogo) { int x, y, i; if (m_hsprLogo == 0) m_hsprLogo = LoadSprite("sprites/%d_logo.spr"); SPR_Set(m_hsprLogo, 250, 250, 250 ); x = SPR_Width(m_hsprLogo, 0); x = ScreenWidth - x; y = SPR_Height(m_hsprLogo, 0)/2; // Draw the logo at 20 fps int iFrame = (int)(flTime * 20) % MAX_LOGO_FRAMES; i = grgLogoFrame[iFrame] - 1; SPR_DrawAdditive(i, x, y, NULL); } return 1; }
bool AvHFont::Load(const char* inFileName) { std::string theSpriteFileName; theSpriteFileName = inFileName; theSpriteFileName += ".spr"; std::string theWidthFileName; theWidthFileName = getModDirectory(); theWidthFileName += "/"; theWidthFileName += inFileName; theWidthFileName += ".dat"; FILE* file = fopen(theWidthFileName.c_str(), "rb"); if (file != NULL) { struct LABC { long a; long b; long c; }; LABC labc[256]; fread(labc, sizeof(LABC), 256, file); for (int i = 0; i < 256; ++i) { mCharWidth[i].a = labc[i].a; mCharWidth[i].b = labc[i].b; mCharWidth[i].c = labc[i].c; } fclose(file); } else { return false; } mSprite = Safe_SPR_Load(theSpriteFileName.c_str()); if (mSprite != 0) { mSpriteWidth = SPR_Width(mSprite, 0); mSpriteHeight = SPR_Height(mSprite, 0); } return mSprite != 0; }
int CHudTrain::Draw( float fTime ) { if( !m_hSprite ) m_hSprite = LoadSprite( "sprites/640_train.spr" ); if( m_iPos ) { int r, g, b, x, y; UnpackRGB( r, g, b, gHUD.m_iHUDColor ); SPR_Set( m_hSprite, r, g, b ); // This should show up to the right and part way up the armor number y = ScreenHeight - SPR_Height( m_hSprite, 0 ) - gHUD.m_iFontHeight; x = ScreenWidth / 3 + SPR_Width( m_hSprite, 0 ) / 4; SPR_DrawAdditive( m_iPos - 1, x, y, NULL ); } return 1; }
// Demonstrates black lines around the edge of sprites (both using tri API and SPR_* calls) // Demonstrates scissor not working properly void Direct3DTest() { static int theSprite = 0; if(!theSprite) { theSprite = Safe_SPR_Load("sprites/640a-energy.spr"); } // Draw alien energy if(theSprite) { int theFrame = 0; int theX = ScreenWidth() - SPR_Width(theSprite, theFrame); int theY = ScreenHeight() - SPR_Height(theSprite, theFrame); // 0-1, depending how much to draw float theFactor = .5f; UIDrawVariableBarSpriteHoles(theSprite, theX, theY, theFactor); } }
void FadingImageLabel::DoPaint() { //const float thePercentToChopOffXEdge = .1f; //const float thePercentToChopOffYEdge = 0.0f; int theX, theY; this->getPos(theX, theY); //if(!IEngineStudio.IsHardware()) //{ // theX += ScreenWidth/2; // theY += ScreenHeight/2; //} int theWidth, theHeight; this->getSize(theWidth, theHeight); //ASSERT(this->mVisibleWidth <= theWidth); //ASSERT(this->mVisibleHeight <= theHeight); if((this->mVisibleWidth <= theWidth) && (this->mVisibleHeight <= theHeight)) { int r, g, b, a; this->getBgColor(r, g, b, a); float theGammaSlope = gHUD.GetGammaSlope(); r = r/theGammaSlope; g = g/theGammaSlope; b = b/theGammaSlope; // Don't take gamma slope into account for alpha a = 255 - a; ////int theXBorder = thePercentToChopOffXEdge*ScreenWidth; ////int theYBorder = thePercentToChopOffYEdge*ScreenHeight; int theXBorder = (theWidth - this->mVisibleWidth)/2; int theYBorder = (theHeight - this->mVisibleHeight)/2; //vguiSimpleBox(theXBorder, theYBorder, theWidth - theXBorder*2 + theXBorder, theHeight - theYBorder*2 + theYBorder, r, g, b, a); if(!this->mImageMode) { //FillRGBA(theXBorder, theYBorder, theWidth - theXBorder*2, theHeight - theYBorder*2, r, g, b, a); //int theSprite = Safe_SPR_Load("sprites/marinenode.spr"); //DrawScaledHUDSprite(theSprite, kRenderTransAdd, 1, theX, theY, theWidth, theHeight, 0); gEngfuncs.pTriAPI->RenderMode(kRenderTransAlpha); gEngfuncs.pTriAPI->CullFace(TRI_NONE); //gEngfuncs.pTriAPI->Brightness(1); theX = theXBorder; theY = theYBorder; theWidth = theWidth - theXBorder*2; theHeight = theHeight - theYBorder*2; // 0 = selectable, valid // 1 = selectable, valid, current // 2 = selectable, invalid // 3 = selectable, invalid, current int theFrame = 0; if(this->GetEnabled() && this->GetDrawHighlighted()) { theFrame = 1; } else if(!this->GetEnabled()) { theFrame = this->GetFadeState() ? 3 : 2; } //char theFrameNumber[64]; //sprintf(theFrameNumber, "Frame %d", theFrame); //this->mTextImage.setText(theFrameNumber); if(!this->mSprite) { this->mSprite = Safe_SPR_Load(this->mImageName.c_str()); this->mSpriteWidth = SPR_Width(this->mSprite, this->mSpriteFrame); this->mSpriteHeight = SPR_Height(this->mSprite, this->mSpriteFrame); ASSERT(this->mSprite > 0); } if(this->mSprite && gEngfuncs.pTriAPI->SpriteTexture((struct model_s*)gEngfuncs.GetSpritePointer(this->mSprite), theFrame)) { gEngfuncs.pTriAPI->Begin(TRI_TRIANGLE_STRIP); vec3_t theVertex; gEngfuncs.pTriAPI->TexCoord2f(0, 1); theVertex.x = theX; theVertex.y = theY + theHeight; theVertex.z = 0; //gEngfuncs.pTriAPI->Color4ub(255, 255, 255, a); gEngfuncs.pTriAPI->Vertex3fv((float*)&theVertex); gEngfuncs.pTriAPI->TexCoord2f(0, 0); theVertex.x = theX; theVertex.y = theY; //gEngfuncs.pTriAPI->Color4ub(255, 255, 255, a); gEngfuncs.pTriAPI->Vertex3fv((float*)&theVertex); gEngfuncs.pTriAPI->TexCoord2f(1, 1); theVertex.x = theX + theWidth; theVertex.y = theY + theHeight; //gEngfuncs.pTriAPI->Color4ub(255, 255, 255, a); gEngfuncs.pTriAPI->Vertex3fv((float*)&theVertex); gEngfuncs.pTriAPI->TexCoord2f(1, 0); theVertex.x = theX + theWidth; theVertex.y = theY; //gEngfuncs.pTriAPI->Color4ub(255, 255, 255, a); gEngfuncs.pTriAPI->Vertex3fv((float*)&theVertex); gEngfuncs.pTriAPI->End(); } gEngfuncs.pTriAPI->RenderMode(kRenderNormal); } else { SPR_Set(this->mSprite, a, a, a); int theSpriteWidth = SPR_Width(this->mSprite, this->mSpriteFrame); int theSpriteHeight = SPR_Height(this->mSprite, this->mSpriteFrame); //SPR_DrawAdditive(theFrame, (theWidth - theSpriteWidth)/2, (theHeight - theSpriteHeight)/2, NULL); SPR_DrawHoles(this->mSpriteFrame, (theWidth - theSpriteWidth)/2, (theHeight - theSpriteHeight)/2, NULL); } } }
// Redraw // step through the local data, placing the appropriate graphics & text as appropriate // returns 1 if they've changed, 0 otherwise int CHud :: Redraw( float flTime, int intermission ) { m_fOldTime = m_flTime; // save time of previous redraw m_flTime = flTime; m_flTimeDelta = (double)m_flTime - m_fOldTime; static m_flShotTime = 0; // Clock was reset, reset delta if ( m_flTimeDelta < 0 ) m_flTimeDelta = 0; // Bring up the scoreboard during intermission if (gViewPort) { if ( m_iIntermission && !intermission ) { // Have to do this here so the scoreboard goes away m_iIntermission = intermission; gViewPort->HideCommandMenu(); gViewPort->HideScoreBoard(); gViewPort->UpdateSpectatorPanel(); } else if ( !m_iIntermission && intermission ) { m_iIntermission = intermission; gViewPort->HideCommandMenu(); gViewPort->HideVGUIMenu(); gViewPort->ShowScoreBoard(); gViewPort->UpdateSpectatorPanel(); // Take a screenshot if the client's got the cvar set if ( CVAR_GET_FLOAT( "hud_takesshots" ) != 0 ) m_flShotTime = flTime + 1.0; // Take a screenshot in a second } } if (m_flShotTime && m_flShotTime < flTime) { gEngfuncs.pfnClientCmd("snapshot\n"); m_flShotTime = 0; } // if no redrawing is necessary // return 0; // draw all registered HUD elements if ( m_pCvarDraw->value ) { HUDLIST *pList = m_pHudList; while (pList) { if ( !intermission ) { if ((pList->p->m_iFlags & HUD_ACTIVE) && !(m_iHideHUDDisplay & HIDEHUD_ALL)) pList->p->Draw(flTime); } else { // it's an intermission, so only draw hud elements that are set to draw during intermissions if ( pList->p->m_iFlags & HUD_INTERMISSION ) pList->p->Draw( flTime ); } pList = pList->pNext; } } // are we in demo mode? do we need to draw the logo in the top corner? if (m_iLogo) { int x, y, i; if (m_hsprLogo == 0) m_hsprLogo = LoadSprite("sprites/%d_logo.spr"); SPR_Set(m_hsprLogo, 250, 250, 250 ); x = SPR_Width(m_hsprLogo, 0); x = ScreenWidth - x; y = SPR_Height(m_hsprLogo, 0)/2; // Draw the logo at 20 fps int iFrame = (int)(flTime * 20) % MAX_LOGO_FRAMES; i = grgLogoFrame[iFrame] - 1; SPR_DrawAdditive(i, x, y, NULL); } return 1; }
// Draw node lines void PieNode::paintBackground() { // For each child for(int i = 0; i < kNumNodes; i++) { PieNode* theCurrentPieNode = this->mArray[i]; if(theCurrentPieNode) { // Draw line from us to them indicating pie node in that direction if(theCurrentPieNode->GetValveAlpha() < 255) { // If node above us isn't highlighted, don't draw line to us //if(theCurrentPieNode->HasSelectedNodeAbove() || theCurrentPieNode->HasSelectedNodeBelow()) // All those lines are getting confusing. Only draw the lines around this pie node that // connect to a selected parent or selected child if(theCurrentPieNode->HasSelectedNodeBelow() || this->GetDrawSelected()) { // Find correct line to draw from center of edge of source pie node to center // of edge of dest pie node int theRelativeLineX0, theRelativeLineY0, theRelativeLineX1, theRelativeLineY1; if(this->ComputeRelativeConnectorCoordinates(theCurrentPieNode, theRelativeLineX0, theRelativeLineY0, theRelativeLineX1, theRelativeLineY1)) { // What color to draw the line in? //vgui::Color theCurrentColor = this->GetColor(); vgui::Color theCurrentColor; //theCurrentPieNode->getBgColor(theCurrentColor); if(this->mEnabled) { theCurrentPieNode->getFgColor(theCurrentColor); } else { theCurrentPieNode->getBgColor(theCurrentColor); } int r, g, b, a; theCurrentColor.getColor(r, g, b, a); // Take gamma into account //r *= this->mColorBias; //g *= this->mColorBias; //b *= this->mColorBias; a = this->GetValveAlpha(); // //if(theCurrentPieNode->GetEnabled()) // //{ // g = (theCurrentPieNode->HasSelectedNodeBelow() ? 255 : kDarkGreenColor); // //g = (theCurrentPieNode->HasSelectedNodeAbove() ? 255 : kDarkGreenColor); // //} // // ...else this will draw lines in disabled color too, using current fade alpha // Stupid Valve-alpha, vguiSimpleLine wants normal alpha of course a = 255 - a; a *= this->mColorBias; // Only draw if child isn't invisible. Draw line // relative from current node. if(this->mConnectorSprite == 0 && (this->mConnectorSpriteName != "")) { this->mConnectorSprite = Safe_SPR_Load(this->mConnectorSpriteName.c_str()); } if(this->mConnectorSprite > 0) { // Approximate alpha float theAlpha = a/255.0f; int theSpriteRed = theAlpha*r; int theSpriteGreen = theAlpha*g; int theSpriteBlue = theAlpha*b; SPR_Set(this->mConnectorSprite, theSpriteRed, theSpriteGreen, theSpriteBlue); int theLineWidth = abs(theRelativeLineX1 - theRelativeLineX0); int theLineHeight = abs(theRelativeLineY1 - theRelativeLineY0); // Use second frame if vertical int theConnectorFrame = 0; if(theLineHeight > 0) { theConnectorFrame = 1; } int theConnectorSpriteWidth = SPR_Width(this->mConnectorSprite, theConnectorFrame); int theConnectorSpriteHeight = SPR_Height(this->mConnectorSprite, theConnectorFrame); int thePieNodeWidth, thePieNodeHeight; this->getContentSize(thePieNodeWidth, thePieNodeHeight); int thePieNodeX, thePieNodeY; this->getPos(thePieNodeX, thePieNodeY); int theStartX = 0; int theStartY = 0; if(theConnectorFrame == 0) { int theXOffset = (theLineWidth - theConnectorSpriteWidth)/2; //if(theXOffset < 0) // theXOffset = 0; theStartX = min(theRelativeLineX0, theRelativeLineX1) + theXOffset; theStartY = min(theRelativeLineY0, theRelativeLineY1) - theConnectorSpriteHeight/2; // int theScissorStartX = thePieNodeX + min(theRelativeLineX0, theRelativeLineX1) + thePieNodeWidth/2; // int theScissorStartY = thePieNodeY + theStartY; // int theScissorEndX = theScissorStartX + theLineWidth - thePieNodeWidth/2; // int theScissorEndY = theScissorStartY + theConnectorSpriteHeight; //vguiSimpleBox(theScissorStartX - thePieNodeX, theScissorStartY - thePieNodeY, theScissorEndX - thePieNodeX, theScissorEndY - thePieNodeY, 255, 255, 0, 128); // SPR_EnableScissor(theScissorStartX, theScissorStartY, theLineWidth, theConnectorSpriteHeight); } else { int theYOffset = (theLineHeight - theConnectorSpriteHeight)/2; //if(theYOffset < 0) // theYOffset = 0; theStartX = min(theRelativeLineX0, theRelativeLineX1) - theConnectorSpriteWidth/2; theStartY = min(theRelativeLineY0, theRelativeLineY1) + theYOffset; // int theScissorStartX = thePieNodeX + theStartX; // int theScissorStartY = thePieNodeY + min(theRelativeLineY0, theRelativeLineY1); // int theScissorEndX = theScissorStartX + theConnectorSpriteWidth; // int theScissorEndY = theScissorStartY + theLineHeight - thePieNodeHeight; //vguiSimpleBox(theScissorStartX - thePieNodeX, theScissorStartY - thePieNodeY, theScissorEndX - thePieNodeX, theScissorEndY - thePieNodeY, 255, 255, 0, 128); // SPR_EnableScissor(theScissorStartX, theScissorStartY, theConnectorSpriteWidth, theLineHeight); } // Take into account our position, including our parent(s), when drawing // Panel* theParent = this->getParent(); // while(theParent) // { // int theX, theY; // theParent->getPos(theX, theY); // theStartX += theX; // theStartY += theY; // theParent = theParent->getParent(); // } // Draw it //SPR_DrawAdditive(theConnectorFrame, theStartX, theStartY, NULL); SPR_DrawHoles(theConnectorFrame, theStartX, theStartY, NULL); // gEngfuncs.pfnSPR_DisableScissor(); } else { vguiSimpleLine(theRelativeLineX0, theRelativeLineY0, theRelativeLineX1, theRelativeLineY1, r, g, b, a); } vguiSimpleBox(theRelativeLineX0, theRelativeLineY0, theRelativeLineX1, theRelativeLineY1, 255, 255, 0, 128); } } } } } }
int CHudHealth::DrawPain(float flTime) { if(!(m_fAttackFront || m_fAttackRear || m_fAttackLeft || m_fAttackRight)) return 1; int r, g, b; int x, y, a, shade; // TODO: get the shift value of the health a = 255; // max brightness until then float fFade = gHUD.m_flTimeDelta * 2; // SPR_Draw top if(m_fAttackFront > 0.4) { GetPainColor(r, g, b); shade = a * max(m_fAttackFront, 0.5); ScaleColors(r, g, b, shade); SPR_Set(m_hSprite, r, g, b); x = ScreenWidth / 2 - SPR_Width(m_hSprite, 0) / 2; y = ScreenHeight / 2 - SPR_Height(m_hSprite, 0) * 3; SPR_DrawAdditive(0, x, y, NULL); m_fAttackFront = max(0, m_fAttackFront - fFade); } else m_fAttackFront = 0; if(m_fAttackRight > 0.4) { GetPainColor(r, g, b); shade = a * max(m_fAttackRight, 0.5); ScaleColors(r, g, b, shade); SPR_Set(m_hSprite, r, g, b); x = ScreenWidth / 2 + SPR_Width(m_hSprite, 1) * 2; y = ScreenHeight / 2 - SPR_Height(m_hSprite, 1) / 2; SPR_DrawAdditive(1, x, y, NULL); m_fAttackRight = max(0, m_fAttackRight - fFade); } else m_fAttackRight = 0; if(m_fAttackRear > 0.4) { GetPainColor(r, g, b); shade = a * max(m_fAttackRear, 0.5); ScaleColors(r, g, b, shade); SPR_Set(m_hSprite, r, g, b); x = ScreenWidth / 2 - SPR_Width(m_hSprite, 2) / 2; y = ScreenHeight / 2 + SPR_Height(m_hSprite, 2) * 2; SPR_DrawAdditive(2, x, y, NULL); m_fAttackRear = max(0, m_fAttackRear - fFade); } else m_fAttackRear = 0; if(m_fAttackLeft > 0.4) { GetPainColor(r, g, b); shade = a * max(m_fAttackLeft, 0.5); ScaleColors(r, g, b, shade); SPR_Set(m_hSprite, r, g, b); x = ScreenWidth / 2 - SPR_Width(m_hSprite, 3) * 3; y = ScreenHeight / 2 - SPR_Height(m_hSprite, 3) / 2; SPR_DrawAdditive(3, x, y, NULL); m_fAttackLeft = max(0, m_fAttackLeft - fFade); } else m_fAttackLeft = 0; return 1; }
// Redraw // step through the local data, placing the appropriate graphics & text as appropriate // returns 1 if they've changed, 0 otherwise int CHud :: Redraw( float flTime, int intermission ) { m_fOldTime = m_flTime; // save time of previous redraw m_flTime = flTime; m_flTimeDelta = (double)m_flTime - m_fOldTime; static float m_flShotTime = 0; // Clock was reset, reset delta if ( m_flTimeDelta < 0 ) m_flTimeDelta = 0; if (m_flShotTime && m_flShotTime < flTime) { gEngfuncs.pfnClientCmd("snapshot\n"); m_flShotTime = 0; } m_iIntermission = intermission; // if no redrawing is necessary // return 0; if ( m_pCvarDraw->value ) { HUDLIST *pList = m_pHudList; while (pList) { if ( !intermission ) { if ( (pList->p->m_iFlags & HUD_ACTIVE) && !(m_iHideHUDDisplay & HIDEHUD_ALL) ) pList->p->Draw(flTime); } else { // it's an intermission, so only draw hud elements that are set to draw during intermissions if ( pList->p->m_iFlags & HUD_INTERMISSION ) pList->p->Draw( flTime ); } pList = pList->pNext; } } // are we in demo mode? do we need to draw the logo in the top corner? if (m_iLogo) { int x, y, i; if (m_hsprLogo == 0) m_hsprLogo = LoadSprite("sprites/%d_logo.spr"); SPR_Set(m_hsprLogo, 250, 250, 250 ); x = SPR_Width(m_hsprLogo, 0); x = ScreenWidth - x; y = SPR_Height(m_hsprLogo, 0)/2; // Draw the logo at 20 fps int iFrame = (int)(flTime * 20) % MAX_LOGO_FRAMES; i = grgLogoFrame[iFrame] - 1; SPR_DrawAdditive(i, x, y, NULL); } /* if ( g_iVisibleMouse ) { void IN_GetMousePos( int *mx, int *my ); int mx, my; IN_GetMousePos( &mx, &my ); if (m_hsprCursor == 0) { char sz[256]; sprintf( sz, "sprites/cursor.spr" ); m_hsprCursor = SPR_Load( sz ); } SPR_Set(m_hsprCursor, 250, 250, 250 ); // Draw the logo at 20 fps SPR_DrawAdditive( 0, mx, my, NULL ); } */ return 1; }
// Redraw // step through the local data, placing the appropriate graphics & text as appropriate // returns 1 if they've changed, 0 otherwise int CHud :: Redraw( float flTime, int intermission ) { m_fOldTime = m_flTime; // save time of previous redraw m_flTime = flTime; m_flTimeDelta = (double)m_flTime - m_fOldTime; static int m_flShotTime = 0; //LRC - handle fog fading effects. (is this the right place for it?) if (g_fFadeDuration) { // Nicer might be to use some kind of logarithmic fade-in? double fFraction = m_flTimeDelta/g_fFadeDuration; // g_fStartDist -= (FOG_LIMIT - g_iFinalStartDist)*fFraction; g_fEndDist -= (FOG_LIMIT - g_iFinalEndDist)*fFraction; // CONPRINT("FogFading: %f - %f, frac %f, time %f, final %d\n", g_fStartDist, g_fEndDist, fFraction, flTime, g_iFinalEndDist); // cap it // if (g_fStartDist > FOG_LIMIT) g_fStartDist = FOG_LIMIT; if (g_fEndDist > FOG_LIMIT) g_fEndDist = FOG_LIMIT; // if (g_fStartDist < g_iFinalStartDist) g_fStartDist = g_iFinalStartDist; if (g_fEndDist < g_iFinalEndDist) g_fEndDist = g_iFinalEndDist; } // Clock was reset, reset delta if ( m_flTimeDelta < 0 ) m_flTimeDelta = 0; // Bring up the scoreboard during intermission /*if (gViewPort) { if ( m_iIntermission && !intermission ) { // Have to do this here so the scoreboard goes away m_iIntermission = intermission; gViewPort->HideCommandMenu(); gViewPort->HideScoreBoard(); gViewPort->UpdateSpectatorPanel(); } else if ( !m_iIntermission && intermission ) { m_iIntermission = intermission; gViewPort->HideCommandMenu(); gViewPort->HideVGUIMenu(); gViewPort->ShowScoreBoard(); gViewPort->UpdateSpectatorPanel(); // Take a screenshot if the client's got the cvar set if ( CVAR_GET_FLOAT( "hud_takesshots" ) != 0 ) m_flShotTime = flTime + 1.0; // Take a screenshot in a second } }*/ if (m_flShotTime && m_flShotTime < flTime) { gEngfuncs.pfnClientCmd("snapshot\n"); m_flShotTime = 0; } m_iIntermission = intermission; // if no redrawing is necessary // return 0; if ( m_pCvarDraw->value ) { HUDLIST *pList = m_pHudList; while (pList) { if ( !intermission ) { if ( (pList->p->m_iFlags & HUD_ACTIVE) && !(m_iHideHUDDisplay & HIDEHUD_ALL) ) pList->p->Draw(flTime); } else { // it's an intermission, so only draw hud elements that are set to draw during intermissions if ( pList->p->m_iFlags & HUD_INTERMISSION ) pList->p->Draw( flTime ); } pList = pList->pNext; } } // are we in demo mode? do we need to draw the logo in the top corner? if (m_iLogo) { int x, y, i; if (m_hsprLogo == 0) m_hsprLogo = LoadSprite("sprites/%d_logo.spr"); SPR_Set(m_hsprLogo, 250, 250, 250 ); x = SPR_Width(m_hsprLogo, 0); x = ScreenWidth - x; y = SPR_Height(m_hsprLogo, 0)/2; // Draw the logo at 20 fps int iFrame = (int)(flTime * 20) % MAX_LOGO_FRAMES; i = grgLogoFrame[iFrame] - 1; SPR_DrawAdditive(i, x, y, NULL); } /* if ( g_iVisibleMouse ) { void IN_GetMousePos( int *mx, int *my ); int mx, my; IN_GetMousePos( &mx, &my ); if (m_hsprCursor == 0) { char sz[256]; sprintf( sz, "sprites/cursor.spr" ); m_hsprCursor = SPR_Load( sz ); } SPR_Set(m_hsprCursor, 250, 250, 250 ); // Draw the logo at 20 fps SPR_DrawAdditive( 0, mx, my, NULL ); } */ return 1; }
void AvHSpriteDraw(int spriteHandle, int frame, float x1, float y1, float x2, float y2, float u1, float v1, float u2, float v2) { gEngfuncs.pTriAPI->RenderMode(gRenderMode); gEngfuncs.pTriAPI->CullFace(TRI_NONE); struct model_s* spritePtr = (struct model_s*)(gEngfuncs.GetSpritePointer(spriteHandle)); ASSERT(spritePtr); if (!gEngfuncs.pTriAPI->SpriteTexture(spritePtr, frame)) { return; } Vertex vertex[8]; vertex[0].x = x1; vertex[0].y = y1; vertex[0].u = u1; vertex[0].v = v1; vertex[1].x = x2; vertex[1].y = y1; vertex[1].u = u2; vertex[1].v = v1; vertex[2].x = x2; vertex[2].y = y2; vertex[2].u = u2; vertex[2].v = v2; vertex[3].x = x1; vertex[3].y = y2; vertex[3].u = u1; vertex[3].v = v2; int numVertices = 4; float pw = SPR_Width(spriteHandle, frame); float ph = SPR_Height(spriteHandle, frame); float uOffset = 0; float vOffset = 0; if (IEngineStudio.IsHardware() == 2) { // Direct3D addresses textures differently than OpenGL so compensate // for that here. uOffset = 0.5 / pw; vOffset = 0.5 / ph; } // Apply the transformation to the vertices. for (int i = 0; i < numVertices; ++i) { if (vertex[i].u < 0.25 / pw) { vertex[i].u = 0.25 / pw; } if (vertex[i].v < 0.25 / ph) { vertex[i].v = 0.25 / ph; } if (vertex[i].u > 1 - 0.25 / pw) { vertex[i].u = 1 - 0.25 / pw; } if (vertex[i].v > 1 - 0.25 / ph) { vertex[i].v = 1 - 0.25 / ph; } vertex[i].u += uOffset; vertex[i].v += vOffset; float x = vertex[i].x; float y = vertex[i].y; vertex[i].x = x * gTransform[0][0] + y * gTransform[0][1] + gTransform[0][2]; vertex[i].y = x * gTransform[1][0] + y * gTransform[1][1] + gTransform[1][2]; } if (gClippingEnabled) { // Clip the polygon to each side of the clipping rectangle. This isn't the // fastest way to clip a polygon against a rectangle, but it's probably the // simplest. ClipPolygon(vertex, numVertices, 1, 0, -gClipRectX1); ClipPolygon(vertex, numVertices, -1, 0, gClipRectX2); ClipPolygon(vertex, numVertices, 0, 1, -gClipRectY1); ClipPolygon(vertex, numVertices, 0, -1, gClipRectY2); } // Compensate for the overbrightening effect. float gammaScale = 1.0f / gHUD.GetGammaSlope(); gEngfuncs.pTriAPI->Color4f(gammaScale * gColor[0], gammaScale * gColor[1], gammaScale * gColor[2], gColor[3]); // Output the vertices. if (gDrawMode == kSpriteDrawModeFilled) { gEngfuncs.pTriAPI->Begin(TRI_TRIANGLE_FAN); for (int j = 0; j < numVertices; ++j) { Vector worldPoint; if (gVGUIEnabled) { worldPoint.x = (vertex[j].x - gVGUIOffsetX) * gViewportXScale + gViewportXOffset; worldPoint.y = (vertex[j].y - gVGUIOffsetY) * gViewportYScale + gViewportYOffset; worldPoint.z = 1; } else { worldPoint = gViewOrigin + gViewXAxis * vertex[j].x + gViewYAxis * vertex[j].y + gViewZAxis * (gDepth + gDepthOffset); } gEngfuncs.pTriAPI->TexCoord2f(vertex[j].u, vertex[j].v); gEngfuncs.pTriAPI->Vertex3fv((float*)&worldPoint); } gEngfuncs.pTriAPI->End(); } else if (gDrawMode == kSpriteDrawModeBorder) { gEngfuncs.pTriAPI->Begin(TRI_LINES); for (int j = 0; j < numVertices; ++j) { int k = (j + 1) % numVertices; Vector worldPoint1; Vector worldPoint2; if (gVGUIEnabled) { worldPoint1.x = vertex[j].x - gVGUIOffsetX; worldPoint1.y = vertex[j].y - gVGUIOffsetY; worldPoint1.z = 1; worldPoint2.x = vertex[k].x - gVGUIOffsetX; worldPoint2.y = vertex[k].y - gVGUIOffsetY; worldPoint2.z = 1; } else { worldPoint1 = gViewOrigin + gViewXAxis * vertex[j].x + gViewYAxis * vertex[j].y + gViewZAxis * (gDepth + gDepthOffset); worldPoint2 = gViewOrigin + gViewXAxis * vertex[k].x + gViewYAxis * vertex[k].y + gViewZAxis * (gDepth + gDepthOffset); } gEngfuncs.pTriAPI->TexCoord2f(vertex[j].u, vertex[j].v); gEngfuncs.pTriAPI->Vertex3fv((float*)&worldPoint1); gEngfuncs.pTriAPI->TexCoord2f(vertex[k].u, vertex[k].v); gEngfuncs.pTriAPI->Vertex3fv((float*)&worldPoint2); } gEngfuncs.pTriAPI->End(); } gDepth += kDepthIncrement; }