Remove unused code files
This commit is contained in:
Francesco Abbate
parent
a2a4668887
commit
ac36cfc59c
|
|
@ -1,256 +0,0 @@
|
|||
//----------------------------------------------------------------------------
|
||||
// Anti-Grain Geometry (AGG) - Version 2.5
|
||||
// A high quality rendering engine for C++
|
||||
// Copyright (C) 2002-2006 Maxim Shemanarev
|
||||
// Contact: mcseem@antigrain.com
|
||||
// mcseemagg@yahoo.com
|
||||
// http://antigrain.com
|
||||
//
|
||||
// AGG is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License
|
||||
// as published by the Free Software Foundation; either version 2
|
||||
// of the License, or (at your option) any later version.
|
||||
//
|
||||
// AGG 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 General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with AGG; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
||||
// MA 02110-1301, USA.
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
#ifndef AGG_PIXFMT_BGRA32_LCD_INCLUDED
|
||||
#define AGG_PIXFMT_BGRA32_LCD_INCLUDED
|
||||
|
||||
#include <string.h>
|
||||
#include "agg_basics.h"
|
||||
#include "agg_color_rgba.h"
|
||||
#include "agg_rendering_buffer.h"
|
||||
|
||||
static int floor_div(int a, int b) {
|
||||
int rem = a % b;
|
||||
if (rem < 0) {
|
||||
rem += b;
|
||||
}
|
||||
return (a - rem) / b;
|
||||
}
|
||||
|
||||
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];
|
||||
};
|
||||
|
||||
//========================================================pixfmt_bgra32_lcd
|
||||
class pixfmt_bgra32_lcd
|
||||
{
|
||||
public:
|
||||
typedef rgba8 color_type;
|
||||
typedef rendering_buffer::row_data row_data;
|
||||
typedef color_type::value_type value_type;
|
||||
typedef color_type::calc_type calc_type;
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
pixfmt_bgra32_lcd(rendering_buffer& rb, const lcd_distribution_lut& lut)
|
||||
: m_rbuf(&rb), m_lut(&lut)
|
||||
{
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
unsigned width() const {
|
||||
return m_rbuf->width() * 3;
|
||||
}
|
||||
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)
|
||||
{
|
||||
int8u* p = m_rbuf->row_ptr(y) + (x / 3) * 4;
|
||||
for (int ilen = len; ilen > 0; p += 4, ilen -= 3)
|
||||
{
|
||||
p[0] = c.b;
|
||||
p[1] = c.g;
|
||||
p[2] = c.r;
|
||||
p[3] = 0xff;
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
void blend_solid_hspan(int x_lcd, int y,
|
||||
unsigned len,
|
||||
const color_type& c,
|
||||
const int8u* covers)
|
||||
{
|
||||
const int pixel_size = 4;
|
||||
unsigned rowlen = width();
|
||||
int cx = (x_lcd - 2 >= 0 ? -2 : -x_lcd);
|
||||
int cx_max = (len + 2 <= rowlen ? len + 1 : rowlen - 1);
|
||||
|
||||
const int x_min = floor_div(x_lcd + cx, 3);
|
||||
const int x_max = floor_div(x_lcd + cx_max, 3);
|
||||
|
||||
const int8u rgb[3] = { c.r, c.g, c.b };
|
||||
int8u* p = m_rbuf->row_ptr(y) + x_min * pixel_size;
|
||||
|
||||
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 = m_lut->convolution(covers, new_cx, 0, len - 1);
|
||||
unsigned alpha = (c_conv + 1) * (c.a + 1);
|
||||
unsigned dst_col = rgb[i];
|
||||
unsigned src_col = *(p + pixel_index[i]);
|
||||
*(p + pixel_index[i]) = (int8u)((((dst_col - src_col) * alpha) + (src_col << 16)) >> 16);
|
||||
}
|
||||
p[3] = 0xff;
|
||||
p += 4;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
rendering_buffer* m_rbuf;
|
||||
const lcd_distribution_lut* m_lut;
|
||||
};
|
||||
|
||||
template <class Gamma>
|
||||
class pixfmt_bgra32_lcd_gamma
|
||||
{
|
||||
public:
|
||||
typedef rgba8 color_type;
|
||||
typedef rendering_buffer::row_data row_data;
|
||||
typedef color_type::value_type value_type;
|
||||
typedef color_type::calc_type calc_type;
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
pixfmt_bgra32_lcd_gamma(rendering_buffer& rb, const lcd_distribution_lut& lut, const Gamma& gamma)
|
||||
: m_rbuf(&rb), m_lut(&lut), m_gamma(gamma)
|
||||
{
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
unsigned width() const {
|
||||
return m_rbuf->width() * 3;
|
||||
}
|
||||
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)
|
||||
{
|
||||
int8u* p = m_rbuf->row_ptr(y) + (x / 3) * 4;
|
||||
for (int ilen = len; ilen > 0; p += 4, ilen -= 3)
|
||||
{
|
||||
p[0] = c.b;
|
||||
p[1] = c.g;
|
||||
p[2] = c.r;
|
||||
p[3] = 0xff;
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
void blend_solid_hspan(int x_lcd, int y,
|
||||
unsigned len,
|
||||
const color_type& c,
|
||||
const int8u* covers)
|
||||
{
|
||||
const int pixel_size = 4;
|
||||
unsigned rowlen = width();
|
||||
int cx = (x_lcd - 2 >= 0 ? -2 : -x_lcd);
|
||||
int cx_max = (len + 2 <= rowlen ? len + 1 : rowlen - 1);
|
||||
|
||||
const int x_min = floor_div(x_lcd + cx, 3);
|
||||
const int x_max = floor_div(x_lcd + cx_max, 3);
|
||||
|
||||
const int8u rgb[3] = { c.r, c.g, c.b };
|
||||
int8u* p = m_rbuf->row_ptr(y) + x_min * pixel_size;
|
||||
|
||||
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 = m_lut->convolution(covers, new_cx, 0, len - 1);
|
||||
unsigned alpha = (c_conv + 1) * (c.a + 1);
|
||||
unsigned dst_col = m_gamma.dir(rgb[i]);
|
||||
unsigned src_col = m_gamma.dir(*(p + pixel_index[i]));
|
||||
*(p + pixel_index[i]) = m_gamma.inv((((dst_col - src_col) * alpha) + (src_col << 16)) >> 16);
|
||||
}
|
||||
p[3] = 0xff;
|
||||
p += 4;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
rendering_buffer* m_rbuf;
|
||||
const lcd_distribution_lut* m_lut;
|
||||
const Gamma& m_gamma;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -1,238 +0,0 @@
|
|||
//----------------------------------------------------------------------------
|
||||
// Anti-Grain Geometry (AGG) - Version 2.5
|
||||
// A high quality rendering engine for C++
|
||||
// Copyright (C) 2002-2006 Maxim Shemanarev
|
||||
// Contact: mcseem@antigrain.com
|
||||
// mcseemagg@yahoo.com
|
||||
// http://antigrain.com
|
||||
//
|
||||
// AGG is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License
|
||||
// as published by the Free Software Foundation; either version 2
|
||||
// of the License, or (at your option) any later version.
|
||||
//
|
||||
// AGG 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 General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with AGG; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
||||
// MA 02110-1301, USA.
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
#ifndef AGG_PIXFMT_RGB24_LCD_INCLUDED
|
||||
#define AGG_PIXFMT_RGB24_LCD_INCLUDED
|
||||
|
||||
#include <string.h>
|
||||
#include "agg_basics.h"
|
||||
#include "agg_color_rgba.h"
|
||||
#include "agg_rendering_buffer.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];
|
||||
};
|
||||
|
||||
|
||||
//========================================================pixfmt_rgb24_lcd
|
||||
class pixfmt_rgb24_lcd
|
||||
{
|
||||
public:
|
||||
typedef rgba8 color_type;
|
||||
typedef rendering_buffer::row_data row_data;
|
||||
typedef color_type::value_type value_type;
|
||||
typedef color_type::calc_type calc_type;
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
pixfmt_rgb24_lcd(rendering_buffer& rb, const lcd_distribution_lut& lut)
|
||||
: m_rbuf(&rb), m_lut(&lut)
|
||||
{
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
unsigned width() const {
|
||||
return m_rbuf->width() * 3;
|
||||
}
|
||||
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)
|
||||
{
|
||||
int xr = x - (x % 3);
|
||||
int8u* p = m_rbuf->row_ptr(y) + xr;
|
||||
for (int ilen = len; ilen > 0; p += 3, ilen -= 3)
|
||||
{
|
||||
p[0] = c.r;
|
||||
p[1] = c.g;
|
||||
p[2] = c.b;
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
void blend_solid_hspan(int x, int y,
|
||||
unsigned len,
|
||||
const color_type& c,
|
||||
const int8u* covers)
|
||||
{
|
||||
unsigned rowlen = width();
|
||||
int cx = (x - 2 >= 0 ? -2 : -x);
|
||||
int cx_max = (len + 2 <= rowlen ? len + 1 : rowlen - 1);
|
||||
|
||||
int i = (x + cx) % 3;
|
||||
|
||||
int8u rgb[3] = { c.r, c.g, c.b };
|
||||
int8u* p = m_rbuf->row_ptr(y) + (x + cx);
|
||||
|
||||
for (/* */; cx <= cx_max; cx++)
|
||||
{
|
||||
unsigned c_conv = m_lut->convolution(covers, cx, 0, len - 1);
|
||||
unsigned alpha = (c_conv + 1) * (c.a + 1);
|
||||
unsigned dst_col = rgb[i], src_col = (*p);
|
||||
*p = (int8u)((((dst_col - src_col) * alpha) + (src_col << 16)) >> 16);
|
||||
|
||||
p ++;
|
||||
i = (i + 1) % 3;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
rendering_buffer* m_rbuf;
|
||||
const lcd_distribution_lut* m_lut;
|
||||
};
|
||||
|
||||
|
||||
template <class Gamma>
|
||||
class pixfmt_rgb24_lcd_gamma
|
||||
{
|
||||
public:
|
||||
typedef rgba8 color_type;
|
||||
typedef rendering_buffer::row_data row_data;
|
||||
typedef color_type::value_type value_type;
|
||||
typedef color_type::calc_type calc_type;
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
pixfmt_rgb24_lcd_gamma(rendering_buffer& rb, const lcd_distribution_lut& lut, const Gamma& gamma)
|
||||
: m_rbuf(&rb), m_lut(&lut), m_gamma(gamma)
|
||||
{
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
unsigned width() const {
|
||||
return m_rbuf->width() * 3;
|
||||
}
|
||||
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)
|
||||
{
|
||||
int xr = x - (x % 3);
|
||||
int8u* p = m_rbuf->row_ptr(y) + xr;
|
||||
for (int ilen = len; ilen > 0; p += 3, ilen -= 3)
|
||||
{
|
||||
p[0] = c.r;
|
||||
p[1] = c.g;
|
||||
p[2] = c.b;
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
void blend_solid_hspan(int x, int y,
|
||||
unsigned len,
|
||||
const color_type& c,
|
||||
const int8u* covers)
|
||||
{
|
||||
unsigned rowlen = width();
|
||||
int cx = (x - 2 >= 0 ? -2 : -x);
|
||||
int cx_max = (len + 2 <= rowlen ? len + 1 : rowlen - 1);
|
||||
|
||||
int i = (x + cx) % 3;
|
||||
|
||||
int8u rgb[3] = { c.r, c.g, c.b };
|
||||
int8u* p = m_rbuf->row_ptr(y) + (x + cx);
|
||||
|
||||
for (/* */; cx <= cx_max; cx++)
|
||||
{
|
||||
unsigned c_conv = m_lut->convolution(covers, cx, 0, len - 1);
|
||||
unsigned alpha = (c_conv + 1) * (c.a + 1);
|
||||
unsigned dst_col = m_gamma.dir(rgb[i]), src_col = m_gamma.dir(*p);
|
||||
*p = m_gamma.inv((((dst_col - src_col) * alpha) + (src_col << 16)) >> 16);
|
||||
|
||||
p ++;
|
||||
i = (i + 1) % 3;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
rendering_buffer* m_rbuf;
|
||||
const lcd_distribution_lut* m_lut;
|
||||
const Gamma& m_gamma;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -1,187 +0,0 @@
|
|||
#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_rgb.h"
|
||||
#include "agg_pixfmt_rgba.h"
|
||||
// #include "agg_pixfmt_rgb24_lcd.h"
|
||||
#include "agg_pixfmt_bgra32_lcd.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"
|
||||
|
||||
// FIXME: the pixel type rgb24 of rgba32 is hard coded below
|
||||
class font_renderer_lcd
|
||||
{
|
||||
typedef agg::pixfmt_bgra32 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;
|
||||
agg::gamma_lut<> m_gamma_lut;
|
||||
|
||||
// Font rendering options.
|
||||
bool m_hinting;
|
||||
bool m_kerning;
|
||||
bool m_grayscale;
|
||||
double m_gamma;
|
||||
|
||||
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:
|
||||
font_renderer_lcd(bool hinting, bool kerning, bool subpixel, double gamma):
|
||||
m_feng(),
|
||||
m_fman(m_feng),
|
||||
m_hinting(hinting),
|
||||
m_kerning(kerning),
|
||||
m_grayscale(!subpixel),
|
||||
m_gamma(gamma),
|
||||
m_font_loaded(false),
|
||||
m_curves(m_fman.path_adaptor()),
|
||||
m_trans(m_curves, m_mtx)
|
||||
{
|
||||
m_gamma_lut.gamma(m_gamma);
|
||||
}
|
||||
|
||||
bool get_font_vmetrics(int& ascender, int& 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() * face_height;
|
||||
descender = m_feng.descender() * face_height;
|
||||
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_text(Rasterizer& ras, Scanline& sl,
|
||||
RenSolid& ren_solid, const agg::rgba8 color,
|
||||
const char* text,
|
||||
double& x, double& y, double height,
|
||||
unsigned subpixel_scale)
|
||||
{
|
||||
const double scale_x = 100;
|
||||
|
||||
m_feng.height(height);
|
||||
m_feng.width(height * scale_x * subpixel_scale);
|
||||
m_feng.hinting(m_hinting);
|
||||
|
||||
const char* p = text;
|
||||
|
||||
// Represent the delta in x scaled by subpixel and scale_x.
|
||||
double x_delta = 0;
|
||||
double start_x_lcd = x * subpixel_scale;
|
||||
|
||||
while(*p)
|
||||
{
|
||||
if(*p == '\n')
|
||||
{
|
||||
x_delta = 0;
|
||||
y -= height * 1.25;
|
||||
++p;
|
||||
continue;
|
||||
}
|
||||
|
||||
const agg::glyph_cache* glyph = m_fman.glyph(*p);
|
||||
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_lcd + x_delta / scale_x, ty);
|
||||
ras.add_path(m_trans);
|
||||
ren_solid.color(color);
|
||||
agg::render_scanlines(ras, sl, ren_solid);
|
||||
}
|
||||
|
||||
// increment pen position
|
||||
x_delta += glyph->advance_x;
|
||||
y += glyph->advance_y;
|
||||
}
|
||||
++p;
|
||||
}
|
||||
// Update x value befor returning.
|
||||
x += x_delta / (scale_x * subpixel_scale);
|
||||
}
|
||||
|
||||
void clear(agg::rendering_buffer& ren_buf, const agg::rgba8 color) {
|
||||
agg::pixfmt_bgra32 pf(ren_buf);
|
||||
base_ren_type ren_base(pf);
|
||||
ren_base.clear(color);
|
||||
}
|
||||
|
||||
void render_text(agg::rendering_buffer& ren_buf,
|
||||
const double text_size,
|
||||
const agg::rgba8 text_color,
|
||||
double& x, double& y,
|
||||
const char *text)
|
||||
{
|
||||
if (!m_font_loaded) {
|
||||
return;
|
||||
}
|
||||
|
||||
agg::scanline_u8 sl;
|
||||
agg::rasterizer_scanline_aa<> ras;
|
||||
ras.clip_box(0, 0, ren_buf.width()*3, ren_buf.height());
|
||||
|
||||
//--------------------------------------
|
||||
if(m_grayscale)
|
||||
{
|
||||
agg::pixfmt_bgra32 pf(ren_buf);
|
||||
base_ren_type ren_base(pf);
|
||||
renderer_solid ren_solid(ren_base);
|
||||
draw_text(ras, sl, ren_solid, text_color, text, x, y, text_size, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Conventional LUT values: (1./3., 2./9., 1./9.)
|
||||
// The values below are fine tuned as in the Elementary Plot library.
|
||||
// The primary weight should be 0.448 but is left adjustable.
|
||||
agg::lcd_distribution_lut lut(0.448, 0.184, 0.092);
|
||||
typedef agg::pixfmt_bgra32_lcd_gamma<agg::gamma_lut<> > pixfmt_lcd_type;
|
||||
pixfmt_lcd_type pf_lcd(ren_buf, lut, m_gamma_lut);
|
||||
agg::renderer_base<pixfmt_lcd_type> ren_base_lcd(pf_lcd);
|
||||
agg::renderer_scanline_aa_solid<agg::renderer_base<pixfmt_lcd_type> > ren_solid_lcd(ren_base_lcd);
|
||||
draw_text(ras, sl, ren_solid_lcd, text_color, text, x, y, text_size, 3);
|
||||
}
|
||||
}
|
||||
};
|
||||
Loading…
Reference in New Issue