RE/RE_OGLTextureFont.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Joe Drew
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        RE_OGLTextureFont.h (RE Library, C++)
 *
 * COMMENTS:
 *      This is the owner and renderer of textured fonts - that is, fonts
 *      rendered using textures on quads. This is as opposed to bitmap fonts,
 *      rendred using glBitmap.
 */

#ifndef __RE_OGLTextureFont__
#define __RE_OGLTextureFont__

#include "RE_API.h"

#include <SYS/SYS_Types.h>
#include <SYS/SYS_Math.h>

#include <UT/UT_AssocArray.h>
#include <UT/UT_RefArray.h>

#include "RE_OGLFont.h"

class RE_OGLFontCache;
class RE_Render;
class re_DeferTexFont;

#define RE_TEXTURE_FONT_LOW_CODEPOINTS 256

struct reGlyphInfo
{
    reGlyphInfo()
     : myBearingX(0),
       myBearingY(0),
       myAdvanceX(0),
       myGlyphWidth(0),
       myGlyphHeight(0),
       myGlyphData(NULL),
       myDisplayList(0),
       myTextureIndex(0)
    {}

    ~reGlyphInfo()
    {
        delete[] myGlyphData;
    }

    // The horizontal distance, in pixels, from the current pen position to
    // the left edge of the glyph's bounding box.
    int myBearingX;

    // The vertical distance, in pixels, from the current pen position to
    // the top of the glyph's bounding box.
    int myBearingY;

    // The horizontal distance, in pixels, the pen must be incremented
    // (in left-to-right locales) or decremented (in right-to-left locales)
    // after each glyph is rendered.
    // The horizontal advance is always positive.
    int myAdvanceX;

    // The width and height, in pixels, of the glyph's raster
    // representation. This is the width and height from the top left
    // corner of the texture, although the texture may extend further
    // because of the requirement that the size be a power of two.
    int myGlyphWidth, myGlyphHeight;

    // The start and end S and T coordinates for this glyph in the texture.
    double myStartS, myEndS;
    double myStartT, myEndT;

    // The glyph data itself.
    unsigned char *myGlyphData;

    // Which texture (out of all of those that are allocated in the font) this
    // glyph belongs to.
    int myTextureIndex;

    // The display list that contains the definition for this glyph.
    int myDisplayList;
};

class RE_API RE_OGLTextureFont : public RE_OGLFont
{
public:
             RE_OGLTextureFont(const char *name, float size,
                               RE_OGLFontCache *cache);
    virtual ~RE_OGLTextureFont();

    virtual void         render(RE_Render *r, const char *s);
    virtual int          getCharWidth(char c, char prev);
    virtual int          getStringWidth(const char *s);

    template <typename T> 
    static bool          loadFontFile(const char *filename, T *owner);

    typedef UT_AssocArray<int, reGlyphInfo> reGlyphInfoArray;
    typedef UT_AssocArray<int, int8> reGlyphKerningArray;
    typedef UT_AssocArray<int, reGlyphKerningArray> reKerningArray;

    typedef UT_RefArray<reGlyphInfo> reLowGlyphInfoArray;
    typedef UT_RefArray<int8> reLowGlyphKerningArray;
    typedef UT_RefArray<reLowGlyphKerningArray> reLowKerningArray;

    static void beginFontDefer(RE_Render *r);
    static void flushFontDefer(RE_Render *r);
    static void endFontDefer(RE_Render *r);
protected:

    virtual void         loadFont();
    virtual void         genDisplayLists(RE_Render *r);

private:// functions
    template <typename T>
    static bool          loadGlyph(int codepoint, UT_IStream &in, T *owner);
    
    static void          processDeferredFonts(RE_Render *r,
                                              re_DeferTexFont *font);

    // Create a new glyph info structure for the specified codepoint, and
    // return a reference to it. Ensure that it'll be cleaned up on 
    // destruction.
    reGlyphInfo         &newGlyphInfo(int codepoint);

    bool                 loadFont(const char *fontname);
    void                 createTextures(RE_Render *r);
    void                 doRenderGlyph(RE_Render *r, 
                                       const reGlyphInfo &gi) const;

    /// Retrieve the kerning distance between glyphs left and right.
    /// Use the codepoints for the characters.
    int                  getKerning(int left, int right) const;

    void                 initGlyphTexture(reGlyphInfo &gi,
                                          unsigned char *texbuf, 
                                          int &curx, int &pos,
                                          int texwidth, int texheight);

private: // variables

    /// For speed, we maintain two parallel sets of data, under the assumption
    /// that all fonts will contain the 'low' codepoints of unicode, and that
    /// using those low codepoints is a much more common event.

    /// An array of glyph information - an associative array between codepoint
    /// and glyph information.
    /// We use an associative array instead of just a regular array because
    /// codepoints aren't guaranteed to be contiguous.
    reGlyphInfoArray     myGlyphInfo;

    /// An array of kerning information, one entry per glyph that contains
    /// kerning information. Indices are the glyph's codepoints.
    /// Each entry is itself another associative array that contains all the
    /// kerning information between the two glyphs.
    /// If you want to find the kerning distance between characters X and Y,
    /// where X is on the left and Y is on the right, you can index the array
    /// like so:
    /// myKerningInfo[codepoint(X)][codepoint(Y)]
    /// (But doing so will create the entries, so it's better to actually
    /// use myKerningInfo.find().)
    /// The kerning information itself is a distance in pixels, positive or
    /// negative.
    reKerningArray       myKerningInfo;

    /// These are as above, but dense, simple arrays.

    /// A dense array of glyph information, one entry per codepoint, in the
    /// range of 0...(LOW_CODEPOINTS-1).
    reLowGlyphInfoArray  myLowGlyphInfo;

    /// A dense square array of kerning information. We only maintain 8 bits
    /// of precision here because we're very unlikely to need more than that
    /// much kerning on a particular character.
    reLowKerningArray    myLowKerningInfo;

    /// Have the textures for this face been created yet?
    bool                 myTexturesCreated;

    /// The ID for the textures that store the glyphs. We may have many
    /// textures if the video card can't allocate one large texture.
    UT_RefArray<uint>    myTextureIDs;

    /// We don't use this right now, but it is the distance between baselines.
    int                  myFaceHeight;

    /// The directory texture fonts are located in.
    static UT_String     ourFontDirectory;
};

#include "RE_OGLTextureFontTemplate.C"

#endif

---