#define DEBUG_FONT_RENDERING 1
#if DEBUG_FONT_RENDERING
int fixedFontSize = 10;
bool drawAAText = true;
bool drawFill = true;
bool drawOutline = false;
bool drawWholeOutline = false;
bool drawControlPoints = false;
std::string fontOpt = "Arial";
#else
const bool drawAAText = true;
const bool drawFill = true;
#endif
void DrawCurveC(PixelBuffer* a_target, uint32_t a_color, const vec2i& p1, const vec2i& p2, const vec2i& p3)
{
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;
// Fixed precision version
for (int i = 0; i < dx; i++)
{
vec2i pos1 = bezierCurveFixed(p1, p2, p3, (i * 65536) / dx);
vec2i pos2 = bezierCurveFixed(p1, p2, p3, ((i+1) * 65536) / dx);
DrawLine(a_target, a_color, pos1.x, pos1.y, pos2.x, pos2.y);
}
}
void DrawRectangleB(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]);
*dst += a_color;//0x2000000;
//*dst = a_color;//0x2000000;
}
}
}
void DrawRectangleC(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]);
*dst = a_color;//0x2000000;
//*dst = a_color;//0x2000000;
}
}
}
void DrawCurveB(PixelBuffer* a_target, uint32_t a_color,
const vec2i& p1, const vec2i& p2, const vec2i& p3, // 3 control points
bool firstInContour, bool lastInContour, int firstAngle) // connectivity flags
{
// if firstInContour - always output the first point
// if lastInContour - don't output the last point
// TODO: what if the angle from p1->p2->p3 makes a 'v' or '^' shape?
// if so, at the apex of this bezier curve, it won't have
// output 2 points as required.
// Probably some checking of angle between p1->p2 and p2->p3 are needed
// Definately some edge cases there.
int dy = p1.y - p3.y;
//int dx = p1.x - p3.x;
int thisAngle = (dy < 0) ? -1 : ((dy > 0) ? +1 : 0);
//if (firstInContour)
// firstAngle = thisAngle;
static int lastAngle = 0;
bool drawFirst = true;
bool drawLast = true;
if (!firstInContour)
drawFirst = ((thisAngle != 0) && ((thisAngle + lastAngle) == 0))
//|| ( (thisAngle == 0) && (dx > 0))
//|| ( (thisAngle > 0) && (lastAngle == 0))
;//lastAngle != 0) );
if (lastInContour)
drawLast = (thisAngle != 0) && ((thisAngle + firstAngle) == 0);
// if (firstInContour)
// drawFirst = true;
if (lastInContour) {
//drawLast = (thisAngle != 0) && ((thisAngle + firstAngle) == 0);
//if (thisAngle != 0 && thisAngle == firstAngle)
// drawLast = true;//false;
}
lastAngle = (thisAngle) ? thisAngle : (1 - lastAngle);
dy = (dy < 0) ? -dy : dy; // dy = |dy|
dy *= 2; // over-sampling -> we try to sample
// the bezier with an even distribution of 't' values but this
// doesn't mean the resulting positions are evenly spaced along
// the curve, but because we want one sample for each y value,
// we need to over-sample the bezier curve to actually ensure we
// get what we want in an efficient way. Less efficient would be
// to try to solve the linear equation to figure out the value
// of 't' that gives a given y value. But doing the forward
// calculation twice instead is quite efficient and practical.
if (!dy) {
dy = 0;//1024;//512;
}
// Fixed precision version
if (dy)
{
//dy+=5;
int lastX = -1;
int lastY = -1;
for (int i = 0; i <= dy;)// i++)
{
vec2i pos1;
bool final = false;
do {
pos1 = bezierCurveFixed(p1, p2, p3, (i << 16) / dy);
final = pos1.y == p3.y && pos1.x == p3.x;
i++;
} while (!final && (pos1.y == lastY));
bool first = pos1.y == p1.y && pos1.x == p1.x;
//bool final = pos1.y == p3.y && pos1.x == p3.x;
bool canDraw = /*(final && lastInContour) ||*/ pos1.y != lastY; // do we need to output something
if (first && !drawFirst)
canDraw = false;
if (final && !drawLast)
canDraw = false;
if (canDraw)
DrawRectangleB(a_target, a_color, pos1.x, pos1.y, 1, 1);
//if (lastInContour && pos1.y == p3.y)
// DrawRectangleB(a_target, a_color, pos1.x, pos1.y, 1, 1);
//else {
// DrawRectangleB(a_target, a_color, pos1.x, pos1.y, 1, 1);
// DrawRectangleB(a_target, a_color, pos1.x, pos1.y, 1, 1);
//}
lastY = pos1.y;
lastX = pos1.x;
if (final)
break;
}
if (drawLast) {
DrawRectangleB(a_target, a_color, p3.x, p3.y, 1, 1);
DrawRectangleB(a_target, a_color, p3.x, p3.y, 1, 1);
}
}
else
{
if (p1.y != p3.y)
exit(0);
//if (p1.x == p3.x)
//exit(0);
// if (drawFirst)
DrawRectangleC(a_target, a_color, p1.x, p1.y, 1, 1);
// else if (p3.x > (p1.x + 2)) {
//DrawRectangleC(a_target, a_color, p1.x + 1, p3.y, 1, 1);
//DrawRectangleC(a_target, a_color, p3.x - 1, p3.y, 1, 1);
//}
//if (!lastInContour && drawLast)
DrawRectangleC(a_target, a_color, p3.x, p3.y, 1, 1);
//else //if (p1.x != p3.x)
//DrawRectangleB(a_target, a_color, p3.x - 1, p3.y, 1, 1);
}
}
void RasterizeCharacter(PixelBuffer* a_target, uint32_t a_color, int a_size, int a_x, int a_y, Glyph::Outline& outline)
{
int aaShift = 3;
int bias = 512;
if (drawAAText)
a_size <<= aaShift;
Rectangle rect = glyphBounds(outline);
rect.m_width = ((rect.m_width * a_size + bias) >> 10) + 3;
rect.m_height = (rect.m_height * a_size + bias) >> 10;
PixelBuffer buf = {
new uint32_t[rect.m_width*rect.m_height],
rect.m_width*4,
rect.m_width,
rect.m_height,
PF_ARGB8888
};
for (int i = 0; i < rect.m_width*rect.m_height; i++)
buf.m_pixels[i] = 0x00C0C0C0;
vec2i lastPos{ -1, -1 };
vec2i firstPos{ -1, -1 };
int firstAngle = 0;
bool firstInContour = true;
bool lastInContour = true;
// iterate the bezier curves
for (size_t i = 0; i < outline.m_lines.size(); i++)
{
Glyph::Outline::Curve& b = outline.m_lines[i];
{
vec2i pnts[3];
for (int c = 0; c < 3; c++)
pnts[c] = (vec2i){ int((((b.m_controlPoints[c].m_x - rect.m_x) * a_size) + bias) >> 10),
rect.m_height - int((((b.m_controlPoints[c].m_y - rect.m_y) * a_size) + bias) >> 10) };
const vec2i &p1 = pnts[0], &p2 = pnts[1], &p3 = pnts[2];
firstInContour = lastInContour;
if (firstInContour)
{
int dy = p1.y - p3.y;
firstAngle = (dy < 0) ? -1 : ((dy > 0) ? +1 : 0);
firstPos = p1;
}
lastInContour = p3.x == firstPos.x && p3.y == firstPos.y;
if (1) // alternative way to determine first
{
if (p1.x != lastPos.x || p1.y != lastPos.y)
{
assert(firstInContour);
}
lastPos = p3;
}
DrawCurveB(&buf, 0x02000000, p1, p2, p3, firstInContour, lastInContour, firstAngle);
}
}
if (drawFill) {
for (int j = 0; j < rect.m_height; j++)
{
uint8_t state = 0; // 0 off 1 off->on 2 on 3 on->off
for (int i = 0; i < rect.m_width; i++)
{
int count = buf.m_pixels[j*rect.m_width + i] >> 25;
do
{
if (count)
{
buf.m_pixels[j*rect.m_width + i] = 0x80C0C0C0 | a_color;
state = 1 - state;
count--;
}
else
{
if (state)
buf.m_pixels[j*rect.m_width + i] = 0xFF000000 | a_color;
}
}
while (count);
}
}
}
#if DEBUG_FONT_RENDERING
if (drawControlPoints) {
lastPos = vec2i{ -1, -1 };
firstPos = vec2i{ -1, -1 };
firstInContour = true;
lastInContour = true;
// iterate the bezier curves
for (size_t i = 0; i < outline.m_lines.size(); i++)
{
Glyph::Outline::Curve& b = outline.m_lines[i];
{
vec2i pnts[3];
for (int c = 0; c < 3; c++)
pnts[c] = (vec2i){ int((((b.m_controlPoints[c].m_x - rect.m_x) * a_size) + bias) >> 10),
rect.m_height - int((((b.m_controlPoints[c].m_y - rect.m_y) * a_size) + bias) >> 10) };
const vec2i &p1 = pnts[0], &p2 = pnts[1], &p3 = pnts[2];
firstInContour = lastInContour;
if (firstInContour)
{
int dy = pnts[0].y - pnts[2].y;
firstAngle = (dy < 0) ? -1 : ((dy > 0) ? +1 : 0);
firstPos = pnts[0];
}
lastInContour = p3.x == firstPos.x && p3.y == firstPos.y;
if (firstInContour)//p1.x != lastPos.x || p1.y != lastPos.y)
{
DrawRectangle(&buf, 0xFF00FF00, p1.x-3, p1.y-3, 5, 5);
DrawRectangle(&buf, 0xFF0000FF, p2.x-3, p2.y-3, 5, 5);
DrawRectangle(&buf, 0xFF0000FF, p3.x-3, p3.y-3, 5, 5);
}
else if (lastInContour)
{
DrawRectangleAlpha(&buf, 0x1FFF7F00, p1.x-3, p1.y-3, 5, 5);
DrawRectangle(&buf, 0xFFFF4444, p2.x-3, p2.y-3, 5, 5);
DrawRectangleAlpha(&buf, 0x1F1FFF1F, p3.x-3, p3.y-3, 5, 5);
}
else
{
DrawRectangleAlpha(&buf, 0x3F808044, p1.x-1, p1.y-1, 3, 3);
DrawRectangleAlpha(&buf, 0x3FFF4444, p2.x-1, p2.y-1, 3, 3);
DrawRectangleAlpha(&buf, 0x3FFF4444, p3.x-1, p3.y-1, 3, 3);
}
lastPos = p3;
}
}
}
if (drawOutline) {
lastPos = vec2i{ -1, -1 };
firstPos = vec2i{ -1, -1 };
firstInContour = true;
lastInContour = true;
firstAngle = 0;
// iterate the bezier curves
for (size_t i = 0; i < outline.m_lines.size(); i++)
{
Glyph::Outline::Curve& b = outline.m_lines[i];
{
vec2i pnts[3];
for (int c = 0; c < 3; c++)
pnts[c] = (vec2i){ int((((b.m_controlPoints[c].m_x - rect.m_x) * a_size) + bias) >> 10),
rect.m_height - int((((b.m_controlPoints[c].m_y - rect.m_y) * a_size) + bias) >> 10) };
firstInContour = lastInContour;
if (firstInContour)
{
int dy = pnts[0].y - pnts[2].y;
firstAngle = (dy < 0) ? -1 : ((dy > 0) ? +1 : 0);
firstPos = pnts[0];
}
lastInContour = pnts[2].x == firstPos.x && pnts[2].y == firstPos.y;
DrawCurveB(&buf, 0xFF007F7F, pnts[0], pnts[1], pnts[2], firstInContour, lastInContour, firstAngle);
}
}
}
#endif // DEBUG_FONT_RENDERING
if (drawAAText)
{
int w = rect.m_width >> aaShift;
int h = rect.m_height >> aaShift;
PixelBuffer downScaled = { new uint32_t[w*h], w*4, w, h, PF_ARGB8888 };
if (SmoothDownSample(downScaled.m_pixels, w, h, buf.m_pixels, rect.m_width, rect.m_height))
{
a_size >>= aaShift;
//int fy = (((rect.m_y+511)*a_size)>>10);
int fy = (rect.m_y*a_size + bias) >> 10;
int fh = rect.m_height >> aaShift;
int yOff = a_y + a_size - fh - fy;
DrawPixelsAlpha(a_target, downScaled.m_pixels, 5 + a_x + ((rect.m_x*a_size)>>10),
a_y + 2 + yOff, w, h, 0, 0, w, h);
}
delete[] downScaled.m_pixels;
}
else
{
int yOff = a_size - rect.m_height;
DrawPixels(a_target, buf.m_pixels, a_x + ((rect.m_x*a_size)>>10),
a_y + yOff - ((rect.m_y*a_size)>>10), buf.m_width, buf.m_height, 0, 0, buf.m_width, buf.m_height);
}
delete[] buf.m_pixels;
}
