XFuRLESpritePrinter.cpp Source File

Main Page Class Hierarchy Alphabetical List Compound List File List Compound Members File Members Related Pages

# XFuRLESpritePrinter.cpp

Go to the documentation of this file.

    00001 /*! \file
    00002  * X-Forge Util <br>
    00003  * Copyright 2000-2003 Fathammer Ltd
    00004  *
    00005  * \brief Primitive RLESprite font printer class.
    00006  * Needs some work (create instead of init; gl sprites instead
    00007  * of the glsurface drawing currently in use.
    00008  *
    00009  * $Id: XFuRLESpritePrinter.cpp,v 1.11 2003/08/12 13:34:08 lars Exp $
    00010  * $Date: 2003/08/12 13:34:08 $
    00011  * $Revision: 1.11 $
    00012  */
    00013
    00014 #include <stdlib.h>
    00015 #include <xfcore/XFcCore.h>
    00016 #include <xfutil/XFuPrinter.h>
    00017 #include <xfutil/XFuRLESpritePrinter.h>
    00018 #include <xfcore/XFcPixelConverter.h>
    00019
    00020
    00021 XFuRLESpritePrinter * XFuRLESpritePrinter::create(const CHAR *aFname)
    00022 {
    00023     return create(aFname,0xff000000,0x00000000,REALi(1),REALi(1));
    00024 }
    00025
    00026 XFuRLESpritePrinter * XFuRLESpritePrinter::create(const CHAR *aFname, UINT32 aBaseMask, UINT32 aBaseColor)
    00027 {
    00028     return create(aFname,aBaseMask,aBaseColor,REALi(1),REALi(1));
    00029 }
    00030
    00031 XFuRLESpritePrinter * XFuRLESpritePrinter::create(const CHAR *aFname, UINT32 aBaseMask, UINT32 aBaseColor, REAL aXScale, REAL aYScale)
    00032 {
    00033     INT32 wid, ht;
    00034     INT32 i;
    00035
    00036     XFcGLSurface *img = XFcImageLoader::load(aFname,XFCGF_A8R8G8B8);
    00037     if (img == NULL) return NULL;
    00038
    00039     XFuRLESpritePrinter *p = new XFuRLESpritePrinter();
    00040
    00041     if (p == NULL)
    00042     {
    00043         delete img;
    00044         return NULL;
    00045     }
    00046
    00047     p->mLetterSpacing = 2; // default letter spacing
    00048
    00049     wid = img->getWidth();
    00050     ht = img->getHeight();
    00051
    00052     p->mLineSpacing = (INT32)(aXScale * (REAL)wid);
    00053     p->mLineHeight = (INT32)(aYScale * (REAL)wid);
    00054
    00055     p->mMaxletter = ht / wid;
    00056     p->mLetterSprite = new XFcRLESprite *[p->mMaxletter];
    00057
    00058     if (p->mLetterSprite == NULL)
    00059     {
    00060         delete img;
    00061         delete p;
    00062         return NULL;
    00063     }
    00064
    00065     XFcGLSurface *tImg = XFcGLSurface::create(wid,wid,XFCGF_A8R8G8B8);
    00066
    00067     if (tImg == NULL)
    00068     {
    00069         delete img;
    00070         delete p;
    00071         return NULL;
    00072     }
    00073
    00074     // init to NULL so that delete wouldn't fail if creation fails
    00075     for (i = 0; i < p->mMaxletter; ++i)
    00076         p->mLetterSprite[i] = NULL;
    00077
    00078     UINT32 *pic;
    00079     INT32 pitch = img->lock((void **)(&pic));
    00080     if (pitch == 0)
    00081     {
    00082         delete tImg;
    00083         delete img;
    00084         delete p;
    00085         return NULL;
    00086     }
    00087
    00088     pitch /= 4;
    00089     for (i = 0; i < p->mMaxletter; ++i)
    00090     {
    00091         INT32 letterofs = i * wid * pitch;
    00092
    00093         UINT32 *fb;
    00094         INT32 tPitch = tImg->lock((void **)&fb);
    00095         if (tPitch == 0)
    00096         {
    00097             delete tImg;
    00098             img->unlock();
    00099             delete img;
    00100             delete p;
    00101             return NULL;
    00102         }
    00103         tPitch /= 4;
    00104
    00105         INT32 j,k;
    00106         for (j = 0; j < wid; j++)
    00107         {
    00108             for (k = 0; k < wid; k++)
    00109             {
    00110                 fb[j*tPitch + k] = pic[letterofs + j*pitch + k];
    00111             }
    00112         }
    00113
    00114         tImg->unlock();
    00115
    00116         if (aXScale != REALi(1) || aYScale != REALi(1))
    00117         {
    00118             XFcGLSurface *tImg2 = XFcGLSurfaceToolkit::resampleSurface(tImg,aXScale,aYScale);
    00119             if (tImg2)
    00120                 p->mLetterSprite[i] = XFcRLESprite::create(tImg2, aBaseMask, aBaseColor);
    00121             delete tImg2;
    00122         }
    00123         else
    00124             p->mLetterSprite[i] = XFcRLESprite::create(tImg, aBaseMask, aBaseColor);
    00125
    00126         if (p->mLetterSprite[i] == NULL)
    00127         {
    00128             delete tImg;
    00129             img->unlock();
    00130             delete img;
    00131             delete p;
    00132             return NULL;
    00133         }
    00134         if (p->mLetterSprite[i]->getWidth() == 0)
    00135         {
    00136             delete p->mLetterSprite[i];
    00137             p->mLetterSprite[i] = NULL;
    00138         }
    00139         else
    00140         {
    00141             p->mLetterSprite[i]->setXOffset(0);
    00142         }
    00143     }
    00144     img->unlock();
    00145     delete tImg;
    00146     delete img;
    00147
    00148     if (p->mLetterSprite['0' - 33])
    00149         p->mSpaceWidth = p->mLetterSprite['0' - 33]->getWidth() / 2;
    00150     else
    00151         p->mSpaceWidth = p->mLineHeight / 2;
    00152
    00153     return p;
    00154
    00155 }
    00156
    00157
    00158 void XFuRLESpritePrinter::print(XFcGLSurface *aTarget, INT32 aX, INT32 aY, const CHAR *aText,
    00159                                 INT32 aBlendType, INT32 /*aBlendValue*/, XFcRectangle *aClipRect)
    00160 {
    00161     if (this == NULL) return;
    00162     unsigned char *p = (unsigned char *)aText;
    00163     int xo = 0;
    00164     INT32 i;
    00165
    00166     XFcRectangle tRect;
    00167     if (aClipRect == NULL)
    00168     {
    00169         tRect.mX = 0;
    00170         tRect.mY = 0;
    00171         tRect.mWidth = aTarget->getWidth();
    00172         tRect.mHeight = aTarget->getHeight();
    00173         aClipRect = &tRect;
    00174     }
    00175
    00176     while (*p)
    00177     {
    00178         if (*p == 32)
    00179         {
    00180             xo += mSpaceWidth + mLetterSpacing;
    00181         }
    00182         else
    00183         {
    00184             if (*p == '\n')
    00185             {
    00186                 xo = 0;
    00187                 aY += mLineSpacing;
    00188             }
    00189             else
    00190             {
    00191                 i = ((UINT8)*p) - 33;
    00192                 if (i >= 0 && i < mMaxletter)
    00193                 {
    00194                     if (mLetterSprite[i] != NULL)
    00195                     {
    00196                         INT32 w = mLetterSprite[i]->getWidth();
    00197                         INT32 xp = aX + xo;
    00198                         switch (aBlendType)
    00199                         {
    00200                             case XFCBLEND_NONE:
    00201                                 mLetterSprite[i]->blit(aTarget,aClipRect,xp,aY);
    00202                                 break;
    00203                             case XFCBLEND_MUL:
    00204                                 mLetterSprite[i]->blitMultiplicative(aTarget,aClipRect,xp,aY);
    00205                                 break;
    00206                             case XFCBLEND_ADD:
    00207                                 mLetterSprite[i]->blitAdditive(aTarget,aClipRect,xp,aY);
    00208                                 break;
    00209                             default:
    00210                                 mLetterSprite[i]->blit(aTarget,aClipRect,xp,aY);
    00211                                 break;
    00212                         }
    00213                         xo += w;
    00214                     }
    00215                     xo += mLetterSpacing;
    00216                 }
    00217             }
    00218         }
    00219         ++p;
    00220     }
    00221 }
    00222
    00223
    00224 void XFuRLESpritePrinter::stringMetrics(const CHAR *aText, INT32 &aWidth, INT32 &aHeight)
    00225 {
    00226     if (aText == NULL)
    00227     {
    00228         aHeight = 0;
    00229         aWidth = 0;
    00230         return;
    00231     }
    00232     unsigned char *p = (unsigned char *)aText;
    00233     int xo = 0, y = 0;
    00234     int maxx = 0;
    00235     INT32 i;
    00236     while (*p)
    00237     {
    00238         if (*p == 32)
    00239         {
    00240             xo += mSpaceWidth;
    00241             if (maxx < xo) maxx = xo;
    00242             xo += mLetterSpacing;
    00243         }
    00244         else
    00245         {
    00246             if (*p == '\n')
    00247             {
    00248                 xo = 0;
    00249                 y += mLineSpacing;
    00250             }
    00251             else
    00252             {
    00253                 i = ((UINT8)*p) - 33;
    00254                 if ( i >= 0 && i < mMaxletter )
    00255                 {
    00256                     if (mLetterSprite[i])
    00257                         xo += mLetterSprite[i]->getWidth();
    00258                     if (maxx < xo) maxx = xo;
    00259                     xo += mLetterSpacing;
    00260                 }
    00261             }
    00262         }
    00263
    00264         ++p;
    00265
    00266     }
    00267     y += mLineHeight;
    00268     aHeight = y;
    00269     aWidth = maxx;
    00270 }
    00271
    00272
    00273 INT32 XFuRLESpritePrinter:: getCharWidth(CHAR aChar)
    00274 {
    00275     INT32 i = (INT32)(((UINT8)aChar) - 33);
    00276     if (aChar == 32)
    00277         return mSpaceWidth;
    00278     else if (i < 0 || i >= mMaxletter || mLetterSprite[i] == NULL)
    00279         return 0;
    00280     else
    00281         return mLetterSprite[i]->getWidth();
    00282 }
    00283
    00284
    00285 XFuRLESpritePrinter::~XFuRLESpritePrinter()
    00286 {
    00287     int i;
    00288     if (mLetterSprite)
    00289     {
    00290         for (i = 0; i < mMaxletter; ++i)
    00291             delete mLetterSprite[i];
    00292     }
    00293     delete[] mLetterSprite;
    00294 }
    00295
    00296
    00297 XFuRLESpritePrinter::XFuRLESpritePrinter()
    00298 {
    00299     mLetterSprite = NULL;
    00300 }
    00301

|  | X-Forge Documentation Confidential Copyright © 2002-2003 Fathammer |  | Documentation generated with doxygen by Dimitri van Heesch