// C RunTime Header Files
#include <cstdlib>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <climits>
#include <cassert>
// C++ Headers
#include <iostream>
#include <iomanip>
#include <fstream>
#include <vector>
#include <map>
// Project Headers
#include "Graphics.h"
#include "Common.h"
#include "MemoryMapping.h"
#include "Window.h"
#include "TrueType.h"
//#include "Font.h"
BEGIN_NAMESPACE
void LogMessage(LogLevel a_level, const char* a_utf8TextFmt, ...);
// Using Debug can be used for quickly adding debug output, and in release builds the calls to it shouldn't
// produce any code (if NDEBUG is defined which the ANSI C standard defines for disabling assert in release builds)
#ifdef NDEBUG
# define Debug(a_utf8TextFmt, ...) ((void)0)
#else
# define Debug(a_utf8TextFmt, ...) LogMessage(DEBUG, a_utf8TextFmt, __VA_ARGS__)
#endif
struct vec2i
{
int x, y;
template <typename T>
vec2i operator*=(T scale) {
x *= scale;
y *= scale;
return *this;
}
template <typename T>
vec2i operator*(T scale) {
vec2i ret;
ret.x = x * scale;
ret.y = y * scale;
return ret;
}
};
static uint32_t blendColors(uint32_t a_color1, uint32_t a_color2, uint8_t a_alpha)
{
unsigned alpha2 = 255 - a_alpha;
unsigned red = ((a_color1 >> 16) & 0xff) * a_alpha + ((a_color2 >> 16) & 0xff) * alpha2;
unsigned green = ((a_color1 >> 8) & 0xff) * a_alpha + ((a_color2 >> 8) & 0xff) * alpha2;
unsigned blue = ((a_color1 >> 0) & 0xff) * a_alpha + ((a_color2 >> 0) & 0xff) * alpha2;
unsigned alpha = ((a_color1 >> 24) & 0xff) * a_alpha + ((a_color2 >> 24) & 0xff) * alpha2;
// return 0xff000000 | ((red & 0xff00) << 8) | (green & 0xff00) | (blue >> 8);
return ((alpha & 0xff00) << 16) | ((red & 0xff00) << 8) | (green & 0xff00) | (blue >> 8);
}
static uint32_t blendColorsF(uint32_t a_color1, uint32_t a_color2, float a_alpha)
{
float alpha2 = 1.0f - a_alpha;
float red = float((a_color1 >> 16) & 0xff) * a_alpha + float((a_color2 >> 16) & 0xff) * alpha2;
float green = float((a_color1 >> 8) & 0xff) * a_alpha + float((a_color2 >> 8) & 0xff) * alpha2;
float blue = float((a_color1 >> 0) & 0xff) * a_alpha + float((a_color2 >> 0) & 0xff) * alpha2;
return 0xff000000 | ((int(red) & 0xff) << 16) | ((int(green) & 0xff) << 8) | (int(blue) & 0xff);
}
/*
Another approach is to have a ROP enum - Raster operation
This defines how for each pixel in a function, how it combines the src, dst and static color colors
This could be like the Porter-Duff ops.
Then this ROP value is passed as a template parameter, and the functions are all templated on this.
At the calling site, it picks the implementation based on the currently set ROP for the painter
*/
/*
// Clipping should be outside the loop
template <typename functor>
void ForEachPixel(PixelBuffer* a_target, uint32_t a_color, int a_x, int a_y, int a_width, int a_height)
{
for (int j = 0; j < a_height; j++)
for (int i = 0; i < a_width; i++)
{
int x = i + a_x;
int y = j + a_y;
if ( x >= 0 && x < a_target->m_width && y >= 0 && y < a_target->m_height ) {
uint32_t *dst = &(a_target->m_pixels[y*a_target->m_strideBytes/4 + x]);
functor.func(); // TODO: This needs parameters
}
}
}
*/
struct ClipRect
{
bool valid;
int x1, x2;
int y1, y2;
};
inline bool PixelClipTest(const ClipRect& clip, int x, int y)
{
return (x >= clip.x1 && x <= clip.x2 && y >= clip.y1 && y <= clip.y2);
}
inline ClipRect SetupClip(PixelBuffer* a_target, bool retina = true)//false)
{
if (!a_target || !a_target->m_pixels || a_target->m_width < 1 || a_target->m_height < 1)
{
printf("Invalid target\n");
//abort();
return { false, 1, 0, 1, 0 };;
}
if (retina)
{
int clipW = a_target->m_isRetina ? a_target->m_width / c_retinaScale : a_target->m_width;
int clipH = a_target->m_isRetina ? a_target->m_height / c_retinaScale : a_target->m_height;
return { true, 0, clipW - 1, 0, clipH - 1 };
}
int clipW = a_target->m_width;
int clipH = a_target->m_height;
return { true, 0, clipW - 1, 0, clipH - 1 };
}
void DrawRectangleAlpha(PixelBuffer* a_target, uint32_t a_color, int a_x, int a_y, int a_width, int a_height)
{
ClipRect clip = SetupClip(a_target); if (!clip.valid) return;
for (int j = 0; j < a_height; j++)
for (int i = 0; i < a_width; i++)
{
int x = i + a_x;
int y = j + a_y;
if (PixelClipTest(clip, x, y))
{
//if ( x >= 0 && x < a_target->m_width && y >= 0 && y < a_target->m_height ) {
uint32_t *dst = &(a_target->m_pixels[y*a_target->m_strideBytes/4 + x]);
*dst = blendColors(*dst, a_color, a_color >> 24);
}
}
}
void DrawRectangle(PixelBuffer* a_target, uint32_t a_color, int a_x, int a_y, int a_width, int a_height, bool a_setAlpha)
{
ClipRect clip = SetupClip(a_target, true); if (!clip.valid) return;
if (a_setAlpha)
a_color |= 0xFF000000;
for (int j = 0; j < a_height; j++)
for (int i = 0; i < a_width; i++)
{
int x = i + a_x;
int y = j + a_y;
if (PixelClipTest(clip, x, y))
{
//if ( x >= 0 && x < a_target->m_width && y >= 0 && y < a_target->m_height ) {
uint32_t *dst = &(a_target->m_pixels[y*a_target->m_strideBytes/4 + x]);
*dst = a_color;
}
}
}
// NOTE: This isn't highly optimized at the moment, could be made to be a lot more efficient
// such as clipping outside the loops, using shifts instead of divides, not needing to iterate over
// the entire area to draw the ellipse etc.
// It does draw the ellipse filled, not just the outline, but that could be done more efficiently by
// scanning from top to bottom and algerbraically calculate the first x pos for each scan line, then
// can do x2 = width - x1, then fill from x1 to x2
// Currently a_smoothEdge is not used
void DrawEllipse(PixelBuffer* a_target, uint32_t a_color, int a_x, int a_y, int a_width, int a_height, bool a_smoothEdge)
{
ClipRect clip = SetupClip(a_target); if (!clip.valid) return;
int alpha = (a_color >> 24) & 0xff;
if ( alpha == 0 )
return;
int centerX = a_width/2;
int centerY = a_height/2;
// TODO: convert to shifts instead of dividing by scale
int scale = 64; // This is to stop overflows with 32bit ints
if ( a_width < 256 && a_height < 256 )
scale = 1;
if ( alpha == 255 )
{
for (int j = 0; j < a_height; j++)
for (int i = 0; i < a_width; i++)
{
int x = i + a_x;
int y = j + a_y;
if (PixelClipTest(clip, x, y))
{
//if ( x >= 0 && x < a_target->m_width && y >= 0 && y < a_target->m_height ) {
uint32_t *dst = &(a_target->m_pixels[y*a_target->m_strideBytes/4 + x]);
int a = (i - centerX) * a_height / scale;
int b = (j - centerY) * a_width / scale;
int c1 = a_width * a_height / (2 * scale);
int c2 = (a_width-1) * (a_height-1) / (2 * scale);
//int c2 = ((a_width+1) * (a_height+1)) / (2 * scale);
int innerR = c1*c1;
int outerR = c2*c2;
int dist = a*a + b*b;
int diffR = outerR - innerR;
int distR = dist - innerR;
// FIXME: alpha variable aliases earlier alpha variable
int alpha = ((distR * 255) / diffR);
if ( dist < outerR )
*dst = a_color;
else if ( dist < innerR )
*dst = blendColors(a_color, *dst, alpha);
//a_antiAlias
}
}
} else {
for (int j = 0; j < a_height; j++)
for (int i = 0; i < a_width; i++)
{
int x = i + a_x;
int y = j + a_y;
if (PixelClipTest(clip, x, y))
{
//if ( x >= 0 && x < a_target->m_width && y >= 0 && y < a_target->m_height ) {
uint32_t *dst = &(a_target->m_pixels[y*a_target->m_strideBytes/4 + x]);
int a = (i - centerX) * a_height / scale;
int b = (j - centerY) * a_width / scale;
int c = a_width * a_height / (2 * scale);
if ( (a*a + b*b) < c*c )
*dst = (alpha<<24) | (blendColors(a_color, *dst, alpha) & 0xffffff);
}
}
}
}
void DrawGradient(PixelBuffer* a_target, const Gradient& a_gradient, int a_x, int a_y, int a_width, int a_height)
{
ClipRect clip = SetupClip(a_target); if (!clip.valid) return;
for ( int j = 0; j < a_height; j++ )
for ( int i = 0; i < a_width; i++ )
{
int x = i + a_x;
int y = j + a_y;
if (PixelClipTest(clip, x, y))
// if ( x >= 0 && x < a_target->m_width && y >= 0 && y < a_target->m_height )
{
float dist = 0.0;
if (a_gradient.m_type == RADIAL_GRADIENT)
{
int centerX = a_gradient.m_data.m_radial.m_centerX;
int centerY = a_gradient.m_data.m_radial.m_centerY;
//float errLUT[16] = { 1.1, -1.1, 2.2, -2.2, 3.3, -3.3, 4.4, -4.4, 5.5, -5.5, 6.6, -6.6, 7.7, -7.7, 8.8, -8.8 };
//int dist = (int)(errLUT[rand() % 4] + sqrt(float((centerX - i)*(centerX - i) + (centerY - j)*(centerY - j))) * 256 / a_gradient.m_data.m_radial.m_distance);
dist = sqrt(float((centerX - i)*(centerX - i) + (centerY - j)*(centerY - j))) / a_gradient.m_data.m_radial.m_distance;
/*
float distf = sqrt(float((centerX - i)*(centerX - i) + (centerY - j)*(centerY - j))) * 256 / a_gradient.m_data.m_radial.m_distance;
float frac = distf - floor(distf) - 0.51;
float frac2 = frac + 0.7;
float frac3 = float(j*8) / a_height + float(i-90) / a_width;
if ( frac < 0.1 && frac > -0.1 )
frac = ( frac < 0.0 ) ? -0.081 : 0.08;
int dist = (int)(float(frac * 64) - float(frac2 * frac3) + distf);
//dist += ;
*/
//dist = (dist > 255) ? 255 : ((dist < 0) ? 0 : dist);
}
else if (a_gradient.m_type == CONICAL_GRADIENT)
{
// TODO: implement me
}
else if (a_gradient.m_type == LINEAR_GRADIENT)
{
/*
m = dy / dx
y = mx + c;
c = y - mx;
m = (y - c) / x;
*/
// TODO:
int y1 = a_gradient.m_data.m_linear.m_y1;
int y2 = a_gradient.m_data.m_linear.m_y2;
if ( y <= y1 )
dist = 0;
else if ( y >= y2 )
dist = 1.0;
else {
dist = float(y2 - y) / (y2 - y1);
}
}
uint32_t *dst = &(a_target->m_pixels[y*a_target->m_strideBytes/4 + x]);
// TODO: this is where flags to do repeat or reflect etc of the gradient
// pattern should be added
dist = (dist > 1.0f) ? 1.0f : ((dist < 0.0f) ? 0.0f : dist);
#define ENABLE_GRADIENT_STOPS 1
#if ENABLE_GRADIENT_STOPS
// Apply gradient stops - perhaps there are more intelligent ways to do this
// that remember the last stop
for (int stop = 0; stop < (a_gradient.m_gradientStops.size() - 1); stop++)
{
float pos1 = a_gradient.m_gradientStops[stop + 0].m_position;
float pos2 = a_gradient.m_gradientStops[stop + 1].m_position;
if (dist >= pos1 && dist <= pos2)
{
dist = (dist - pos1) / (pos2 - pos1);
uint32_t col1 = a_gradient.m_gradientStops[stop + 0].m_color;
uint32_t col2 = a_gradient.m_gradientStops[stop + 1].m_color;
*dst = blendColorsF(col1, col2, dist);
break;
}
}
#else
*dst = blendColorsF(a_gradient.m_color1, a_gradient.m_color2, dist);
#endif
}
}
}
/*
void DrawLineFloat(PixelBuffer* a_target, uint32_t a_color, int a_x1, int a_y1, int a_x2, int a_y2)
{
float x = 0.0f;
float y = 0.0f;
float fdy = 1.0f;
float fdx = 1.0f;
int dx = a_x2 - a_x1;
int dy = a_y2 - a_y1;
int count = 1;
if ( !dy && !dx ) {
if ( a_x1 >= 0 && a_x1 < a_target->m_width && a_y1 >= 0 && a_y1 < a_target->m_height )
a_target->m_pixels[a_y1*a_target->m_strideBytes/4 + a_x1] = a_color;
return;
}
if ( dx*dx > dy*dy ) {
count = dx;
fdy = float(dy) / dx;
} else {
count = dy;
fdx = float(dx) / dy;
}
if ( count < 0 ) {
count = -count;
fdy = -fdy;
fdx = -fdx;
}
//count++;
// TODO: Using fixed-point would be faster to avoid float->int conversion
for (; count--; x+=fdx, y+=fdy)
{
int xi = int(a_x1 + x);
int yi = int(a_y1 + y);
if ( xi >= 0 && xi < a_target->m_width && yi >= 0 && yi < a_target->m_height )
a_target->m_pixels[yi*a_target->m_strideBytes/4 + xi] = a_color;
}
}
*/
void ClipLinePoint(int& a_x, int& a_y, int a_dx, int a_dy, const Rectangle& a_bounds)
{
float m1 = float(a_dy) / a_dx;
float m2 = float(a_dx) / a_dy;
int c1 = a_y - m1 * a_x;
int c2 = a_x - m2 * a_y;
int bx1 = a_bounds.m_x;
int by1 = a_bounds.m_y;
int bx2 = bx1 + a_bounds.m_width - 1;
int by2 = by1 + a_bounds.m_height - 1;
a_x = (a_x < bx1) ? bx1 : ((a_x > bx2) ? bx2 : a_x);
a_y = m1 * a_x + c1;
a_y = (a_y < by1) ? by1 : ((a_y > by2) ? by2 : a_y);
a_x = m2 * a_y + c2;
}
void DrawHLine(PixelBuffer* a_target, uint32_t a_color, int a_x1, int a_x2, int a_y, bool a_blend)
{
if (!a_target || a_y < 0)
return;
if (a_y >= a_target->m_height)
return;
if (!a_blend)
a_color |= 0xFF000000;
if (a_x1 > a_x2)
{
int tmp = a_x1;
a_x1 = a_x2;
a_x2 = tmp;
}
if (a_x1 < 0)
a_x1 = 0;
if (a_x2 < 0)
a_x2 = 0;
if (a_x1 >= a_target->m_width)
a_x1 = a_target->m_width - 1;
if (a_x2 >= a_target->m_width)
a_x2 = a_target->m_width - 1;
uint32_t *pix = &a_target->m_pixels[a_y*a_target->m_strideBytes/4 + a_x1];
int dx = a_x2 - a_x1 + 1;
for (int i = 0; i < dx; ++i)
{
*pix = a_color;
++pix;
}
}
void DrawLine(PixelBuffer* a_target, uint32_t a_color, int a_x1, int a_y1, int a_x2, int a_y2, bool a_blend)
{
ClipRect clip = SetupClip(a_target, true); if (!clip.valid) return;
int dx = a_x2 - a_x1;
int dy = a_y2 - a_y1;
if (!a_blend)
a_color |= 0xFF000000;
// Single pixel case
if ( !dy && !dx ) {
if (PixelClipTest(clip, a_x1, a_y1))
//if ( a_x1 >= 0 && a_x1 < clipW && a_y1 >= 0 && a_y1 < clipH )
a_target->m_pixels[a_y1*a_target->m_strideBytes/4 + a_x1] = a_color;
return;
}
// Work out gradients in 32:32 fixed point maths
const unsigned shiftCount = 32;
int count = 1;
int64_t x = int64_t(a_x1) << shiftCount;
int64_t y = int64_t(a_y1) << shiftCount;
int64_t fdy = 1LL << shiftCount;
int64_t fdx = 1LL << shiftCount;
if ( dx*dx > dy*dy ) {
count = dx;
fdy = (dy * fdy) / dx; // fdy = dy/dx and fdx = 1 (in fixed-point math)
} else {
count = dy;
fdx = (dx * fdx) / dy; // fdx = dx/dy and fdy = 1
}
if ( count < 0 ) {
count = -count;
fdy = -fdy;
fdx = -fdx;
}
// Why isn't it count++?
count++;
if (count > 0)
for (; count--; x += fdx, y += fdy)
{
int xi = x >> shiftCount;
int yi = y >> shiftCount;
if (PixelClipTest(clip, xi, yi))
//if ( xi >= 0 && xi < clipW && yi >= 0 && yi < clipH )
a_target->m_pixels[yi*a_target->m_strideBytes/4 + xi] = a_color;
}
}
void DrawLine__Old_But_With_Clipping_Attempt(PixelBuffer* a_target, uint32_t a_color, int a_x1, int a_y1, int a_x2, int a_y2, bool a_blend)
{
int dx = a_x2 - a_x1;
int dy = a_y2 - a_y1;
if (!a_blend)
a_color |= 0xFF000000;
if (!a_target) // || !a_target->m_pixels || a_x1 < 0 || a_y1 < 0 || a_x2 < 0 || a_y2 < 0)
return;
// line-clipping may be broken - getting crashes with it enabled
#define USE_LINE_CLIPPING 0
#if USE_LINE_CLIPPING
// Might be a more optimal line clipping method
// Figure out flags for the start and end points, and use those flags.
uint8_t clippingFlags = 0;
if ( a_x1 < 0 ) clippingFlags |= 1;
else if ( a_x1 >= a_target->m_width ) clippingFlags |= 2;
if ( a_y1 < 0 ) clippingFlags |= 4;
else if ( a_y1 >= a_target->m_height) clippingFlags |= 8;
if ( a_x2 < 0 ) clippingFlags |= 16;
else if ( a_x2 >= a_target->m_width ) clippingFlags |= 32;
if ( a_y2 < 0 ) clippingFlags |= 64;
else if ( a_y2 >= a_target->m_height) clippingFlags |= 128;
if ( clippingFlags ) {
// Trivial rejections
if ( (clippingFlags & 17) == 17 ) return; // off left 1 + 16
if ( (clippingFlags & 34) == 34 ) return; // off right 2 + 32
if ( (clippingFlags & 68) == 68 ) return; // off top 4 + 64
if ( (clippingFlags & 136) == 136 ) return; // off bottom 8 + 128
}
#endif
// TODO: get ClipLinePoint working, then enable using it and disable the verbose clipping code lower down
// Ideally the clipping can be applied to other functions in Graphics.cpp to reduce the bounds checking
// inside the loops
if (dx && dy)
{
/*
Rectangle rect = { { { 0, 0 } }, { { a_target->m_width, a_target->m_height } } };
ClipLinePoint(a_x1, a_y1, dx, dy, rect);
ClipLinePoint(a_x2, a_y2, dx, dy, rect);
*/
}
if ( !dy && !dx ) {
#if !USE_LINE_CLIPPING
if ( a_x1 >= 0 && a_x1 < a_target->m_width && a_y1 >= 0 && a_y1 < a_target->m_height )
#endif
a_target->m_pixels[a_y1*a_target->m_strideBytes/4 + a_x1] = a_color;
return;
}
const unsigned shiftCount = 32;
int count = 1;
int64_t x = int64_t(a_x1) << shiftCount;
int64_t y = int64_t(a_y1) << shiftCount;
int64_t fdy = 1LL << shiftCount;
int64_t fdx = 1LL << shiftCount;
if ( dx*dx > dy*dy ) {
count = dx;
fdy = (dy * fdy) / dx; // fdy is dydx & fdx is 1
} else {
count = dy;
fdx = (dx * fdx) / dy; // fdx is dxdy & fdy is 1
}
if ( count < 0 ) {
count = -count;
fdy = -fdy;
fdx = -fdx;
}
#if USE_LINE_CLIPPING
// Try to start iterating the line in bounds
int iterations = 0;
if ( x < 0 ) {
if ( fdx <= 0 ) {
return; // Line starts off-screen and is going wrong way
} else {
iterations = x / -fdx; // fdx can't be zero
}
}
if ( y < 0 ) {
if ( fdy <= 0 ) {
return; // Line starts off-screen and is going wrong way
} else {
iterations = std::max<int>(iterations, y / -fdy); // fdy can't be zero
}
}
if ( a_x1 >= a_target->m_width ) {
if ( fdx >= 0 ) {
return; // Line starts off-screen and is going wrong way
} else {
iterations = std::max<int>(iterations, (int64_t(a_x1 - (a_target->m_width-1))<<shiftCount) / -fdx); // fdx can't be zero
}
}
if ( a_y1 >= a_target->m_height ) {
if ( fdy >= 0 ) {
return; // Line starts off-screen and is going wrong way
} else {
iterations = std::max<int>(iterations, (int64_t(a_y1 - (a_target->m_height-1))<<shiftCount) / -fdy); // fdy can't be zero
}
}
if ( iterations > count ) {
return;
} else {
x += fdx * iterations;
y += fdy * iterations;
count -= iterations;
// For some reason need this, sometimes xi is -1
if (x < 0) {
x += fdx;
y += fdy;
count--;
}
}
iterations = count;
int64_t x2 = int64_t(a_x2) << shiftCount;
int64_t y2 = int64_t(a_y2) << shiftCount;
if ( x2 < 0 ) { // fdx can't be 0 by this point
iterations = std::min<int>(iterations, (count-1) - ((x2 - (1LL<<(shiftCount))) / fdx));
}
if ( y2 < 0 ) {
iterations = std::min<int>(iterations, (count-1) - ((y2 - (1LL<<(shiftCount))) / fdy));
}
if ( a_x2 >= a_target->m_width ) {
iterations = std::min<int>(iterations, (count-1) - ((int64_t(a_x2 - (a_target->m_width+1))<<shiftCount) / fdx)); // fdx can't be zero
}
if ( a_y2 >= a_target->m_height ) {
iterations = std::min<int>(iterations, (count-1) - ((int64_t(a_y2 - (a_target->m_height+1))<<shiftCount) / fdy)); // fdy can't be zero
}
count = iterations;
if (count > 0)
for (; count--; x += fdx, y += fdy)
{
int xi = x >> shiftCount;
int yi = y >> shiftCount;
//a_target->m_pixels[yi*a_target->m_strideBytes/4 + xi] = a_color;
if ( xi >= 0 && xi < a_target->m_width && yi >= 0 && yi < a_target->m_height )
{
uint32_t *dst = &(a_target->m_pixels[yi*a_target->m_strideBytes/4 + xi]);
*dst = (!a_blend) ? a_color : blendColors(a_color, *dst, (a_color>>24) & 0xff);
}
else {
fprintf(stderr, "count: %i, xi: %i, yi: %i\n", count, (int)xi, (int)yi);
}
}
#else
//count++;
if (count > 0)
for (; count--; x += fdx, y += fdy)
{
int xi = x >> shiftCount;
int yi = y >> shiftCount;
if ( xi >= 0 && xi < a_target->m_width && yi >= 0 && yi < (a_target->m_height/2) )
a_target->m_pixels[yi*a_target->m_strideBytes/4 + xi] = a_color;
//else {
// fprintf(stderr, "count: %i, xi: %i, yi: %i\n", count, (int)xi, (int)yi);
//}
}
#endif
}
void DrawPixels(PixelBuffer* a_target, uint32_t* a_bits, int a_x, int a_y, int a_width, int a_height, int a_xOffset, int a_yOffset, int a_pixelsWidth, int a_pixelsHeight)
{
ClipRect clip = SetupClip(a_target); if (!clip.valid) return;
for (int j = 0; j < a_height; j++)
for (int i = 0; i < a_width; i++)
{
int x = i + a_x;
int y = j + a_y;
if (PixelClipTest(clip, x, y))
//if ( y > 0 && y < a_target->m_height && x > 0 && x < a_target->m_width )
{
uint32_t *dst = &(a_target->m_pixels[(j+a_y)*a_target->m_strideBytes/4 + (i+a_x)]);
uint32_t src = a_bits[(j+a_yOffset)*a_pixelsWidth+(i+a_xOffset)];
if ( src & 0xff000000 )
*dst = src;
}
}
}
void DrawPixelsAlpha(PixelBuffer* a_target, uint32_t* a_bits, int a_x, int a_y, int a_width, int a_height, int a_xOffset, int a_yOffset, int a_pixelsWidth, int a_pixelsHeight)
{
ClipRect clip = SetupClip(a_target); if (!clip.valid) return;
for (int j = 0; j < a_height; j++)
for (int i = 0; i < a_width; i++)
{
int x = i + a_x;
int y = j + a_y;
if (PixelClipTest(clip, x, y))
// if ( y > 0 && y < a_target->m_height && x > 0 && x < a_target->m_width )
{
uint32_t *dst = &(a_target->m_pixels[(j+a_y)*a_target->m_strideBytes/4 + (i+a_x)]);
uint32_t src = a_bits[(j+a_yOffset)*a_pixelsWidth+(i+a_xOffset)];
if ( src & 0xff000000 )
*dst = blendColors(src, *dst, (src>>24) & 0xff);
}
}
}
// Specialized function for blitting a cached glyph to the output colorized with a_color
// a_bits are the rasterized glyph, where it contains alpha, as well as black for the character, and color on the edges for sub-pixel rendering
void DrawPixelsText(PixelBuffer* a_target, uint32_t a_color, uint32_t* a_bits, int a_x, int a_y, int a_width, int a_height, int a_xOffset, int a_yOffset, int a_pixelsWidth, int a_pixelsHeight)
{
ClipRect clip = SetupClip(a_target); if (!clip.valid) return;
for (int j = 0; j < a_height; j++)
for (int i = 0; i < a_width; i++)
{
int x = i + a_x;
int y = j + a_y;
if (PixelClipTest(clip, x, y))
// if ( y > 0 && y < a_target->m_height && x > 0 && x < a_target->m_width )
{
uint32_t *dst = &(a_target->m_pixels[(j+a_y)*a_target->m_strideBytes/4 + (i+a_x)]);
uint32_t src = a_bits[(j+a_yOffset)*a_pixelsWidth+(i+a_xOffset)];
if ( src & 0xff000000 )
*dst = blendColors(a_color | src, *dst, (src>>24) & 0xff);
}
}
}
void DrawPixelsAlphaBlended(PixelBuffer* a_target, uint32_t* a_bits, int a_x, int a_y, int a_width, int a_height, int a_xOffset, int a_yOffset, int a_pixelsWidth, int a_pixelsHeight, int a_alpha)
{
ClipRect clip = SetupClip(a_target); if (!clip.valid) return;
for (int j = 0; j < a_height; j++)
for (int i = 0; i < a_width; i++)
{
int x = i + a_x;
int y = j + a_y;
if (PixelClipTest(clip, x, y))
//if ( y > 0 && y < a_target->m_height && x > 0 && x < a_target->m_width )
{
uint32_t *dst = &(a_target->m_pixels[(j+a_y)*a_target->m_strideBytes/4 + (i+a_x)]);
uint32_t src = a_bits[(j+a_yOffset)*a_pixelsWidth+(i+a_xOffset)];
if ( src & 0xff000000 )
*dst = blendColors(src, *dst, a_alpha);
}
}
}
// TODO: move to header/common, make use of else where
// perhaps PixelBuffer can be of PixelValue instead of uint32_t
struct PixelValue
{
PixelValue(uint32_t v) : m_value(v) {}
operator uint32_t() const { return m_value; }
PixelValue& operator=(uint32_t val) { m_value = val; return *this; }
union
{
uint32_t m_value;
uint8_t m_components[4];
};
};
struct WidePixelValue
{
WidePixelValue()
{
for (int i = 0; i < 4; i++)
m_components[i] = 0;
}
WidePixelValue& operator=(PixelValue other) {
for (int i = 0; i < 4; i++)
m_components[i] = other.m_components[i];
return *this;
}
WidePixelValue& operator+=(PixelValue other) {
for (int i = 0; i < 4; i++)
m_components[i] += other.m_components[i];
return *this;
}
WidePixelValue& operator/=(int v) {
for (int i = 0; i < 4; i++)
m_components[i] /= v;
return *this;
}
operator uint32_t() {
PixelValue out(0);
for (int i = 0; i < 4; i++)
out.m_components[i] = m_components[i];
return out;
}
uint32_t m_components[4];
};
template <bool axis>
void SmoothDownSampleHelper(uint32_t* a_dstBits, int a_dstW, int a_dstH, uint32_t* a_srcBits, int a_width, int a_height)
{
int64_t maxJ = (axis) ? a_height : a_width;
int64_t maxI = (axis) ? a_width : a_height;
int64_t maxDI = (axis) ? a_dstW : a_dstH;
if (!maxI)
return;
// 32.32 fixed point
int64_t dDdS = (maxDI << 32) / (maxI);
for (int j = 0; j < maxJ; j++) {
int64_t d = (1LL<<32) / 3;
int c = 0, di = 0;
WidePixelValue col;
for (int i = 0; i < maxI; i++) {
int x = (axis) ? i : j;
int y = (axis) ? j : i;
col += a_srcBits[y * a_width + x];
c++;
d += dDdS; // DDA style
if (d >= (1LL<<32)) { // emit
d -= (1LL<<32);
col /= c;
if (axis)
a_dstBits[y * a_dstW + di] = col;
else
a_dstBits[di * a_dstW + x] = col;
c = 0;
col = 0;
di++;
if (di == maxDI)
break;
}
}
}
}
bool SmoothDownSample(uint32_t* a_dstBits, int a_dstW, int a_dstH, uint32_t* a_srcBits, int a_width, int a_height)
{
if (a_dstW > a_width || a_dstH > a_height)
return false;
uint32_t *tmpBits = new uint32_t[a_height * a_dstW]; // resize in x only
// First scale in the x-axis
SmoothDownSampleHelper<true>(tmpBits, a_dstW, a_height, a_srcBits, a_width, a_height);
// Now scale in the y-axis
SmoothDownSampleHelper<false>(a_dstBits, a_dstW, a_dstH, tmpBits, a_dstW, a_height);
delete[] tmpBits;
return true;
}
#if 0
static bool TestFileExtension(const char* a_file, const char* a_ext)
{
size_t len = strlen(a_file);
if (len < 4 || strlen(a_ext) != 4)
return false;
for (int i = 0; i < 4; i++)
if (toupper(a_file[len-4+i]) != toupper(a_ext[i]))
return false;
return true;
}
extern int DecodePNG(std::vector<unsigned char>& out_image, unsigned long& image_width, unsigned long& image_height, const unsigned char* in_png, size_t in_size, bool convert_to_rgba32);
static bool LoadImage(const char* file, PixelBuffer& a_img, bool chromaKeyed = true)
{
if (TestFileExtension(file, ".png"))
{
// It's a PNG image
MemoryMappingData* mapping = MemoryMapping_Open(file);
if (!mapping)
return false;
// For 32bit builds, this code won't support input PNG files that are more than 4GiB, but neither can it support
// having a buffer as large as that for storing the pixels in to, so perhaps best just to use 64bit builds if dealing with massive images.
size_t siz = (size_t)MemoryMapping_GetSize(mapping);
uint8_t* buf = (uint8_t*)MemoryMapping_GetAddress(mapping);
std::vector<unsigned char> out_image;
unsigned long w, h;
if (DecodePNG(out_image, w, h, buf, siz, true))
{
a_img.m_height = h;
a_img.m_width = w;
a_img.m_strideBytes = w * sizeof(uint32_t);
a_img.m_format = PF_ARGB8888;
a_img.m_pixels = new uint32_t[w * h];
memcpy(a_img.m_pixels, out_image.data(), w * h * sizeof(uint32_t));
for ( int i = 0; i < w*h; i++ )
a_img.m_pixels[i] = ((a_img.m_pixels[i] << 16) & 0xff0000) |
((a_img.m_pixels[i] >> 16) & 0xff) | (a_img.m_pixels[i] & 0xff00ff00);
if ( chromaKeyed )
for ( int i = 0; i < w*h; i++ )
if ( a_img.m_pixels[i] != 0x00ff00 )
a_img.m_pixels[i] |= 0xff000000;
return true;
}
}
return false;
}
void DrawPixmapFile(PixelBuffer* a_target, const char* file, int x, int y, int x1, int y1, int x2, int y2)
{
static std::map<const char*,PixelBuffer> imageMap; // pixmap cache
PixelBuffer img = imageMap[file];
if (!img.m_pixels)
{
if (LoadImage(file, img, false))
{
imageMap[file] = img;
}
}
DrawPixels(a_target, img.m_pixels, x, y, x2-x1+1, y2-y1+1, x1, y1, img.m_width, img.m_height);
}
void DrawNumber(PixelBuffer* a_target, uint32_t col, int x, int y, int num, int width)
{
// LoadImage("numbers.png", g_numbersPixelsW, g_numbersPixelsH, g_numbersPixels, false);
int divisor = 1;
for (int i = width; i != 0; i--, divisor*=10)
DrawPixels(a_target, g_numbersPixels, x + (i-1)*16, y, 16, 30, 0, 30*((num/divisor)%10), g_numbersPixelsW, g_numbersPixelsH);
}
#endif
void LogMessage(LogLevel a_level, const char* a_formatString, ...)
{
char buf[1024];
va_list vaargs;
va_start(vaargs, a_formatString);
vsnprintf(buf, 1024, a_formatString, vaargs);
buf[1023] = 0; // Ensure null terminated
#ifdef _WIN32
OutputDebugStringA(buf);
#endif
puts(buf);
va_end(vaargs);
}
// Simple 3 control point bezier curve
// p1 and p3 are the 2 end points the curve starts/ends at
// p2 is another control point but not a point on the curve
// t is the ratio between the two end points to interpolate a result for
vec2i bezierCurve(const vec2i& p1, const vec2i& p2, const vec2i& p3, double t)
{
double t2 = 1.0 - t;
//return (vec2i){ int(t2*t2*p1.x + 2.0*t2*t*p2.x + t*t*p3.x),
// int(t2*t2*p1.y + 2.0*t2*t*p2.y + t*t*p3.y) };
return (vec2i){ (int)std::ceil(t2*t2*p1.x + 2.0*t2*t*p2.x + t*t*p3.x + 0.5),
(int)std::ceil(t2*t2*p1.y + 2.0*t2*t*p2.y + t*t*p3.y + 0.5) };
}
// Simple 3 control point bezier curve
// p1 and p3 are the 2 end points the curve starts/ends at
// p2 is another control point but not a point on the curve
// t is a ratio (from 0 to 65535) between the two end points to interpolate a result for
vec2i bezierCurveFixed(const vec2i& p1, const vec2i& p2, const vec2i& p3, uint64_t t)
{
uint64_t t2 = 0x10000 - t;
//uint64_t t2 = 0xFFFF - t;
uint64_t t2t2 = t2*t2;
uint64_t t2t = t2*t;
uint64_t tt = t*t;
return (vec2i){ int((t2t2*p1.x + 2*t2t*p2.x + tt*p3.x + (1<<31)) >> 32),
int((t2t2*p1.y + 2*t2t*p2.y + tt*p3.y + (1<<31)) >> 32) };
}
void DrawCurve(PixelBuffer* a_target, uint32_t a_color, const vec2i& p1, const vec2i& p2, const vec2i& p3, bool a_blend)
{
ClipRect clip = SetupClip(a_target); if (!clip.valid) return;
int dx = p1.x - p3.x;
int dy = p1.y - p3.y;
if (dx*dx > dy*dy) {
dx = (dx < 0) ? -dx : dx;
} else {
dx = (dy < 0) ? -dy : dy;
}
dx *= 2;
/*
float divisor = 1.0f / float(dx);
for (int i = 0; i < dx; i++)
{
vec2i pos1 = bezierCurve(p1, p2, p3, float(i) * divisor);
vec2i pos2 = bezierCurve(p1, p2, p3, float(i + 1) * divisor);
DrawLine(a_target, a_color, pos1.x, pos1.y, pos2.x, pos2.y, a_blend);
}
*/
// Fixed precision version
for (int i = 0; i < dx; i++)
{
vec2i pos1 = bezierCurveFixed(p1, p2, p3, ((i << 16) - (dx/2)) / dx);
vec2i pos2 = bezierCurveFixed(p1, p2, p3, (((i+1) << 16) - (dx/2)) / dx);
DrawLine(a_target, a_color, pos1.x, pos1.y, pos2.x, pos2.y, a_blend);
}
}
void DrawFontCurveInternal(PixelBuffer* a_target, uint32_t a_color, const vec2i& p1, const vec2i& p2, const vec2i& p3)
{
ClipRect clip = SetupClip(a_target); if (!clip.valid) return;
int dx = p1.x - p3.x;
int dy = p1.y - p3.y;
if (dx*dx > dy*dy) {
dx = (dx < 0) ? -dx : dx;
} else {
dx = (dy < 0) ? -dy : dy;
}
dx *= 2;
/*
float divisor = 1.0f / float(dx);
for (int i = 0; i < dx; i++)
{
vec2i pos1 = bezierCurve(p1, p2, p3, float(i) * divisor);
vec2i pos2 = bezierCurve(p1, p2, p3, float(i + 1) * divisor);
if (PixelClipTest(clip, pos1.x, pos1.y))
a_target->m_pixels[pos1.y*a_target->m_strideBytes/4 + pos1.x] |= a_color;
if (PixelClipTest(clip, pos2.x, pos2.y))
a_target->m_pixels[pos2.y*a_target->m_strideBytes/4 + pos2.x] |= a_color;
}
*/
// Fixed precision version
for (int i = 0; i < dx; i++)
{
vec2i pos1 = bezierCurveFixed(p1, p2, p3, ((i << 16) - (dx/2)) / dx);
vec2i pos2 = bezierCurveFixed(p1, p2, p3, (((i+1) << 16) - (dx/2)) / dx);
if (PixelClipTest(clip, pos1.x, pos1.y))
a_target->m_pixels[pos1.y*a_target->m_strideBytes/4 + pos1.x] |= a_color;
if (PixelClipTest(clip, pos2.x, pos2.y))
a_target->m_pixels[pos2.y*a_target->m_strideBytes/4 + pos2.x] |= a_color;
}
}
Rectangle glyphBounds(const Glyph::Outline& outline)
{
Rectangle ret;
int minX = INT_MAX, minY = INT_MAX;
int maxX = INT_MIN, maxY = INT_MIN;
for (size_t i = 0; i < outline.m_lines.size(); i++)
{
const Glyph::Outline::Curve& b = outline.m_lines[i];
for (int c = 0; c < 3; c++) {
int x = b.m_controlPoints[c].m_x;
int y = b.m_controlPoints[c].m_y;
if (x < minX) minX = x; if (x > maxX) maxX = x;
if (y < minY) minY = y; if (y > maxY) maxY = y;
}
}
ret.m_x = minX;
ret.m_y = minY;
ret.m_width = maxX - minX + 1;
ret.m_height = maxY - minY + 1;
return ret;
}
// TODO: remove these debugging variables
#define DEBUG_FONT_RENDERING 1
#if DEBUG_FONT_RENDERING
bool drawWholeOutline = false;
std::string fontOpt = "Arial";
bool drawAAText = true;
#else
const bool drawWholeOutline = false;
const std::string fontOpt = "Arial";
const bool drawAAText = true;
#endif
// debug thing for debugging the rasterization stages:
int g_stage = 100; // 100 - means do all the stages
bool g_enableKerning = true;
struct CachedGlyphData
{
Rectangle rect;
PixelBuffer buf;
};
struct GlyphRasterizationCache : public Glyph::CacheDataInterface
{
std::map<int, CachedGlyphData> m_sizeMap;
std::map<int, CachedGlyphData> m_aaSizeMap;
};
CachedGlyphData CreateCachedGlyphData(int a_size, const Glyph::Outline& outline, const int bias)
{
CachedGlyphData data;
Rectangle rect = glyphBounds(outline);
if (a_size <= 0)
{
printf("bad size\n");
exit(-1);
}
assert(a_size > 0);
rect.m_width = ((rect.m_width * a_size + bias) >> 10) + 5; // TODO: What's the +7 for?
rect.m_height = ((rect.m_height * a_size + bias) >> 10) + 5; // With the bias for sub-pixel placement, a one pixel guard band is needed, so +2
const int size = rect.m_width*rect.m_height;
PixelBuffer buf = {
new uint32_t[size],
rect.m_width*4,
rect.m_width,
rect.m_height,
PF_ARGB8888,
false
};
for (int i = 0; i < size; i++)
buf.m_pixels[i] = 0x00000000;
data.rect = rect;
data.buf = buf;
return data;
}
void ReleaseCachedGlyphData(CachedGlyphData& data)
{
delete[] data.buf.m_pixels;
}
void DrawOutlineInternal(PixelBuffer& buf, const int a_size, const Rectangle& rect, const Glyph::Outline& outline, const int bias)
{
const uint32_t leftColor = 0xFF0000AF;
const uint32_t rightColor = 0xFFAF0000;
// iterate the bezier curves drawing the left sides of the outline
for (size_t i = 0; i < outline.m_lines.size(); i++)
{
const Glyph::Outline::Curve& b = outline.m_lines[i];
vec2i pnts[3];
for (int c = 0; c < 3; c++)
pnts[c] = (vec2i){ 1 + int((((b.m_controlPoints[c].m_x - rect.m_x) * a_size) + bias) >> 10),
rect.m_height - 1 - int((((b.m_controlPoints[c].m_y - rect.m_y) * a_size) + bias) >> 10) };
const uint32_t color = (pnts[0].y > pnts[2].y) ? leftColor : rightColor;
DrawFontCurveInternal(&buf, color, pnts[0], pnts[1], pnts[2]);
}
}
CachedGlyphData RasterizeCharacterToBuffer(int a_size, const Glyph::Outline& outline)
{
const int bias = 512;// 512;//0;//512;
//a_size -= 1;
//a_size++;
CachedGlyphData data = CreateCachedGlyphData(a_size, outline, bias);
Rectangle& rect = data.rect;
PixelBuffer& buf = data.buf;
// TODO: why does this magic number work?
//rect.m_y -= 128;//bias;
DrawOutlineInternal(buf, a_size, rect, outline, bias);
const uint32_t leftColor = 0xFF0000AF;
const uint32_t rightColor = 0xFFAF0000;
const uint32_t fillColor = 0xFF202020;
// Simplest and best solution to flood-filling so far
// Potentially could be done in a shader
for (int j = 0; j < rect.m_height; j++)
{
// #define GPU_TEST // Try to do it just by looking at the pixel/texture values
// assumes can read the modified values and it
// processes in the same order
#ifndef GPU_TEST
bool wasLeft = false;
bool wasRight = false;
bool wasFilled = false;
#endif
for (int i = 0; i < rect.m_width; i++)
{
uint32_t color = buf.m_pixels[j*rect.m_width + i];
uint32_t aboveColor = (j == 0) ? 0 : buf.m_pixels[(j-1)*rect.m_width + i];
#ifdef GPU_TEST
uint32_t previousColor = (i == 0) ? 0 : buf.m_pixels[j*rect.m_width + (i-1)];
bool wasLeft = (previousColor & leftColor) == leftColor;
bool wasRight = (previousColor & rightColor) == rightColor;
bool wasFilled = previousColor == fillColor;
#endif
bool isLeft = (color & leftColor) == leftColor;
bool isRight = (color & rightColor) == rightColor;
bool aboveIsFill = aboveColor == fillColor;
bool aboveIsRight = (aboveColor & rightColor) == rightColor;
bool aboveIsLeft = (aboveColor & leftColor) == leftColor;
bool fill = (!isLeft && !isRight && (wasFilled || wasLeft) && (aboveIsLeft || aboveIsRight || aboveIsFill));
// && !(!wasLeft && wasRight && aboveIsRight) )
if (fill)
{
buf.m_pixels[j*rect.m_width + i] = fillColor;
}
#ifndef GPU_TEST
wasFilled = fill;
wasLeft = isLeft;
wasRight = isRight;
#endif
}
}
if (g_stage == 100)
return data;
//if (g_stage == 5)
// return data;
// For debugging
DrawOutlineInternal(buf, a_size, rect, outline, bias);
return data;
}
int nextPowerOfTwo(int a_value)
{
int i = 1;
while (i < a_value)
i <<= 1;
return i;
}
template <typename Tout, typename Tin>
Tout dynamic_cast2(Tin ptr)
{
#ifndef NO_RTTI
return dynamic_cast<Tout>(ptr);
#else
return reinterpret_cast<Tout>(ptr);
#endif
}
void DrawGlyphOutlineBlend(const Glyph& a_glyph, PixelBuffer* a_target, uint32_t a_color, int a_size, int& a_x, int& a_y);
void RasterizeCharacter2(PixelBuffer* a_target, uint32_t a_color, int a_size, int a_x, int a_y, const Glyph& a_glyph)
{
const int bias = 0;//512;
const Glyph::Outline& outline = a_glyph.m_outline;
GlyphRasterizationCache* cache = dynamic_cast2<GlyphRasterizationCache*>(a_glyph.m_userData);
if (!cache) // TODO: Assumes no one else is using m_userData with another type
{
// TODO: this is a cache per glyph - might be hard to have a global cache size limit / policy
cache = new GlyphRasterizationCache;
a_glyph.m_userData = cache;
}
int nonAASize = a_size; // for aa, size we scale down from, otherwise the original requested size
if (drawAAText) {
if (a_size < 64) {
nonAASize = nextPowerOfTwo(a_size);
nonAASize *= 3;
}
}
if (g_stage != 100)
{
CachedGlyphData data = RasterizeCharacterToBuffer(nonAASize, outline);
const Rectangle& rect = data.rect;
const PixelBuffer& buf = data.buf;
int yOff = a_size - rect.m_height + 1;
// DrawPixelsText(a_target, a_color, buf.m_pixels, a_x + ((rect.m_x*a_size + bias)>>10),
DrawPixelsAlpha(a_target, buf.m_pixels, a_x + ((rect.m_x*a_size + bias)>>10),
a_y + yOff - ((rect.m_y*a_size + bias)>>10), buf.m_width, buf.m_height, 0, 0, buf.m_width, buf.m_height);
return;
}
if (!cache->m_sizeMap.count(nonAASize)) {
CachedGlyphData data = RasterizeCharacterToBuffer(nonAASize, outline);
cache->m_sizeMap[nonAASize] = data;
}
if (drawAAText) {
if (!cache->m_aaSizeMap.count(a_size)) {
const CachedGlyphData& data = cache->m_sizeMap[nonAASize];
const Rectangle& rect = data.rect;
CachedGlyphData ret = data;
if (a_size < 64) {
float aaScale = a_size / float(nonAASize);
int w = rect.m_width * aaScale;
int h = rect.m_height * aaScale;
ret.buf = { new uint32_t[w*h], w*4, w, h, PF_ARGB8888, false };
ret.rect.m_width = w;
ret.rect.m_height = h;
SmoothDownSample(ret.buf.m_pixels, w, h, data.buf.m_pixels, rect.m_width, rect.m_height);
} else {
int w = rect.m_width;
int h = rect.m_height;
ret.buf = { new uint32_t[w*h], w*4, w, h, PF_ARGB8888, false };
for (int i = 0; i < w*h; i++)
{
uint32_t col = data.buf.m_pixels[i];
ret.buf.m_pixels[i] = (col & 0xFF000000) ? 0xFF000000 : 0x00000000;
}
/*
int x = 0, y = 0;
int yOff = a_size - rect.m_height;
int x1 = -((rect.m_x*a_size - bias)>>10);
int y1 = -yOff + ((rect.m_y*a_size - bias)>>10);
const uint32_t col = 0x20000000;
x = x1-1, y = y1;
DrawGlyphOutlineBlend(a_glyph, &ret.buf, col, a_size, x, y);
x = x1+1, y = y1;
DrawGlyphOutlineBlend(a_glyph, &ret.buf, col, a_size, x, y);
x = x1-1, y = y1-1;
DrawGlyphOutlineBlend(a_glyph, &ret.buf, col, a_size, x, y);
x = x1-1, y = y1+1;
DrawGlyphOutlineBlend(a_glyph, &ret.buf, col, a_size, x, y);
x = x1, y = y1-1;
DrawGlyphOutlineBlend(a_glyph, &ret.buf, col, a_size, x, y);
x = x1, y = y1+1;
DrawGlyphOutlineBlend(a_glyph, &ret.buf, col, a_size, x, y);
x = x1+1, y = y1-1;
DrawGlyphOutlineBlend(a_glyph, &ret.buf, col, a_size, x, y);
x = x1+1, y = y1+1;
DrawGlyphOutlineBlend(a_glyph, &ret.buf, col, a_size, x, y);
x = x1, y = y1;
DrawGlyphOutlineBlend(a_glyph, &ret.buf, col, a_size, x, y);
*/
}
cache->m_aaSizeMap[a_size] = ret;
}
}
const CachedGlyphData& data = (drawAAText) ? cache->m_aaSizeMap[a_size] : cache->m_sizeMap[a_size];
const Rectangle& rect = data.rect;
const PixelBuffer& buf = data.buf;
int yOff = a_size - rect.m_height + 1;
DrawPixelsText(a_target, a_color, buf.m_pixels, a_x + ((rect.m_x*a_size + bias)>>10),
a_y + yOff - ((rect.m_y*a_size + bias)>>10), buf.m_width, buf.m_height, 0, 0, buf.m_width, buf.m_height);
//ReleaseCachedGlyphData(data);
}
void DrawGlyphOutline(const Glyph& a_glyph, PixelBuffer* a_target, uint32_t a_color, int a_size, int& a_x, int& a_y)
{
// iterate the bezier curves
for (size_t i = 0; i < a_glyph.m_outline.m_lines.size(); i++)
{
const Glyph::Outline::Curve& b = a_glyph.m_outline.m_lines[i];
vec2i pnts[3];
for (int c = 0; c < 3; c++)
pnts[c] = (vec2i){ a_x + int((b.m_controlPoints[c].m_x * a_size) >> 10),
a_y + a_size + 3 - int((b.m_controlPoints[c].m_y * a_size) >> 10) }; // TODO: this +3 is a bit magic to make it line up with filled drawing
DrawCurve(a_target, a_color, pnts[0], pnts[1], pnts[2], false);
}
}
void DrawGlyphOutlineBlend(const Glyph& a_glyph, PixelBuffer* a_target, uint32_t a_color, int a_size, int& a_x, int& a_y)
{
// iterate the bezier curves
for (size_t i = 0; i < a_glyph.m_outline.m_lines.size(); i++)
{
const Glyph::Outline::Curve& b = a_glyph.m_outline.m_lines[i];
vec2i pnts[3];
for (int c = 0; c < 3; c++)
pnts[c] = (vec2i){ a_x + int((b.m_controlPoints[c].m_x * a_size) >> 10),
a_y + a_size - int((b.m_controlPoints[c].m_y * a_size) >> 10) };
DrawCurve(a_target, a_color, pnts[0], pnts[1], pnts[2], true);
}
}
void DrawGlyphFilled(const Glyph& a_glyph, PixelBuffer* a_target, uint32_t a_color, int a_size, int& a_x, int& a_y)
{
// TODO: Add rasterized glyph caching?? - Perhaps try to do the SDF thing with the multiple distance fields
// - Probably would want to do that with a few glyphs at a time
// - Then see about using it to draw text in varying styles - bold, normal, outlined, shadowed etc in shaders
// - The text can skew, rotate, scale and move by manipulation of the vertices. Need to tie that with kerning somehow.
// Next step if can do all of that is to see if can then do all of that with asian fonts/characters
// And then with any font/language
int y = a_y + 1;
//y -= a_size / 2; // FIXME: hack
//RasterizeCharacter(a_target, a_color, a_size, a_x, a_y + 1, outline);
RasterizeCharacter2(a_target, a_color, a_size, a_x, y, a_glyph);
#if DEBUG_FONT_RENDERING
if (drawWholeOutline)
DrawGlyphOutline(a_glyph, a_target, 0xFF000000, a_size, a_x, a_y);
#endif
}
void GetGlyphExtents(const Glyph& a_glyph, PixelBuffer* a_target, uint32_t a_color, int a_size, int& a_width, int& a_height)
{
Rectangle rect = glyphBounds(a_glyph.m_outline);
if (rect.m_height > a_height)
a_height = rect.m_height;
}
typedef void (*ProcessTextHandler)(const Glyph& a_glyph, PixelBuffer* a_target, uint32_t a_color, int a_size, int& a_x, int& a_y);
//FontManager g_fontManager;
FontMetrics GetFontMetrics()
{
TrueTypeFont& font = getFont(fontOpt.c_str());
Metrics& fm = font.getMetrics();
struct FontMetrics fm2;
fm2.m_ascent = fm.m_ascent;
fm2.m_descent = fm.m_descent;
fm2.m_xHeight = fm.m_xHeight;
fm2.m_capHeight = fm.m_capHeight;
fm2.m_lineGap = fm.m_lineGap;
return fm2;
}
GlyphMetrics GetGlyphMetrics(uint32_t a_unicodeCharacter)
{
TrueTypeFont& font = getFont(fontOpt.c_str());
Glyph& glyph = font.getGlyph(a_unicodeCharacter);
struct GlyphMetrics gm;
gm.m_advanceWidth = glyph.m_metrics.m_advanceWidth;
gm.m_leftSideBearing = glyph.m_metrics.m_leftSideBearing;
gm.m_rightSideBearing = glyph.m_metrics.rightSideBearing();
gm.m_minX = glyph.m_metrics.m_min.m_x;
gm.m_minY = glyph.m_metrics.m_min.m_y;
gm.m_maxX = glyph.m_metrics.m_max.m_x;
gm.m_maxY = glyph.m_metrics.m_max.m_y;
return gm;
}
void ProcessText(ProcessTextHandler a_func, PixelBuffer* a_target, uint32_t a_color, const char* a_fontFamily, int a_size, int& a_x, int& a_y, const char* a_utf8String)
{
if (!a_target || !a_fontFamily || !a_utf8String || a_size <= 0)
{
return;
}
// TODO: Doesn't use the given font, uses a fixed font name
TrueTypeFont& font = getFont(fontOpt.c_str());
// Font& font = getFont(a_fontFamily);
// TODO: Fix me
// getFontName(fontOpt.c_str());
// TODO: Loop over the string and break on line-breaks and call some internal function which does the body of this function
while (*a_utf8String)
{
// TODO: need to decode the UTF8 in to Unicode characters - this is assuming everything is latin1
uint32_t unicodeCharacter = *a_utf8String;
Glyph& glyph = font.getGlyph(unicodeCharacter);
a_func(glyph, a_target, a_color, a_size, a_x, a_y);
a_utf8String++;
uint32_t rightUnicodeCharacter = *a_utf8String;
int16_t kerningAdjustment = (g_enableKerning ? 1 : 0) * font.getKerningAdjustment(unicodeCharacter, rightUnicodeCharacter);
const float spacing = 1.0;
a_x += (((glyph.m_metrics.m_advanceWidth + kerningAdjustment) * a_size) >> 10) + (int)(spacing + 0.5);
}
}
// TODO: refactor with DrawText so that it aligns with same font, same character spacing etc
void DrawOutlineText(PixelBuffer* a_target, uint32_t a_color, const char* a_fontFamily, int a_size, int a_x, int a_y, const char* a_utf8String)
{
ProcessText(DrawGlyphOutline, a_target, a_color, a_fontFamily, a_size, a_x, a_y, a_utf8String);
}
void GetTextExtents(PixelBuffer* a_target, const char* a_fontFamily, int a_size, const char* a_utf8String, int& a_width, int& a_height)
{
const int bias = 512;
a_width = 0;
a_height = 0;
ProcessText(GetGlyphExtents, a_target, 0xFF000000, a_fontFamily, a_size, a_width, a_height, a_utf8String);
a_height *= a_size;
a_height += bias;
a_height >>= 10;
// TODO: more magic:
a_height += 6;
a_width += 10;
//a_height = a_size;
}
void DrawText(PixelBuffer* a_target, uint32_t a_color, const char* a_fontFamily, int a_size, int a_x, int a_y, const char* a_utf8String, int a_flags)
{
ProcessTextHandler handler = DrawGlyphFilled;
g_stage = a_flags - 3;
switch (a_flags)
{
case 0: g_stage = 100; break;
case 1: handler = DrawGlyphOutline; break;
case 2: handler = DrawGlyphOutlineBlend; break;
}
// TODO: some dodgy offsets
a_x += 4;
a_y += 7;
ProcessText(handler, a_target, a_color, a_fontFamily, a_size, a_x, a_y, a_utf8String);
g_stage = 100;
}
/*
struct vec2f
{
float x, y;
};
vec2f operator*(const vec2f& v, float c)
{
return (vec2f){ v.x*c, v.y*c };
}
vec2f operator*(float c, const vec2f& v)
{
return (vec2f){ v.x*c, v.y*c };
}
vec2f operator+(const vec2f& v1, const vec2f& v2)
{
return (vec2f){ v1.x+v2.x, v1.y+v2.y };
}
// Generalized spline function
// a_tension -1.0 -> 1.0 Round -> Tight
// a_bias -1.0 -> 1.0 Pre shoot -> Post shoot
// a_continuity -1.0 -> 1.0 Box corners -> Inverted corners
vec2f kochanekBartelsSpline(const std::vector<vec2f>& a_points, float t, float a_tension, float a_bias, float a_continuity)
{
int pnts = a_points.size();
if (!pnts)
return (vec2f){ 0.0f, 0.0f };
t = std::max(0.0f, std::min(1.0f, t)); // clamp t to be between 0->1
int intervals = pnts - 1; // the intervals are the segments between each point
int n = std::max(0, std::min(pnts-1, int(intervals * t))); // figure out which interval t is between
t = t * intervals - n; // the new t value is the ratio between the points at n and n+1
float tmp1 = 0.5f * (1.0f - a_tension);
float A = tmp1 * (1.0f + a_continuity) * (1.0f + a_bias); // A,B,C,D are the parameter factors
float B = tmp1 * (1.0f - a_continuity) * (1.0f - a_bias);
float C = tmp1 * (1.0f - a_continuity) * (1.0f + a_bias);
float D = tmp1 * (1.0f + a_continuity) * (1.0f - a_bias);
const vec2f& pnt0 = a_points[std::max(n - 1, 0)];
const vec2f& pnt1 = a_points[n];
const vec2f& pnt2 = a_points[std::min(pnts - 1, n + 1)];
const vec2f& pnt3 = a_points[std::min(pnts - 1, n + 2)];
vec2f vA = -A*pnt0 + (2+A-B-C)*pnt1 + (-2+B+C-D)*pnt2 + D*pnt3; // vA,vB,vC - polynomial factors
vec2f vB = 2*A*pnt0 + (-3-2*A+2*B+C)*pnt1 + (3-2*B-C+D)*pnt2 + -D*pnt3;
vec2f vC = -A*pnt0 + (A-B)*pnt1 + B*pnt2;
return ((vA*t + vB)*t + vC)*t + pnt1; // blends by the factors between the 4 closest control points
}
vec2f catmulRomSpline(const std::vector<vec2f>& a_points, float t)
{
return kochanekBartelsSpline(a_points, t, 0.0f, 0.0f, 0.0f);
}
vec2f cubicSpline(const std::vector<vec2f>& a_points, float t)
{
return kochanekBartelsSpline(a_points, t, 1.0f, 0.0f, 0.0f);
}
vec2f lineSpline(const std::vector<vec2f>& a_points, float t)
{
return kochanekBartelsSpline(a_points, t, 0.0f, 0.0f, -1.0f);
}
*/
END_NAMESPACE
