This repository has been archived on 2025-02-27. You can view files and clone it, but cannot push or open issues or pull requests.
CnC_Renegade/Code/ww3d2/textdraw.cpp

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 ) );
}