AaronCameron.net

Not Left, nor right. Just correct.

• 
• 
• 
• 
• 

Not a Member? - Login or Create an Account

Tuesday the 22nd of May 2012 @ 03:58pm

Front Page Journal Projects Your Profile About

LibN2L N2L Home Older News Downloads Documentation (n2l5) Class Hierarchy Compound List File List n2l:: Members Functions Whole n2l:: Ref Documentation (libN2L-4) Class Hierarchy Compound List File List n2l:: Members Functions Whole n2l:: Ref Bugtracker Project Page Report a Bug Bug List Related Things Life 2130 Devel Game Journal

LibN2L-4 Library Code Reference Classes Compounds Files Members Method Index Full Reference cTextureFont.cpp Go to the documentation of this file. /************************************************************************ Nova-2 Library (libN2L, or simply n2l) Game development C++ Library Copyright (C) 2003 Aaron Cameron This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA A copy of the GNU Lesser General Public License has been provided with this library in the file 'COPYING'. Contact information for the author of this library has been provided with this library in the file 'AUTHOR'. ************************************************************************/ #include "cTextureFont.h" #include "n2l/video.h" #include "n2l/materials.h" #include <GL/gl.h> #include <iostream> using namespace std; /******************************************************************************/ namespace n2l { const tUint cTextureFont::MaxGlyphs = 255; const tGlyphID cTextureFont::UndefinedGlyphID = 0; const tUint cTextureFont::GlyphPadding = 1; const tUint cTextureFont::PreferredMaxGenTexXSize = 255; const tUint cTextureFont::PreferredMaxGenTexYSize = 255; const tUint cTextureFont::MaxGenTexXSize = 1024; const tUint cTextureFont::MaxGenTexYSize = 1024; // SDL_ttf dies if passed 0 as a character, and it's the terminate // character, so probably for the best that it doesn't show properly. // Manually mapped surfaces may define 0, however. So this // restriction is a sort of magical number. const tGlyphID cTextureFont::MinGenGlyphID = 1; const tGlyphID cTextureFont::MaxGenGlyphID = cTextureFont::MaxGlyphs; /**************************************************************************/ cTextureFont::cTextureFont( const cVfsNodeInterface &iFile, const tUint iPtSize ) { // Load and convert the file. cTTFSurfaceFactory factory( iFile, iPtSize ); // Get the memory for our glyph map mTexCoords = new tTexCoords[ MaxGlyphs ]; mGlyphWidths = new tFloat[ MaxGlyphs ]; buildGlyphs(factory); } /**************************************************************************/ cTextureFont::cTextureFont( const cSurfaceInterface &iSurface, const tCoordMap & iMap ) { // Get the memory for our glyph map mTexCoords = new tTexCoords[ MaxGlyphs ]; mGlyphWidths = new tFloat[ MaxGlyphs ]; buildGlyphs(iSurface,iMap); } /**************************************************************************/ cTextureFont::cTextureFont( const cTTFSurfaceFactory &iFactory ) { // Get the memory for our glyph map mTexCoords = new tTexCoords[ MaxGlyphs ]; mGlyphWidths = new tFloat[ MaxGlyphs ]; buildGlyphs(iFactory); } /**************************************************************************/ cTextureFont::~cTextureFont() { delete []mGlyphWidths; delete []mTexCoords; } /**************************************************************************/ void cTextureFont::buildGlyphs( const cSurfaceInterface &iSurface, const tCoordMap &iMap ) { if (iMap.empty()) throw cBadDataUseException( "cTextureFont::buildGlyphs", "No coordinates in the map" ); // Check to make sure there's mapping for an 'undefined' // character const tCoordMap::const_iterator UndefinedGlyphCoordsIt( iMap.find(UndefinedGlyphID) ); if (UndefinedGlyphCoordsIt==iMap.end()) throw cBadDataUseException( "cTextureFont::buildGlyphs", "No coordinates for required glyph \'undefined\'" ); // Create the GL texture we'll use to hold the actual pixel data for // these glyphs mGlyphs = new cGLTexture( iSurface ); // Get the new size of the glTexture so we can get the final glyph // coordinates as a percentage [0->1.0f] of its size. // Any dead space in the texture will have been created to // the right, and the bottom so we don't need to consider it when // modifying our surface coordinates to texture coordinates const tFloat XMax = mGlyphs->size().x(); const tFloat YMax = mGlyphs->size().y(); // Step through our source coordinates and convert them to fractions of // one which will apply to the GLTexture we'll use to hold the pixel // data itself. // Blank all of the tex coordinates by setting them to the 'undefined' // glyph. for (tGlyphID g=0; g<MaxGlyphs; ++g) { mTexCoords[g] = tTexCoords( UndefinedGlyphCoordsIt->second.x()/XMax, UndefinedGlyphCoordsIt->second.y()/YMax, UndefinedGlyphCoordsIt->second.x2()/XMax, UndefinedGlyphCoordsIt->second.y2()/YMax ); mGlyphWidths[g] = UndefinedGlyphCoordsIt->second.w()/ tFloat(UndefinedGlyphCoordsIt->second.h()); } // Now set the rest of the glyphs that ARE defined. for(tCoordMap::const_iterator cSet = iMap.begin(); cSet!=iMap.end(); ++cSet) { mTexCoords[cSet->first] = tTexCoords( cSet->second.x()/XMax, cSet->second.y()/YMax, cSet->second.x2()/XMax, cSet->second.y2()/YMax ); // Store the percentage of the glyphs height to width from the // original coordinates. mGlyphWidths[cSet->first] = cSet->second.w()/tFloat(cSet->second.h()); } // for // Figure out how far apart to space individual glyphs. // There's a better way to do this, but for now we'll just // take a 1 pixel buffer and convert it with the same ratio // we've be using. mGlyphSeperation = 1.0f/(iMap.begin()->second.h()); // Same for the row count. mGlyphRowSeperation = 1.0f/(iMap.begin()->second.h()); // That's it. We have a font. } /**************************************************************************/ void cTextureFont::buildGlyphs( const cTTFSurfaceFactory &iFactory ) { // For a factory based font, we have to build a surface and // mapping coordinates from the factory itself. During the // surface generation, we'll get get a map of coordinates and // then we can pass the whole thing into the cSurface/coordMap // buildGlyphs to do the rest. Why? Because I'm lazy. // Note: This will likely have to change eventually to speed // up loading of ttf fonts. // We'll do this in two passes. First, we need to crawl over // the faces in the surface to get their sizes. That way we // can figure out the width and height we need for the temp // surface. It's also important that we restrict how wide the // texture becomes, rather than just going straight left to // right on one line, as some video cards have a cap on how // large the dimention of a texture can be. And we might end // up with a software texture, which achieves nothing. // When I said 2, I meant three. First we try to fit within // ideal dimentions, something more likely to fit into memory, // then // WE need to make sure that the glyphs from this font all // have the same y size. If not, our system breaks down. tUint GlyphHeight = iFactory.glyphSize(MinGenGlyphID).y(); for (tUint g=MinGenGlyphID; g<MaxGenGlyphID; ++g) if (GlyphHeight!=iFactory.glyphSize(g).y()) throw cBadDataUseException( "cTextureFont::buildGlyphs", "All glyphs from this factory dont\'t have the " "same y-size" ); tUint x=0; tUint y=0; tUint finalXSize, finalYSize; // We use a tUint instead of tGlyphID because MaxGenGlyphID // is usually MaxGlyphs, which is usually 255. Which means // this loop would never end since the tGlyphID usually only // has 8-bit precision. if (!willFitIn( iFactory, PreferredMaxGenTexXSize, PreferredMaxGenTexYSize, finalXSize, finalYSize) && !willFitIn( iFactory, MaxGenTexXSize, MaxGenTexYSize, finalXSize, finalYSize) ) { throw cOutOfBoundsException( "cTextureFont::buildGlyphs", "Can't fit glyphs into an acceptable texture size " "try lowering the texture factory font point size"); } // Create a surface to hold this thing. // Get a glyph from the factory to let us know what format // we're going to need for the final surface. cAutoPtr<cSurface> glyphSurface = iFactory.generate(MinGenGlyphID); cSurface tempSurface; tempSurface.create( finalXSize,finalYSize, glyphSurface->format().bitsPerPixel(), glyphSurface->format().channelMask(cPixelFormat::Channel_Red), glyphSurface->format().channelMask(cPixelFormat::Channel_Green), glyphSurface->format().channelMask(cPixelFormat::Channel_Blue), glyphSurface->format().channelMask(cPixelFormat::Channel_Alpha) ); if (glyphSurface->format().channelMask(cPixelFormat::Channel_Alpha)) tempSurface.clearSurface( tempSurface.mapRGBA(0x00,0x00,0x00,0x00) ); else tempSurface.clearSurface( tempSurface.mapRGB(0x00,0x00,0x00) ); // Now step through our glyphs one last time to generate the // coordinate map and tempSurface face x = 0; y = 0; tCoordMap tempMap; for (tUint g=MinGenGlyphID; g<MaxGenGlyphID; ++g) { //cout << __FILE__ << ": " << __LINE__ << endl; glyphSurface = iFactory.generate(g); //cout << __FILE__ << ": " << __LINE__ << endl; if ( (x+glyphSurface->properties().size().x()) >= finalXSize ) { x = 0; y += GlyphHeight+GlyphPadding; } //tempSurface.blit( tVector2u(x,y), *glyphSurface ); tempSurface.literalCopyBlit( tVector2u(x,y), *glyphSurface ); tempMap[g] = tCoordSet( x,y, x+glyphSurface->properties().size().x(), y+glyphSurface->properties().size().y() ); // Move our x x += glyphSurface->properties().size().x() + GlyphPadding; } // Pasting for // Finally, since the font factory won't generate a font for // 'undefined', we need to pick the closest other glyphID // possible instead, and use those coordinates tempMap[UndefinedGlyphID] = tempMap[MinGenGlyphID]; // Wheuph... now we can call the OTHER buildGlyphs to actually // do the texturing work. buildGlyphs( tempSurface, tempMap ); } /**************************************************************************/ void cTextureFont::drawGlyph( const tGlyphID iGlyphID ) const { if (iGlyphID>=MaxGlyphs) throw cOutOfBoundsException( "cTextureFont::drawGlyph", "No such glyphID" ); /* glPushAttrib( GL_ALL_ATTRIB_BITS ); glEnable(GL_CULL_FACE); glCullFace(GL_FRONT); glEnable( GL_TEXTURE_2D ); if (mGlyphs->hasAlpha()) { glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glEnable( GL_BLEND ); } */ mGlyphs->bind(); glBegin( GL_QUADS ); glTexCoord2f( mTexCoords[iGlyphID].x(), mTexCoords[iGlyphID].y2() ); glVertex3f(0,0,0); glTexCoord2f( mTexCoords[iGlyphID].x(), mTexCoords[iGlyphID].y() ); glVertex3f(0,1,0); glTexCoord2f( mTexCoords[iGlyphID].x2(), mTexCoords[iGlyphID].y() ); glVertex3f(1,1,0); glTexCoord2f( mTexCoords[iGlyphID].x2(), mTexCoords[iGlyphID].y2() ); glVertex3f(1,0,0); glPopAttrib(); } /**************************************************************************/ void cTextureFont::draw( const tString &iText ) const { const tString::size_type SLen(iText.size()); tFloat xPos = 0.0f; /* glEnable( GL_TEXTURE_2D ); if (mGlyphs->hasAlpha()) { glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glEnable( GL_BLEND ); } */ mGlyphs->bind(); glBegin( GL_QUADS ); for (tString::size_type i=0; i<SLen; ++i) { const tFloat gWidth = mGlyphWidths[iText[i]]; glTexCoord2f( mTexCoords[iText[i]].x(), mTexCoords[iText[i]].y() ); glVertex3f(xPos,0,0); glTexCoord2f( mTexCoords[iText[i]].x(), mTexCoords[iText[i]].y2() ); glVertex3f(xPos,1,0); glTexCoord2f( mTexCoords[iText[i]].x2(), mTexCoords[iText[i]].y2() ); glVertex3f(xPos+gWidth,1,0); glTexCoord2f( mTexCoords[iText[i]].x2(), mTexCoords[iText[i]].y() ); glVertex3f(xPos+gWidth,0,0); xPos += gWidth+mGlyphSeperation; } // for. glEnd(); /* if (mGlyphs->hasAlpha()) glDisable( GL_BLEND ); glDisable( GL_TEXTURE_2D ); */ } /**************************************************************************/ void cTextureFont::draw( const tVector2f &iPos, const tString &iText, const tFloat &iGlyphHeight, const tString::size_type iStartPos, const tString::size_type iLength ) const { const tString::size_type SLen(iText.size()); if (iStartPos>=SLen) return; const tString::size_type EPos = n2l_min(SLen,iStartPos+iLength); tFloat xPos = iPos.x(); tFloat yPos = iPos.y(); tFloat yPos2 = iPos.y()+iGlyphHeight; /* glEnable( GL_TEXTURE_2D ); if (mGlyphs->hasAlpha()) { glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glEnable( GL_BLEND ); } */ mGlyphs->bind(); glBegin( GL_QUADS ); for (tString::size_type i=iStartPos; i<EPos; ++i) { const tFloat gWidth = mGlyphWidths[iText[i]]*iGlyphHeight; const tFloat xPos2 = xPos+gWidth; glTexCoord2f( mTexCoords[iText[i]].x(), mTexCoords[iText[i]].y() ); glVertex3f(xPos,yPos,0); glTexCoord2f( mTexCoords[iText[i]].x(), mTexCoords[iText[i]].y2() ); glVertex3f(xPos,yPos2,0); glTexCoord2f( mTexCoords[iText[i]].x2(), mTexCoords[iText[i]].y2() ); glVertex3f(xPos2,yPos2,0); glTexCoord2f( mTexCoords[iText[i]].x2(), mTexCoords[iText[i]].y() ); glVertex3f(xPos2,yPos,0); xPos += gWidth + (mGlyphSeperation*iGlyphHeight); } // for. glEnd(); /* if (mGlyphs->hasAlpha()) glDisable( GL_BLEND ); glDisable( GL_TEXTURE_2D ); */ } /**************************************************************************/ const tVector2f cTextureFont::calcSize( const tString &iText, const tFloat &iGlyphHeight, const tString::size_type iStartPos, const tString::size_type iLength ) const { const tString::size_type SLen(iText.size()); if (iStartPos>=SLen) return tVector2f(0,0); const tString::size_type EPos = n2lMin(SLen,iStartPos+iLength); tFloat width = 0.0f; for (tString::size_type i=iStartPos; i<EPos; ++i) width += (mGlyphWidths[iText[i]]+mGlyphSeperation)*iGlyphHeight; return tVector2f(width,iGlyphHeight); } /**************************************************************************/ const tFloat cTextureFont::glyphWidth( const tGlyphID iGlyphID, const tFloat &iGlyphHeight ) const { return mGlyphWidths[iGlyphID]*iGlyphHeight; } /**************************************************************************/ const tFloat cTextureFont::glyphSeperation( const tFloat &iGlyphHeight ) const { return mGlyphSeperation*iGlyphHeight; } /**************************************************************************/ const tFloat cTextureFont::glyphRowSeperation( const tFloat &iGlyphHeight ) const { return mGlyphRowSeperation*iGlyphHeight; } /**************************************************************************/ const tBool cTextureFont::willFitIn( const cTTFSurfaceFactory &iFactory, const tUint iMaxX, const tUint iMaxY, tUint &oActualXSize, tUint &oActualYSize ) const { tUint x=0; tUint y=0; for (tUint g=MinGenGlyphID; g<MaxGenGlyphID; ++g) { tVector2u gSize = iFactory.glyphSize(g); // If this glyph is too big to fit on this line, // bump it down if ( (x+gSize.x()) >= iMaxX ) { x = 0; y += gSize.y()+GlyphPadding; // Check to see if we've blown our cap if ( (y+gSize.y()) >= iMaxY ) return false; } x+= gSize.x()+GlyphPadding; } // for oActualXSize = iMaxX; oActualYSize = y+iFactory.glyphSize(MinGenGlyphID).y(); return true; } } // namespace

©2012 Aaron Cameron