Glenn Maynard
6d2ad43826
their default ortho transforms) (at least, I believe that's where it differs; it may be at the viewport or something)
356 lines
9.7 KiB
C++
356 lines
9.7 KiB
C++
#include "stdafx.h"
|
|
/*
|
|
-----------------------------------------------------------------------------
|
|
File: BitmapText
|
|
|
|
Desc: See header.
|
|
|
|
Copyright (c) 2001-2002 by the person(s) listed below. All rights reserved.
|
|
Chris Danford
|
|
-----------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "BitmapText.h"
|
|
#include "IniFile.h"
|
|
#include "FontManager.h"
|
|
#include "RageLog.h"
|
|
#include "RageException.h"
|
|
#include "RageTimer.h"
|
|
#include "RageDisplay.h"
|
|
#include "PrefsManager.h"
|
|
#include "ThemeManager.h"
|
|
#include "GameConstantsAndTypes.h"
|
|
|
|
|
|
#define RAINBOW_COLOR_1 THEME->GetMetricC("BitmapText","RainbowColor1")
|
|
#define RAINBOW_COLOR_2 THEME->GetMetricC("BitmapText","RainbowColor2")
|
|
#define RAINBOW_COLOR_3 THEME->GetMetricC("BitmapText","RainbowColor3")
|
|
#define RAINBOW_COLOR_4 THEME->GetMetricC("BitmapText","RainbowColor4")
|
|
#define RAINBOW_COLOR_5 THEME->GetMetricC("BitmapText","RainbowColor5")
|
|
#define RAINBOW_COLOR_6 THEME->GetMetricC("BitmapText","RainbowColor6")
|
|
#define RAINBOW_COLOR_7 THEME->GetMetricC("BitmapText","RainbowColor7")
|
|
|
|
const int NUM_RAINBOW_COLORS = 7;
|
|
RageColor RAINBOW_COLORS[NUM_RAINBOW_COLORS];
|
|
|
|
|
|
BitmapText::BitmapText()
|
|
{
|
|
// Loading these theme metrics is slow, so only do it ever 20th time.
|
|
static int iReloadCounter = 0;
|
|
if( iReloadCounter%20==0 )
|
|
{
|
|
RAINBOW_COLORS[0] = RAINBOW_COLOR_1;
|
|
RAINBOW_COLORS[1] = RAINBOW_COLOR_2;
|
|
RAINBOW_COLORS[2] = RAINBOW_COLOR_3;
|
|
RAINBOW_COLORS[3] = RAINBOW_COLOR_4;
|
|
RAINBOW_COLORS[4] = RAINBOW_COLOR_5;
|
|
RAINBOW_COLORS[5] = RAINBOW_COLOR_6;
|
|
RAINBOW_COLORS[6] = RAINBOW_COLOR_7;
|
|
}
|
|
iReloadCounter++;
|
|
|
|
m_HorizAlign = align_center;
|
|
m_VertAlign = align_middle;
|
|
|
|
m_pFont = NULL;
|
|
|
|
m_iNumLines = 0;
|
|
m_iWidestLineWidth = 0;
|
|
|
|
for( int i=0; i<MAX_TEXT_LINES; i++ )
|
|
{
|
|
m_szTextLines[i] = '\0';
|
|
m_iLineLengths[i] = -1;
|
|
m_iLineWidths[i] = 1;
|
|
}
|
|
|
|
m_bShadow = true;
|
|
|
|
m_bRainbow = false;
|
|
}
|
|
|
|
BitmapText::~BitmapText()
|
|
{
|
|
if( m_pFont )
|
|
FONT->UnloadFont( m_pFont->m_sTexturePath );
|
|
}
|
|
|
|
bool BitmapText::LoadFromFont( CString sFontFilePath )
|
|
{
|
|
LOG->Trace( "BitmapText::LoadFromFontName(%s)", sFontFilePath.GetString() );
|
|
|
|
if( m_pFont ) {
|
|
FONT->UnloadFont( m_pFont->m_sTexturePath );
|
|
m_pFont = NULL;
|
|
}
|
|
|
|
// load font
|
|
m_pFont = FONT->LoadFont( sFontFilePath );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool BitmapText::LoadFromTextureAndChars( CString sTexturePath, CString sChars )
|
|
{
|
|
LOG->Trace( "BitmapText::LoadFromTextureAndChars(%s)", sTexturePath.GetString() );
|
|
|
|
if( m_pFont ) {
|
|
FONT->UnloadFont( m_pFont->m_sTexturePath );
|
|
m_pFont = NULL;
|
|
}
|
|
|
|
// load font
|
|
m_pFont = FONT->LoadFont( sTexturePath, sChars );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
void BitmapText::SetText( CString sText )
|
|
{
|
|
//LOG->Trace( "BitmapText::SetText()" );
|
|
|
|
ASSERT( m_pFont );
|
|
|
|
if( m_pFont->m_bCapitalsOnly )
|
|
sText.MakeUpper();
|
|
|
|
//
|
|
// save the string and crop if necessary
|
|
//
|
|
ASSERT( sText.GetLength() < MAX_TEXT_CHARS/2 );
|
|
|
|
strncpy( m_szText, sText, MAX_TEXT_CHARS );
|
|
m_szText[MAX_TEXT_CHARS-1] = '\0';
|
|
|
|
/*
|
|
Do NOT stop out all extended ASCII chars. Why was this here? -Chris
|
|
|
|
int iLength = strlen( m_szText );
|
|
|
|
//
|
|
// strip out non-low ASCII chars
|
|
//
|
|
for( int i=0; i<iLength; i++ ) // for each character
|
|
{
|
|
if( m_szText[i] < 0 || m_szText[i] > MAX_FONT_CHARS-1 )
|
|
m_szText[i] = ' ';
|
|
}
|
|
*/
|
|
//
|
|
// break the string into lines
|
|
//
|
|
m_iNumLines = 0;
|
|
LPSTR token;
|
|
|
|
/* Establish string and get the first token: */
|
|
token = strtok( m_szText, "\n" );
|
|
while( token != NULL )
|
|
{
|
|
m_szTextLines[m_iNumLines++] = token;
|
|
token = strtok( NULL, "\n" );
|
|
}
|
|
|
|
//
|
|
// calculate line lengths and widths
|
|
//
|
|
m_iWidestLineWidth = 0;
|
|
|
|
for( int l=0; l<m_iNumLines; l++ ) // for each line
|
|
{
|
|
m_iLineLengths[l] = strlen( m_szTextLines[l] );
|
|
m_iLineWidths[l] = m_pFont->GetLineWidthInSourcePixels( m_szTextLines[l], m_iLineLengths[l] );
|
|
if( m_iLineWidths[l] > m_iWidestLineWidth )
|
|
m_iWidestLineWidth = m_iLineWidths[l];
|
|
}
|
|
|
|
// fill the RageScreen's vertex buffer with what we're going to draw
|
|
//RebuildVertexBuffer();
|
|
|
|
}
|
|
|
|
void BitmapText::CropToWidth( int iMaxWidthInSourcePixels )
|
|
{
|
|
iMaxWidthInSourcePixels = max( 0, iMaxWidthInSourcePixels );
|
|
|
|
for( int l=0; l<m_iNumLines; l++ ) // for each line
|
|
{
|
|
while( m_iLineWidths[l] > iMaxWidthInSourcePixels )
|
|
{
|
|
m_iLineLengths[l]--;
|
|
m_iLineWidths[l] = m_pFont->GetLineWidthInSourcePixels( m_szTextLines[l], m_iLineLengths[l] );
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// draw text at x, y using colorTop blended down to colorBottom, with size multiplied by scale
|
|
void BitmapText::DrawPrimitives()
|
|
{
|
|
if( m_iNumLines == 0 )
|
|
return;
|
|
|
|
RageTexture* pTexture = m_pFont->m_pTexture;
|
|
|
|
|
|
// make the object in logical units centered at the origin
|
|
static RageVertex v[4000];
|
|
int iNumV = 0; // the current vertex number
|
|
|
|
|
|
const int iHeight = pTexture->GetSourceFrameHeight(); // height of a character
|
|
const int iLineSpacing = m_pFont->m_iLineSpacing; // spacing between lines
|
|
const int iFrameWidth = pTexture->GetSourceFrameWidth(); // width of a character frame in logical units
|
|
|
|
int iY; // the center position of the first row of characters
|
|
switch( m_VertAlign )
|
|
{
|
|
case align_bottom: iY = -(m_iNumLines) * iLineSpacing + iLineSpacing/2; break;
|
|
case align_middle: iY = -(m_iNumLines-1) * iLineSpacing/2; break;
|
|
case align_top: iY = + iLineSpacing/2; break;
|
|
default: ASSERT( false ); return;
|
|
}
|
|
|
|
|
|
for( int i=0; i<m_iNumLines; i++ ) // foreach line
|
|
{
|
|
const char *szLine = m_szTextLines[i];
|
|
const int iLineLength = m_iLineLengths[i];
|
|
const int iLineWidth = m_iLineWidths[i];
|
|
|
|
int iX;
|
|
switch( m_HorizAlign )
|
|
{
|
|
case align_left: iX = 0; break;
|
|
case align_center: iX = -(iLineWidth/2); break;
|
|
case align_right: iX = -iLineWidth; break;
|
|
default: ASSERT( false ); return;
|
|
}
|
|
|
|
for( int j=0; j<iLineLength; j++ ) // for each character in the line
|
|
{
|
|
const char c = szLine[j];
|
|
const int iFrameNo = m_pFont->m_iCharToFrameNo[ (unsigned char)c ];
|
|
if( iFrameNo == -1 ) // this font doesn't impelemnt this character
|
|
RageException::Throw( "The font '%s' does not implement the character '%c'", m_sFontFilePath.GetString(), c );
|
|
const int iCharWidth = m_pFont->m_iFrameNoToWidth[iFrameNo];
|
|
|
|
// The right side of any italic letter is being cropped. So, we're going to draw a little bit
|
|
// to the right of the normal character.
|
|
const int iDrawExtraPixelsLeft = min( m_pFont->m_iDrawExtraPixelsLeft, (iFrameWidth-iCharWidth)/2 );
|
|
const int iDrawExtraPixelsRight = min( m_pFont->m_iDrawExtraPixelsRight, (iFrameWidth-iCharWidth)/2 );
|
|
|
|
//
|
|
// set vertex positions
|
|
//
|
|
v[iNumV++].p = RageVector3( (float)iX-iDrawExtraPixelsLeft, iY-iHeight/2.0f, 0 ); // top left
|
|
v[iNumV++].p = RageVector3( (float)iX-iDrawExtraPixelsLeft, iY+iHeight/2.0f, 0 ); // bottom left
|
|
v[iNumV++].p = RageVector3( (float)iX-iDrawExtraPixelsLeft+iCharWidth+iDrawExtraPixelsRight, iY+iHeight/2.0f, 0 ); // bottom right
|
|
v[iNumV++].p = RageVector3( (float)iX-iDrawExtraPixelsLeft+iCharWidth+iDrawExtraPixelsRight, iY-iHeight/2.0f, 0 ); // top right
|
|
|
|
iX += iCharWidth;
|
|
|
|
//
|
|
// set texture coordinates
|
|
//
|
|
iNumV -= 4;
|
|
|
|
RectF frectTexCoords = *pTexture->GetTextureCoordRect( iFrameNo );
|
|
|
|
// Tweak the textures frame rectangles so we don't draw extra
|
|
// to the left and right of the character, saving us fill rate.
|
|
float fPixelsToChopOff = pTexture->GetSourceFrameWidth() - (float)iCharWidth;
|
|
float fTexCoordsToChopOff = fPixelsToChopOff / pTexture->GetSourceWidth();
|
|
frectTexCoords.left += fTexCoordsToChopOff/2;
|
|
frectTexCoords.right -= fTexCoordsToChopOff/2;
|
|
|
|
const float fExtraTexCoordsLeft = iDrawExtraPixelsLeft / (float)pTexture->GetSourceWidth();
|
|
const float fExtraTexCoordsRight = iDrawExtraPixelsRight / (float)pTexture->GetSourceWidth();
|
|
|
|
v[iNumV++].t = RageVector2( frectTexCoords.left - fExtraTexCoordsLeft, frectTexCoords.top ); // top left
|
|
v[iNumV++].t = RageVector2( frectTexCoords.left - fExtraTexCoordsLeft, frectTexCoords.bottom ); // bottom left
|
|
v[iNumV++].t = RageVector2( frectTexCoords.right + fExtraTexCoordsRight, frectTexCoords.bottom ); // bottom right
|
|
v[iNumV++].t = RageVector2( frectTexCoords.right + fExtraTexCoordsRight, frectTexCoords.top ); // top right
|
|
}
|
|
|
|
iY += iLineSpacing;
|
|
}
|
|
|
|
|
|
DISPLAY->SetTexture( pTexture );
|
|
DISPLAY->SetTextureModeModulate();
|
|
if( m_bBlendAdd )
|
|
DISPLAY->SetBlendModeAdd();
|
|
else
|
|
DISPLAY->SetBlendModeNormal();
|
|
|
|
|
|
/* Draw if we're not fully transparent or the zbuffer is enabled (which ignores
|
|
* alpha). */
|
|
if( m_temp.diffuse[0].a != 0 || DISPLAY->ZBufferEnabled())
|
|
{
|
|
//////////////////////
|
|
// render the shadow
|
|
//////////////////////
|
|
if( m_bShadow )
|
|
{
|
|
DISPLAY->PushMatrix();
|
|
DISPLAY->TranslateLocal( m_fShadowLength, m_fShadowLength, 0 ); // shift by 5 units
|
|
|
|
RageColor dim(0,0,0,0.5f*m_temp.diffuse[0].a); // semi-transparent black
|
|
|
|
for( int i=0; i<iNumV; i++ )
|
|
v[i].c = dim;
|
|
DISPLAY->DrawQuads( v, iNumV );
|
|
|
|
DISPLAY->PopMatrix();
|
|
}
|
|
|
|
//////////////////////
|
|
// render the diffuse pass
|
|
//////////////////////
|
|
if( m_bRainbow )
|
|
{
|
|
int color_index = int(RageTimer::GetTimeSinceStart() / 0.200) % NUM_RAINBOW_COLORS;
|
|
for( int i=0; i<iNumV; i+=4 )
|
|
{
|
|
const RageColor color = RAINBOW_COLORS[color_index];
|
|
for( int j=i; j<i+4; j++ )
|
|
v[j].c = color;
|
|
|
|
color_index = (color_index+1)%NUM_RAINBOW_COLORS;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for( int i=0; i<iNumV; i+=4 )
|
|
{
|
|
v[i+0].c = m_temp.diffuse[0]; // top left
|
|
v[i+1].c = m_temp.diffuse[2]; // bottom left
|
|
v[i+2].c = m_temp.diffuse[3]; // bottom right
|
|
v[i+3].c = m_temp.diffuse[1]; // top right
|
|
}
|
|
}
|
|
|
|
DISPLAY->DrawQuads( v, iNumV );
|
|
}
|
|
|
|
//////////////////////
|
|
// render the glow pass
|
|
//////////////////////
|
|
if( m_temp.glow.a != 0 )
|
|
{
|
|
DISPLAY->SetTextureModeGlow();
|
|
|
|
int i;
|
|
for( i=0; i<iNumV; i++ )
|
|
v[i].c = m_temp.glow;
|
|
DISPLAY->DrawQuads( v, iNumV );
|
|
}
|
|
|
|
}
|