[mupen64plus-pandora.git] / source / mupen64plus-core / src / osd / OGLFT.h

// -*- c++ -*-
/*
 * OGLFT: A library for drawing text with OpenGL using the FreeType library
 * Copyright (C) 2002 lignum Computing, Inc. <oglft@lignumcomputing.com>
 * $Id: OGLFT.h,v 1.15 2003/10/01 14:41:09 allen Exp $
 *
 * 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
 * Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#ifndef OGLFT_H
#define OGLFT_H

#include <cmath>
#include <map>
#include <list>
#include <vector>
#include <wchar.h>

#define GL_GLEXT_PROTOTYPES
#ifdef PANDORA
#include <SDL_opengles2.h>
#else
#include <SDL_opengl.h>
#endif
#if defined(__MACOSX__)
#include <OpenGL/glu.h>
#elif defined(__MACOS__)
#include <glu.h>
#elif defined(PANDORA)
#include <GLES2/glu.h>
#else
#include <GL/glu.h>
#endif

#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_GLYPH_H
#include FT_OUTLINE_H
#include FT_TRIGONOMETRY_H

namespace OGLFT 
{
    enum Coordinates 
    {
        X, Y, Z, W
    };

    enum ColorSpace 
    {
        R, G, B, A
    };

    // global library functions
    bool Init_FT(void);
    bool Uninit_FT(void);

    struct Advance 
    {
        float dx_;
        float dy_;

        Advance ( float dx = 0, float dy = 0 ) : dx_( dx ), dy_( dy )
        {
            return;
        }

        Advance ( FT_Vector v )
        {
            dx_ = (float) (v.x / 64.);
            dy_ = (float) (v.y / 64.);
        }

        Advance& operator+= ( const FT_Vector v )
        {
            dx_ += (float) (v.x / 64.);
            dy_ += (float) (v.y / 64.);
            return *this;
        }
    };

    struct BBox 
    {
        float x_min_;
        float y_min_;
        float x_max_;
        float y_max_;
        Advance advance_;

        BBox () : x_min_( 0 ), y_min_( 0 ), x_max_( 0 ), y_max_( 0 )
        {
            return;
        }
        BBox ( FT_BBox ft_bbox )
        {
            x_min_ = (float) (ft_bbox.xMin / 64.);
            y_min_ = (float) (ft_bbox.yMin / 64.);
            x_max_ = (float) (ft_bbox.xMax / 64.);
            y_max_ = (float) (ft_bbox.yMax / 64.);
        }
        BBox& operator*= ( double k )
        {
            x_min_ *= (float) k;
            y_min_ *= (float) k;
            x_max_ *= (float) k;
            y_max_ *= (float) k;
            advance_.dx_ *= (float) k;
            advance_.dy_ *= (float) k;

            return *this;
        }
        BBox& operator+= ( const BBox& b )
        {
            float new_value;

            new_value = b.x_min_ + advance_.dx_;
            if ( new_value < x_min_ ) x_min_ = new_value;
            new_value = b.y_min_ + advance_.dy_;
            if ( new_value < y_min_ ) y_min_ = new_value;
            new_value = b.x_max_ + advance_.dx_;
            if ( new_value > x_max_ ) x_max_ = new_value;
            new_value = b.y_max_ + advance_.dy_;
            if ( new_value > y_max_ ) y_max_ = new_value;

            advance_.dx_ += b.advance_.dx_;
            advance_.dy_ += b.advance_.dy_;

            return *this;
        }
    };
    typedef std::vector<GLuint> DisplayLists;
    typedef DisplayLists::const_iterator DLCI;
    typedef DisplayLists::iterator DLI;
    class Face 
    {
        public:
            enum HorizontalJustification 
            {
                LEFT,
                ORIGIN,
                CENTER,
                RIGHT
            };

            enum VerticalJustification 
            {
                BOTTOM,
                BASELINE,
                MIDDLE,
                TOP
            };
            
            enum GlyphCompileMode 
            {
                COMPILE,
                IMMEDIATE
            };

        private:
            struct FaceData 
            {
                FT_Face face_;
                bool free_on_exit_;
                FaceData ( FT_Face face, bool free_on_exit = true )
                    : face_( face ), free_on_exit_( free_on_exit )
                {
                    return;
                }
            };
            
        protected:
            std::vector< FaceData > faces_;
            bool valid_;
            enum GlyphCompileMode compile_mode_;
            float point_size_;
            FT_UInt resolution_;
            bool advance_;
            GLfloat foreground_color_[4];
            GLfloat background_color_[4];
            enum HorizontalJustification horizontal_justification_;
            enum VerticalJustification vertical_justification_;
            GLfloat string_rotation_;
            FT_UInt rotation_reference_glyph_;
            FT_Face rotation_reference_face_;
            GLfloat rotation_offset_y_;
            typedef std::map< FT_UInt, GLuint > GlyphDLists;
            typedef GlyphDLists::const_iterator GDLCI;
            typedef GlyphDLists::iterator GDLI;
            GlyphDLists glyph_dlists_;
            DisplayLists character_display_lists_;

        public:
            Face ( const char* filename, float point_size = 12, FT_UInt resolution = 100 );
            Face ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 );
            virtual ~Face ( void );
            bool isValid ( void ) const { return valid_; }
            bool addAuxiliaryFace ( const char* filename );
            bool addAuxiliaryFace ( FT_Face face );
            void setCompileMode ( enum GlyphCompileMode compile_mode ) { compile_mode_ = compile_mode; }
            enum GlyphCompileMode compileMode ( void ) const { return compile_mode_; }
            void setPointSize ( float point_size );
            float pointSize ( void ) { return point_size_; }
            void setResolution ( FT_UInt resolution );
            FT_UInt resolution ( void ) { return resolution_; }
            void setAdvance ( bool advance ) { advance_ = advance; }
            bool advance ( void ) const { return advance_; }
            void setForegroundColor ( GLfloat red = 0.0, GLfloat green = 0.0, GLfloat blue = 0.0, GLfloat alpha = 1.0 );
            void setForegroundColor ( const GLfloat foreground_color[4] );
            GLfloat foregroundRed ( void ) const { return foreground_color_[R]; }
            GLfloat foregroundGreen ( void ) const { return foreground_color_[G]; }
            GLfloat foregroundBlue ( void ) const { return foreground_color_[B]; }
            GLfloat foregroundAlpha ( void ) const { return foreground_color_[A]; }
            void setBackgroundColor ( GLfloat red = 1.0, GLfloat green = 1.0, GLfloat blue = 1.0, GLfloat alpha = 0.0 );
            void setBackgroundColor ( const GLfloat background_color[4] );
            GLfloat backgroundRed ( void ) const { return background_color_[R]; }
            GLfloat backgroundGreen ( void ) const { return background_color_[G]; }
            GLfloat backgroundBlue ( void ) const { return background_color_[B]; }
            GLfloat backgroundAlpha ( void ) const { return background_color_[A]; }
            virtual void setCharacterRotationZ ( GLfloat character_rotation_z ) = 0;
            virtual GLfloat characterRotationZ ( void ) const = 0;
            void setCharacterRotationReference ( unsigned char c );
            void setStringRotation ( GLfloat string_rotation );
            GLfloat stringRotation ( void ) const { return string_rotation_; }
            void setHorizontalJustification ( enum HorizontalJustification horizontal_justification )
            {
                horizontal_justification_ = horizontal_justification;
            }
            enum HorizontalJustification horizontalJustification ( void ) const { return horizontal_justification_; }
            void setVerticalJustification ( enum VerticalJustification vertical_justification )
            {
                vertical_justification_ = vertical_justification;
            }

            enum VerticalJustification verticaljustification ( void ) const { return vertical_justification_; }
            void setCharacterDisplayLists ( const DisplayLists& character_display_lists ) { character_display_lists_ = character_display_lists; }
            DisplayLists& characterDisplayLists ( void ) { return character_display_lists_; }
            virtual double height ( void ) const = 0;
            virtual BBox measure ( unsigned char c ) = 0;
            virtual BBox measure ( wchar_t c ) = 0;
            virtual BBox measure ( const char* s );
            virtual BBox measureRaw ( const char* s );
            virtual BBox measure ( const wchar_t* s );
            virtual BBox measure ( const wchar_t* format, double number );
            virtual BBox measureRaw ( const wchar_t* s );
            GLuint compile ( unsigned char c );
            GLuint compile ( const wchar_t c );
            void draw ( const char* s );
            void draw ( const wchar_t* s );
            void draw ( unsigned char c );
            void draw ( const wchar_t c );
            void draw ( GLfloat x, GLfloat y, unsigned char c );
            void draw ( GLfloat x, GLfloat y, GLfloat z, unsigned char c );
            void draw ( GLfloat x, GLfloat y, wchar_t c );
            void draw ( GLfloat x, GLfloat y, GLfloat z, wchar_t c );
            void draw ( GLfloat x, GLfloat y, const char* s, float *sizebox );
            void draw ( GLfloat x, GLfloat y, GLfloat z, const char* s );
            void draw ( GLfloat x, GLfloat y, const wchar_t* s );
            void draw ( GLfloat x, GLfloat y, GLfloat z, const wchar_t* s );
            int ascender ( void ) { return faces_.front().face_->ascender; }
            int descender ( void ) { return faces_.front().face_->descender; }
            BBox measure_nominal ( const char* s );
            BBox measure_nominal ( const wchar_t* s );

        protected:
            virtual GLuint compileGlyph ( FT_Face face, FT_UInt glyph_index ) = 0;
            virtual void renderGlyph ( FT_Face face, FT_UInt glyph_index ) = 0;
            virtual void setCharSize ( void ) = 0;
            virtual void clearCaches ( void ) = 0;
            virtual void setRotationOffset ( void ) = 0;

        private:
            void init ( void );
    };

    class Raster : public Face 
    {
        protected:
            GLfloat character_rotation_z_;
        public:
            Raster ( const char* filename, float point_size = 12, FT_UInt resolution = 100 );
            Raster ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 );
            virtual ~Raster ( void );
            void setCharacterRotationZ ( GLfloat character_rotation_z );
            GLfloat characterRotationZ ( void ) const { return character_rotation_z_; }
            double height ( void ) const;
            BBox measure ( unsigned char c );
            BBox measure ( wchar_t c );
            BBox measure ( const char* s ) { return Face::measure( s ); }
            BBox measure ( const wchar_t* format, double number ) { return Face::measure( format, number ); }

        private:
            void init ( void );
            GLuint compileGlyph ( FT_Face face, FT_UInt glyph_index );
            void setCharSize ( void );
            void setRotationOffset ( void );
            void clearCaches ( void );
    };
    class Monochrome : public Raster
    {
        public:
            Monochrome ( const char* filename, float point_size = 12, FT_UInt resolution = 100 );
            Monochrome ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 );
            ~Monochrome ( void );

        private:
            GLubyte* invertBitmap ( const FT_Bitmap& bitmap );
            void renderGlyph ( FT_Face face, FT_UInt glyph_index );
    };

}
#endif /* OGLFT_H */
Commit	Line	Data
451ab91e	1	// -- c++ --
	2	/*
	3	* OGLFT: A library for drawing text with OpenGL using the FreeType library
	4	* Copyright (C) 2002 lignum Computing, Inc. <oglft@lignumcomputing.com>
	5	* $Id: OGLFT.h,v 1.15 2003/10/01 14:41:09 allen Exp $
	6	*
	7	* This library is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU Lesser General Public
	9	* License as published by the Free Software Foundation; either
	10	* version 2.1 of the License, or (at your option) any later version.
	11	*
	12	* This library is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public
	18	* License along with this library; if not, write
	19	* Free Software Foundation, Inc.,
	20	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	21	*/
	22
	23	#ifndef OGLFT_H
	24	#define OGLFT_H
	25
	26	#include <cmath>
	27	#include <map>
	28	#include <list>
	29	#include <vector>
	30	#include <wchar.h>
	31
	32	#define GL_GLEXT_PROTOTYPES
	33	#ifdef PANDORA
	34	#include <SDL_opengles2.h>
	35	#else
	36	#include <SDL_opengl.h>
	37	#endif
	38	#if defined(__MACOSX__)
	39	#include <OpenGL/glu.h>
	40	#elif defined(__MACOS__)
	41	#include <glu.h>
	42	#elif defined(PANDORA)
	43	#include <GLES2/glu.h>
	44	#else
	45	#include <GL/glu.h>
	46	#endif
	47
	48	#include <ft2build.h>
	49	#include FT_FREETYPE_H
	50	#include FT_GLYPH_H
	51	#include FT_OUTLINE_H
	52	#include FT_TRIGONOMETRY_H
	53
	54	namespace OGLFT
	55	{
	56	enum Coordinates
	57	{
	58	X, Y, Z, W
	59	};
	60
	61	enum ColorSpace
	62	{
	63	R, G, B, A
	64	};
65
66	// global library functions
67	bool Init_FT(void);
68	bool Uninit_FT(void);
69
70	struct Advance
71	{
72	float dx_;
73	float dy_;
74
75	Advance ( float dx = 0, float dy = 0 ) : dx_( dx ), dy_( dy )
76	{
77	return;
78	}
79
80	Advance ( FT_Vector v )
81	{
82	dx_ = (float) (v.x / 64.);
83	dy_ = (float) (v.y / 64.);
84	}
85
86	Advance& operator+= ( const FT_Vector v )
87	{
88	dx_ += (float) (v.x / 64.);
89	dy_ += (float) (v.y / 64.);
90	return *this;
91	}
92	};
93
94	struct BBox
95	{
96	float x_min_;
97	float y_min_;
98	float x_max_;
99	float y_max_;
100	Advance advance_;
101
102	BBox () : x_min_( 0 ), y_min_( 0 ), x_max_( 0 ), y_max_( 0 )
103	{
104	return;
105	}
106	BBox ( FT_BBox ft_bbox )
107	{
108	x_min_ = (float) (ft_bbox.xMin / 64.);
109	y_min_ = (float) (ft_bbox.yMin / 64.);
110	x_max_ = (float) (ft_bbox.xMax / 64.);
111	y_max_ = (float) (ft_bbox.yMax / 64.);
112	}
113	BBox& operator*= ( double k )
114	{
115	x_min_ *= (float) k;
116	y_min_ *= (float) k;
117	x_max_ *= (float) k;
118	y_max_ *= (float) k;
119	advance_.dx_ *= (float) k;
120	advance_.dy_ *= (float) k;
121
122	return *this;
123	}
124	BBox& operator+= ( const BBox& b )
125	{
126	float new_value;
127
128	new_value = b.x_min_ + advance_.dx_;
129	if ( new_value < x_min_ ) x_min_ = new_value;
130	new_value = b.y_min_ + advance_.dy_;
131	if ( new_value < y_min_ ) y_min_ = new_value;
132	new_value = b.x_max_ + advance_.dx_;
133	if ( new_value > x_max_ ) x_max_ = new_value;
134	new_value = b.y_max_ + advance_.dy_;
135	if ( new_value > y_max_ ) y_max_ = new_value;
136
137	advance_.dx_ += b.advance_.dx_;
138	advance_.dy_ += b.advance_.dy_;
139
140	return *this;
141	}
142	};
143	typedef std::vector<GLuint> DisplayLists;
144	typedef DisplayLists::const_iterator DLCI;
145	typedef DisplayLists::iterator DLI;
146	class Face
147	{
148	public:
149	enum HorizontalJustification
150	{
151	LEFT,
152	ORIGIN,
153	CENTER,
154	RIGHT
155	};
156
157	enum VerticalJustification
158	{
159	BOTTOM,
160	BASELINE,
161	MIDDLE,
162	TOP
163	};
164
165	enum GlyphCompileMode
166	{
167	COMPILE,
168	IMMEDIATE
169	};
170
171	private:
172	struct FaceData
173	{
174	FT_Face face_;
175	bool free_on_exit_;
176	FaceData ( FT_Face face, bool free_on_exit = true )
177	: face_( face ), free_on_exit_( free_on_exit )
178	{
179	return;
180	}
181	};
182
183	protected:
184	std::vector< FaceData > faces_;
185	bool valid_;
186	enum GlyphCompileMode compile_mode_;
187	float point_size_;
188	FT_UInt resolution_;
189	bool advance_;
190	GLfloat foreground_color_[4];
191	GLfloat background_color_[4];
192	enum HorizontalJustification horizontal_justification_;
193	enum VerticalJustification vertical_justification_;
194	GLfloat string_rotation_;
195	FT_UInt rotation_reference_glyph_;
196	FT_Face rotation_reference_face_;
197	GLfloat rotation_offset_y_;
198	typedef std::map< FT_UInt, GLuint > GlyphDLists;
199	typedef GlyphDLists::const_iterator GDLCI;
200	typedef GlyphDLists::iterator GDLI;
201	GlyphDLists glyph_dlists_;
202	DisplayLists character_display_lists_;
203
204	public:
205	Face ( const char* filename, float point_size = 12, FT_UInt resolution = 100 );
206	Face ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 );
207	virtual ~Face ( void );
208	bool isValid ( void ) const { return valid_; }
209	bool addAuxiliaryFace ( const char* filename );
210	bool addAuxiliaryFace ( FT_Face face );
211	void setCompileMode ( enum GlyphCompileMode compile_mode ) { compile_mode_ = compile_mode; }
212	enum GlyphCompileMode compileMode ( void ) const { return compile_mode_; }
213	void setPointSize ( float point_size );
214	float pointSize ( void ) { return point_size_; }
215	void setResolution ( FT_UInt resolution );
216	FT_UInt resolution ( void ) { return resolution_; }
217	void setAdvance ( bool advance ) { advance_ = advance; }
218	bool advance ( void ) const { return advance_; }
219	void setForegroundColor ( GLfloat red = 0.0, GLfloat green = 0.0, GLfloat blue = 0.0, GLfloat alpha = 1.0 );
220	void setForegroundColor ( const GLfloat foreground_color[4] );
221	GLfloat foregroundRed ( void ) const { return foreground_color_[R]; }
222	GLfloat foregroundGreen ( void ) const { return foreground_color_[G]; }
223	GLfloat foregroundBlue ( void ) const { return foreground_color_[B]; }
224	GLfloat foregroundAlpha ( void ) const { return foreground_color_[A]; }
225	void setBackgroundColor ( GLfloat red = 1.0, GLfloat green = 1.0, GLfloat blue = 1.0, GLfloat alpha = 0.0 );
226	void setBackgroundColor ( const GLfloat background_color[4] );
227	GLfloat backgroundRed ( void ) const { return background_color_[R]; }
228	GLfloat backgroundGreen ( void ) const { return background_color_[G]; }
229	GLfloat backgroundBlue ( void ) const { return background_color_[B]; }
230	GLfloat backgroundAlpha ( void ) const { return background_color_[A]; }
231	virtual void setCharacterRotationZ ( GLfloat character_rotation_z ) = 0;
232	virtual GLfloat characterRotationZ ( void ) const = 0;
233	void setCharacterRotationReference ( unsigned char c );
234	void setStringRotation ( GLfloat string_rotation );
235	GLfloat stringRotation ( void ) const { return string_rotation_; }
236	void setHorizontalJustification ( enum HorizontalJustification horizontal_justification )
237	{
238	horizontal_justification_ = horizontal_justification;
239	}
240	enum HorizontalJustification horizontalJustification ( void ) const { return horizontal_justification_; }
241	void setVerticalJustification ( enum VerticalJustification vertical_justification )
242	{
243	vertical_justification_ = vertical_justification;
244	}
245
246	enum VerticalJustification verticaljustification ( void ) const { return vertical_justification_; }
247	void setCharacterDisplayLists ( const DisplayLists& character_display_lists ) { character_display_lists_ = character_display_lists; }
248	DisplayLists& characterDisplayLists ( void ) { return character_display_lists_; }
249	virtual double height ( void ) const = 0;
250	virtual BBox measure ( unsigned char c ) = 0;
251	virtual BBox measure ( wchar_t c ) = 0;
252	virtual BBox measure ( const char* s );
253	virtual BBox measureRaw ( const char* s );
254	virtual BBox measure ( const wchar_t* s );
255	virtual BBox measure ( const wchar_t* format, double number );
256	virtual BBox measureRaw ( const wchar_t* s );
257	GLuint compile ( unsigned char c );
258	GLuint compile ( const wchar_t c );
259	void draw ( const char* s );
260	void draw ( const wchar_t* s );
261	void draw ( unsigned char c );
262	void draw ( const wchar_t c );
263	void draw ( GLfloat x, GLfloat y, unsigned char c );
264	void draw ( GLfloat x, GLfloat y, GLfloat z, unsigned char c );
265	void draw ( GLfloat x, GLfloat y, wchar_t c );
266	void draw ( GLfloat x, GLfloat y, GLfloat z, wchar_t c );
267	void draw ( GLfloat x, GLfloat y, const char* s, float *sizebox );
268	void draw ( GLfloat x, GLfloat y, GLfloat z, const char* s );
269	void draw ( GLfloat x, GLfloat y, const wchar_t* s );
270	void draw ( GLfloat x, GLfloat y, GLfloat z, const wchar_t* s );
271	int ascender ( void ) { return faces_.front().face_->ascender; }
272	int descender ( void ) { return faces_.front().face_->descender; }
273	BBox measure_nominal ( const char* s );
274	BBox measure_nominal ( const wchar_t* s );
275
276	protected:
277	virtual GLuint compileGlyph ( FT_Face face, FT_UInt glyph_index ) = 0;
278	virtual void renderGlyph ( FT_Face face, FT_UInt glyph_index ) = 0;
279	virtual void setCharSize ( void ) = 0;
280	virtual void clearCaches ( void ) = 0;
281	virtual void setRotationOffset ( void ) = 0;
282
283	private:
284	void init ( void );
285	};
286
287	class Raster : public Face
288	{
289	protected:
290	GLfloat character_rotation_z_;
291	public:
292	Raster ( const char* filename, float point_size = 12, FT_UInt resolution = 100 );
293	Raster ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 );
294	virtual ~Raster ( void );
295	void setCharacterRotationZ ( GLfloat character_rotation_z );
296	GLfloat characterRotationZ ( void ) const { return character_rotation_z_; }
297	double height ( void ) const;
298	BBox measure ( unsigned char c );
299	BBox measure ( wchar_t c );
300	BBox measure ( const char* s ) { return Face::measure( s ); }
301	BBox measure ( const wchar_t* format, double number ) { return Face::measure( format, number ); }
302
303	private:
304	void init ( void );
305	GLuint compileGlyph ( FT_Face face, FT_UInt glyph_index );
306	void setCharSize ( void );
307	void setRotationOffset ( void );
308	void clearCaches ( void );
309	};
310	class Monochrome : public Raster
311	{
312	public:
313	Monochrome ( const char* filename, float point_size = 12, FT_UInt resolution = 100 );
314	Monochrome ( FT_Face face, float point_size = 12, FT_UInt resolution = 100 );
315	~Monochrome ( void );
316
317	private:
318	GLubyte* invertBitmap ( const FT_Bitmap& bitmap );
319	void renderGlyph ( FT_Face face, FT_UInt glyph_index );
320	};
321
322	}
323	#endif /* OGLFT_H */
324