1.11 Добавляем поддержку шрифтов

//-----------------------------------------------------------------------------
// File: Font.h
// A font render that draws the characters using textured quads.
// Поддержка рендеринга шрифтов, которые выводят символы с помощью
// т.н. "текстурированных квадов"
// 
// Note: This is just a cutdown, modified version of the CD3DFont class.
// Примечание: Это всего лишь урезанная версия класса CD3DFont из примера
// DirectXSDK.
//
// Original sourcecode:
// Programming a Multiplayer First Person Shooter in DirectX
// Copyright (c) 2004 Vaughan Young
//-----------------------------------------------------------------------------
#ifndef FONT_H
#define FONT_H

//-----------------------------------------------------------------------------
// Font Class
//-----------------------------------------------------------------------------
class Font
{
public:
	Font( char *name = "Arial", short size = 10, unsigned long bold = FW_NORMAL, bool italic = false );
	virtual ~Font();

	void Render( char *text, float x, float y, D3DCOLOR colour = D3DCOLOR_COLORVALUE( 1.0f, 1.0f, 1.0f, 1.0f ) );

private:
	bool PrepareFont( HDC hDC, bool measure = false );

private:
	IDirect3DStateBlock9 *m_states; // Стейтблок (state block), используемый для восстановления рендер-стейтов.
	IDirect3DVertexBuffer9 *m_vb; // Вершинный буфер (vertex buffer) для рендеримого текста.
	IDirect3DTexture9 *m_texture; // Direct3D-текстура для шрифта.
	unsigned long m_textureWidth; // Ширина текстуры.
	unsigned long m_textureHeight; // Высота текстуры.
	float m_textureCoords[96][4]; // Текстурные координаты символа (Character texture coordinates).
	short m_spacing; // Расстояние между символами в пикселах (Character pixel spacing per side).
};

#endif

//-----------------------------------------------------------------------------
// File: Font.cpp
//
// Описание: Реализация класса Font, объявленного в Font.h.
// Обращаемся к интерфейсу Font.h за подробностями.
// 
// Original Source code:
// Copyright (c) 2004 Vaughan Young
//-----------------------------------------------------------------------------
#include "Engine.h"

//-----------------------------------------------------------------------------
// The font class constructor
//-----------------------------------------------------------------------------
Font::Font( char *name, short size, unsigned long bold, bool italic )
{
	HBITMAP bitmap = NULL;
	HGDIOBJ oldBitmap = NULL;
	HFONT oldFont = NULL;
	BYTE *dstRow = NULL;
	unsigned long x, y;

	HDC hDC = CreateCompatibleDC( NULL );
	SetMapMode( hDC, MM_TEXT );

	// Создаём шрифт.
	char height = -MulDiv( size, GetDeviceCaps( hDC, LOGPIXELSY ), 72 );
	HFONT font = CreateFont( height, 0, 0, 0, bold, italic, false, false,
		DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
		ANTIALIASED_QUALITY, VARIABLE_PITCH, name );
	if( font == NULL )
		goto End;

	oldFont = (HFONT)SelectObject( hDC, font );

	// Ищем размеры наименьшей текстуры, содержащей символы.
	m_textureWidth = m_textureHeight = 128;
	while( !PrepareFont( hDC, true ) )
	{
		m_textureWidth *= 2;
		m_textureHeight *= 2;
	}

	// Создаём новую текстуру для шрифта
	if( FAILED( g_engine->GetDevice()->CreateTexture( m_textureWidth, m_textureHeight, 1, 0, D3DFMT_A4R4G4B4, D3DPOOL_MANAGED, &m_texture, NULL ) ) )
		goto End;

	// Готовим растровое изображение (bitmap).
	unsigned long *bitmapBits;
	BITMAPINFO bmi;
	ZeroMemory( &bmi.bmiHeader, sizeof( BITMAPINFOHEADER ) );
	bmi.bmiHeader.biSize = sizeof( BITMAPINFOHEADER );
	bmi.bmiHeader.biWidth = (int)m_textureWidth;
	bmi.bmiHeader.biHeight = -(int)m_textureHeight;
	bmi.bmiHeader.biPlanes = 1;
	bmi.bmiHeader.biCompression = BI_RGB;
	bmi.bmiHeader.biBitCount = 32;

	// Создаём растровое изображение (bitmap) для шрифта.
	bitmap = CreateDIBSection( hDC, &bmi, DIB_RGB_COLORS, (void**)&bitmapBits, NULL, 0 );

	oldBitmap = SelectObject( hDC, bitmap );

	// Устанавливаем свойства текста.
	SetTextColor( hDC, RGB( 255,255,255 ) );
	SetBkColor( hDC, 0x00000000 );
	SetTextAlign( hDC, TA_TOP );

	// Готовим шрифт к прорисовке символов на битмапе.
	if( !PrepareFont( hDC ) )
		goto End;

	// Лочим (блокируем) поверхность и записываем значения альфа-канала для набора пикселей.
	D3DLOCKED_RECT d3dlr;
	m_texture->LockRect( 0, &d3dlr, 0, 0 );
	dstRow = (BYTE*)d3dlr.pBits;
	WORD *dst16;
	BYTE alpha;

	for( y = 0; y < m_textureHeight; y++ )
	{
		dst16 = (WORD*)dstRow;
		for( x = 0; x < m_textureWidth; x++ )
		{
			alpha = (BYTE)( ( bitmapBits[m_textureWidth*y + x] & 0xff ) >> 4 );
			if( alpha > 0 )
				*dst16++ = (WORD)( ( alpha << 12 ) | 0x0fff );
			else
				*dst16++ = 0x0000;
		}
		dstRow += d3dlr.Pitch;
	}

	// Создаём вершинный буфер (vertex buffer) для символов.
	g_engine->GetDevice()->CreateVertexBuffer( 1020 * sizeof( TLVertex ), D3DUSAGE_WRITEONLY | D3DUSAGE_DYNAMIC, 0, D3DPOOL_DEFAULT, &m_vb, NULL );

	// Готовим альфа-проверку (alpha testing) для рендеринга символов.
	g_engine->GetDevice()->SetRenderState( D3DRS_ALPHAREF, 0x08 );
	g_engine->GetDevice()->SetRenderState( D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL );

	// Создаём блок стейтов для захвата волатильных (volatile, нестабильных, постоянно изменяющихся) рендер-стейтов.
	g_engine->GetDevice()->BeginStateBlock();
	g_engine->GetDevice()->SetRenderState( D3DRS_LIGHTING, false );
	g_engine->GetDevice()->SetRenderState( D3DRS_ALPHATESTENABLE, false );
	g_engine->GetDevice()->SetRenderState( D3DRS_FOGENABLE, false );
	g_engine->GetDevice()->EndStateBlock( &m_states );

	// Прибираемся и возвращаем управление движку.
End:
	if( m_texture )
		m_texture->UnlockRect( 0 );

	SelectObject( hDC, oldBitmap );
	SelectObject( hDC, oldFont );
	DeleteObject( bitmap );
	DeleteObject( font );
	DeleteDC( hDC );
}

//-----------------------------------------------------------------------------
// The font class destructor
//-----------------------------------------------------------------------------
Font::~Font()
{
	SAFE_RELEASE( m_states );
	SAFE_RELEASE( m_vb );
	SAFE_RELEASE( m_texture );
}

//-----------------------------------------------------------------------------
// Готовит шрифт путём прорисовки всех символов в контексте устройтсва (device context).
//-----------------------------------------------------------------------------
bool Font::PrepareFont( HDC hDC, bool measure )
{
	SIZE size;
	char string[2];

	// Определяем отступы между символами, основываясь на высоте линии (line height).
	if( GetTextExtentPoint32( hDC, string, 1, &size ) == 0 )
		return false;
	m_spacing = (short)ceil( size.cy * 0.1f );

	// Устанавливаем позицию начала прорисовки.
	unsigned long x = m_spacing;
	unsigned long y = 0;

	// Выводим каждый символ в контекст устройства (device context, DC) и перемещаемся на след. позицию.
	for( char c = 32; c < 127; c++ )
	{
		string[0] = c;
		if( GetTextExtentPoint32( hDC, string, 1, &size ) == 0 )
			return false;

		if( (unsigned long)( x + size.cx + m_spacing ) > m_textureWidth )
		{
			x = m_spacing;
			y += size.cy + 1;
		}

		// Проверяем, осталось ли ещё место для прорисовки очередного символа.
		if( y + size.cy > m_textureHeight )
			return false;

		// Выводим символ, если не измерено.
		if( !measure )
		{
			if( ExtTextOut( hDC, x + 0, y + 0, ETO_OPAQUE, NULL, string, 1, NULL ) == 0 )
				return false;

			m_textureCoords[c - 32][0] = (float)( x - m_spacing ) / m_textureWidth;
			m_textureCoords[c - 32][1] = (float)( y ) / m_textureHeight;
			m_textureCoords[c - 32][2] = (float)( x + size.cx + m_spacing ) / m_textureWidth;
			m_textureCoords[c - 32][3] = (float)( y + size.cy ) / m_textureHeight;
		}

		x += size.cx + ( 2 * m_spacing );
	}

	return true;
}

//-----------------------------------------------------------------------------
// Рендерит указанный текст на экран, используя данный шрифт.
//-----------------------------------------------------------------------------
void Font::Render( char *text, float x, float y, D3DCOLOR colour )
{
	// Захватываем текущие волатильные (volatile, непостоянные) рендер-стейты.
	m_states->Capture();

	// Устанавливаем волатильные (volatile, непостоянные) рендер-стейты.
	g_engine->GetDevice()->SetRenderState( D3DRS_LIGHTING, false );
	g_engine->GetDevice()->SetRenderState( D3DRS_ALPHATESTENABLE, true );
	g_engine->GetDevice()->SetRenderState( D3DRS_FOGENABLE, false );

	// Устанавливаем неволатильные рендер-стейты.
	g_engine->GetDevice()->SetTexture( 0, m_texture );
	g_engine->GetDevice()->SetFVF( TL_VERTEX_FVF );
	g_engine->GetDevice()->SetStreamSource( 0, m_vb, 0, TL_VERTEX_FVF_SIZE );

	// Регулируем расстояние между символами.
	x -= m_spacing;
	float startX = x;

	// Заполняем вершинный буфер (vertex buffer).
	TLVertex* vertices = NULL;
	unsigned long totalTriangles = 0;
	m_vb->Lock( 0, 0, (void**)&vertices, D3DLOCK_DISCARD );

	// Для каждой буквы текста добавляем текстурированный квад (= две грани, образующие прямоугольник) в вершинный буфер.
	while( *text )
	{
		char c = *text++;

		if( c == _T( '\n' ) )
		{
			x = startX;
			y += ( m_textureCoords[0][3] - m_textureCoords[0][1] ) * m_textureHeight;
		}

		if( ( c - 32 ) < 0 || ( c - 32 ) >= 96 )
			continue;

		float tx1 = m_textureCoords[c - 32][0];
		float ty1 = m_textureCoords[c - 32][1];
		float tx2 = m_textureCoords[c - 32][2];
		float ty2 = m_textureCoords[c - 32][3];

		float w = ( tx2 - tx1 ) * m_textureWidth;
		float h = ( ty2 - ty1 ) * m_textureHeight;

		if( c != _T( ' ' ) )
		{
			*vertices++ = TLVertex( D3DXVECTOR4( x - 0.5f, y + h - 0.5f, 0.0f, 1.0f ), colour, tx1, ty2 );
			*vertices++ = TLVertex( D3DXVECTOR4( x - 0.5f, y - 0.5f, 0.0f, 1.0f ), colour, tx1, ty1 );
			*vertices++ = TLVertex( D3DXVECTOR4( x + w - 0.5f, y + h - 0.5f, 0.0f, 1.0f ), colour, tx2, ty2 );
			*vertices++ = TLVertex( D3DXVECTOR4( x + w - 0.5f, y - 0.5f, 0.0f, 1.0f ), colour, tx2, ty1 );
			*vertices++ = TLVertex( D3DXVECTOR4( x + w - 0.5f, y + h - 0.5f, 0.0f, 1.0f ), colour, tx2, ty2 );
			*vertices++ = TLVertex( D3DXVECTOR4( x - 0.5f, y - 0.5f, 0.0f, 1.0f ), colour, tx1, ty1 );
			totalTriangles += 2;

			if( totalTriangles == 340 )
			{
				// Разблокируем, рендерим и снова блокируем вершинный буфер.
				m_vb->Unlock();
				g_engine->GetDevice()->DrawPrimitive( D3DPT_TRIANGLELIST, 0, totalTriangles );
				vertices = NULL;
				m_vb->Lock( 0, 0, (void**)&vertices, D3DLOCK_DISCARD );
				totalTriangles = 0;
			}
		}

		x += w - ( 2 * m_spacing );
	}

	// Разблокируем и рендерим содержимое вершинного буфера (vertex buffer).
	m_vb->Unlock();
	if( totalTriangles > 0 )
		g_engine->GetDevice()->DrawPrimitive( D3DPT_TRIANGLELIST, 0, totalTriangles );

	// Восстанавливаем волатильные (изменяющиеся) рендер-стейты.
	m_states->Apply();
}

...
//-----------------------------
// Engine Includes
//-----------------------------
#include "resource.h"
#include "LinkedList.h"
#include "ResourceManagement.h"
#include "Geometry.h"
#include "Font.h"
#include "Scripting.h"
#include "DeviceEnumeration.h"
#include "Input.h"
#include "State.h"
...

//-----------------------------------------------------------------------------
// System Includes
//-----------------------------------------------------------------------------
#include <windows.h>

//-----------------------------------------------------------------------------
// Engine Includes
//-----------------------------------------------------------------------------
#include "..\GameProject01\Engine.h"

//-----------------------------------------------------------------------------
// Test State Class
//-----------------------------------------------------------------------------
class TestState : public State
{
public:
	//-------------------------------------------------------------------------
	// Позволяет стейту выполнить какие-либо препроцессорные (pre-processing) инструкции.
	//-------------------------------------------------------------------------
	virtual void Load()
	{
		m_font = new Font;
	}

	//-------------------------------------------------------------------------
	// Позвоялет стейту выполнить какие-либо постпроцессорные (post-processing) инструкции.
	//-------------------------------------------------------------------------
	virtual void Close()
	{
		SAFE_DELETE( m_font );
	}

	//-------------------------------------------------------------------------
	// Возвращает установки вида для данного фрейма.
	//-------------------------------------------------------------------------
	virtual void RequestViewer( ViewerSetup *viewer )
	{
		viewer->viewClearFlags = D3DCLEAR_TARGET;
	}

	//-------------------------------------------------------------------------
	// Updates the state.
	//-------------------------------------------------------------------------
	virtual void Update( float elapsed )
	{
		// Подсчитываем фреймрейт (fps, частоту кадров).
		static float frameTime = 1.0f;
		static int frameCount = 0;
		frameTime += elapsed;
		frameCount++;

		// Обновляем данные о fps каждую сукунду.
		if( frameTime > 1.0f )
		{
			sprintf( m_fps, "%d fps", frameCount );

			frameTime = 0.0f;
			frameCount = 0;
		}
	}

	//-------------------------------------------------------------------------
	// Renders the state.
	//-------------------------------------------------------------------------
	virtual void Render()
	{
		m_font->Render( "Hello! This text is rendered using the new Direct3D device.", 0, 0 );
		m_font->Render( m_fps, 10, 100, D3DCOLOR_COLORVALUE( 1.0f, 0.0f, 1.0f, 1.0f ) );
	}

private:
	Font *m_font; // Шрифт, применяемый для рендеринга стейта.
	char m_fps[16]; // Сохраняет показания fps в виде строки текста для вывода на экран.
};

//-----------------------------------------------------------------------------
// Установки стейта, специфичные для приложения.
//-----------------------------------------------------------------------------
void StateSetup()
{
	g_engine->AddState( new TestState, true );
}

//-----------------------------------------------------------------------------
// Точка входа в приложение.
//-----------------------------------------------------------------------------
int WINAPI WinMain( HINSTANCE instance, HINSTANCE prev, LPSTR cmdLine, int cmdShow )
{
	// Создаём структуру engine setup.
	EngineSetup setup;
	setup.instance = instance;
	setup.name = "Rendering Test";
	setup.totalBackBuffers = 2;
	setup.StateSetup = StateSetup;

	// Создаём движок (на основе данных структуры EngineSetup), затем запускаем его.
	new Engine( &setup );
	g_engine->Run();

	return true;
}