lite-xl/src/renderer.c

507 lines
19 KiB
C
Raw Permalink Normal View History

2019-12-28 12:16:32 +01:00
#include <stdio.h>
#include <stdbool.h>
#include <stdint.h>
2019-12-28 12:16:32 +01:00
#include <assert.h>
#include <math.h>
2021-09-11 04:22:30 +02:00
#include <ft2build.h>
#include <freetype/ftlcdfil.h>
#include <freetype/ftoutln.h>
#include FT_FREETYPE_H
2021-04-29 14:15:24 +02:00
#include "renderer.h"
#include "renwindow.h"
2019-12-28 12:16:32 +01:00
#define MAX_GLYPHSET 256
2021-11-01 15:03:36 +01:00
#define MAX_LOADABLE_GLYPHSETS 1024
2021-09-11 04:22:30 +02:00
#define SUBPIXEL_BITMAPS_CACHED 3
2019-12-28 12:16:32 +01:00
2021-04-29 14:15:24 +02:00
static RenWindow window_renderer = {0};
2021-09-11 04:22:30 +02:00
static FT_Library library;
2019-12-28 12:16:32 +01:00
// draw_rect_surface is used as a 1x1 surface to simplify ren_draw_rect with blending
static SDL_Surface *draw_rect_surface;
2020-05-08 14:41:39 +02:00
static void* check_alloc(void *ptr) {
if (!ptr) {
fprintf(stderr, "Fatal error: memory allocation failed\n");
exit(EXIT_FAILURE);
}
return ptr;
}
2021-09-11 04:22:30 +02:00
/************************* Fonts *************************/
typedef struct {
2021-10-13 05:24:52 +02:00
unsigned short x0, x1, y0, y1, loaded;
2021-09-11 04:22:30 +02:00
short bitmap_left, bitmap_top;
float xadvance;
} GlyphMetric;
typedef struct {
2021-10-02 03:20:44 +02:00
SDL_Surface* surface;
GlyphMetric metrics[MAX_GLYPHSET];
2021-09-11 04:22:30 +02:00
} GlyphSet;
typedef struct RenFont {
FT_Face face;
GlyphSet* sets[SUBPIXEL_BITMAPS_CACHED][MAX_LOADABLE_GLYPHSETS];
float size, space_advance, tab_advance;
unsigned short max_height, baseline, height;
2021-11-23 00:13:43 +01:00
ERenFontAntialiasing antialiasing;
2021-09-11 04:22:30 +02:00
ERenFontHinting hinting;
unsigned char style;
unsigned short underline_thickness;
char path[1];
2021-09-11 04:22:30 +02:00
} RenFont;
2020-05-08 14:41:39 +02:00
2019-12-28 12:16:32 +01:00
static const char* utf8_to_codepoint(const char *p, unsigned *dst) {
const unsigned char *up = (unsigned char*)p;
2019-12-28 12:16:32 +01:00
unsigned res, n;
switch (*p & 0xf0) {
case 0xf0 : res = *up & 0x07; n = 3; break;
case 0xe0 : res = *up & 0x0f; n = 2; break;
2019-12-28 12:16:32 +01:00
case 0xd0 :
case 0xc0 : res = *up & 0x1f; n = 1; break;
default : res = *up; n = 0; break;
2019-12-28 12:16:32 +01:00
}
while (n--) {
res = (res << 6) | (*(++up) & 0x3f);
2019-12-28 12:16:32 +01:00
}
*dst = res;
return (const char*)up + 1;
2019-12-28 12:16:32 +01:00
}
2021-09-11 04:22:30 +02:00
static int font_set_load_options(RenFont* font) {
int load_target = font->antialiasing == FONT_ANTIALIASING_NONE ? FT_LOAD_TARGET_MONO
2021-11-23 00:13:43 +01:00
: (font->hinting == FONT_HINTING_SLIGHT ? FT_LOAD_TARGET_LIGHT : FT_LOAD_TARGET_NORMAL);
int hinting = font->hinting == FONT_HINTING_NONE ? FT_LOAD_NO_HINTING : FT_LOAD_FORCE_AUTOHINT;
return load_target | hinting;
}
2021-09-11 04:22:30 +02:00
static int font_set_render_options(RenFont* font) {
2021-11-23 00:13:43 +01:00
if (font->antialiasing == FONT_ANTIALIASING_NONE)
return FT_RENDER_MODE_MONO;
if (font->antialiasing == FONT_ANTIALIASING_SUBPIXEL) {
2021-09-27 01:46:32 +02:00
unsigned char weights[] = { 0x10, 0x40, 0x70, 0x40, 0x10 } ;
2021-09-11 04:22:30 +02:00
switch (font->hinting) {
case FONT_HINTING_NONE: FT_Library_SetLcdFilter(library, FT_LCD_FILTER_NONE); break;
2021-09-27 01:46:32 +02:00
case FONT_HINTING_SLIGHT:
2021-09-27 02:09:51 +02:00
case FONT_HINTING_FULL: FT_Library_SetLcdFilterWeights(library, weights); break;
2021-09-11 04:22:30 +02:00
}
return FT_RENDER_MODE_LCD;
} else {
switch (font->hinting) {
case FONT_HINTING_NONE: return FT_RENDER_MODE_NORMAL; break;
case FONT_HINTING_SLIGHT: return FT_RENDER_MODE_LIGHT; break;
case FONT_HINTING_FULL: return FT_RENDER_MODE_LIGHT; break;
}
}
2021-09-11 04:22:30 +02:00
return 0;
2019-12-28 12:16:32 +01:00
}
static int font_set_style(FT_Outline* outline, int x_translation, unsigned char style) {
FT_Outline_Translate(outline, x_translation, 0 );
if (style & FONT_STYLE_SMOOTH)
FT_Outline_Embolden(outline, 1 << 5);
if (style & FONT_STYLE_BOLD)
FT_Outline_EmboldenXY(outline, 1 << 5, 0);
if (style & FONT_STYLE_ITALIC) {
FT_Matrix matrix = { 1 << 16, 1 << 14, 0, 1 << 16 };
FT_Outline_Transform(outline, &matrix);
}
return 0;
}
2021-10-17 06:39:08 +02:00
static void font_load_glyphset(RenFont* font, int idx) {
2021-09-11 04:22:30 +02:00
unsigned int render_option = font_set_render_options(font), load_option = font_set_load_options(font);
2021-11-23 00:13:43 +01:00
int bitmaps_cached = font->antialiasing == FONT_ANTIALIASING_SUBPIXEL ? SUBPIXEL_BITMAPS_CACHED : 1;
unsigned int byte_width = font->antialiasing == FONT_ANTIALIASING_SUBPIXEL ? 3 : 1;
2021-10-02 03:20:44 +02:00
for (int j = 0, pen_x = 0; j < bitmaps_cached; ++j) {
GlyphSet* set = check_alloc(calloc(1, sizeof(GlyphSet)));
font->sets[j][idx] = set;
2021-10-31 18:27:51 +01:00
for (int i = 0; i < MAX_GLYPHSET; ++i) {
2021-10-13 05:24:52 +02:00
int glyph_index = FT_Get_Char_Index(font->face, i + idx * MAX_GLYPHSET);
if (!glyph_index || FT_Load_Glyph(font->face, glyph_index, load_option | FT_LOAD_BITMAP_METRICS_ONLY)
|| font_set_style(&font->face->glyph->outline, j * (64 / SUBPIXEL_BITMAPS_CACHED), font->style) || FT_Render_Glyph(font->face->glyph, render_option)) {
2021-10-02 03:20:44 +02:00
continue;
}
2021-10-02 03:20:44 +02:00
FT_GlyphSlot slot = font->face->glyph;
int glyph_width = slot->bitmap.width / byte_width;
2021-11-23 00:13:43 +01:00
if (font->antialiasing == FONT_ANTIALIASING_NONE)
glyph_width *= 8;
2021-10-13 05:24:52 +02:00
set->metrics[i] = (GlyphMetric){ pen_x, pen_x + glyph_width, 0, slot->bitmap.rows, true, slot->bitmap_left, slot->bitmap_top, (slot->advance.x + slot->lsb_delta - slot->rsb_delta) / 64.0f};
2021-10-02 03:20:44 +02:00
pen_x += glyph_width;
font->max_height = slot->bitmap.rows > font->max_height ? slot->bitmap.rows : font->max_height;
// In order to fix issues with monospacing; we need the unhinted xadvance; as FreeType doesn't correctly report the hinted advance for spaces on monospace fonts (like RobotoMono). See #843.
if (!glyph_index || FT_Load_Glyph(font->face, glyph_index, (load_option | FT_LOAD_BITMAP_METRICS_ONLY | FT_LOAD_NO_HINTING) & ~FT_LOAD_FORCE_AUTOHINT)
|| font_set_style(&font->face->glyph->outline, j * (64 / SUBPIXEL_BITMAPS_CACHED), font->style) || FT_Render_Glyph(font->face->glyph, render_option)) {
continue;
}
slot = font->face->glyph;
set->metrics[i].xadvance = slot->advance.x / 64.0f;
2021-10-02 03:20:44 +02:00
}
if (pen_x == 0)
continue;
2021-11-23 00:13:43 +01:00
set->surface = check_alloc(SDL_CreateRGBSurface(0, pen_x, font->max_height, font->antialiasing == FONT_ANTIALIASING_SUBPIXEL ? 24 : 8, 0, 0, 0, 0));
uint8_t* pixels = set->surface->pixels;
2021-10-31 18:27:51 +01:00
for (int i = 0; i < MAX_GLYPHSET; ++i) {
2021-09-11 04:22:30 +02:00
int glyph_index = FT_Get_Char_Index(font->face, i + idx * MAX_GLYPHSET);
if (!glyph_index || FT_Load_Glyph(font->face, glyph_index, load_option))
continue;
FT_GlyphSlot slot = font->face->glyph;
font_set_style(&slot->outline, (64 / bitmaps_cached) * j, font->style);
2021-09-11 04:22:30 +02:00
if (FT_Render_Glyph(slot, render_option))
continue;
for (unsigned int line = 0; line < slot->bitmap.rows; ++line) {
2021-10-02 03:20:44 +02:00
int target_offset = set->surface->pitch * line + set->metrics[i].x0 * byte_width;
2021-09-11 04:22:30 +02:00
int source_offset = line * slot->bitmap.pitch;
2021-11-23 00:13:43 +01:00
if (font->antialiasing == FONT_ANTIALIASING_NONE) {
for (unsigned int column = 0; column < slot->bitmap.width; ++column) {
2021-11-23 00:13:43 +01:00
int current_source_offset = source_offset + (column / 8);
int source_pixel = slot->bitmap.buffer[current_source_offset];
pixels[++target_offset] = ((source_pixel >> (7 - (column % 8))) & 0x1) << 7;
}
} else
memcpy(&pixels[target_offset], &slot->bitmap.buffer[source_offset], slot->bitmap.width);
2021-09-11 04:22:30 +02:00
}
}
}
2019-12-28 12:16:32 +01:00
}
static GlyphSet* font_get_glyphset(RenFont* font, unsigned int codepoint, int subpixel_idx) {
int idx = (codepoint >> 8) % MAX_LOADABLE_GLYPHSETS;
2021-11-23 00:13:43 +01:00
if (!font->sets[font->antialiasing == FONT_ANTIALIASING_SUBPIXEL ? subpixel_idx : 0][idx])
2021-10-02 03:20:44 +02:00
font_load_glyphset(font, idx);
2021-11-23 00:13:43 +01:00
return font->sets[font->antialiasing == FONT_ANTIALIASING_SUBPIXEL ? subpixel_idx : 0][idx];
}
2021-10-17 06:39:08 +02:00
static RenFont* font_group_get_glyph(GlyphSet** set, GlyphMetric** metric, RenFont** fonts, unsigned int codepoint, int bitmap_index) {
if (!metric) {
return NULL;
}
2021-10-17 06:39:08 +02:00
if (bitmap_index < 0)
bitmap_index += SUBPIXEL_BITMAPS_CACHED;
for (int i = 0; i < FONT_FALLBACK_MAX && fonts[i]; ++i) {
*set = font_get_glyphset(fonts[i], codepoint, bitmap_index);
*metric = &(*set)->metrics[codepoint % 256];
if ((*metric)->loaded || codepoint < 0xFF)
return fonts[i];
}
if (*metric && !(*metric)->loaded && codepoint > 0xFF && codepoint != 0x25A1)
2021-10-17 06:39:08 +02:00
return font_group_get_glyph(set, metric, fonts, 0x25A1, bitmap_index);
return fonts[0];
}
static void font_clear_glyph_cache(RenFont* font) {
for (int i = 0; i < SUBPIXEL_BITMAPS_CACHED; ++i) {
for (int j = 0; j < MAX_GLYPHSET; ++j) {
if (font->sets[i][j]) {
if (font->sets[i][j]->surface)
SDL_FreeSurface(font->sets[i][j]->surface);
free(font->sets[i][j]);
font->sets[i][j] = NULL;
}
}
}
}
2021-11-23 00:13:43 +01:00
RenFont* ren_font_load(const char* path, float size, ERenFontAntialiasing antialiasing, ERenFontHinting hinting, unsigned char style) {
2021-09-11 04:22:30 +02:00
FT_Face face;
if (FT_New_Face( library, path, 0, &face))
2020-06-01 17:01:42 +02:00
return NULL;
const int surface_scale = renwin_surface_scale(&window_renderer);
if (FT_Set_Pixel_Sizes(face, 0, (int)(size*surface_scale)))
2021-09-11 04:22:30 +02:00
goto failure;
int len = strlen(path);
RenFont* font = check_alloc(calloc(1, sizeof(RenFont) + len + 1));
strcpy(font->path, path);
font->face = face;
font->size = size;
font->height = (short)((face->height / (float)face->units_per_EM) * font->size);
font->baseline = (short)((face->ascender / (float)face->units_per_EM) * font->size);
2021-11-23 00:13:43 +01:00
font->antialiasing = antialiasing;
2021-09-11 04:22:30 +02:00
font->hinting = hinting;
font->style = style;
if(FT_IS_SCALABLE(face))
font->underline_thickness = (unsigned short)((face->underline_thickness / (float)face->units_per_EM) * font->size);
if(!font->underline_thickness) font->underline_thickness = ceil((double) font->height / 14.0);
if (FT_Load_Char(face, ' ', font_set_load_options(font)))
goto failure;
font->space_advance = face->glyph->advance.x / 64.0f;
2021-09-11 04:22:30 +02:00
font->tab_advance = font->space_advance * 2;
2019-12-28 12:16:32 +01:00
return font;
failure:
2021-09-11 04:22:30 +02:00
FT_Done_Face(face);
return NULL;
2019-12-28 12:16:32 +01:00
}
RenFont* ren_font_copy(RenFont* font, float size, ERenFontAntialiasing antialiasing, ERenFontHinting hinting, int style) {
antialiasing = antialiasing == -1 ? font->antialiasing : antialiasing;
hinting = hinting == -1 ? font->hinting : hinting;
style = style == -1 ? font->style : style;
return ren_font_load(font->path, size, antialiasing, hinting, style);
}
const char* ren_font_get_path(RenFont *font) {
return font->path;
2021-09-11 04:22:30 +02:00
}
2019-12-28 12:16:32 +01:00
2021-09-11 04:22:30 +02:00
void ren_font_free(RenFont* font) {
font_clear_glyph_cache(font);
2021-09-11 04:22:30 +02:00
FT_Done_Face(font->face);
2020-05-08 14:41:39 +02:00
free(font);
2019-12-28 12:16:32 +01:00
}
2021-10-13 05:24:52 +02:00
void ren_font_group_set_tab_size(RenFont **fonts, int n) {
for (int j = 0; j < FONT_FALLBACK_MAX && fonts[j]; ++j) {
for (int i = 0; i < (fonts[j]->antialiasing == FONT_ANTIALIASING_SUBPIXEL ? SUBPIXEL_BITMAPS_CACHED : 1); ++i)
2021-10-13 05:24:52 +02:00
font_get_glyphset(fonts[j], '\t', i)->metrics['\t'].xadvance = fonts[j]->space_advance * n;
}
2019-12-28 12:16:32 +01:00
}
2021-10-13 05:24:52 +02:00
int ren_font_group_get_tab_size(RenFont **fonts) {
float advance = font_get_glyphset(fonts[0], '\t', 0)->metrics['\t'].xadvance;
if (fonts[0]->space_advance) {
advance /= fonts[0]->space_advance;
}
return advance;
}
2021-10-17 05:49:42 +02:00
float ren_font_group_get_size(RenFont **fonts) {
return fonts[0]->size;
}
void ren_font_group_set_size(RenFont **fonts, float size) {
const int surface_scale = renwin_surface_scale(&window_renderer);
for (int i = 0; i < FONT_FALLBACK_MAX && fonts[i]; ++i) {
font_clear_glyph_cache(fonts[i]);
FT_Face face = fonts[i]->face;
FT_Set_Pixel_Sizes(face, 0, (int)(size*surface_scale));
fonts[i]->size = size;
fonts[i]->height = (short)((face->height / (float)face->units_per_EM) * size);
fonts[i]->baseline = (short)((face->ascender / (float)face->units_per_EM) * size);
FT_Load_Char(face, ' ', font_set_load_options(fonts[i]));
fonts[i]->space_advance = face->glyph->advance.x / 64.0f;
fonts[i]->tab_advance = fonts[i]->space_advance * 2;
}
}
2021-10-17 05:49:42 +02:00
int ren_font_group_get_height(RenFont **fonts) {
return fonts[0]->height;
2021-10-17 05:49:42 +02:00
}
2021-10-13 05:24:52 +02:00
float ren_font_group_get_width(RenFont **fonts, const char *text) {
2021-09-25 05:34:19 +02:00
float width = 0;
2021-09-11 04:22:30 +02:00
const char* end = text + strlen(text);
2021-10-17 06:10:40 +02:00
GlyphMetric* metric = NULL; GlyphSet* set = NULL;
2021-09-11 04:22:30 +02:00
while (text < end) {
unsigned int codepoint;
text = utf8_to_codepoint(text, &codepoint);
RenFont* font = font_group_get_glyph(&set, &metric, fonts, codepoint, 0);
if (!metric)
break;
width += (!font || metric->xadvance) ? metric->xadvance : fonts[0]->space_advance;
2019-12-28 12:16:32 +01:00
}
const int surface_scale = renwin_surface_scale(&window_renderer);
return width / surface_scale;
2019-12-28 12:16:32 +01:00
}
2021-10-13 05:24:52 +02:00
float ren_draw_text(RenFont **fonts, const char *text, float x, int y, RenColor color) {
2021-09-11 04:22:30 +02:00
SDL_Surface *surface = renwin_get_surface(&window_renderer);
const RenRect clip = window_renderer.clip;
const int surface_scale = renwin_surface_scale(&window_renderer);
float pen_x = x * surface_scale;
y *= surface_scale;
2021-09-11 04:22:30 +02:00
int bytes_per_pixel = surface->format->BytesPerPixel;
const char* end = text + strlen(text);
uint8_t* destination_pixels = surface->pixels;
2021-09-11 04:22:30 +02:00
int clip_end_x = clip.x + clip.width, clip_end_y = clip.y + clip.height;
RenFont* last;
float last_pen_x = x;
bool underline = fonts[0]->style & FONT_STYLE_UNDERLINE;
bool strikethrough = fonts[0]->style & FONT_STYLE_STRIKETHROUGH;
2021-09-11 04:22:30 +02:00
while (text < end) {
unsigned int codepoint, r, g, b;
text = utf8_to_codepoint(text, &codepoint);
GlyphSet* set = NULL; GlyphMetric* metric = NULL;
2021-10-17 06:10:40 +02:00
RenFont* font = font_group_get_glyph(&set, &metric, fonts, codepoint, (int)(fmod(pen_x, 1.0) * SUBPIXEL_BITMAPS_CACHED));
if (!metric)
break;
2021-10-08 00:54:23 +02:00
int start_x = floor(pen_x) + metric->bitmap_left;
int end_x = (metric->x1 - metric->x0) + start_x;
int glyph_end = metric->x1, glyph_start = metric->x0;
if (!metric->loaded && codepoint > 0xFF)
ren_draw_rect((RenRect){ start_x + 1, y, font->space_advance - 1, ren_font_group_get_height(fonts) }, color);
if (set->surface && color.a > 0 && end_x >= clip.x && start_x < clip_end_x) {
uint8_t* source_pixels = set->surface->pixels;
2021-09-11 04:22:30 +02:00
for (int line = metric->y0; line < metric->y1; ++line) {
int target_y = line + y - metric->bitmap_top + font->baseline * surface_scale;
if (target_y < clip.y)
2021-09-11 04:22:30 +02:00
continue;
if (target_y >= clip_end_y)
2021-09-11 04:22:30 +02:00
break;
if (start_x + (glyph_end - glyph_start) >= clip_end_x)
glyph_end = glyph_start + (clip_end_x - start_x);
if (start_x < clip.x) {
2021-10-13 03:22:02 +02:00
int offset = clip.x - start_x;
start_x += offset;
glyph_start += offset;
}
uint32_t* destination_pixel = (uint32_t*)&(destination_pixels[surface->pitch * target_y + start_x * bytes_per_pixel]);
uint8_t* source_pixel = &source_pixels[line * set->surface->pitch + glyph_start * (font->antialiasing == FONT_ANTIALIASING_SUBPIXEL ? 3 : 1)];
for (int x = glyph_start; x < glyph_end; ++x) {
uint32_t destination_color = *destination_pixel;
// the standard way of doing this would be SDL_GetRGBA, but that introduces a performance regression. needs to be investigated
SDL_Color dst = { (destination_color & surface->format->Rmask) >> surface->format->Rshift, (destination_color & surface->format->Gmask) >> surface->format->Gshift, (destination_color & surface->format->Bmask) >> surface->format->Bshift, (destination_color & surface->format->Amask) >> surface->format->Ashift };
SDL_Color src;
if (font->antialiasing == FONT_ANTIALIASING_SUBPIXEL) {
src.r = *(source_pixel++);
src.g = *(source_pixel++);
}
else {
src.r = *(source_pixel);
src.g = *(source_pixel);
}
src.b = *(source_pixel++);
src.a = 0xFF;
r = (color.r * src.r * color.a + dst.r * (65025 - src.r * color.a) + 32767) / 65025;
g = (color.g * src.g * color.a + dst.g * (65025 - src.g * color.a) + 32767) / 65025;
b = (color.b * src.b * color.a + dst.b * (65025 - src.b * color.a) + 32767) / 65025;
// the standard way of doing this would be SDL_GetRGBA, but that introduces a performance regression. needs to be investigated
*destination_pixel++ = dst.a << surface->format->Ashift | r << surface->format->Rshift | g << surface->format->Gshift | b << surface->format->Bshift;
2021-09-11 04:22:30 +02:00
}
}
}
float adv = metric->xadvance ? metric->xadvance : font->space_advance;
if(!last) last = font;
else if(font != last || text == end) {
float local_pen_x = text == end ? pen_x + adv : pen_x;
if (underline)
ren_draw_rect((RenRect){last_pen_x, y / surface_scale + last->height - 1, (local_pen_x - last_pen_x) / surface_scale, last->underline_thickness * surface_scale}, color);
if (strikethrough)
ren_draw_rect((RenRect){last_pen_x, y / surface_scale + last->height / 2, (local_pen_x - last_pen_x) / surface_scale, last->underline_thickness * surface_scale}, color);
last = font;
last_pen_x = pen_x;
}
pen_x += adv;
2021-09-11 04:22:30 +02:00
}
return pen_x / surface_scale;
2021-09-11 04:22:30 +02:00
}
2019-12-28 12:16:32 +01:00
2021-09-11 04:22:30 +02:00
/******************* Rectangles **********************/
2019-12-28 12:16:32 +01:00
static inline RenColor blend_pixel(RenColor dst, RenColor src) {
int ia = 0xff - src.a;
dst.r = ((src.r * src.a) + (dst.r * ia)) >> 8;
dst.g = ((src.g * src.a) + (dst.g * ia)) >> 8;
dst.b = ((src.b * src.a) + (dst.b * ia)) >> 8;
return dst;
}
void ren_draw_rect(RenRect rect, RenColor color) {
if (color.a == 0) { return; }
2021-04-29 14:15:24 +02:00
const int surface_scale = renwin_surface_scale(&window_renderer);
/* transforms coordinates in pixels. */
rect.x *= surface_scale;
rect.y *= surface_scale;
rect.width *= surface_scale;
rect.height *= surface_scale;
2021-04-29 14:15:24 +02:00
const RenRect clip = window_renderer.clip;
int x1 = rect.x < clip.x ? clip.x : rect.x;
int y1 = rect.y < clip.y ? clip.y : rect.y;
2019-12-28 12:16:32 +01:00
int x2 = rect.x + rect.width;
int y2 = rect.y + rect.height;
2021-04-29 14:15:24 +02:00
x2 = x2 > clip.x + clip.width ? clip.x + clip.width : x2;
y2 = y2 > clip.y + clip.height ? clip.y + clip.height : y2;
2019-12-28 12:16:32 +01:00
2021-04-29 14:15:24 +02:00
SDL_Surface *surface = renwin_get_surface(&window_renderer);
uint32_t *d = surface->pixels;
2022-09-26 18:27:35 +02:00
#if defined(__amigaos4__) || defined(__morphos__)
d += x1 + y1 * surface->pitch/sizeof(uint32_t);
int dr = surface->pitch/sizeof(uint32_t) - (x2 - x1);
#else
2021-04-29 14:15:24 +02:00
d += x1 + y1 * surface->w;
int dr = surface->w - (x2 - x1);
#endif
2019-12-28 12:16:32 +01:00
if (color.a == 0xff) {
uint32_t translated = SDL_MapRGB(surface->format, color.r, color.g, color.b);
2021-06-10 01:34:02 +02:00
SDL_Rect rect = { x1, y1, x2 - x1, y2 - y1 };
SDL_FillRect(surface, &rect, translated);
2019-12-28 12:16:32 +01:00
} else {
RenColor current_color;
RenColor blended_color;
for (int j = y1; j < y2; j++) {
for (int i = x1; i < x2; i++, d++) {
SDL_GetRGB(*d, surface->format, &current_color.r, &current_color.g, &current_color.b);
blended_color = blend_pixel(current_color, color);
*d = SDL_MapRGB(surface->format, blended_color.r, blended_color.g, blended_color.b);
}
d += dr;
}
2019-12-28 12:16:32 +01:00
}
}
2021-09-11 04:22:30 +02:00
/*************** Window Management ****************/
void ren_free_window_resources() {
renwin_free(&window_renderer);
SDL_FreeSurface(draw_rect_surface);
2021-09-11 04:22:30 +02:00
}
2019-12-28 12:16:32 +01:00
2021-09-11 04:22:30 +02:00
void ren_init(SDL_Window *win) {
assert(win);
int error = FT_Init_FreeType( &library );
if ( error ) {
fprintf(stderr, "internal font error when starting the application\n");
return;
}
2021-09-11 04:22:30 +02:00
window_renderer.window = win;
renwin_init_surface(&window_renderer);
renwin_clip_to_surface(&window_renderer);
draw_rect_surface = SDL_CreateRGBSurface(0, 1, 1, 32,
0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF);
}
2021-04-29 14:15:24 +02:00
2021-09-11 04:22:30 +02:00
void ren_resize_window() {
renwin_resize_surface(&window_renderer);
2021-04-29 14:15:24 +02:00
}
2021-09-11 04:22:30 +02:00
void ren_update_rects(RenRect *rects, int count) {
static bool initial_frame = true;
if (initial_frame) {
renwin_show_window(&window_renderer);
initial_frame = false;
2019-12-28 12:16:32 +01:00
}
2021-09-11 04:22:30 +02:00
renwin_update_rects(&window_renderer, rects, count);
}
2021-09-11 04:22:30 +02:00
void ren_set_clip_rect(RenRect rect) {
renwin_set_clip_rect(&window_renderer, rect);
}
2021-09-11 04:22:30 +02:00
void ren_get_size(int *x, int *y) {
RenWindow *ren = &window_renderer;
const int scale = renwin_surface_scale(ren);
SDL_Surface *surface = renwin_get_surface(ren);
*x = surface->w / scale;
*y = surface->h / scale;
}