344 lines
14 KiB
C++
344 lines
14 KiB
C++
/*
|
|
** Command & Conquer Renegade(tm)
|
|
** Copyright 2025 Electronic Arts Inc.
|
|
**
|
|
** This program is free software: you can redistribute it and/or modify
|
|
** it under the terms of the GNU General Public License as published by
|
|
** the Free Software Foundation, either version 3 of the License, or
|
|
** (at your option) any later version.
|
|
**
|
|
** This program is distributed in the hope that it will be useful,
|
|
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
** GNU General Public License for more details.
|
|
**
|
|
** You should have received a copy of the GNU General Public License
|
|
** along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/***************************************************************************
|
|
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
|
|
***************************************************************************
|
|
* *
|
|
* Project Name : Commando *
|
|
* *
|
|
* $Archive:: /Commando/Code/ww3d2/textdraw.cpp $*
|
|
* *
|
|
* $Author:: Jani_p $*
|
|
* *
|
|
* $Modtime:: 3/22/01 8:03p $*
|
|
* *
|
|
* $Revision:: 7 $*
|
|
* *
|
|
*-------------------------------------------------------------------------*
|
|
* Functions: *
|
|
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
|
|
|
#include "textdraw.h"
|
|
#include "font3d.h"
|
|
#include "simplevec.h"
|
|
|
|
/***********************************************************************************************
|
|
* *
|
|
* TextDrawClass::TextDrawClass( int ) -- Constructor *
|
|
* *
|
|
* Creates a TextDrawClass object by creating and initializing a Dynamic Mesh, inserting it *
|
|
* into the given scene, and allocating space for the given number of maximum chars. *
|
|
* *
|
|
***********************************************************************************************/
|
|
TextDrawClass::TextDrawClass( int max_chars ) :
|
|
DynamicMeshClass( max_chars * 2, max_chars * 4 ),
|
|
TextColor( 1.0f, 1.0f, 1.0f )
|
|
{
|
|
// Build the default Vertex Material
|
|
DefaultVertexMaterial = NEW_REF( VertexMaterialClass, () );
|
|
DefaultVertexMaterial->Set_Diffuse( 0, 0, 0 );
|
|
DefaultVertexMaterial->Set_Opacity(1);
|
|
DefaultVertexMaterial->Set_Emissive( 1, 1, 1 );
|
|
Set_Vertex_Material( DefaultVertexMaterial );
|
|
|
|
// Build the default Shader
|
|
DefaultShader.Set_Depth_Mask( ShaderClass::DEPTH_WRITE_DISABLE );
|
|
DefaultShader.Set_Depth_Compare( ShaderClass::PASS_ALWAYS );
|
|
DefaultShader.Set_Dst_Blend_Func( ShaderClass::DSTBLEND_ONE_MINUS_SRC_ALPHA );
|
|
DefaultShader.Set_Src_Blend_Func( ShaderClass::SRCBLEND_SRC_ALPHA );
|
|
DefaultShader.Set_Texturing( ShaderClass::TEXTURING_ENABLE );
|
|
DefaultShader.Set_Cull_Mode( ShaderClass::CULL_MODE_DISABLE );
|
|
Set_Shader( DefaultShader );
|
|
Enable_Sort();
|
|
|
|
Set_Coordinate_Ranges( Vector2( 0,0 ), Vector2( 1,1 ), Vector2( -1,0.75f ), Vector2( 1,-0.75 ) );
|
|
// Set_Coordinate_Ranges( Vector2( -320,240 ), Vector2( 320,-240 ), Vector2( -320,240 ), Vector2( 320,-240 ) );
|
|
}
|
|
|
|
/***********************************************************************************************
|
|
* *
|
|
* TextDrawClass::~TextDrawClass( void ) -- Destructor *
|
|
* *
|
|
***********************************************************************************************/
|
|
TextDrawClass::~TextDrawClass( void )
|
|
{
|
|
DefaultVertexMaterial->Release_Ref();
|
|
}
|
|
|
|
/***********************************************************************************************
|
|
* *
|
|
* TextDrawClass::Reset( void ) -- Flush the mesh
|
|
* *
|
|
***********************************************************************************************/
|
|
void TextDrawClass::Reset( void )
|
|
{
|
|
Reset_Flags();
|
|
Reset_Mesh_Counters();
|
|
|
|
// Reinstall the default vertex material and shader
|
|
Enable_Sort();
|
|
Set_Vertex_Material( DefaultVertexMaterial );
|
|
Set_Shader( DefaultShader );
|
|
}
|
|
|
|
/*
|
|
**
|
|
*/
|
|
void TextDrawClass::Set_Coordinate_Ranges(
|
|
const Vector2 & src_ul, const Vector2 & src_lr,
|
|
const Vector2 & dest_ul, const Vector2 & dest_lr )
|
|
{
|
|
TranslateScale.X = (dest_lr.X - dest_ul.X) / (src_lr.X - src_ul.X);
|
|
TranslateScale.Y = (dest_lr.Y - dest_ul.Y) / (src_lr.Y - src_ul.Y);
|
|
TranslateOffset.X = dest_ul.X - TranslateScale.X * src_ul.X;
|
|
TranslateOffset.Y = dest_ul.Y - TranslateScale.Y * src_ul.Y;
|
|
|
|
PixelSize.X = fabs((src_lr.X - src_ul.X) / 640.0f);
|
|
PixelSize.Y = fabs((src_lr.Y - src_ul.Y) / 480.0f);
|
|
}
|
|
|
|
|
|
/*
|
|
**
|
|
*/
|
|
void TextDrawClass::Quad( float x0, float y0, float x1, float y1, float u0, float v0, float u1, float v1 )
|
|
{
|
|
// Translate coordinates
|
|
x0 = x0 * TranslateScale.X + TranslateOffset.X;
|
|
x1 = x1 * TranslateScale.X + TranslateOffset.X;
|
|
y0 = y0 * TranslateScale.Y + TranslateOffset.Y;
|
|
y1 = y1 * TranslateScale.Y + TranslateOffset.Y;
|
|
|
|
bool flip_faces = ((x1-x0) * (y1-y0)) > 0;
|
|
|
|
Begin_Tri_Strip();
|
|
Vertex( x0, y0, 0, u0, v0);
|
|
if ( flip_faces ) {
|
|
Vertex( x1, y0, 0, u1, v0);
|
|
Vertex( x0, y1, 0, u0, v1);
|
|
} else {
|
|
Vertex( x0, y1, 0, u0, v1);
|
|
Vertex( x1, y0, 0, u1, v0);
|
|
}
|
|
Vertex( x1, y1, 0, u1, v1);
|
|
End_Tri_Strip();
|
|
}
|
|
|
|
void TextDrawClass::Quad( const RectClass & rect, const RectClass & uv )
|
|
{
|
|
TextDrawClass::Quad( rect.Left, rect.Top, rect.Right, rect.Bottom, uv.Left, uv.Top, uv.Right, uv.Bottom );
|
|
}
|
|
|
|
void TextDrawClass::Line( const Vector2 & _a, const Vector2 & _b, float width )
|
|
{
|
|
// Translate coordinates
|
|
Vector2 a;
|
|
Vector2 b;
|
|
a.X = _a.X * TranslateScale.X + TranslateOffset.X;
|
|
a.Y = _a.Y * TranslateScale.Y + TranslateOffset.Y;
|
|
b.X = _b.X * TranslateScale.X + TranslateOffset.X;
|
|
b.Y = _b.Y * TranslateScale.Y + TranslateOffset.Y;
|
|
width *= WWMath::Fabs(TranslateScale.X);
|
|
|
|
Vector2 corner_offset = a - b; // get line relative to b
|
|
float temp = corner_offset.X; // Rotate 90
|
|
corner_offset.X = corner_offset.Y;
|
|
corner_offset.Y = -temp;
|
|
corner_offset.Normalize(); // scale to length width/2
|
|
corner_offset *= width / 2;
|
|
|
|
Begin_Tri_Strip();
|
|
Vertex( a + corner_offset );
|
|
Vertex( a - corner_offset );
|
|
Vertex( b + corner_offset );
|
|
Vertex( b - corner_offset );
|
|
End_Tri_Strip();
|
|
}
|
|
|
|
void TextDrawClass::Line_Ends( const Vector2 & a, const Vector2 & b, float width, float end_percent )
|
|
{
|
|
Vector2 a_ = b - a;
|
|
a_ *= end_percent;
|
|
a_ += a;
|
|
Line( a, a_, width );
|
|
Vector2 b_ = a - b;
|
|
b_ *= end_percent;
|
|
b_ += b;
|
|
Line( b, b_, width );
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* *
|
|
* float TextDrawClass::Get_Width( Font3DInstanceClass *, char * ) *
|
|
* *
|
|
* WARNING: Should not be used to draw characters which need to wrap or have embedded line *
|
|
* feeds. *
|
|
* *
|
|
* Returns the scaled string width in normalized screen unit *
|
|
* *
|
|
***********************************************************************************************/
|
|
float TextDrawClass::Get_Width( Font3DInstanceClass *font, const char *message )
|
|
{
|
|
float total_width = 0.0f;
|
|
|
|
/*
|
|
** for each character, get_width it
|
|
*/
|
|
while (*message != 0) {
|
|
total_width += font->Char_Spacing( *message++ );
|
|
}
|
|
|
|
return total_width;
|
|
}
|
|
|
|
float TextDrawClass::Get_Inter_Char_Width( Font3DInstanceClass *font )
|
|
{
|
|
// Get rid of this...
|
|
// return font->Get_Inter_Char_Spacing();
|
|
return 1;
|
|
}
|
|
|
|
float TextDrawClass::Get_Height( Font3DInstanceClass *font, const char *message )
|
|
{
|
|
return font->Char_Height();
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* *
|
|
* float TextDrawClass::Print( Font3DInstanceClass *, char, float, float, float ) *
|
|
* *
|
|
* Draws (actually creates two trianlges to display) a character on the screen at the given *
|
|
* normalized screen unit coordinates at the current font scale. *
|
|
* *
|
|
* Returns the scaled character width in normalized screen unit *
|
|
* *
|
|
***********************************************************************************************/
|
|
float TextDrawClass::Print( Font3DInstanceClass *font, char ch, float screen_x, float screen_y )
|
|
{
|
|
/*
|
|
** Get the char width in scaled normalized screen units
|
|
*/
|
|
float width = font->Char_Width( ch ); // in scaled normalized screen units
|
|
float spacing = font->Char_Spacing( ch ); // in scaled normalized screen units
|
|
|
|
/*
|
|
** If asked to draw the space char (' '), don't add any triangles, just return the scaled spacing
|
|
*/
|
|
if (ch == ' ' )
|
|
return spacing;
|
|
|
|
/*
|
|
** Calculate the lower right edge of the displayed rectangle
|
|
*/
|
|
// center each char in its spacing (in case mono spaced )
|
|
// also, round to the nearest 640x480 pixels (needs to change for other reses)
|
|
float screen_x0 = screen_x + spacing/2 - width/2;
|
|
screen_x0 = floor(screen_x0 / PixelSize.X + 0.5f) * PixelSize.X;
|
|
float screen_x1 = screen_x0 + width;
|
|
screen_x1 = floor(screen_x1 / PixelSize.X + 0.5f) * PixelSize.X;
|
|
float screen_y0 = screen_y;
|
|
screen_y0 = floor(screen_y0 / PixelSize.Y + 0.5f) * PixelSize.Y;
|
|
float screen_y1 = screen_y0 + (font->Char_Height() * WWMath::Sign( -TranslateScale.Y ));
|
|
screen_y1 = floor(screen_y1 / PixelSize.Y + 0.5f) * PixelSize.Y;
|
|
|
|
if ( WW3D::Is_Screen_UV_Biased() ) { // Global bais setting
|
|
screen_x0 += PixelSize.X / 2;
|
|
screen_x1 += PixelSize.X / 2;
|
|
screen_y0 += PixelSize.Y / 2;
|
|
screen_y1 += PixelSize.Y / 2;
|
|
}
|
|
|
|
/*
|
|
** Get the font texture uv coordinate for teh upper right and lower left corners of the rect
|
|
*/
|
|
RectClass font_uv = font->Char_UV( ch );
|
|
|
|
/*
|
|
** Set the triangles' texture
|
|
*/
|
|
Set_Texture( font->Peek_Texture( ch ) );
|
|
|
|
/*
|
|
** Draw the quad
|
|
*/
|
|
Quad( screen_x0, screen_y0, screen_x1, screen_y1, font_uv.Left, font_uv.Top, font_uv.Right, font_uv.Bottom );
|
|
|
|
/*
|
|
** return the scaled spacing
|
|
*/
|
|
return spacing;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* *
|
|
* float TextDrawClass::Print( Font3DInstanceClass *, char *, float, float, float ) *
|
|
* *
|
|
* Draws the given string at the given pixel coordinates. Uses the given font and its current *
|
|
* scale. Passes each character to the above routine and moves the x-coordinate forward after *
|
|
* each char. * *
|
|
* *
|
|
* WARNING: Should not be used to draw characters which need to wrap or have embedded line *
|
|
* feeds. * *
|
|
* *
|
|
* Returns the string pixel width *
|
|
* *
|
|
***********************************************************************************************/
|
|
float TextDrawClass::Print( Font3DInstanceClass *font, const char *message, float screen_x, float screen_y )
|
|
{
|
|
/*
|
|
** Keep track of the total drawn width
|
|
*/
|
|
float total_width = 0.0f;
|
|
|
|
/*
|
|
** for each character, print it and moved screen_x forward
|
|
*/
|
|
while (*message != 0) {
|
|
float width = Print( font, *message++, screen_x, screen_y );
|
|
screen_x += width;
|
|
total_width += width;
|
|
}
|
|
|
|
/*
|
|
** return the total drawn width
|
|
*/
|
|
return total_width;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* *
|
|
* void TextDrawClass::Show_Font( Font3DInstanceClass *, float, float, float ) *
|
|
* *
|
|
* Dumps the font texture to the screen as two triangles. For debugging only. *
|
|
* *
|
|
***********************************************************************************************/
|
|
void TextDrawClass::Show_Font( Font3DInstanceClass *font, float screen_x, float screen_y )
|
|
{
|
|
// normalize coordinates
|
|
float size_x = PixelSize.X * 256;
|
|
float size_y = PixelSize.Y * 256;
|
|
|
|
Set_Texture( font->Peek_Texture('A') );
|
|
|
|
Quad( screen_x, screen_y, screen_x + size_x, screen_y + size_y * WWMath::Sign( -TranslateScale.Y ) );
|
|
}
|