Move font renderer in a separate folder as a library
This commit is contained in:
Francesco Abbate
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,198 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// Anti-Grain Geometry - Version 2.4
|
||||
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
|
||||
//
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
// Contact: mcseem@antigrain.com
|
||||
// mcseemagg@yahoo.com
|
||||
// http://www.antigrain.com
|
||||
//----------------------------------------------------------------------------
|
||||
//
|
||||
// See implementation agg_font_freetype.cpp
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
#ifndef AGG_FONT_FREETYPE_INCLUDED
|
||||
#define AGG_FONT_FREETYPE_INCLUDED
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_FREETYPE_H
|
||||
|
||||
|
||||
#include "agg_scanline_storage_aa.h"
|
||||
#include "agg_scanline_storage_bin.h"
|
||||
#include "agg_scanline_u.h"
|
||||
#include "agg_scanline_bin.h"
|
||||
#include "agg_path_storage_integer.h"
|
||||
#include "agg_rasterizer_scanline_aa.h"
|
||||
#include "agg_conv_curve.h"
|
||||
#include "agg_font_cache_manager.h"
|
||||
#include "agg_trans_affine.h"
|
||||
|
||||
namespace agg
|
||||
{
|
||||
|
||||
|
||||
//-----------------------------------------------font_engine_freetype_base
|
||||
class font_engine_freetype_base
|
||||
{
|
||||
public:
|
||||
//--------------------------------------------------------------------
|
||||
typedef serialized_scanlines_adaptor_aa<int8u> gray8_adaptor_type;
|
||||
typedef serialized_scanlines_adaptor_bin mono_adaptor_type;
|
||||
typedef scanline_storage_aa8 scanlines_aa_type;
|
||||
typedef scanline_storage_bin scanlines_bin_type;
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
~font_engine_freetype_base();
|
||||
font_engine_freetype_base(bool flag32, unsigned max_faces = 32);
|
||||
|
||||
// Set font parameters
|
||||
//--------------------------------------------------------------------
|
||||
void resolution(unsigned dpi);
|
||||
bool load_font(const char* font_name, unsigned face_index, glyph_rendering ren_type,
|
||||
const char* font_mem = 0, const long font_mem_size = 0);
|
||||
bool attach(const char* file_name);
|
||||
bool char_map(FT_Encoding map);
|
||||
bool height(double h);
|
||||
bool width(double w);
|
||||
void hinting(bool h);
|
||||
void flip_y(bool f);
|
||||
void transform(const trans_affine& affine);
|
||||
|
||||
// Set Gamma
|
||||
//--------------------------------------------------------------------
|
||||
template<class GammaF> void gamma(const GammaF& f)
|
||||
{
|
||||
m_rasterizer.gamma(f);
|
||||
}
|
||||
|
||||
// Accessors
|
||||
//--------------------------------------------------------------------
|
||||
int last_error() const { return m_last_error; }
|
||||
unsigned resolution() const { return m_resolution; }
|
||||
const char* name() const { return m_name; }
|
||||
unsigned num_faces() const;
|
||||
FT_Encoding char_map() const { return m_char_map; }
|
||||
double height() const { return double(m_height) / 64.0; }
|
||||
double width() const { return double(m_width) / 64.0; }
|
||||
double ascender() const;
|
||||
double descender() const;
|
||||
int face_height() const;
|
||||
int face_units_em()const;
|
||||
bool hinting() const { return m_hinting; }
|
||||
bool flip_y() const { return m_flip_y; }
|
||||
|
||||
|
||||
// Interface mandatory to implement for font_cache_manager
|
||||
//--------------------------------------------------------------------
|
||||
const char* font_signature() const { return m_signature; }
|
||||
int change_stamp() const { return m_change_stamp; }
|
||||
|
||||
bool prepare_glyph(unsigned glyph_code);
|
||||
unsigned glyph_index() const { return m_glyph_index; }
|
||||
unsigned data_size() const { return m_data_size; }
|
||||
glyph_data_type data_type() const { return m_data_type; }
|
||||
const rect_i& bounds() const { return m_bounds; }
|
||||
double advance_x() const { return m_advance_x; }
|
||||
double advance_y() const { return m_advance_y; }
|
||||
void write_glyph_to(int8u* data) const;
|
||||
bool add_kerning(unsigned first, unsigned second,
|
||||
double* x, double* y);
|
||||
|
||||
private:
|
||||
font_engine_freetype_base(const font_engine_freetype_base&);
|
||||
const font_engine_freetype_base& operator = (const font_engine_freetype_base&);
|
||||
|
||||
void update_char_size();
|
||||
void update_signature();
|
||||
int find_face(const char* face_name) const;
|
||||
|
||||
bool m_flag32;
|
||||
int m_change_stamp;
|
||||
int m_last_error;
|
||||
char* m_name;
|
||||
unsigned m_name_len;
|
||||
unsigned m_face_index;
|
||||
FT_Encoding m_char_map;
|
||||
char* m_signature;
|
||||
unsigned m_height;
|
||||
unsigned m_width;
|
||||
bool m_hinting;
|
||||
bool m_flip_y;
|
||||
bool m_library_initialized;
|
||||
FT_Library m_library; // handle to library
|
||||
FT_Face* m_faces; // A pool of font faces
|
||||
char** m_face_names;
|
||||
unsigned m_num_faces;
|
||||
unsigned m_max_faces;
|
||||
FT_Face m_cur_face; // handle to the current face object
|
||||
int m_resolution;
|
||||
glyph_rendering m_glyph_rendering;
|
||||
unsigned m_glyph_index;
|
||||
unsigned m_data_size;
|
||||
glyph_data_type m_data_type;
|
||||
rect_i m_bounds;
|
||||
double m_advance_x;
|
||||
double m_advance_y;
|
||||
trans_affine m_affine;
|
||||
|
||||
path_storage_integer<int16, 6> m_path16;
|
||||
path_storage_integer<int32, 6> m_path32;
|
||||
conv_curve<path_storage_integer<int16, 6> > m_curves16;
|
||||
conv_curve<path_storage_integer<int32, 6> > m_curves32;
|
||||
scanline_u8 m_scanline_aa;
|
||||
scanline_bin m_scanline_bin;
|
||||
scanlines_aa_type m_scanlines_aa;
|
||||
scanlines_bin_type m_scanlines_bin;
|
||||
rasterizer_scanline_aa<> m_rasterizer;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
//------------------------------------------------font_engine_freetype_int16
|
||||
// This class uses values of type int16 (10.6 format) for the vector cache.
|
||||
// The vector cache is compact, but when rendering glyphs of height
|
||||
// more that 200 there integer overflow can occur.
|
||||
//
|
||||
class font_engine_freetype_int16 : public font_engine_freetype_base
|
||||
{
|
||||
public:
|
||||
typedef serialized_integer_path_adaptor<int16, 6> path_adaptor_type;
|
||||
typedef font_engine_freetype_base::gray8_adaptor_type gray8_adaptor_type;
|
||||
typedef font_engine_freetype_base::mono_adaptor_type mono_adaptor_type;
|
||||
typedef font_engine_freetype_base::scanlines_aa_type scanlines_aa_type;
|
||||
typedef font_engine_freetype_base::scanlines_bin_type scanlines_bin_type;
|
||||
|
||||
font_engine_freetype_int16(unsigned max_faces = 32) :
|
||||
font_engine_freetype_base(false, max_faces) {}
|
||||
};
|
||||
|
||||
//------------------------------------------------font_engine_freetype_int32
|
||||
// This class uses values of type int32 (26.6 format) for the vector cache.
|
||||
// The vector cache is twice larger than in font_engine_freetype_int16,
|
||||
// but it allows you to render glyphs of very large sizes.
|
||||
//
|
||||
class font_engine_freetype_int32 : public font_engine_freetype_base
|
||||
{
|
||||
public:
|
||||
typedef serialized_integer_path_adaptor<int32, 6> path_adaptor_type;
|
||||
typedef font_engine_freetype_base::gray8_adaptor_type gray8_adaptor_type;
|
||||
typedef font_engine_freetype_base::mono_adaptor_type mono_adaptor_type;
|
||||
typedef font_engine_freetype_base::scanlines_aa_type scanlines_aa_type;
|
||||
typedef font_engine_freetype_base::scanlines_bin_type scanlines_bin_type;
|
||||
|
||||
font_engine_freetype_int32(unsigned max_faces = 32) :
|
||||
font_engine_freetype_base(true, max_faces) {}
|
||||
};
|
||||
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,71 @@
|
||||
// Adapted by Francesco Abbate for GSL Shell
|
||||
// Original code's copyright below.
|
||||
//----------------------------------------------------------------------------
|
||||
// Anti-Grain Geometry - Version 2.4
|
||||
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
|
||||
//
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
// Contact: mcseem@antigrain.com
|
||||
// mcseemagg@yahoo.com
|
||||
// http://www.antigrain.com
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
#ifndef AGG_LCD_DISTRIBUTION_LUT_INCLUDED
|
||||
#define AGG_LCD_DISTRIBUTION_LUT_INCLUDED
|
||||
|
||||
#include "agg_basics.h"
|
||||
|
||||
namespace agg
|
||||
{
|
||||
|
||||
//=====================================================lcd_distribution_lut
|
||||
class lcd_distribution_lut
|
||||
{
|
||||
public:
|
||||
lcd_distribution_lut(double prim, double second, double tert)
|
||||
{
|
||||
double norm = 1.0 / (prim + second*2 + tert*2);
|
||||
prim *= norm;
|
||||
second *= norm;
|
||||
tert *= norm;
|
||||
for(unsigned i = 0; i < 256; i++)
|
||||
{
|
||||
unsigned b = (i << 8);
|
||||
unsigned s = round(second * b);
|
||||
unsigned t = round(tert * b);
|
||||
unsigned p = b - (2*s + 2*t);
|
||||
|
||||
m_data[3*i + 1] = s; /* secondary */
|
||||
m_data[3*i + 2] = t; /* tertiary */
|
||||
m_data[3*i ] = p; /* primary */
|
||||
}
|
||||
}
|
||||
|
||||
unsigned convolution(const int8u* covers, int i0, int i_min, int i_max) const
|
||||
{
|
||||
unsigned sum = 0;
|
||||
int k_min = (i0 >= i_min + 2 ? -2 : i_min - i0);
|
||||
int k_max = (i0 <= i_max - 2 ? 2 : i_max - i0);
|
||||
for (int k = k_min; k <= k_max; k++)
|
||||
{
|
||||
/* select the primary, secondary or tertiary channel */
|
||||
int channel = abs(k) % 3;
|
||||
int8u c = covers[i0 + k];
|
||||
sum += m_data[3*c + channel];
|
||||
}
|
||||
|
||||
return (sum + 128) >> 8;
|
||||
}
|
||||
|
||||
private:
|
||||
unsigned short m_data[256*3];
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,93 @@
|
||||
#pragma once
|
||||
|
||||
#include <string.h>
|
||||
#include "agg_basics.h"
|
||||
#include "agg_rendering_buffer.h"
|
||||
|
||||
namespace agg
|
||||
{
|
||||
// This is a special purpose color type that only has the alpha channel.
|
||||
// It can be thought as a gray color but with the intensity always on.
|
||||
// It is actually used to store coverage information.
|
||||
struct alpha8
|
||||
{
|
||||
typedef int8u value_type;
|
||||
typedef int32u calc_type;
|
||||
typedef int32 long_type;
|
||||
enum base_scale_e
|
||||
{
|
||||
base_shift = 8,
|
||||
base_scale = 1 << base_shift,
|
||||
base_mask = base_scale - 1
|
||||
};
|
||||
|
||||
value_type a;
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
alpha8(unsigned a_=base_mask) :
|
||||
a(int8u(a_)) {}
|
||||
};
|
||||
|
||||
// Pixer format to store coverage information.
|
||||
class pixfmt_alpha8
|
||||
{
|
||||
public:
|
||||
typedef alpha8 color_type;
|
||||
typedef int8u value_type;
|
||||
typedef int32u calc_type;
|
||||
typedef typename agg::rendering_buffer::row_data row_data;
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
pixfmt_alpha8(rendering_buffer& rb): m_rbuf(&rb)
|
||||
{
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
unsigned width() const {
|
||||
return m_rbuf->width();
|
||||
}
|
||||
unsigned height() const {
|
||||
return m_rbuf->height();
|
||||
}
|
||||
|
||||
// This method should never be called when using the scanline_u8.
|
||||
// The use of scanline_p8 should be avoided because if does not works
|
||||
// properly for rendering fonts because single hspan are split in many
|
||||
// hline/hspan elements and pixel whitening happens.
|
||||
void blend_hline(int x, int y, unsigned len,
|
||||
const color_type& c, int8u cover)
|
||||
{ }
|
||||
|
||||
void copy_hline(int x, int y, unsigned len, const color_type& c)
|
||||
{
|
||||
value_type* p = (value_type*) m_rbuf->row_ptr(y) + x;
|
||||
do
|
||||
{
|
||||
*p = c.a;
|
||||
p++;
|
||||
}
|
||||
while(--len);
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
void blend_solid_hspan(int x, int y,
|
||||
unsigned len,
|
||||
const color_type& c,
|
||||
const int8u* covers)
|
||||
{
|
||||
value_type* p = (value_type*) m_rbuf->row_ptr(y) + x;
|
||||
do
|
||||
{
|
||||
calc_type alpha = (calc_type(c.a) * (calc_type(*covers) + 1)) >> 8;
|
||||
*p = alpha;
|
||||
p++;
|
||||
++covers;
|
||||
}
|
||||
while(--len);
|
||||
}
|
||||
|
||||
private:
|
||||
rendering_buffer* m_rbuf;
|
||||
};
|
||||
|
||||
}
|
||||
@@ -0,0 +1,292 @@
|
||||
#include "font_renderer.h"
|
||||
|
||||
#include "agg_lcd_distribution_lut.h"
|
||||
#include "agg_pixfmt_rgb.h"
|
||||
#include "agg_pixfmt_rgba.h"
|
||||
#include "agg_gamma_lut.h"
|
||||
|
||||
#include "font_renderer_alpha.h"
|
||||
|
||||
typedef agg::blender_rgb_gamma<agg::rgba8, agg::order_bgra, agg::gamma_lut<> > blender_gamma_type;
|
||||
|
||||
class FontRendererImpl {
|
||||
public:
|
||||
// Conventional LUT values: (1./3., 2./9., 1./9.)
|
||||
// The values below are fine tuned as in the Elementary Plot library.
|
||||
|
||||
FontRendererImpl(bool hinting, bool kerning, float gamma_value) :
|
||||
m_renderer(hinting, kerning),
|
||||
m_gamma_lut(double(gamma_value)),
|
||||
m_blender(),
|
||||
m_lcd_lut(0.448, 0.184, 0.092)
|
||||
{
|
||||
m_blender.gamma(m_gamma_lut);
|
||||
}
|
||||
|
||||
font_renderer_alpha& renderer_alpha() { return m_renderer; }
|
||||
blender_gamma_type& blender() { return m_blender; }
|
||||
agg::gamma_lut<>& gamma() { return m_gamma_lut; }
|
||||
agg::lcd_distribution_lut& lcd_distribution_lut() { return m_lcd_lut; }
|
||||
|
||||
private:
|
||||
font_renderer_alpha m_renderer;
|
||||
agg::gamma_lut<> m_gamma_lut;
|
||||
blender_gamma_type m_blender;
|
||||
agg::lcd_distribution_lut m_lcd_lut;
|
||||
};
|
||||
|
||||
FontRenderer *FontRendererNew(unsigned int flags, float gamma) {
|
||||
bool hinting = ((flags & FONT_RENDERER_HINTING) != 0);
|
||||
bool kerning = ((flags & FONT_RENDERER_KERNING) != 0);
|
||||
return new FontRendererImpl(hinting, kerning, gamma);
|
||||
}
|
||||
|
||||
void FontRendererFree(FontRenderer *font_renderer) {
|
||||
delete font_renderer;
|
||||
}
|
||||
|
||||
int FontRendererLoadFont(FontRenderer *font_renderer, const char *filename) {
|
||||
bool success = font_renderer->renderer_alpha().load_font(filename);
|
||||
return (success ? 0 : 1);
|
||||
}
|
||||
|
||||
int FontRendererGetFontHeight(FontRenderer *font_renderer, float size) {
|
||||
font_renderer_alpha& renderer_alpha = font_renderer->renderer_alpha();
|
||||
double ascender, descender;
|
||||
renderer_alpha.get_font_vmetrics(ascender, descender);
|
||||
int face_height = renderer_alpha.get_face_height();
|
||||
float scale = renderer_alpha.scale_for_em_to_pixels(size);
|
||||
return int((ascender - descender) * face_height * scale + 0.5);
|
||||
}
|
||||
|
||||
static void glyph_trim_rect(agg::rendering_buffer& ren_buf, GlyphBitmapInfo *gli, int subpixel_scale) {
|
||||
const int height = ren_buf.height();
|
||||
int x0 = gli->x0 * subpixel_scale, x1 = gli->x1 * subpixel_scale;
|
||||
int y0 = gli->y0, y1 = gli->y1;
|
||||
for (int y = gli->y0; y < gli->y1; y++) {
|
||||
uint8_t *row = ren_buf.row_ptr(height - 1 - y);
|
||||
unsigned int row_bitsum = 0;
|
||||
for (int x = x0; x < x1; x++) {
|
||||
row_bitsum |= row[x];
|
||||
}
|
||||
if (row_bitsum == 0) {
|
||||
y0++;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
for (int y = gli->y1 - 1; y >= y0; y--) {
|
||||
uint8_t *row = ren_buf.row_ptr(height - 1 - y);
|
||||
unsigned int row_bitsum = 0;
|
||||
for (int x = x0; x < x1; x++) {
|
||||
row_bitsum |= row[x];
|
||||
}
|
||||
if (row_bitsum == 0) {
|
||||
y1--;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
for (int x = gli->x0 * subpixel_scale; x < gli->x1 * subpixel_scale; x += subpixel_scale) {
|
||||
unsigned int xaccu = 0;
|
||||
for (int y = y0; y < y1; y++) {
|
||||
uint8_t *row = ren_buf.row_ptr(height - 1 - y);
|
||||
for (int i = 0; i < subpixel_scale; i++) {
|
||||
xaccu |= row[x + i];
|
||||
}
|
||||
}
|
||||
if (xaccu == 0) {
|
||||
x0 += subpixel_scale;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
for (int x = (gli->x1 - 1) * subpixel_scale; x >= x0; x -= subpixel_scale) {
|
||||
unsigned int xaccu = 0;
|
||||
for (int y = y0; y < y1; y++) {
|
||||
uint8_t *row = ren_buf.row_ptr(height - 1 - y);
|
||||
for (int i = 0; i < subpixel_scale; i++) {
|
||||
xaccu |= row[x + i];
|
||||
}
|
||||
}
|
||||
if (xaccu == 0) {
|
||||
x1 -= subpixel_scale;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
gli->xoff += (x0 / subpixel_scale) - gli->x0;
|
||||
gli->yoff += (y0 - gli->y0);
|
||||
gli->x0 = x0 / subpixel_scale;
|
||||
gli->y0 = y0;
|
||||
gli->x1 = x1 / subpixel_scale;
|
||||
gli->y1 = y1;
|
||||
}
|
||||
|
||||
static int ceil_to_multiple(int n, int p) {
|
||||
return p * ((n + p - 1) / p);
|
||||
}
|
||||
|
||||
int FontRendererBakeFontBitmap(FontRenderer *font_renderer, int font_height,
|
||||
void *pixels, int pixels_width, int pixels_height,
|
||||
int first_char, int num_chars, GlyphBitmapInfo *glyphs, int subpixel_scale)
|
||||
{
|
||||
font_renderer_alpha& renderer_alpha = font_renderer->renderer_alpha();
|
||||
|
||||
const int pixel_size = 1;
|
||||
memset(pixels, 0x00, pixels_width * pixels_height * subpixel_scale * pixel_size);
|
||||
|
||||
double ascender, descender;
|
||||
renderer_alpha.get_font_vmetrics(ascender, descender);
|
||||
|
||||
const int ascender_px = int(ascender * font_height + 0.5);
|
||||
const int descender_px = int(descender * font_height + 0.5);
|
||||
|
||||
const int pad_y = font_height / 10;
|
||||
const int y_step = font_height + 2 * pad_y;
|
||||
|
||||
agg::rendering_buffer ren_buf((agg::int8u *) pixels, pixels_width * subpixel_scale, pixels_height, -pixels_width * subpixel_scale * pixel_size);
|
||||
// When using subpixel font rendering it is needed to leave a padding pixel on the left and on the right.
|
||||
// Since each pixel is composed by n subpixel we set below x_start to subpixel_scale instead than zero.
|
||||
const int x_start = subpixel_scale;
|
||||
int x = x_start, y = pixels_height;
|
||||
int res = 0;
|
||||
const agg::alpha8 text_color(0xff);
|
||||
#ifdef FONT_RENDERER_HEIGHT_HACK
|
||||
const int font_height_reduced = (font_height * 86) / 100;
|
||||
#else
|
||||
const int font_height_reduced = font_height;
|
||||
#endif
|
||||
for (int i = 0; i < num_chars; i++) {
|
||||
int codepoint = first_char + i;
|
||||
if (x + font_height * subpixel_scale > pixels_width * subpixel_scale) {
|
||||
x = x_start;
|
||||
y -= y_step;
|
||||
}
|
||||
if (y - font_height - 2 * pad_y < 0) {
|
||||
res = -1;
|
||||
break;
|
||||
}
|
||||
const int y_baseline = y - pad_y - font_height;
|
||||
|
||||
double x_next = x, y_next = y_baseline;
|
||||
renderer_alpha.render_codepoint(ren_buf, font_height_reduced, text_color, x_next, y_next, codepoint, subpixel_scale);
|
||||
int x_next_i = (subpixel_scale == 1 ? int(x_next + 1.0) : ceil_to_multiple(x_next + 0.5, subpixel_scale));
|
||||
|
||||
GlyphBitmapInfo& glyph_info = glyphs[i];
|
||||
glyph_info.x0 = x / subpixel_scale;
|
||||
glyph_info.y0 = pixels_height - (y_baseline + ascender_px + pad_y);
|
||||
glyph_info.x1 = x_next_i / subpixel_scale;
|
||||
glyph_info.y1 = pixels_height - (y_baseline + descender_px - pad_y);
|
||||
|
||||
glyph_info.xoff = 0;
|
||||
glyph_info.yoff = -pad_y;
|
||||
glyph_info.xadvance = (x_next - x) / subpixel_scale;
|
||||
|
||||
glyph_trim_rect(ren_buf, &glyph_info, subpixel_scale);
|
||||
|
||||
x = x_next_i;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
void blend_solid_hspan(agg::rendering_buffer& rbuf, blender_gamma_type& blender,
|
||||
int x, int y, unsigned len,
|
||||
const agg::rgba8& c, const agg::int8u* covers)
|
||||
{
|
||||
typedef typename blender_gamma_type::color_type color_type;
|
||||
typedef typename blender_gamma_type::order_type order_type;
|
||||
typedef typename color_type::value_type value_type;
|
||||
typedef typename color_type::calc_type calc_type;
|
||||
|
||||
if (c.a)
|
||||
{
|
||||
value_type* p = (value_type*)rbuf.row_ptr(x, y, len) + (x << 2);
|
||||
do
|
||||
{
|
||||
calc_type alpha = (calc_type(c.a) * (calc_type(*covers) + 1)) >> 8;
|
||||
if(alpha == color_type::base_mask)
|
||||
{
|
||||
p[order_type::R] = c.r;
|
||||
p[order_type::G] = c.g;
|
||||
p[order_type::B] = c.b;
|
||||
}
|
||||
else
|
||||
{
|
||||
blender.blend_pix(p, c.r, c.g, c.b, alpha, *covers);
|
||||
}
|
||||
p += 4;
|
||||
++covers;
|
||||
}
|
||||
while(--len);
|
||||
}
|
||||
}
|
||||
|
||||
static int floor_div(int a, int b) {
|
||||
int rem = a % b;
|
||||
if (rem < 0) {
|
||||
rem += b;
|
||||
}
|
||||
return (a - rem) / b;
|
||||
}
|
||||
|
||||
void blend_solid_hspan_rgb_subpixel(agg::rendering_buffer& rbuf, agg::gamma_lut<>& gamma, agg::lcd_distribution_lut& lcd_lut,
|
||||
int x_lcd, int y, unsigned len,
|
||||
const agg::rgba8& c,
|
||||
const agg::int8u* covers)
|
||||
{
|
||||
// cx being negative here and cx_max greater than 'len' means we will
|
||||
// adress the 'covers' array beyond its formal limits here [0, len-1] by -subpixel_scale on the
|
||||
// left and +subpixel_scale on the right.
|
||||
// We assume it is safe to do so because the data are coming from FontRendererBakeFontBitmap
|
||||
// and this latter function leaves three padding pixels on the left and on the right of the buffer.
|
||||
int cx = -2;
|
||||
int cx_max = len + 1;
|
||||
|
||||
const int x_min = floor_div(x_lcd + cx, 3);
|
||||
const int x_max = floor_div(x_lcd + cx_max, 3);
|
||||
|
||||
const int pixel_size = 4;
|
||||
const agg::int8u rgb[3] = { c.r, c.g, c.b };
|
||||
agg::int8u* p = rbuf.row_ptr(y) + x_min * pixel_size;
|
||||
|
||||
// Indexes to adress RGB colors in a BGRA32 format.
|
||||
const int pixel_index[3] = {2, 1, 0};
|
||||
for (int x = x_min; x <= x_max; x++)
|
||||
{
|
||||
for (int i = 0; i < 3; i++) {
|
||||
int new_cx = x * 3 - x_lcd + i;
|
||||
unsigned c_conv = lcd_lut.convolution(covers, new_cx, 0, len - 1);
|
||||
unsigned alpha = (c_conv + 1) * (c.a + 1);
|
||||
unsigned dst_col = gamma.dir(rgb[i]);
|
||||
unsigned src_col = gamma.dir(*(p + pixel_index[i]));
|
||||
*(p + pixel_index[i]) = gamma.inv((((dst_col - src_col) * alpha) + (src_col << 16)) >> 16);
|
||||
}
|
||||
// Leave p[3], the alpha channel value unmodified.
|
||||
p += 4;
|
||||
}
|
||||
}
|
||||
|
||||
// destination implicitly BGRA32. Source implictly single-byte renderer_alpha coverage.
|
||||
void FontRendererBlendGamma(FontRenderer *font_renderer, uint8_t *dst, int dst_stride, uint8_t *src, int src_stride, int region_width, int region_height, FontRendererColor color) {
|
||||
blender_gamma_type& blender = font_renderer->blender();
|
||||
agg::rendering_buffer dst_ren_buf(dst, region_width, region_height, dst_stride);
|
||||
const agg::rgba8 color_a(color.r, color.g, color.b);
|
||||
for (int x = 0, y = 0; y < region_height; y++) {
|
||||
agg::int8u *covers = src + y * src_stride;
|
||||
blend_solid_hspan(dst_ren_buf, blender, x, y, region_width, color_a, covers);
|
||||
}
|
||||
}
|
||||
|
||||
// destination implicitly BGRA32. Source implictly single-byte renderer_alpha coverage with subpixel scale = 3.
|
||||
void FontRendererBlendGammaSubpixel(FontRenderer *font_renderer, uint8_t *dst, int dst_stride, uint8_t *src, int src_stride, int region_width, int region_height, FontRendererColor color) {
|
||||
const int subpixel_scale = 3;
|
||||
agg::gamma_lut<>& gamma = font_renderer->gamma();
|
||||
agg::lcd_distribution_lut& lcd_lut = font_renderer->lcd_distribution_lut();
|
||||
agg::rendering_buffer dst_ren_buf(dst, region_width, region_height, dst_stride);
|
||||
const agg::rgba8 color_a(color.r, color.g, color.b);
|
||||
for (int x = 0, y = 0; y < region_height; y++) {
|
||||
agg::int8u *covers = src + y * src_stride;
|
||||
blend_solid_hspan_rgb_subpixel(dst_ren_buf, gamma, lcd_lut, x, y, region_width * subpixel_scale, color_a, covers);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
#ifndef FONT_RENDERER_H
|
||||
#define FONT_RENDERER_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// Mirrors stbtt_bakedchar.
|
||||
typedef struct {
|
||||
unsigned short x0, y0, x1, y1;
|
||||
float xoff, yoff, xadvance;
|
||||
} GlyphBitmapInfo;
|
||||
|
||||
struct FontRendererImpl;
|
||||
typedef struct FontRendererImpl FontRenderer;
|
||||
|
||||
enum {
|
||||
FONT_RENDERER_HINTING = 1 << 0,
|
||||
FONT_RENDERER_KERNING = 1 << 1,
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
uint8_t r, g, b;
|
||||
} FontRendererColor;
|
||||
|
||||
FontRenderer * FontRendererNew(unsigned int flags, float gamma);
|
||||
|
||||
void FontRendererFree(FontRenderer *);
|
||||
|
||||
int FontRendererLoadFont(FontRenderer *, const char *filename);
|
||||
|
||||
int FontRendererGetFontHeight(FontRenderer *, float size);
|
||||
|
||||
int FontRendererBakeFontBitmap(FontRenderer *, int font_height,
|
||||
void *pixels, int pixels_width, int pixels_height,
|
||||
int first_char, int num_chars, GlyphBitmapInfo *glyph_info,
|
||||
int subpixel_scale);
|
||||
|
||||
void FontRendererBlendGamma(FontRenderer *,
|
||||
uint8_t *dst, int dst_stride,
|
||||
uint8_t *src, int src_stride,
|
||||
int region_width, int region_height,
|
||||
FontRendererColor color);
|
||||
|
||||
void FontRendererBlendGammaSubpixel(FontRenderer *,
|
||||
uint8_t *dst, int dst_stride,
|
||||
uint8_t *src, int src_stride,
|
||||
int region_width, int region_height,
|
||||
FontRendererColor color);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,146 @@
|
||||
#pragma once
|
||||
|
||||
#include "agg_basics.h"
|
||||
#include "agg_conv_curve.h"
|
||||
#include "agg_conv_transform.h"
|
||||
#include "agg_gamma_lut.h"
|
||||
#include "agg_font_freetype.h"
|
||||
#include "agg_pixfmt_alpha8.h"
|
||||
#include "agg_rasterizer_scanline_aa.h"
|
||||
#include "agg_renderer_primitives.h"
|
||||
#include "agg_renderer_scanline.h"
|
||||
#include "agg_rendering_buffer.h"
|
||||
#include "agg_scanline_u.h"
|
||||
|
||||
class font_renderer_alpha
|
||||
{
|
||||
typedef agg::pixfmt_alpha8 pixfmt_type;
|
||||
typedef agg::renderer_base<pixfmt_type> base_ren_type;
|
||||
typedef agg::renderer_scanline_aa_solid<base_ren_type> renderer_solid;
|
||||
typedef agg::font_engine_freetype_int32 font_engine_type;
|
||||
typedef agg::font_cache_manager<font_engine_type> font_manager_type;
|
||||
|
||||
font_engine_type m_feng;
|
||||
font_manager_type m_fman;
|
||||
|
||||
// Font rendering options.
|
||||
bool m_hinting;
|
||||
bool m_kerning;
|
||||
|
||||
bool m_font_loaded;
|
||||
|
||||
// Pipeline to process the vectors glyph paths (curves + contour)
|
||||
agg::trans_affine m_mtx;
|
||||
agg::conv_curve<font_manager_type::path_adaptor_type> m_curves;
|
||||
agg::conv_transform<agg::conv_curve<font_manager_type::path_adaptor_type> > m_trans;
|
||||
public:
|
||||
typedef agg::pixfmt_alpha8::color_type color_type;
|
||||
|
||||
font_renderer_alpha(bool hinting, bool kerning):
|
||||
m_feng(),
|
||||
m_fman(m_feng),
|
||||
m_hinting(hinting),
|
||||
m_kerning(kerning),
|
||||
m_font_loaded(false),
|
||||
m_curves(m_fman.path_adaptor()),
|
||||
m_trans(m_curves, m_mtx)
|
||||
{ }
|
||||
|
||||
int get_face_height() const {
|
||||
return m_feng.face_height();
|
||||
}
|
||||
|
||||
bool get_font_vmetrics(double& ascender, double& descender) {
|
||||
int face_height = m_feng.face_height();
|
||||
if (face_height > 0) {
|
||||
double current_height = m_feng.height();
|
||||
m_feng.height(1.0);
|
||||
ascender = m_feng.ascender();
|
||||
descender = m_feng.descender();
|
||||
m_feng.height(current_height);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
float scale_for_em_to_pixels(float size) {
|
||||
int units_per_em = m_feng.face_units_em();
|
||||
if (units_per_em > 0) {
|
||||
return size / units_per_em;
|
||||
}
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
bool load_font(const char *font_filename) {
|
||||
if(m_feng.load_font(font_filename, 0, agg::glyph_ren_outline)) {
|
||||
m_font_loaded = true;
|
||||
}
|
||||
return m_font_loaded;
|
||||
}
|
||||
|
||||
template<class Rasterizer, class Scanline, class RenSolid>
|
||||
void draw_codepoint(Rasterizer& ras, Scanline& sl,
|
||||
RenSolid& ren_solid, const color_type color,
|
||||
int codepoint, double& x, double& y, double height, int subpixel_scale)
|
||||
{
|
||||
const double scale_x = 100;
|
||||
|
||||
m_feng.height(height);
|
||||
m_feng.width(height * scale_x * subpixel_scale);
|
||||
m_feng.hinting(m_hinting);
|
||||
|
||||
// Represent the delta in x scaled by scale_x.
|
||||
double x_delta = 0;
|
||||
double start_x = x;
|
||||
|
||||
const agg::glyph_cache* glyph = m_fman.glyph(codepoint);
|
||||
if(glyph)
|
||||
{
|
||||
if(m_kerning)
|
||||
{
|
||||
m_fman.add_kerning(&x_delta, &y);
|
||||
}
|
||||
|
||||
m_fman.init_embedded_adaptors(glyph, 0, 0);
|
||||
if(glyph->data_type == agg::glyph_data_outline)
|
||||
{
|
||||
double ty = m_hinting ? floor(y + 0.5) : y;
|
||||
ras.reset();
|
||||
m_mtx.reset();
|
||||
m_mtx *= agg::trans_affine_scaling(1.0 / scale_x, 1);
|
||||
m_mtx *= agg::trans_affine_translation(start_x + x_delta / scale_x, ty);
|
||||
ras.add_path(m_trans);
|
||||
ren_solid.color(color);
|
||||
agg::render_scanlines(ras, sl, ren_solid);
|
||||
}
|
||||
|
||||
y += glyph->advance_y;
|
||||
x += (x_delta + glyph->advance_x) / scale_x;
|
||||
}
|
||||
}
|
||||
|
||||
void clear(agg::rendering_buffer& ren_buf, const color_type color) {
|
||||
pixfmt_type pf(ren_buf);
|
||||
base_ren_type ren_base(pf);
|
||||
ren_base.clear(color);
|
||||
}
|
||||
|
||||
void render_codepoint(agg::rendering_buffer& ren_buf,
|
||||
const double text_size,
|
||||
const color_type text_color,
|
||||
double& x, double& y,
|
||||
int codepoint, int subpixel_scale)
|
||||
{
|
||||
if (!m_font_loaded) {
|
||||
return;
|
||||
}
|
||||
agg::scanline_u8 sl;
|
||||
agg::rasterizer_scanline_aa<> ras;
|
||||
ras.clip_box(0, 0, ren_buf.width(), ren_buf.height());
|
||||
|
||||
agg::pixfmt_alpha8 pf(ren_buf);
|
||||
base_ren_type ren_base(pf);
|
||||
renderer_solid ren_solid(ren_base);
|
||||
draw_codepoint(ras, sl, ren_solid, text_color, codepoint, x, y, text_size, subpixel_scale);
|
||||
}
|
||||
};
|
||||
@@ -0,0 +1,18 @@
|
||||
libagg_dep = dependency('libagg')
|
||||
freetype_dep = dependency('freetype2')
|
||||
|
||||
font_renderer_sources = [
|
||||
'agg_font_freetype.cpp',
|
||||
'font_renderer.cpp',
|
||||
]
|
||||
|
||||
font_renderer_cdefs = ['-DFONT_RENDERER_HEIGHT_HACK']
|
||||
|
||||
font_renderer_include = include_directories('.')
|
||||
|
||||
libfontrenderer = static_library('fontrenderer',
|
||||
font_renderer_sources,
|
||||
dependencies: [libagg_dep, freetype_dep],
|
||||
cpp_args: font_renderer_cdefs,
|
||||
)
|
||||
|
||||
Reference in New Issue
Block a user