/******************************************************************************
|
|
@file PVRTPrint3D.cpp
|
@copyright Copyright (c) Imagination Technologies Limited.
|
@brief Displays a text string using 3D polygons. Can be done in two ways:
|
using a window defined by the user or writing straight on the
|
screen.
|
|
******************************************************************************/
|
|
/****************************************************************************
|
** Includes
|
****************************************************************************/
|
#include <stdarg.h>
|
#include <stdio.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <wchar.h>
|
|
#include "PVRTGlobal.h"
|
#include "PVRTFixedPoint.h"
|
#include "PVRTMatrix.h"
|
#include "PVRTTexture.h"
|
#include "PVRTPrint3D.h"
|
#include "PVRTUnicode.h"
|
#include "PVRTContext.h"
|
#include "PVRTMap.h"
|
|
/* Print3D texture data */
|
#include "PVRTPrint3DIMGLogo.h"
|
#include "PVRTPrint3DHelveticaBold.h"
|
|
static inline float PVRTMakeWhole(float f)
|
{
|
return floorf(f + 0.5f);
|
}
|
|
|
/****************************************************************************
|
** Defines
|
****************************************************************************/
|
#define MAX_LETTERS (5120)
|
#define MIN_CACHED_VTX (0x1000)
|
#define MAX_CACHED_VTX (0x00100000)
|
#define LINES_SPACING (29.0f)
|
#define PVRPRINT3DVERSION (1)
|
|
#if defined(_WIN32)
|
#define vsnprintf _vsnprintf
|
#endif
|
|
const PVRTuint32 PVRFONT_HEADER = 0xFCFC0050;
|
const PVRTuint32 PVRFONT_CHARLIST = 0xFCFC0051;
|
const PVRTuint32 PVRFONT_RECTS = 0xFCFC0052;
|
const PVRTuint32 PVRFONT_METRICS = 0xFCFC0053;
|
const PVRTuint32 PVRFONT_YOFFSET = 0xFCFC0054;
|
const PVRTuint32 PVRFONT_KERNING = 0xFCFC0055;
|
|
/****************************************************************************
|
** Constants
|
****************************************************************************/
|
static const unsigned int PVRTPRINT3D_INVALID_CHAR = 0xFDFDFDFD;
|
|
/****************************************************************************
|
** Auxiliary functions
|
****************************************************************************/
|
/*!***************************************************************************
|
@fn CharacterCompareFunc
|
@param[in] pA
|
@param[in] pB
|
@return PVRTint32
|
@brief Compares two characters for binary search.
|
*****************************************************************************/
|
PVRTint32 CPVRTPrint3D::CharacterCompareFunc(const void* pA, const void* pB)
|
{
|
return (*(PVRTint32*)pA - *(PVRTint32*)pB);
|
}
|
|
/*!***************************************************************************
|
@fn KerningCompareFunc
|
@param[in] pA
|
@param[in] pB
|
@return PVRTint32
|
@brief Compares two kerning pairs for binary search.
|
*****************************************************************************/
|
PVRTint32 CPVRTPrint3D::KerningCompareFunc(const void* pA, const void* pB)
|
{
|
KerningPair* pPairA = (KerningPair*)pA;
|
KerningPair* pPairB = (KerningPair*)pB;
|
|
if(pPairA->uiPair > pPairB->uiPair) return 1;
|
if(pPairA->uiPair < pPairB->uiPair) return -1;
|
|
return 0;
|
}
|
|
/****************************************************************************
|
** Class: CPVRTPrint3D
|
****************************************************************************/
|
/*****************************************************************************
|
@fn CPVRTPrint3D
|
@brief Init some values.
|
*****************************************************************************/
|
CPVRTPrint3D::CPVRTPrint3D() : m_pAPI(NULL), m_uLogoToDisplay(ePVRTPrint3DLogoNone), m_pwFacesFont(NULL), m_pPrint3dVtx(NULL), m_bTexturesSet(false), m_pVtxCache(NULL), m_nVtxCache(0),
|
m_nVtxCacheMax(0), m_bRotate(false), m_nCachedNumVerts(0), m_pwzPreviousString(NULL), m_pszPreviousString(NULL), m_fPrevScale(0.0f), m_fPrevX(0.0f),
|
m_fPrevY(0.0f), m_uiPrevCol(0), m_pUVs(NULL), m_pKerningPairs(NULL), m_pCharMatrics(NULL), m_fTexW(0.0f), m_fTexH(0.0f), m_pRects(NULL), m_pYOffsets(NULL),
|
m_uiNextLineH(0), m_uiSpaceWidth(0), m_uiNumCharacters(0), m_uiNumKerningPairs(0), m_uiAscent(0), m_pszCharacterList(NULL), m_bHasMipmaps(false),
|
m_bUsingProjection(false)
|
{
|
memset(m_fScreenScale, 0, sizeof(m_fScreenScale));
|
memset(m_ui32ScreenDim, 0, sizeof(m_ui32ScreenDim));
|
|
PVRTMatrixIdentity(m_mModelView);
|
PVRTMatrixIdentity(m_mProj);
|
|
m_pwzPreviousString = new wchar_t[MAX_LETTERS + 1];
|
m_pszPreviousString = new char[MAX_LETTERS + 1];
|
m_pwzPreviousString[0] = 0;
|
m_pszPreviousString[0] = 0;
|
|
m_eFilterMethod[eFilterProc_Min] = eFilter_Default;
|
m_eFilterMethod[eFilterProc_Mag] = eFilter_Default;
|
m_eFilterMethod[eFilterProc_Mip] = eFilter_MipDefault;
|
}
|
|
/*****************************************************************************
|
@fn ~CPVRTPrint3D
|
@brief De-allocate the working memory
|
*****************************************************************************/
|
CPVRTPrint3D::~CPVRTPrint3D()
|
{
|
delete [] m_pwzPreviousString;
|
delete [] m_pszPreviousString;
|
|
delete [] m_pszCharacterList;
|
delete [] m_pYOffsets;
|
delete [] m_pCharMatrics;
|
delete [] m_pKerningPairs;
|
delete [] m_pRects;
|
delete [] m_pUVs;
|
}
|
|
/*!***************************************************************************
|
@fn ReadMetaBlock
|
@param[in] pDataCursor
|
@return bool true if successful.
|
@brief Reads a single meta data block from the data file.
|
*****************************************************************************/
|
bool CPVRTPrint3D::ReadMetaBlock(const PVRTuint8** pDataCursor)
|
{
|
SPVRTPrint3DHeader* header;
|
|
unsigned int uiDataSize;
|
|
MetaDataBlock block;
|
if(!block.ReadFromPtr(pDataCursor))
|
{
|
return false; // Must have been an error.
|
}
|
|
switch(block.u32Key)
|
{
|
case PVRFONT_HEADER:
|
header = (SPVRTPrint3DHeader*)block.Data;
|
if(header->uVersion != PVRTPRINT3D_VERSION)
|
{
|
return false;
|
}
|
// Copy options
|
m_uiAscent = header->wAscent;
|
m_uiNextLineH = header->wLineSpace;
|
m_uiSpaceWidth = header->uSpaceWidth;
|
m_uiNumCharacters = header->wNumCharacters & 0xFFFF;
|
m_uiNumKerningPairs = header->wNumKerningPairs & 0xFFFF;
|
break;
|
case PVRFONT_CHARLIST:
|
uiDataSize = sizeof(PVRTuint32) * m_uiNumCharacters;
|
_ASSERT(block.u32DataSize == uiDataSize);
|
m_pszCharacterList = new PVRTuint32[m_uiNumCharacters];
|
memcpy(m_pszCharacterList, block.Data, uiDataSize);
|
break;
|
case PVRFONT_YOFFSET:
|
uiDataSize = sizeof(PVRTint32) * m_uiNumCharacters;
|
_ASSERT(block.u32DataSize == uiDataSize);
|
m_pYOffsets = new PVRTint32[m_uiNumCharacters];
|
memcpy(m_pYOffsets, block.Data, uiDataSize);
|
break;
|
case PVRFONT_METRICS:
|
uiDataSize = sizeof(CharMetrics) * m_uiNumCharacters;
|
_ASSERT(block.u32DataSize == uiDataSize);
|
m_pCharMatrics = new CharMetrics[m_uiNumCharacters];
|
memcpy(m_pCharMatrics, block.Data, uiDataSize);
|
break;
|
case PVRFONT_KERNING:
|
uiDataSize = sizeof(KerningPair) * m_uiNumKerningPairs;
|
_ASSERT(block.u32DataSize == uiDataSize);
|
m_pKerningPairs = new KerningPair[m_uiNumKerningPairs];
|
memcpy(m_pKerningPairs, block.Data, uiDataSize);
|
break;
|
case PVRFONT_RECTS:
|
uiDataSize = sizeof(Rectanglei) * m_uiNumCharacters;
|
_ASSERT(block.u32DataSize == uiDataSize);
|
|
m_pRects = new Rectanglei[m_uiNumCharacters];
|
memcpy(m_pRects, block.Data, uiDataSize);
|
break;
|
default:
|
_ASSERT(!"Unhandled key!");
|
}
|
|
return true;
|
}
|
|
/*!***************************************************************************
|
@fn LoadFontData
|
@param[in] texHeader
|
@param[in] MetaDataMap
|
@return bool true if successful.
|
@brief Loads font data bundled with the texture file.
|
*****************************************************************************/
|
bool CPVRTPrint3D::LoadFontData( const PVRTextureHeaderV3* texHeader, CPVRTMap<PVRTuint32, CPVRTMap<PVRTuint32, MetaDataBlock> >& MetaDataMap )
|
{
|
m_fTexW = (float)texHeader->u32Width;
|
m_fTexH = (float)texHeader->u32Height;
|
|
// Mipmap data is stored in the texture header data.
|
m_bHasMipmaps = (texHeader->u32MIPMapCount > 1 ? true : false);
|
if(m_bHasMipmaps)
|
{
|
m_eFilterMethod[eFilterProc_Min] = eFilter_Linear;
|
m_eFilterMethod[eFilterProc_Mag] = eFilter_Linear;
|
m_eFilterMethod[eFilterProc_Mip] = eFilter_Linear;
|
}
|
else
|
{
|
m_eFilterMethod[eFilterProc_Min] = eFilter_Linear;
|
m_eFilterMethod[eFilterProc_Mag] = eFilter_Linear;
|
m_eFilterMethod[eFilterProc_Mip] = eFilter_None;
|
}
|
|
|
// Header
|
SPVRTPrint3DHeader* header = (SPVRTPrint3DHeader*)MetaDataMap[PVRTEX3_IDENT][PVRFONT_HEADER].Data;
|
if(header->uVersion != PVRTPRINT3D_VERSION)
|
{
|
return false;
|
}
|
// Copy options
|
m_uiAscent = header->wAscent;
|
m_uiNextLineH = header->wLineSpace;
|
m_uiSpaceWidth = header->uSpaceWidth;
|
m_uiNumCharacters = header->wNumCharacters & 0xFFFF;
|
m_uiNumKerningPairs = header->wNumKerningPairs & 0xFFFF;
|
|
// Char list
|
m_pszCharacterList = new PVRTuint32[m_uiNumCharacters];
|
memcpy(m_pszCharacterList, MetaDataMap[PVRTEX3_IDENT][PVRFONT_CHARLIST].Data, MetaDataMap[PVRTEX3_IDENT][PVRFONT_CHARLIST].u32DataSize);
|
|
m_pYOffsets = new PVRTint32[m_uiNumCharacters];
|
memcpy(m_pYOffsets, MetaDataMap[PVRTEX3_IDENT][PVRFONT_YOFFSET].Data, MetaDataMap[PVRTEX3_IDENT][PVRFONT_YOFFSET].u32DataSize);
|
|
m_pCharMatrics = new CharMetrics[m_uiNumCharacters];
|
memcpy(m_pCharMatrics, MetaDataMap[PVRTEX3_IDENT][PVRFONT_METRICS].Data, MetaDataMap[PVRTEX3_IDENT][PVRFONT_METRICS].u32DataSize);
|
|
m_pKerningPairs = new KerningPair[m_uiNumKerningPairs];
|
memcpy(m_pKerningPairs, MetaDataMap[PVRTEX3_IDENT][PVRFONT_KERNING].Data, MetaDataMap[PVRTEX3_IDENT][PVRFONT_KERNING].u32DataSize);
|
|
m_pRects = new Rectanglei[m_uiNumCharacters];
|
memcpy(m_pRects, MetaDataMap[PVRTEX3_IDENT][PVRFONT_RECTS].Data, MetaDataMap[PVRTEX3_IDENT][PVRFONT_RECTS].u32DataSize);
|
|
|
// Build UVs
|
m_pUVs = new CharacterUV[m_uiNumCharacters];
|
for(unsigned int uiChar = 0; uiChar < m_uiNumCharacters; uiChar++)
|
{
|
m_pUVs[uiChar].fUL = m_pRects[uiChar].nX / m_fTexW;
|
m_pUVs[uiChar].fUR = m_pUVs[uiChar].fUL + m_pRects[uiChar].nW / m_fTexW;
|
m_pUVs[uiChar].fVT = m_pRects[uiChar].nY / m_fTexH;
|
m_pUVs[uiChar].fVB = m_pUVs[uiChar].fVT + m_pRects[uiChar].nH / m_fTexH;
|
}
|
|
return true;
|
}
|
|
/*!***************************************************************************
|
@fn FindCharacter
|
@param[in] character
|
@return The character index, or PVRPRINT3D_INVALID_CHAR if not found.
|
@brief Finds a given character in the binary data and returns it's
|
index.
|
*****************************************************************************/
|
PVRTuint32 CPVRTPrint3D::FindCharacter(PVRTuint32 character) const
|
{
|
PVRTuint32* pItem = (PVRTuint32*)bsearch(&character, m_pszCharacterList, m_uiNumCharacters, sizeof(PVRTuint32), CharacterCompareFunc);
|
if(!pItem)
|
return PVRTPRINT3D_INVALID_CHAR;
|
|
PVRTuint32 uiIdx = (PVRTuint32) (pItem - m_pszCharacterList);
|
return uiIdx;
|
}
|
|
/*!***************************************************************************
|
@fn ApplyKerning
|
@param[in] cA
|
@param[in] cB
|
@param[out] fOffset
|
@brief Calculates kerning offset.
|
*****************************************************************************/
|
void CPVRTPrint3D::ApplyKerning(const PVRTuint32 cA, const PVRTuint32 cB, float& fOffset) const
|
{
|
PVRTuint64 uiPairToSearch = ((PVRTuint64)cA << 32) | (PVRTuint64)cB;
|
KerningPair* pItem = (KerningPair*)bsearch(&uiPairToSearch, m_pKerningPairs, m_uiNumKerningPairs, sizeof(KerningPair), KerningCompareFunc);
|
if(pItem)
|
fOffset += (float)pItem->iOffset;
|
}
|
|
/*!***************************************************************************
|
@fn SetTextures
|
@param[in] pContext Context
|
@param[in] dwScreenX Screen resolution along X
|
@param[in] dwScreenY Screen resolution along Y
|
@param[in] bRotate Rotate print3D by 90 degrees
|
@param[in] bMakeCopy This instance of Print3D creates a copy
|
of it's data instead of sharing with previous
|
contexts. Set this parameter if you require
|
thread safety.
|
@return PVR_SUCCESS or PVR_FAIL
|
@brief Initialization and texture upload. Should be called only once
|
for a given context.
|
*****************************************************************************/
|
EPVRTError CPVRTPrint3D::SetTextures(
|
const SPVRTContext * const pContext,
|
const unsigned int dwScreenX,
|
const unsigned int dwScreenY,
|
const bool bRotate,
|
const bool bMakeCopy)
|
{
|
// Determine which set of textures to use depending on the screen resolution.
|
const unsigned int uiShortestEdge = PVRT_MIN(dwScreenX, dwScreenY);
|
const void* pData = NULL;
|
|
if(uiShortestEdge >= 720)
|
{
|
pData = (void*)_helvbd_56_pvr;
|
}
|
else if(uiShortestEdge >= 640)
|
{
|
pData = (void*)_helvbd_46_pvr;
|
}
|
else
|
{
|
pData = (void*)_helvbd_36_pvr;
|
}
|
|
PVRT_UNREFERENCED_PARAMETER(_helvbd_36_pvr_size);
|
PVRT_UNREFERENCED_PARAMETER(_helvbd_46_pvr_size);
|
PVRT_UNREFERENCED_PARAMETER(_helvbd_56_pvr_size);
|
|
return SetTextures(pContext, pData, dwScreenX, dwScreenY, bRotate, bMakeCopy);
|
}
|
|
/*!***************************************************************************
|
@fn SetTextures
|
@param[in] pContext Context
|
@param[in] pTexData User-provided font texture
|
@param[in] uiDataSize Size of the data provided
|
@param[in] dwScreenX Screen resolution along X
|
@param[in] dwScreenY Screen resolution along Y
|
@param[in] bRotate Rotate print3D by 90 degrees
|
@param[in] bMakeCopy This instance of Print3D creates a copy
|
of it's data instead of sharing with previous
|
contexts. Set this parameter if you require
|
thread safety.
|
@return PVR_SUCCESS or PVR_FAIL
|
@brief Initialization and texture upload of user-provided font
|
data. Should be called only once for a Print3D object.
|
*****************************************************************************/
|
EPVRTError CPVRTPrint3D::SetTextures(
|
const SPVRTContext * const pContext,
|
const void * const pTexData,
|
const unsigned int dwScreenX,
|
const unsigned int dwScreenY,
|
const bool bRotate,
|
const bool bMakeCopy)
|
{
|
#if !defined (DISABLE_PRINT3D)
|
|
unsigned short i;
|
bool bStatus;
|
|
// Set the aspect ratio, so we can change it without updating textures or anything else
|
float fX, fY;
|
|
m_bRotate = bRotate;
|
m_ui32ScreenDim[0] = bRotate ? dwScreenY : dwScreenX;
|
m_ui32ScreenDim[1] = bRotate ? dwScreenX : dwScreenY;
|
|
// Alter the X, Y resolutions if the screen isn't portrait.
|
if(dwScreenX > dwScreenY)
|
{
|
fX = (float) dwScreenX;
|
fY = (float) dwScreenY;
|
}
|
else
|
{
|
fX = (float) dwScreenY;
|
fY = (float) dwScreenX;
|
}
|
|
m_fScreenScale[0] = (bRotate ? fY : fX) /640.0f;
|
m_fScreenScale[1] = (bRotate ? fX : fY) /480.0f;
|
|
// Check whether textures are already set up just in case
|
if (m_bTexturesSet)
|
return PVR_SUCCESS;
|
|
// INDEX BUFFERS
|
m_pwFacesFont = (unsigned short*)malloc(PVRTPRINT3D_MAX_RENDERABLE_LETTERS*2*3*sizeof(unsigned short));
|
|
if(!m_pwFacesFont)
|
{
|
return PVR_FAIL;
|
}
|
|
// Vertex indices for letters
|
for (i=0; i < PVRTPRINT3D_MAX_RENDERABLE_LETTERS; i++)
|
{
|
m_pwFacesFont[i*6+0] = 0+i*4;
|
m_pwFacesFont[i*6+1] = 3+i*4;
|
m_pwFacesFont[i*6+2] = 1+i*4;
|
|
m_pwFacesFont[i*6+3] = 3+i*4;
|
m_pwFacesFont[i*6+4] = 0+i*4;
|
m_pwFacesFont[i*6+5] = 2+i*4;
|
}
|
|
|
if(!APIInit(pContext, bMakeCopy))
|
{
|
return PVR_FAIL;
|
}
|
/*
|
This is the texture with the fonts.
|
*/
|
PVRTextureHeaderV3 header;
|
CPVRTMap<PVRTuint32, CPVRTMap<PVRTuint32, MetaDataBlock> > MetaDataMap;
|
bStatus = APIUpLoadTexture((unsigned char *)pTexData, &header, MetaDataMap);
|
|
if (!bStatus)
|
{
|
return PVR_FAIL;
|
}
|
/*
|
This is the associated font data with the default font
|
*/
|
bStatus = LoadFontData(&header, MetaDataMap);
|
|
bStatus = APIUpLoadIcons(reinterpret_cast<const PVRTuint8* const>(PVRTPrint3DIMGLogo), reinterpret_cast<const PVRTuint8* const>(PVRTPrint3DPowerVRLogo));
|
|
if (!bStatus) return PVR_FAIL;
|
|
m_nVtxCacheMax = MIN_CACHED_VTX;
|
m_pVtxCache = (SPVRTPrint3DAPIVertex*)malloc(m_nVtxCacheMax * sizeof(*m_pVtxCache));
|
m_nVtxCache = 0;
|
|
if(!m_pVtxCache)
|
{
|
return PVR_FAIL;
|
}
|
|
// Everything is OK
|
m_bTexturesSet = true;
|
|
// Return Success
|
return PVR_SUCCESS;
|
|
#else
|
return PVR_SUCCESS;
|
#endif
|
}
|
|
/*!***************************************************************************
|
@fn Print3D
|
@param[in] fPosX X Position
|
@param[in] fPosY Y Position
|
@param[in] fScale Text scale
|
@param[in] Colour ARGB colour
|
@param[in] UTF32 Array of UTF32 characters
|
@param[in] bUpdate Whether to update the vertices
|
@return EPVRTError Success of failure
|
@brief Takes an array of UTF32 characters and generates the required mesh.
|
*****************************************************************************/
|
EPVRTError CPVRTPrint3D::Print3D(float fPosX, float fPosY, const float fScale, unsigned int Colour, const CPVRTArray<PVRTuint32>& UTF32, bool bUpdate)
|
{
|
// No textures! so... no window
|
if (!m_bTexturesSet)
|
{
|
PVRTErrorOutputDebug("DisplayWindow : You must call CPVRTPrint3D::SetTextures(...) before using this function.\n");
|
return PVR_FAIL;
|
}
|
|
// nothing to be drawn
|
if(UTF32.GetSize() == 0)
|
return PVR_FAIL;
|
|
// Adjust input parameters
|
if(!m_bUsingProjection)
|
{
|
fPosX = (float)((int)(fPosX * (640.0f/100.0f)));
|
fPosY = -(float)((int)(fPosY * (480.0f/100.0f)));
|
}
|
|
// Create Vertex Buffer (only if it doesn't exist)
|
if(m_pPrint3dVtx == 0)
|
{
|
m_pPrint3dVtx = (SPVRTPrint3DAPIVertex*)malloc(MAX_LETTERS*4*sizeof(SPVRTPrint3DAPIVertex));
|
|
if(!m_pPrint3dVtx)
|
return PVR_FAIL;
|
}
|
|
// Fill up our buffer
|
if(bUpdate)
|
m_nCachedNumVerts = UpdateLine(0.0f, fPosX, fPosY, fScale, Colour, UTF32, m_pPrint3dVtx);
|
|
// Draw the text
|
if(!DrawLine(m_pPrint3dVtx, m_nCachedNumVerts))
|
return PVR_FAIL;
|
|
return PVR_SUCCESS;
|
}
|
|
/*!***************************************************************************
|
@fn Print3D
|
@param[in] fPosX Position of the text along X
|
@param[in] fPosY Position of the text along Y
|
@param[in] fScale Scale of the text
|
@param[in] Colour Colour of the text
|
@param[in] pszFormat Format string for the text
|
@return PVR_SUCCESS or PVR_FAIL
|
@brief Display wide-char 3D text on screen.
|
CPVRTPrint3D::SetTextures(...) must have been called
|
beforehand.
|
This function accepts formatting in the printf way.
|
*****************************************************************************/
|
EPVRTError CPVRTPrint3D::Print3D(float fPosX, float fPosY, const float fScale, unsigned int Colour, const wchar_t * const pszFormat, ...)
|
{
|
#ifdef DISABLE_PRINT3D
|
return PVR_SUCCESS;
|
#endif
|
|
static wchar_t s_Text[MAX_LETTERS+1] = {0};
|
|
/*
|
Unfortunately only Windows seems to properly support non-ASCII characters formatted in
|
vswprintf.
|
*/
|
#if defined(_WIN32) && !defined(UNDER_CE)
|
va_list args;
|
// Reading the arguments to create our Text string
|
va_start(args, pszFormat);
|
vswprintf(s_Text, MAX_LETTERS+1, pszFormat, args);
|
va_end(args);
|
#else
|
wcscpy(s_Text, pszFormat);
|
#endif
|
|
bool bUpdate = false;
|
|
// Optimisation to check that the strings are actually different.
|
if(wcscmp(s_Text, m_pwzPreviousString) != 0 || m_fPrevX != fPosX || m_fPrevY != fPosY || m_fPrevScale != fScale || m_uiPrevCol != Colour)
|
{
|
// Copy strings
|
wcscpy(m_pwzPreviousString, s_Text);
|
m_fPrevX = fPosX;
|
m_fPrevY = fPosY;
|
m_fPrevScale = fScale;
|
m_uiPrevCol = Colour;
|
|
m_CachedUTF32.Clear();
|
#if PVRTSIZEOFWCHAR == 2 // 2 byte wchar.
|
PVRTUnicodeUTF16ToUTF32((PVRTuint16*)s_Text, m_CachedUTF32);
|
#elif PVRTSIZEOFWCHAR == 4 // 4 byte wchar (POSIX)
|
unsigned int uiC = 0;
|
PVRTuint32* pUTF32 = (PVRTuint32*)s_Text;
|
while(*pUTF32 && uiC < MAX_LETTERS)
|
{
|
m_CachedUTF32.Append(*pUTF32++);
|
uiC++;
|
}
|
#else
|
return PVR_FAIL;
|
#endif
|
|
bUpdate = true;
|
}
|
|
// Print
|
return Print3D(fPosX, fPosY, fScale, Colour, m_CachedUTF32, bUpdate);
|
}
|
|
/*!***************************************************************************
|
@fn PVRTPrint3D
|
@param[in] fPosX Position of the text along X
|
@param[in] fPosY Position of the text along Y
|
@param[in] fScale Scale of the text
|
@param[in] Colour Colour of the text
|
@param[in] pszFormat Format string for the text
|
@return PVR_SUCCESS or PVR_FAIL
|
@brief Display 3D text on screen.
|
No window needs to be allocated to use this function.
|
However, CPVRTPrint3D::SetTextures(...) must have been called
|
beforehand.
|
This function accepts formatting in the printf way.
|
*****************************************************************************/
|
EPVRTError CPVRTPrint3D::Print3D(float fPosX, float fPosY, const float fScale, unsigned int Colour, const char * const pszFormat, ...)
|
{
|
#ifdef DISABLE_PRINT3D
|
return PVR_SUCCESS;
|
#endif
|
|
va_list args;
|
static char s_Text[MAX_LETTERS+1] = {0};
|
|
// Reading the arguments to create our Text string
|
va_start(args, pszFormat);
|
vsnprintf(s_Text, MAX_LETTERS+1, pszFormat, args);
|
va_end(args);
|
|
bool bUpdate = false;
|
|
// Optimisation to check that the strings are actually different.
|
if(strcmp(s_Text, m_pszPreviousString) != 0 || m_fPrevX != fPosX || m_fPrevY != fPosY || m_fPrevScale != fScale || m_uiPrevCol != Colour)
|
{
|
// Copy strings
|
strcpy (m_pszPreviousString, s_Text);
|
m_fPrevX = fPosX;
|
m_fPrevY = fPosY;
|
m_fPrevScale = fScale;
|
m_uiPrevCol = Colour;
|
|
// Convert from UTF8 to UTF32
|
m_CachedUTF32.Clear();
|
PVRTUnicodeUTF8ToUTF32((const PVRTuint8*)s_Text, m_CachedUTF32);
|
|
bUpdate = true;
|
}
|
|
// Print
|
return Print3D(fPosX, fPosY, fScale, Colour, m_CachedUTF32, bUpdate);
|
}
|
|
/*!***************************************************************************
|
@fn DisplayDefaultTitle
|
@param[in] sTitle Title to display
|
@param[in] sDescription Description to display
|
@param[in] uDisplayLogo 1 = Display the logo
|
@return PVR_SUCCESS or PVR_FAIL
|
@brief Creates a default title with predefined position and colours.
|
It displays as well company logos when requested:
|
0 = No logo
|
1 = PowerVR logo
|
2 = Img Tech logo
|
*****************************************************************************/
|
EPVRTError CPVRTPrint3D::DisplayDefaultTitle(const char * const pszTitle, const char * const pszDescription, const unsigned int uDisplayLogo)
|
{
|
EPVRTError eRet = PVR_SUCCESS;
|
|
#if !defined (DISABLE_PRINT3D)
|
|
// Display Title
|
if(pszTitle)
|
{
|
if(Print3D(0.0f, -1.0f, 1.0f, PVRTRGBA(255, 255, 255, 255), pszTitle) != PVR_SUCCESS)
|
eRet = PVR_FAIL;
|
}
|
|
float fYVal;
|
if(m_bRotate)
|
fYVal = m_fScreenScale[0] * 480.0f;
|
else
|
fYVal = m_fScreenScale[1] * 480.0f;
|
|
// Display Description
|
if(pszDescription)
|
{
|
float fY;
|
float a = 320.0f/fYVal;
|
fY = m_uiNextLineH / (480.0f/100.0f) * a;
|
|
if(Print3D(0.0f, fY, 0.8f, PVRTRGBA(255, 255, 255, 255), pszDescription) != PVR_SUCCESS)
|
eRet = PVR_FAIL;
|
}
|
|
m_uLogoToDisplay = uDisplayLogo;
|
|
#endif
|
|
return eRet;
|
}
|
|
/*!***************************************************************************
|
@fn MeasureText
|
@param[out] pfWidth Width of the string in pixels
|
@param[out] pfHeight Height of the string in pixels
|
@param[in] fFontSize Font size
|
@param[in] sString String to take the size of
|
@brief Returns the size of a string in pixels.
|
*****************************************************************************/
|
void CPVRTPrint3D::MeasureText(
|
float * const pfWidth,
|
float * const pfHeight,
|
float fScale,
|
const CPVRTArray<PVRTuint32>& utf32)
|
{
|
#if !defined (DISABLE_PRINT3D)
|
if(utf32.GetSize() == 0) {
|
if(pfWidth)
|
*pfWidth = 0;
|
if(pfHeight)
|
*pfHeight = 0;
|
return;
|
}
|
|
float fLength = 0;
|
float fMaxLength = -1.0f;
|
float fMaxHeight = (float)m_uiNextLineH;
|
PVRTuint32 txNextChar = 0;
|
PVRTuint32 uiIdx;
|
for(PVRTuint32 uiIndex = 0; uiIndex < utf32.GetSize(); uiIndex++)
|
{
|
if(utf32[uiIndex] == 0x0D || utf32[uiIndex] == 0x0A)
|
{
|
if(fLength > fMaxLength)
|
fMaxLength = fLength;
|
|
fLength = 0;
|
fMaxHeight += (float)m_uiNextLineH;
|
}
|
uiIdx = FindCharacter(utf32[uiIndex]);
|
if(uiIdx == PVRTPRINT3D_INVALID_CHAR) // No character found. Add a space.
|
{
|
fLength += m_uiSpaceWidth;
|
continue;
|
}
|
|
txNextChar = utf32[uiIndex + 1];
|
float fKernOffset = 0;
|
ApplyKerning(utf32[uiIndex], txNextChar, fKernOffset);
|
|
fLength += m_pCharMatrics[uiIdx].nAdv + fKernOffset; // Add on this characters width
|
}
|
|
if(fMaxLength < 0.0f) // Obviously no new line.
|
fMaxLength = fLength;
|
|
if(pfWidth)
|
*pfWidth = fMaxLength * fScale;
|
if(pfHeight)
|
*pfHeight = fMaxHeight * fScale;
|
#endif
|
}
|
|
/*!***************************************************************************
|
@fn GetSize
|
@param[out] pfWidth Width of the string in pixels
|
@param[out] pfHeight Height of the string in pixels
|
@param[in] pszUTF8 UTF8 string to take the size of
|
@brief Returns the size of a string in pixels.
|
*****************************************************************************/
|
void CPVRTPrint3D::MeasureText(
|
float * const pfWidth,
|
float * const pfHeight,
|
float fScale,
|
const char * const pszUTF8)
|
{
|
m_CachedUTF32.Clear();
|
PVRTUnicodeUTF8ToUTF32((PVRTuint8*)pszUTF8, m_CachedUTF32);
|
MeasureText(pfWidth,pfHeight,fScale,m_CachedUTF32);
|
}
|
|
/*!***************************************************************************
|
@fn MeasureText
|
@param[out] pfWidth Width of the string in pixels
|
@param[out] pfHeight Height of the string in pixels
|
@param[in] pszUnicode Wide character string to take the length of.
|
@brief Returns the size of a string in pixels.
|
*****************************************************************************/
|
void CPVRTPrint3D::MeasureText(
|
float * const pfWidth,
|
float * const pfHeight,
|
float fScale,
|
const wchar_t* const pszUnicode)
|
{
|
_ASSERT(pszUnicode);
|
m_CachedUTF32.Clear();
|
|
#if PVRTSIZEOFWCHAR == 2 // 2 byte wchar.
|
PVRTUnicodeUTF16ToUTF32((PVRTuint16*)pszUnicode, m_CachedUTF32);
|
#else // 4 byte wchar (POSIX)
|
unsigned int uiC = 0;
|
PVRTuint32* pUTF32 = (PVRTuint32*)pszUnicode;
|
while(*pUTF32 && uiC < MAX_LETTERS)
|
{
|
m_CachedUTF32.Append(*pUTF32++);
|
uiC++;
|
}
|
#endif
|
|
MeasureText(pfWidth,pfHeight,fScale,m_CachedUTF32);
|
}
|
|
/*!***************************************************************************
|
@fn GetAspectRatio
|
@param[out] dwScreenX Screen resolution X
|
@param[out] dwScreenY Screen resolution Y
|
@brief Returns the current resolution used by Print3D
|
*****************************************************************************/
|
void CPVRTPrint3D::GetAspectRatio(unsigned int *dwScreenX, unsigned int *dwScreenY)
|
{
|
#if !defined (DISABLE_PRINT3D)
|
|
*dwScreenX = (int)(640.0f * m_fScreenScale[0]);
|
*dwScreenY = (int)(480.0f * m_fScreenScale[1]);
|
#endif
|
}
|
|
/*************************************************************
|
* PRIVATE FUNCTIONS *
|
**************************************************************/
|
|
/*!***************************************************************************
|
@brief Update a single line
|
@param[in] fZPos
|
@param[in] XPos
|
@param[in] YPos
|
@param[in] fScale
|
@param[in] Colour
|
@param[in] Text
|
@param[in] pVertices
|
@return Number of vertices affected
|
*****************************************************************************/
|
unsigned int CPVRTPrint3D::UpdateLine(const float fZPos, float XPos, float YPos, const float fScale, const unsigned int Colour, const CPVRTArray<PVRTuint32>& Text, SPVRTPrint3DAPIVertex * const pVertices)
|
{
|
/* Nothing to update */
|
if (Text.GetSize() == 0)
|
return 0;
|
|
if(!m_bUsingProjection)
|
{
|
XPos *= ((float)m_ui32ScreenDim[0] / 640.0f);
|
YPos *= ((float)m_ui32ScreenDim[1] / 480.0f);
|
}
|
|
YPos -= m_uiAscent * fScale;
|
|
YPos = PVRTMakeWhole(YPos);
|
|
float fPreXPos = XPos; // The original offset (after screen scale modification) of the X coordinate.
|
|
float fKernOffset;
|
float fAOff;
|
float fYOffset;
|
unsigned int VertexCount = 0;
|
PVRTint32 NextChar;
|
|
unsigned int uiNumCharsInString = Text.GetSize();
|
for(unsigned int uiIndex = 0; uiIndex < uiNumCharsInString; uiIndex++)
|
{
|
if(uiIndex > MAX_LETTERS)
|
break;
|
|
// Newline
|
if(Text[uiIndex] == 0x0A)
|
{
|
XPos = fPreXPos;
|
YPos -= PVRTMakeWhole(m_uiNextLineH * fScale);
|
continue;
|
}
|
|
// Get the character
|
PVRTuint32 uiIdx = FindCharacter(Text[uiIndex]);
|
|
// Not found. Add a space.
|
if(uiIdx == PVRTPRINT3D_INVALID_CHAR) // No character found. Add a space.
|
{
|
XPos += PVRTMakeWhole(m_uiSpaceWidth * fScale);
|
continue;
|
}
|
|
fKernOffset = 0;
|
fYOffset = m_pYOffsets[uiIdx] * fScale;
|
fAOff = PVRTMakeWhole(m_pCharMatrics[uiIdx].nXOff * fScale); // The A offset. Could include overhang or underhang.
|
if(uiIndex < uiNumCharsInString - 1)
|
{
|
NextChar = Text[uiIndex + 1];
|
ApplyKerning(Text[uiIndex], NextChar, fKernOffset);
|
}
|
|
/* Filling vertex data */
|
pVertices[VertexCount+0].sx = f2vt(XPos + fAOff);
|
pVertices[VertexCount+0].sy = f2vt(YPos + fYOffset);
|
pVertices[VertexCount+0].sz = f2vt(fZPos);
|
pVertices[VertexCount+0].rhw = f2vt(1.0f);
|
pVertices[VertexCount+0].tu = f2vt(m_pUVs[uiIdx].fUL);
|
pVertices[VertexCount+0].tv = f2vt(m_pUVs[uiIdx].fVT);
|
|
pVertices[VertexCount+1].sx = f2vt(XPos + fAOff + PVRTMakeWhole(m_pRects[uiIdx].nW * fScale));
|
pVertices[VertexCount+1].sy = f2vt(YPos + fYOffset);
|
pVertices[VertexCount+1].sz = f2vt(fZPos);
|
pVertices[VertexCount+1].rhw = f2vt(1.0f);
|
pVertices[VertexCount+1].tu = f2vt(m_pUVs[uiIdx].fUR);
|
pVertices[VertexCount+1].tv = f2vt(m_pUVs[uiIdx].fVT);
|
|
pVertices[VertexCount+2].sx = f2vt(XPos + fAOff);
|
pVertices[VertexCount+2].sy = f2vt(YPos + fYOffset - PVRTMakeWhole(m_pRects[uiIdx].nH * fScale));
|
pVertices[VertexCount+2].sz = f2vt(fZPos);
|
pVertices[VertexCount+2].rhw = f2vt(1.0f);
|
pVertices[VertexCount+2].tu = f2vt(m_pUVs[uiIdx].fUL);
|
pVertices[VertexCount+2].tv = f2vt(m_pUVs[uiIdx].fVB);
|
|
pVertices[VertexCount+3].sx = f2vt(XPos + fAOff + PVRTMakeWhole(m_pRects[uiIdx].nW * fScale));
|
pVertices[VertexCount+3].sy = f2vt(YPos + fYOffset - PVRTMakeWhole(m_pRects[uiIdx].nH * fScale));
|
pVertices[VertexCount+3].sz = f2vt(fZPos);
|
pVertices[VertexCount+3].rhw = f2vt(1.0f);
|
pVertices[VertexCount+3].tu = f2vt(m_pUVs[uiIdx].fUR);
|
pVertices[VertexCount+3].tv = f2vt(m_pUVs[uiIdx].fVB);
|
|
pVertices[VertexCount+0].color = Colour;
|
pVertices[VertexCount+1].color = Colour;
|
pVertices[VertexCount+2].color = Colour;
|
pVertices[VertexCount+3].color = Colour;
|
|
XPos = XPos + PVRTMakeWhole((m_pCharMatrics[uiIdx].nAdv + fKernOffset) * fScale); // Add on this characters width
|
VertexCount += 4;
|
}
|
|
return VertexCount;
|
}
|
|
/*!***************************************************************************
|
@fn DrawLineUP
|
@return true or false
|
@brief Draw a single line of text.
|
*****************************************************************************/
|
bool CPVRTPrint3D::DrawLine(SPVRTPrint3DAPIVertex *pVtx, unsigned int nVertices)
|
{
|
if(!nVertices)
|
return true;
|
|
_ASSERT((nVertices % 4) == 0);
|
_ASSERT((nVertices/4) < MAX_LETTERS);
|
|
while(m_nVtxCache + (int)nVertices > m_nVtxCacheMax) {
|
if(m_nVtxCache + nVertices > MAX_CACHED_VTX) {
|
_RPT1(_CRT_WARN, "Print3D: Out of space to cache text! (More than %d vertices!)\n", MAX_CACHED_VTX);
|
return false;
|
}
|
|
m_nVtxCacheMax = PVRT_MIN(m_nVtxCacheMax * 2, MAX_CACHED_VTX);
|
SPVRTPrint3DAPIVertex* pTmp = (SPVRTPrint3DAPIVertex*)realloc(m_pVtxCache, m_nVtxCacheMax * sizeof(*m_pVtxCache));
|
|
_ASSERT(pTmp);
|
if(!pTmp)
|
{
|
free(m_pVtxCache);
|
m_pVtxCache = 0;
|
return false; // Failed to re-allocate data
|
}
|
|
m_pVtxCache = pTmp;
|
|
_RPT1(_CRT_WARN, "Print3D: TextCache increased to %d vertices.\n", m_nVtxCacheMax);
|
}
|
|
memcpy(&m_pVtxCache[m_nVtxCache], pVtx, nVertices * sizeof(*pVtx));
|
m_nVtxCache += nVertices;
|
return true;
|
}
|
|
/*!***************************************************************************
|
@fn SetProjection
|
@brief Sets projection matrix.
|
*****************************************************************************/
|
void CPVRTPrint3D::SetProjection(const PVRTMat4& mProj)
|
{
|
m_mProj = mProj;
|
m_bUsingProjection = true;
|
}
|
|
/*!***************************************************************************
|
@fn SetModelView
|
@brief Sets model view matrix.
|
*****************************************************************************/
|
void CPVRTPrint3D::SetModelView(const PVRTMat4& mModelView)
|
{
|
m_mModelView = mModelView;
|
}
|
|
/*!***************************************************************************
|
@fn SetFiltering
|
@param[in] eFilter The method of texture filtering
|
@brief Sets the method of texture filtering for the font texture.
|
Print3D will attempt to pick the best method by default
|
but this method allows the user to override this.
|
*****************************************************************************/
|
void CPVRTPrint3D::SetFiltering(ETextureFilter eMin, ETextureFilter eMag, ETextureFilter eMip)
|
{
|
if(eMin == eFilter_None) eMin = eFilter_Default; // Illegal value
|
if(eMag == eFilter_None) eMag = eFilter_Default; // Illegal value
|
|
m_eFilterMethod[eFilterProc_Min] = eMin;
|
m_eFilterMethod[eFilterProc_Mag] = eMag;
|
m_eFilterMethod[eFilterProc_Mip] = eMip;
|
}
|
|
/*!***************************************************************************
|
@fn GetFontAscent
|
@return unsigned int The ascent.
|
@brief Returns the 'ascent' of the font. This is typically the
|
height from the baseline of the larget glyph in the set.
|
*****************************************************************************/
|
unsigned int CPVRTPrint3D::GetFontAscent()
|
{
|
return m_uiAscent;
|
}
|
|
/*!***************************************************************************
|
@fn GetFontLineSpacing
|
@return unsigned int The line spacing.
|
@brief Returns the default line spacing (i.e baseline to baseline)
|
for the font.
|
*****************************************************************************/
|
unsigned int CPVRTPrint3D::GetFontLineSpacing()
|
{
|
return m_uiNextLineH;
|
}
|
|
/****************************************************************************
|
** Local code
|
****************************************************************************/
|
|
/*****************************************************************************
|
End of file (PVRTPrint3D.cpp)
|
*****************************************************************************/
|
