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/font3d.h

223 lines
No EOL
8.3 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/>.
*/
/***********************************************************************************************
*** Confidential - Westwood Studios ***
***********************************************************************************************
* *
* Project Name : Commando / G 3D Library *
* *
* $Archive:: /Commando/Code/ww3d2/font3d.h $*
* *
* $Author:: Byon_g $*
* *
* $Modtime:: 4/05/01 2:19p $*
* *
* $Revision:: 4 $*
* *
*---------------------------------------------------------------------------------------------*/
#if defined(_MSC_VER)
#pragma once
#endif
#ifndef FONT3D_H
#define FONT3D_H
#include "always.h"
#include "refcount.h"
#include "vector4.h"
#include "widestring.h"
#include "rect.h"
class TextureClass;
class SurfaceClass;
/******************************************************************
**
** Font3DDataClass
**
** This class provides an interface to a font texture. Once
** created and loaded with a font, the object can return texture
** u v coordinate for any character in the font, as well as the
** character width for proportional fonts. Fonts are loaded as
** 16-bit Targa files, then converted to proportional fonts by
** finding the minimum bounding box for each chacter. The font
** texture is then minimized to a 256x256 or 128x128 texture
** material by re-stacking chars by thier minimum bounding box.
**
** During use, this class is really no more than a data table accessor
** Only during creation is any real code run.
**
** Since the space char nevers needs to be drawn, do not use
** the conventional method of acessing and drawing chars (which will
** still work). Instead, call Get_Space_Width to determine the user-
** settable width, and skip the drawing.
**
*******************************************************************/
class Font3DDataClass : public RefCountClass {
public:
/*
** Constructor, Constructor which loads a targa file,
** and Destructor
*/
Font3DDataClass( const char *filename );
~Font3DDataClass();
// the name of the font data (used for name matching and the like.)
char *Name;
/*
** access character width and height in pixels (clamp char to 0.255)
*/
unsigned char Char_Width( WCHAR ch = (WCHAR)'H' ) { return CharWidthTable[ch&0xFF]; }// & 0xFF]; } // No need to "& 0xff" with chars!!!
unsigned char Char_Height( WCHAR /*ch = 'H'*/ ) { return CharHeight; }
// u and v are in normalized texture space
inline float Char_U_Offset( WCHAR ch = (WCHAR)'H') { return UOffsetTable[ch&0xFF]; }// & 0xFF]; }
inline float Char_V_Offset( WCHAR ch = (WCHAR)'H') { return VOffsetTable[ch&0xFF]; }// & 0xFF]; }
inline float Char_U_Width( WCHAR ch = (WCHAR)'H' ) { return UWidthTable[ch&0xFF]; }// & 0xFF]; }
inline float Char_V_Height( WCHAR /*ch = 'H'*/) { return VHeight; }
// get all four UV values as one vector4
Vector4 Char_UV_Corners( WCHAR ch = (WCHAR)'H' )
{
// ch &= 0xFF;
return Vector4( UOffsetTable[ch], VOffsetTable[ch],
UOffsetTable[ch] + UWidthTable[ch],
VOffsetTable[ch] + VHeight );
}
/*
** access texture material
*/
TextureClass * Peek_Texture( void ) { return Texture; }
private:
/*
** The material (texture) which holds the font
*/
TextureClass * Texture;
/*
** Normalized texture page offsets for each character
*/
float UOffsetTable[ 256 ];
float VOffsetTable[ 256 ];
float UWidthTable[ 256 ];
float VHeight;
unsigned char CharWidthTable[ 256 ];
unsigned char CharHeight;
/*
** load a targa font image (.TGA)
*/
bool Load_Font_Image( const char *filename );
/*
** routines to convert a mono-spaced font to a proportional
** font and minimize texture image size as a result
*/
SurfaceClass *Make_Proportional( SurfaceClass *font_image );
SurfaceClass *Minimize_Font_Image( SurfaceClass *font_image );
};
/******************************************************************
**
** Font3DInstanceClass
**
*******************************************************************/
class Font3DInstanceClass : public RefCountClass {
public:
/*
** Constructor which creates/gets a Font3DDataClass object,
** and Destructor
*/
Font3DInstanceClass( const char *filename );
~Font3DInstanceClass();
/*
** access texture material
*/
TextureClass *Peek_Texture( void ) { return FontData->Peek_Texture(); }
/*
** The non-scaled monospace char width in pixels ( set to 0 for proportional spaced font )
*/
void Set_Mono_Spaced( void );
void Set_Proportional( void ) { MonoSpacing = 0; Build_Cached_Tables(); }
/*
** Set the font scale (default to 1)
** This amount will be automatically applied to all Char_Screen_Width calls
*/
void Set_Scale( float scale ) { Scale = scale; Build_Cached_Tables(); }
// float Get_Scale() const { return Scale; }
/*
** The scaled character pixel width, height, and spacing data (clamp char to 0.255)
*/
float Char_Width( WCHAR ch ) const { return ScaledWidthTable[ch&0xFF]; }
float Char_Spacing( WCHAR ch ) const { return ScaledSpacingTable[ch&0xFF]; }
float Char_Height( void ) const { return ScaledHeight; }
/*
** The scaled pixel width of a string; useful before printing to avoid screen overflows.
*/
float String_Width( const WCHAR *test_str );
float String_Width( const char *test_str );
/*
** Char UVs
*/
// u and v are in normalized texture space
// inline float Char_U_Offset( WCHAR ch = (WCHAR)'H') { return FontData->Char_U_Offset( ch & 0xFF ); }
// inline float Char_V_Offset( WCHAR ch = (WCHAR)'H') { return FontData->Char_V_Offset( ch & 0xFF ); }
// inline float Char_U_Width( WCHAR ch = (WCHAR)'H' ) { return FontData->Char_U_Width( ch & 0xFF ); }
// inline float Char_V_Height( WCHAR ch = (WCHAR)'H') { return FontData->Char_V_Height( ch & 0xFF ); }
// Vector4 Char_UV_Corners( WCHAR ch = (WCHAR)'H' ) { return FontData->Char_UV_Corners( ch & 0xFF ); }
RectClass Char_UV( WCHAR ch ) { return RectClass( FontData->Char_U_Offset(ch),
FontData->Char_V_Offset(ch),
FontData->Char_U_Offset(ch) + FontData->Char_U_Width(ch),
FontData->Char_V_Offset(ch) + FontData->Char_V_Height(ch) ); }
private:
Font3DDataClass * FontData; // The font data
float Scale; // The current scale factor
float SpaceSpacing; // non-scaled width of space in pixels ( defaults to 1/2 'H' width )
float InterCharSpacing; // non-scaled width between chars in pixels
float MonoSpacing; // non-scaled monospace char width in pixels (0 for proportional)
float ScaledWidthTable[256]; // scaled cache of the chars pixel widths
float ScaledSpacingTable[256]; // scaled cache of the chars pixel spacing
float ScaledHeight; // scaled cache of the chars pixel height
void Build_Cached_Tables();
};
#endif