mutter/clutter/pango/cogl-pango-glyph-cache.c
Emmanuele Bassi b5cc7a4044 2008-10-30 Emmanuele Bassi <ebassi@linux.intel.com>
Bug 1215 - Move the Pango renderer to the public API

	* clutter/pango/*: Rename PangoClutter -> CoglPango.

	* clutter/Makefile.am:
	* clutter/clutter-backend.c:
	* clutter/clutter-entry.c:
	* clutter/clutter-label.c:
	* clutter/clutter-main.[ch]:
	* clutter/clutter-private.h: Update the users of the Pango
	renderer API.

	* README: Update release notes.
2008-10-30 17:11:29 +00:00

362 lines
10 KiB
C

/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum <mallum@openedhand.com>
*
* Copyright (C) 2008 OpenedHand
*
* 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 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, see <http://www.gnu.org/licenses>.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <glib.h>
#include "cogl-pango-glyph-cache.h"
#include "cogl-pango-private.h"
/* Minimum width/height for each texture */
#define MIN_TEXTURE_SIZE 256
/* All glyph with heights within this margin from each other can be
put in the same band */
#define BAND_HEIGHT_ROUND 4
typedef struct _CoglPangoGlyphCacheKey CoglPangoGlyphCacheKey;
typedef struct _CoglPangoGlyphCacheTexture CoglPangoGlyphCacheTexture;
typedef struct _CoglPangoGlyphCacheBand CoglPangoGlyphCacheBand;
struct _CoglPangoGlyphCache
{
/* Hash table to quickly check whether a particular glyph in a
particular font is already cached */
GHashTable *hash_table;
/* List of textures */
CoglPangoGlyphCacheTexture *textures;
/* List of horizontal bands of glyphs */
CoglPangoGlyphCacheBand *bands;
/* If TRUE all of the textures will be created with automatic mipmap
generation enabled */
gboolean use_mipmapping;
};
struct _CoglPangoGlyphCacheKey
{
PangoFont *font;
PangoGlyph glyph;
};
/* Represents one texture that will be used to store glyphs. The
texture is divided into horizontal bands which all contain glyphs
of approximatly the same height */
struct _CoglPangoGlyphCacheTexture
{
/* The width and height of the texture which should always be a
power of two. This can vary so that glyphs larger than
MIN_TEXTURE_SIZE can use a bigger texture */
int texture_size;
/* The remaining vertical space not taken up by any bands */
int space_remaining;
/* The actual texture */
CoglHandle texture;
CoglPangoGlyphCacheTexture *next;
};
/* Represents one horizontal band of a texture. Each band contains
glyphs of a similar height */
struct _CoglPangoGlyphCacheBand
{
/* The y position of the top of the band */
int top;
/* The height of the band */
int height;
/* The remaining horizontal space not taken up by any glyphs */
int space_remaining;
/* The size of the texture. Needed to calculate texture
coordinates */
int texture_size;
/* The texture containing this band */
CoglHandle texture;
CoglPangoGlyphCacheBand *next;
};
static void
cogl_pango_glyph_cache_value_free (CoglPangoGlyphCacheValue *value)
{
cogl_texture_unref (value->texture);
g_slice_free (CoglPangoGlyphCacheValue, value);
}
static void
cogl_pango_glyph_cache_key_free (CoglPangoGlyphCacheKey *key)
{
g_object_unref (key->font);
g_slice_free (CoglPangoGlyphCacheKey, key);
}
static guint
cogl_pango_glyph_cache_hash_func (gconstpointer key)
{
const CoglPangoGlyphCacheKey *cache_key
= (const CoglPangoGlyphCacheKey *) key;
/* Generate a number affected by both the font and the glyph
number. We can safely directly compare the pointers because the
key holds a reference to the font so it is not possible that a
different font will have the same memory address */
return (guint) cache_key->font ^ cache_key->glyph;
}
static gboolean
cogl_pango_glyph_cache_equal_func (gconstpointer a,
gconstpointer b)
{
const CoglPangoGlyphCacheKey *key_a
= (const CoglPangoGlyphCacheKey *) a;
const CoglPangoGlyphCacheKey *key_b
= (const CoglPangoGlyphCacheKey *) b;
/* We can safely directly compare the pointers for the fonts because
the key holds a reference to the font so it is not possible that
a different font will have the same memory address */
return key_a->font == key_b->font
&& key_a->glyph == key_b->glyph;
}
static void
cogl_pango_glyph_cache_free_textures (CoglPangoGlyphCacheTexture *node)
{
CoglPangoGlyphCacheTexture *next;
while (node)
{
next = node->next;
cogl_texture_unref (node->texture);
g_slice_free (CoglPangoGlyphCacheTexture, node);
node = next;
}
}
static void
cogl_pango_glyph_cache_free_bands (CoglPangoGlyphCacheBand *node)
{
CoglPangoGlyphCacheBand *next;
while (node)
{
next = node->next;
cogl_texture_unref (node->texture);
g_slice_free (CoglPangoGlyphCacheBand, node);
node = next;
}
}
CoglPangoGlyphCache *
cogl_pango_glyph_cache_new (gboolean use_mipmapping)
{
CoglPangoGlyphCache *cache;
cache = g_malloc (sizeof (CoglPangoGlyphCache));
cache->hash_table = g_hash_table_new_full
(cogl_pango_glyph_cache_hash_func,
cogl_pango_glyph_cache_equal_func,
(GDestroyNotify) cogl_pango_glyph_cache_key_free,
(GDestroyNotify) cogl_pango_glyph_cache_value_free);
cache->textures = NULL;
cache->bands = NULL;
cache->use_mipmapping = use_mipmapping;
return cache;
}
void
cogl_pango_glyph_cache_clear (CoglPangoGlyphCache *cache)
{
cogl_pango_glyph_cache_free_textures (cache->textures);
cache->textures = NULL;
cogl_pango_glyph_cache_free_bands (cache->bands);
cache->bands = NULL;
g_hash_table_remove_all (cache->hash_table);
}
void
cogl_pango_glyph_cache_free (CoglPangoGlyphCache *cache)
{
cogl_pango_glyph_cache_clear (cache);
g_hash_table_unref (cache->hash_table);
g_free (cache);
}
CoglPangoGlyphCacheValue *
cogl_pango_glyph_cache_lookup (CoglPangoGlyphCache *cache,
PangoFont *font,
PangoGlyph glyph)
{
CoglPangoGlyphCacheKey key;
key.font = font;
key.glyph = glyph;
return (CoglPangoGlyphCacheValue *)
g_hash_table_lookup (cache->hash_table, &key);
}
CoglPangoGlyphCacheValue *
cogl_pango_glyph_cache_set (CoglPangoGlyphCache *cache,
PangoFont *font,
PangoGlyph glyph,
gconstpointer pixels,
int width,
int height,
int stride,
int draw_x,
int draw_y)
{
int band_height;
CoglPangoGlyphCacheBand *band;
CoglPangoGlyphCacheKey *key;
CoglPangoGlyphCacheValue *value;
/* Reserve an extra pixel gap around the glyph so that it can pull
in blank pixels when linear filtering is enabled */
width++;
height++;
/* Round the height up to the nearest multiple of
BAND_HEIGHT_ROUND */
band_height = (height + BAND_HEIGHT_ROUND - 1) & ~(BAND_HEIGHT_ROUND - 1);
/* Look for a band with the same height and enough width available */
for (band = cache->bands;
band && (band->height != band_height || band->space_remaining < width);
band = band->next);
if (band == NULL)
{
CoglPangoGlyphCacheTexture *texture;
/* Look for a texture with enough vertical space left for a band
with this height */
for (texture = cache->textures;
texture && (texture->space_remaining < band_height
|| texture->texture_size < width);
texture = texture->next);
if (texture == NULL)
{
guchar *clear_data;
/* Allocate a new texture that is the nearest power of two
greater than the band height or the minimum size,
whichever is lower */
texture = g_slice_new (CoglPangoGlyphCacheTexture);
texture->texture_size = MIN_TEXTURE_SIZE;
while (texture->texture_size < band_height
|| texture->texture_size < width)
texture->texture_size *= 2;
/* Allocate an empty buffer to clear the texture */
clear_data = g_malloc0 (texture->texture_size
* texture->texture_size);
texture->texture = cogl_texture_new_from_data
(texture->texture_size, texture->texture_size,
32, cache->use_mipmapping,
COGL_PIXEL_FORMAT_A_8, COGL_PIXEL_FORMAT_A_8,
texture->texture_size, clear_data);
g_free (clear_data);
texture->space_remaining = texture->texture_size;
texture->next = cache->textures;
cache->textures = texture;
if (cache->use_mipmapping)
cogl_texture_set_filters (texture->texture,
CGL_LINEAR_MIPMAP_LINEAR,
CGL_LINEAR);
else
cogl_texture_set_filters (texture->texture,
CGL_LINEAR,
CGL_LINEAR);
}
band = g_slice_new (CoglPangoGlyphCacheBand);
band->top = texture->texture_size - texture->space_remaining;
band->height = band_height;
band->space_remaining = texture->texture_size;
band->texture = cogl_texture_ref (texture->texture);
band->texture_size = texture->texture_size;
band->next = cache->bands;
cache->bands = band;
texture->space_remaining -= band_height;
}
band->space_remaining -= width;
width--;
height--;
cogl_texture_set_region (band->texture,
0, 0,
band->space_remaining,
band->top,
width, height,
width, height,
COGL_PIXEL_FORMAT_A_8,
stride,
pixels);
key = g_slice_new (CoglPangoGlyphCacheKey);
key->font = g_object_ref (font);
key->glyph = glyph;
value = g_slice_new (CoglPangoGlyphCacheValue);
value->texture = cogl_texture_ref (band->texture);
value->tx1 = COGL_FIXED_FROM_INT (band->space_remaining)
/ band->texture_size;
value->tx2 = COGL_FIXED_FROM_INT (band->space_remaining + width)
/ band->texture_size;
value->ty1 = COGL_FIXED_FROM_INT (band->top)
/ band->texture_size;
value->ty2 = COGL_FIXED_FROM_INT (band->top + height)
/ band->texture_size;
value->draw_x = draw_x;
value->draw_y = draw_y;
value->draw_width = width;
value->draw_height = height;
g_hash_table_insert (cache->hash_table, key, value);
return value;
}