deliantra/Deliantra-Client/pango-render.c

/* Pango
 * Rendering routines to OpenGL
 *
 * Copyright (C) 2006 Marc Lehmann <pcg@goof.com>
 * Copyright (C) 2004 Red Hat Software
 * Copyright (C) 2000 Tor Lillqvist
 *
 * This file is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This file 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library 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.
 */

#include <math.h>

#include "pangoopengl.h"

#define PANGO_OPENGL_RENDERER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_OPENGL_RENDERER, PangoOpenGLRendererClass))
#define PANGO_IS_OPENGL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_OPENGL_RENDERER))
#define PANGO_OPENGL_RENDERER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_OPENGL_RENDERER, PangoOpenGLRendererClass))

typedef struct {
  PangoRendererClass parent_class;
} PangoOpenGLRendererClass;

struct _PangoOpenGLRenderer
{
  PangoRenderer parent_instance;
  float r, g, b, a; // modulate
  int flags;
  rc_t *rc; // rendercache
  rc_key_t key; // current render key
  rc_array_t *arr;
};

G_DEFINE_TYPE (PangoOpenGLRenderer, pango_opengl_renderer, PANGO_TYPE_RENDERER)

typedef struct
{
  uint8_t *bitmap;
  int width, stride, height, top, left;
} Glyph;

static void *
temp_buffer (size_t size)
{
  static char *buffer;
  static size_t alloc;

  if (size > alloc)
    {
      size = (size + 4095) & ~4095;
      free (buffer);
      alloc = size;
      buffer = malloc (size);
    }

  return buffer;
}

static void
render_box (Glyph *glyph, int width, int height, int top)
{
  int i;
  int left = 0;

  if (height > 2)
    {
      height -= 2;
      top++;
    }

  if (width > 2)
    {
      width -= 2;
      left++;
    }

  glyph->stride = (width + 3) & ~3;
  glyph->width  = width;
  glyph->height = height;
  glyph->top    = top;
  glyph->left   = left;

  glyph->bitmap = temp_buffer (width * height);
  memset (glyph->bitmap, 0, glyph->stride * height);

  for (i = width; i--; )
    glyph->bitmap [i] = glyph->bitmap [i + (height - 1) * glyph->stride] = 0xff;

  for (i = height; i--; )
    glyph->bitmap [i * glyph->stride] = glyph->bitmap [i * glyph->stride + (width - 1)] = 0xff;
}

static void
font_render_glyph (Glyph *glyph, PangoFont *font, int glyph_index)
{
  FT_Face face;

  if (glyph_index & PANGO_GLYPH_UNKNOWN_FLAG)
    {
      PangoFontMetrics *metrics;

      if (!font)
        goto generic_box;

      metrics = pango_font_get_metrics (font, NULL);
      if (!metrics)
        goto generic_box;

      render_box (glyph, PANGO_PIXELS (metrics->approximate_char_width),
                         PANGO_PIXELS (metrics->ascent + metrics->descent),
                         PANGO_PIXELS (metrics->ascent));

      pango_font_metrics_unref (metrics);

      return;
    }

  face = pango_opengl_font_get_face (font);
  
  if (face)
    {
      PangoOpenGLFont *glfont = (PangoOpenGLFont *)font;

      FT_Load_Glyph (face, glyph_index, glfont->load_flags);
      FT_Render_Glyph (face->glyph, ft_render_mode_normal);

      glyph->width  = face->glyph->bitmap.width;
      glyph->stride = face->glyph->bitmap.pitch;
      glyph->height = face->glyph->bitmap.rows;
      glyph->top    = face->glyph->bitmap_top;
      glyph->left   = face->glyph->bitmap_left;
      glyph->bitmap = face->glyph->bitmap.buffer;
    }
  else
    generic_box:
      render_box (glyph, PANGO_UNKNOWN_GLYPH_WIDTH, PANGO_UNKNOWN_GLYPH_HEIGHT, PANGO_UNKNOWN_GLYPH_HEIGHT);
}

typedef struct glyph_info {
  tc_area tex;
  int left, top;
  int generation;
} glyph_info;

static void
free_glyph_info (glyph_info *g)
{
  tc_put (&g->tex);
  g_slice_free (glyph_info, g);
}

static void
draw_glyph (PangoRenderer *renderer_, PangoFont *font, PangoGlyph glyph, double x, double y)
{
  PangoOpenGLRenderer *renderer = PANGO_OPENGL_RENDERER (renderer_);
  glyph_info *g;

  if (glyph & PANGO_GLYPH_UNKNOWN_FLAG)
    {
      glyph = pango_opengl_get_unknown_glyph (font);

      if (glyph == PANGO_GLYPH_EMPTY)
        glyph = PANGO_GLYPH_UNKNOWN_FLAG;
    }

  g = _pango_opengl_font_get_cache_glyph_data (font, glyph);

  if (!g || g->generation != tc_generation)
    {
      Glyph bm;
      font_render_glyph (&bm, font, glyph);

      if (g)
        g->generation = tc_generation;
      else
        {
          g = g_slice_new (glyph_info);

          _pango_opengl_font_set_glyph_cache_destroy (font, (GDestroyNotify)free_glyph_info);
          _pango_opengl_font_set_cache_glyph_data (font, glyph, g);
        }

      tc_get (&g->tex, bm.width, bm.height);

      g->left = bm.left;
      g->top  = bm.top;

      glBindTexture (GL_TEXTURE_2D, g->tex.name);
      glPixelStorei (GL_UNPACK_ROW_LENGTH, bm.stride);
      glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
      glTexSubImage2D (GL_TEXTURE_2D, 0, g->tex.x, g->tex.y, bm.width, bm.height, GL_ALPHA, GL_UNSIGNED_BYTE, bm.bitmap);
      glPixelStorei (GL_UNPACK_ROW_LENGTH, 0);
      glPixelStorei (GL_UNPACK_ALIGNMENT, 4);
    }

  x += g->left;
  y -= g->top;

  if (g->tex.name != renderer->key.texname)
    {
      renderer->key.texname = g->tex.name;
      renderer->arr = rc_array (renderer->rc, &renderer->key);
    }

  rc_glyph (renderer->arr, g->tex.x, g->tex.y, g->tex.w, g->tex.h, x, y);
}

static void
draw_trapezoid (PangoRenderer   *renderer_,
                PangoRenderPart  part,
                double           y1,
                double           x11,
                double           x21,
                double           y2,
                double           x12,
                double           x22)
{
  PangoOpenGLRenderer *renderer = (PangoOpenGLRenderer *)renderer_;
  rc_key_t key = renderer->key;
  rc_array_t *arr;

  key.mode    = GL_QUADS;
  key.format  = GL_V2F;
  key.texname = 0;

  arr = rc_array (renderer->rc, &key);

  rc_v2f (arr, x11, y1);
  rc_v2f (arr, x21, y1);
  rc_v2f (arr, x22, y2);
  rc_v2f (arr, x12, y2);
}

void 
pango_opengl_render_layout_subpixel (PangoLayout *layout,
                                     rc_t *rc,
                                     int x, int y,
                                     float r, float g, float b, float a,
                                     int flags)
{
  PangoContext *context;
  PangoFontMap *fontmap;
  PangoRenderer *renderer;
  PangoOpenGLRenderer *gl;

  context = pango_layout_get_context (layout);
  fontmap = pango_context_get_font_map (context);
  renderer = _pango_opengl_font_map_get_renderer (PANGO_OPENGL_FONT_MAP (fontmap));
  gl = PANGO_OPENGL_RENDERER (renderer);

  gl->rc = rc;
  gl->r = r;
  gl->g = g;
  gl->b = b;
  gl->a = a;
  gl->flags = flags;
  
  pango_renderer_draw_layout (renderer, layout, x, y);
}

void 
pango_opengl_render_layout (PangoLayout *layout,
                            rc_t *rc,
                            int x, int y,
                            float r, float g, float b, float a,
                            int flags)
{
  pango_opengl_render_layout_subpixel (
     layout, rc, x * PANGO_SCALE, y * PANGO_SCALE, r, g, b, a, flags
  );
}

static void
pango_opengl_renderer_init (PangoOpenGLRenderer *renderer)
{
  memset (&renderer->key, 0, sizeof (rc_key_t));

  renderer->r = 1.;
  renderer->g = 1.;
  renderer->b = 1.;
  renderer->a = 1.;
}

static void
prepare_run (PangoRenderer *renderer, PangoLayoutRun *run)
{
  PangoOpenGLRenderer *gl = (PangoOpenGLRenderer *)renderer;
  PangoColor *fg = 0;
  GSList *l;
  unsigned char r, g, b, a;

  renderer->underline = PANGO_UNDERLINE_NONE;
  renderer->strikethrough = FALSE;

  gl->key.mode    = GL_QUADS;
  gl->key.format  = 0; // glyphs
  gl->key.texname = 0;

  for (l = run->item->analysis.extra_attrs; l; l = l->next)
    {
      PangoAttribute *attr = l->data;
      
      switch (attr->klass->type)
        {
        case PANGO_ATTR_UNDERLINE:
          renderer->underline = ((PangoAttrInt *)attr)->value;
          break;
          
        case PANGO_ATTR_STRIKETHROUGH:
          renderer->strikethrough = ((PangoAttrInt *)attr)->value;
          break;
          
        case PANGO_ATTR_FOREGROUND:
          fg = &((PangoAttrColor *)attr)->color;
          break;
          
        default:
          break;
        }
    }

  if (fg)
    {
      r = fg->red   * (255.f / 65535.f);
      g = fg->green * (255.f / 65535.f);
      b = fg->blue  * (255.f / 65535.f);
    }
  else 
    {
      r = gl->r * 255.f;
      g = gl->g * 255.f;
      b = gl->b * 255.f;
    }

  a = gl->a * 255.f;

  if (gl->flags & FLAG_INVERSE)
    {
      r ^= 0xffU;
      g ^= 0xffU;
      b ^= 0xffU;
    } 

  gl->key.r = r;
  gl->key.g = g;
  gl->key.b = b;
  gl->key.a = a;
}

static void
draw_begin (PangoRenderer *renderer_)
{
  PangoOpenGLRenderer *renderer = (PangoOpenGLRenderer *)renderer_;
}

static void
draw_end (PangoRenderer *renderer_)
{
  PangoOpenGLRenderer *renderer = (PangoOpenGLRenderer *)renderer_;
}

static void
pango_opengl_renderer_class_init (PangoOpenGLRendererClass *klass)
{
  PangoRendererClass *renderer_class = PANGO_RENDERER_CLASS (klass);

  renderer_class->draw_glyph     = draw_glyph;
  renderer_class->draw_trapezoid = draw_trapezoid;
  renderer_class->prepare_run    = prepare_run;
  renderer_class->begin          = draw_begin;
  renderer_class->end            = draw_end;
}

Revision:	1.12
Committed:	Mon Aug 13 15:31:21 2007 UTC (16 years, 9 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-0_99, rel-0_9958, rel-0_9960, rel-0_9956, rel-0_9957, rel-0_9955, rel-0_9959, rel-0_995
Changes since 1.11:	+0 -1 lines
Log Message:	cleanup
#	Content
1	/* Pango
2	* Rendering routines to OpenGL
3	*
4	* Copyright (C) 2006 Marc Lehmann <pcg@goof.com>
5	* Copyright (C) 2004 Red Hat Software
6	* Copyright (C) 2000 Tor Lillqvist
7	*
8	* This file is free software; you can redistribute it and/or
9	* modify it under the terms of the GNU Library General Public
10	* License as published by the Free Software Foundation; either
11	* version 2 of the License, or (at your option) any later version.
12	*
13	* This file is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16	* Library General Public License for more details.
17	*
18	* You should have received a copy of the GNU Library General Public
19	* License along with this library; if not, write to the
20	* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21	* Boston, MA 02111-1307, USA.
22	*/
23
24	#include <math.h>
25
26	#include "pangoopengl.h"
27
28	#define PANGO_OPENGL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_OPENGL_RENDERER, PangoOpenGLRendererClass))
29	#define PANGO_IS_OPENGL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_OPENGL_RENDERER))
30	#define PANGO_OPENGL_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_OPENGL_RENDERER, PangoOpenGLRendererClass))
31
32	typedef struct {
33	PangoRendererClass parent_class;
34	} PangoOpenGLRendererClass;
35
36	struct _PangoOpenGLRenderer
37	{
38	PangoRenderer parent_instance;
39	float r, g, b, a; // modulate
40	int flags;
41	rc_t *rc; // rendercache
42	rc_key_t key; // current render key
43	rc_array_t *arr;
44	};
45
46	G_DEFINE_TYPE (PangoOpenGLRenderer, pango_opengl_renderer, PANGO_TYPE_RENDERER)
47
48	typedef struct
49	{
50	uint8_t *bitmap;
51	int width, stride, height, top, left;
52	} Glyph;
53
54	static void *
55	temp_buffer (size_t size)
56	{
57	static char *buffer;
58	static size_t alloc;
59
60	if (size > alloc)
61	{
62	size = (size + 4095) & ~4095;
63	free (buffer);
64	alloc = size;
65	buffer = malloc (size);
66	}
67
68	return buffer;
69	}
70
71	static void
72	render_box (Glyph *glyph, int width, int height, int top)
73	{
74	int i;
75	int left = 0;
76
77	if (height > 2)
78	{
79	height -= 2;
80	top++;
81	}
82
83	if (width > 2)
84	{
85	width -= 2;
86	left++;
87	}
88
89	glyph->stride = (width + 3) & ~3;
90	glyph->width = width;
91	glyph->height = height;
92	glyph->top = top;
93	glyph->left = left;
94
95	glyph->bitmap = temp_buffer (width * height);
96	memset (glyph->bitmap, 0, glyph->stride * height);
97
98	for (i = width; i--; )
99	glyph->bitmap [i] = glyph->bitmap [i + (height - 1) * glyph->stride] = 0xff;
100
101	for (i = height; i--; )
102	glyph->bitmap [i * glyph->stride] = glyph->bitmap [i * glyph->stride + (width - 1)] = 0xff;
103	}
104
105	static void
106	font_render_glyph (Glyph glyph, PangoFont font, int glyph_index)
107	{
108	FT_Face face;
109
110	if (glyph_index & PANGO_GLYPH_UNKNOWN_FLAG)
111	{
112	PangoFontMetrics *metrics;
113
114	if (!font)
115	goto generic_box;
116
117	metrics = pango_font_get_metrics (font, NULL);
118	if (!metrics)
119	goto generic_box;
120
121	render_box (glyph, PANGO_PIXELS (metrics->approximate_char_width),
122	PANGO_PIXELS (metrics->ascent + metrics->descent),
123	PANGO_PIXELS (metrics->ascent));
124
125	pango_font_metrics_unref (metrics);
126
127	return;
128	}
129
130	face = pango_opengl_font_get_face (font);
131
132	if (face)
133	{
134	PangoOpenGLFont glfont = (PangoOpenGLFont )font;
135
136	FT_Load_Glyph (face, glyph_index, glfont->load_flags);
137	FT_Render_Glyph (face->glyph, ft_render_mode_normal);
138
139	glyph->width = face->glyph->bitmap.width;
140	glyph->stride = face->glyph->bitmap.pitch;
141	glyph->height = face->glyph->bitmap.rows;
142	glyph->top = face->glyph->bitmap_top;
143	glyph->left = face->glyph->bitmap_left;
144	glyph->bitmap = face->glyph->bitmap.buffer;
145	}
146	else
147	generic_box:
148	render_box (glyph, PANGO_UNKNOWN_GLYPH_WIDTH, PANGO_UNKNOWN_GLYPH_HEIGHT, PANGO_UNKNOWN_GLYPH_HEIGHT);
149	}
150
151	typedef struct glyph_info {
152	tc_area tex;
153	int left, top;
154	int generation;
155	} glyph_info;
156
157	static void
158	free_glyph_info (glyph_info *g)
159	{
160	tc_put (&g->tex);
161	g_slice_free (glyph_info, g);
162	}
163
164	static void
165	draw_glyph (PangoRenderer renderer_, PangoFont font, PangoGlyph glyph, double x, double y)
166	{
167	PangoOpenGLRenderer *renderer = PANGO_OPENGL_RENDERER (renderer_);
168	glyph_info *g;
169
170	if (glyph & PANGO_GLYPH_UNKNOWN_FLAG)
171	{
172	glyph = pango_opengl_get_unknown_glyph (font);
173
174	if (glyph == PANGO_GLYPH_EMPTY)
175	glyph = PANGO_GLYPH_UNKNOWN_FLAG;
176	}
177
178	g = _pango_opengl_font_get_cache_glyph_data (font, glyph);
179
180	if (!g \|\| g->generation != tc_generation)
181	{
182	Glyph bm;
183	font_render_glyph (&bm, font, glyph);
184
185	if (g)
186	g->generation = tc_generation;
187	else
188	{
189	g = g_slice_new (glyph_info);
190
191	_pango_opengl_font_set_glyph_cache_destroy (font, (GDestroyNotify)free_glyph_info);
192	_pango_opengl_font_set_cache_glyph_data (font, glyph, g);
193	}
194
195	tc_get (&g->tex, bm.width, bm.height);
196
197	g->left = bm.left;
198	g->top = bm.top;
199
200	glBindTexture (GL_TEXTURE_2D, g->tex.name);
201	glPixelStorei (GL_UNPACK_ROW_LENGTH, bm.stride);
202	glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
203	glTexSubImage2D (GL_TEXTURE_2D, 0, g->tex.x, g->tex.y, bm.width, bm.height, GL_ALPHA, GL_UNSIGNED_BYTE, bm.bitmap);
204	glPixelStorei (GL_UNPACK_ROW_LENGTH, 0);
205	glPixelStorei (GL_UNPACK_ALIGNMENT, 4);
206	}
207
208	x += g->left;
209	y -= g->top;
210
211	if (g->tex.name != renderer->key.texname)
212	{
213	renderer->key.texname = g->tex.name;
214	renderer->arr = rc_array (renderer->rc, &renderer->key);
215	}
216
217	rc_glyph (renderer->arr, g->tex.x, g->tex.y, g->tex.w, g->tex.h, x, y);
218	}
219
220	static void
221	draw_trapezoid (PangoRenderer *renderer_,
222	PangoRenderPart part,
223	double y1,
224	double x11,
225	double x21,
226	double y2,
227	double x12,
228	double x22)
229	{
230	PangoOpenGLRenderer renderer = (PangoOpenGLRenderer )renderer_;
231	rc_key_t key = renderer->key;
232	rc_array_t *arr;
233
234	key.mode = GL_QUADS;
235	key.format = GL_V2F;
236	key.texname = 0;
237
238	arr = rc_array (renderer->rc, &key);
239
240	rc_v2f (arr, x11, y1);
241	rc_v2f (arr, x21, y1);
242	rc_v2f (arr, x22, y2);
243	rc_v2f (arr, x12, y2);
244	}
245
246	void
247	pango_opengl_render_layout_subpixel (PangoLayout *layout,
248	rc_t *rc,
249	int x, int y,
250	float r, float g, float b, float a,
251	int flags)
252	{
253	PangoContext *context;
254	PangoFontMap *fontmap;
255	PangoRenderer *renderer;
256	PangoOpenGLRenderer *gl;
257
258	context = pango_layout_get_context (layout);
259	fontmap = pango_context_get_font_map (context);
260	renderer = _pango_opengl_font_map_get_renderer (PANGO_OPENGL_FONT_MAP (fontmap));
261	gl = PANGO_OPENGL_RENDERER (renderer);
262
263	gl->rc = rc;
264	gl->r = r;
265	gl->g = g;
266	gl->b = b;
267	gl->a = a;
268	gl->flags = flags;
269
270	pango_renderer_draw_layout (renderer, layout, x, y);
271	}
272
273	void
274	pango_opengl_render_layout (PangoLayout *layout,
275	rc_t *rc,
276	int x, int y,
277	float r, float g, float b, float a,
278	int flags)
279	{
280	pango_opengl_render_layout_subpixel (
281	layout, rc, x * PANGO_SCALE, y * PANGO_SCALE, r, g, b, a, flags
282	);
283	}
284
285	static void
286	pango_opengl_renderer_init (PangoOpenGLRenderer *renderer)
287	{
288	memset (&renderer->key, 0, sizeof (rc_key_t));
289
290	renderer->r = 1.;
291	renderer->g = 1.;
292	renderer->b = 1.;
293	renderer->a = 1.;
294	}
295
296	static void
297	prepare_run (PangoRenderer renderer, PangoLayoutRun run)
298	{
299	PangoOpenGLRenderer gl = (PangoOpenGLRenderer )renderer;
300	PangoColor *fg = 0;
301	GSList *l;
302	unsigned char r, g, b, a;
303
304	renderer->underline = PANGO_UNDERLINE_NONE;
305	renderer->strikethrough = FALSE;
306
307	gl->key.mode = GL_QUADS;
308	gl->key.format = 0; // glyphs
309	gl->key.texname = 0;
310
311	for (l = run->item->analysis.extra_attrs; l; l = l->next)
312	{
313	PangoAttribute *attr = l->data;
314
315	switch (attr->klass->type)
316	{
317	case PANGO_ATTR_UNDERLINE:
318	renderer->underline = ((PangoAttrInt *)attr)->value;
319	break;
320
321	case PANGO_ATTR_STRIKETHROUGH:
322	renderer->strikethrough = ((PangoAttrInt *)attr)->value;
323	break;
324
325	case PANGO_ATTR_FOREGROUND:
326	fg = &((PangoAttrColor *)attr)->color;
327	break;
328
329	default:
330	break;
331	}
332	}
333
334	if (fg)
335	{
336	r = fg->red * (255.f / 65535.f);
337	g = fg->green * (255.f / 65535.f);
338	b = fg->blue * (255.f / 65535.f);
339	}
340	else
341	{
342	r = gl->r * 255.f;
343	g = gl->g * 255.f;
344	b = gl->b * 255.f;
345	}
346
347	a = gl->a * 255.f;
348
349	if (gl->flags & FLAG_INVERSE)
350	{
351	r ^= 0xffU;
352	g ^= 0xffU;
353	b ^= 0xffU;
354	}
355
356	gl->key.r = r;
357	gl->key.g = g;
358	gl->key.b = b;
359	gl->key.a = a;
360	}
361
362	static void
363	draw_begin (PangoRenderer *renderer_)
364	{
365	PangoOpenGLRenderer renderer = (PangoOpenGLRenderer )renderer_;
366	}
367
368	static void
369	draw_end (PangoRenderer *renderer_)
370	{
371	PangoOpenGLRenderer renderer = (PangoOpenGLRenderer )renderer_;
372	}
373
374	static void
375	pango_opengl_renderer_class_init (PangoOpenGLRendererClass *klass)
376	{
377	PangoRendererClass *renderer_class = PANGO_RENDERER_CLASS (klass);
378
379	renderer_class->draw_glyph = draw_glyph;
380	renderer_class->draw_trapezoid = draw_trapezoid;
381	renderer_class->prepare_run = prepare_run;
382	renderer_class->begin = draw_begin;
383	renderer_class->end = draw_end;
384	}
385