walkero
/
lite-xl
1
0
Fork 0
Code Issues 7 Pull Requests Projects Releases 14 Wiki Activity
lite-xl/src/renderer.h

69 lines
2.1 KiB
C
Raw Normal View History

Initial commit
2019-12-28 12:16:32 +01:00
#ifndef RENDERER_H
#define RENDERER_H
Fix SDL2 include directives
2020-06-29 15:24:08 +02:00
#include <SDL.h>
Initial commit
2019-12-28 12:16:32 +01:00
#include <stdint.h>
First implementation of scaling for retina display Introduce a new approach that discriminate coordinates in points and pixels. Now all the logic from the Lua side and in rencache is to always use points. The coordinates are converted to pixels only within the renderer, in the file renderer.c. In this way the application logic does not need to care about the scaling of the retina displays. For non-retina display the scaling between points and pixels is equal to one so nothing will change. There is nevertheless a change that leak into the Lua side. The subpixel coordinates are in sub-pixel, not sub-points so they are scaled by the retina scaling factor. But no change in the code is required because the subpixel scaling factor take into account the retina scaling, when present. Because the retina scaling factor is not know when the application starts but only when a window is actually available we introduce a mechanism to render the font with a given scaling factor only from the renderer when they are needed. We use therefore FontDesc to describe the font information but without actually rasterizing the font at a given scale.
2021-04-24 10:21:34 +02:00
#include "fontdesc.h"
Initial commit
2019-12-28 12:16:32 +01:00
typedef struct RenImage RenImage;
Implement optional font rendering options The user can now choose antialiasing grayscale and subpixel and hinting non, slight or full.
2020-12-04 16:15:54 +01:00
enum {
RenFontAntialiasingMask = 1,
RenFontGrayscale = 1,
RenFontSubpixel = 0,
RenFontHintingMask = 3 << 1,
RenFontHintingSlight = 0 << 1,
RenFontHintingNone = 1 << 1,
RenFontHintingFull = 2 << 1,
};
Initial commit
2019-12-28 12:16:32 +01:00
typedef struct { uint8_t b, g, r, a; } RenColor;
typedef struct { int x, y, width, height; } RenRect;
Implement unicode character replacements Useful to draw whitespaces with alternate characters and colors without slowing down the text rendering. A new API is implemented. A renderer.replacements object can be created to list the replacements. In turns the function renderer.draw_text and draw_text_subpixel now accept two optional arguments for replacements.
2021-03-31 17:33:35 +02:00
struct CPReplace {
unsigned codepoint_src;
unsigned codepoint_dst;
};
typedef struct CPReplace CPReplace;
struct CPReplaceTable {
int size;
CPReplace *replacements;
};
typedef struct CPReplaceTable CPReplaceTable;
Initial commit
2019-12-28 12:16:32 +01:00
void ren_init(SDL_Window *win);
First implementation of scaling for retina display Introduce a new approach that discriminate coordinates in points and pixels. Now all the logic from the Lua side and in rencache is to always use points. The coordinates are converted to pixels only within the renderer, in the file renderer.c. In this way the application logic does not need to care about the scaling of the retina displays. For non-retina display the scaling between points and pixels is equal to one so nothing will change. There is nevertheless a change that leak into the Lua side. The subpixel coordinates are in sub-pixel, not sub-points so they are scaled by the retina scaling factor. But no change in the code is required because the subpixel scaling factor take into account the retina scaling, when present. Because the retina scaling factor is not know when the application starts but only when a window is actually available we introduce a mechanism to render the font with a given scaling factor only from the renderer when they are needed. We use therefore FontDesc to describe the font information but without actually rasterizing the font at a given scale.
2021-04-24 10:21:34 +02:00
void ren_setup_renderer();
Initial commit
2019-12-28 12:16:32 +01:00
void ren_update_rects(RenRect *rects, int count);
void ren_set_clip_rect(RenRect rect);
First implementation of scaling for retina display Introduce a new approach that discriminate coordinates in points and pixels. Now all the logic from the Lua side and in rencache is to always use points. The coordinates are converted to pixels only within the renderer, in the file renderer.c. In this way the application logic does not need to care about the scaling of the retina displays. For non-retina display the scaling between points and pixels is equal to one so nothing will change. There is nevertheless a change that leak into the Lua side. The subpixel coordinates are in sub-pixel, not sub-points so they are scaled by the retina scaling factor. But no change in the code is required because the subpixel scaling factor take into account the retina scaling, when present. Because the retina scaling factor is not know when the application starts but only when a window is actually available we introduce a mechanism to render the font with a given scaling factor only from the renderer when they are needed. We use therefore FontDesc to describe the font information but without actually rasterizing the font at a given scale.
2021-04-24 10:21:34 +02:00
void ren_get_size(int *x, int *y); /* Reports the size in points. */
First working implemention Cleanup also debug messages
2021-04-23 14:54:25 +02:00
void ren_free_window_resources();
Initial commit
2019-12-28 12:16:32 +01:00
RenImage* ren_new_image(int width, int height);
void ren_free_image(RenImage *image);
Implement optional font rendering options The user can now choose antialiasing grayscale and subpixel and hinting non, slight or full.
2020-12-04 16:15:54 +01:00
RenFont* ren_load_font(const char *filename, float size, unsigned int renderer_flags);
First implementation of scaling for retina display Introduce a new approach that discriminate coordinates in points and pixels. Now all the logic from the Lua side and in rencache is to always use points. The coordinates are converted to pixels only within the renderer, in the file renderer.c. In this way the application logic does not need to care about the scaling of the retina displays. For non-retina display the scaling between points and pixels is equal to one so nothing will change. There is nevertheless a change that leak into the Lua side. The subpixel coordinates are in sub-pixel, not sub-points so they are scaled by the retina scaling factor. But no change in the code is required because the subpixel scaling factor take into account the retina scaling, when present. Because the retina scaling factor is not know when the application starts but only when a window is actually available we introduce a mechanism to render the font with a given scaling factor only from the renderer when they are needed. We use therefore FontDesc to describe the font information but without actually rasterizing the font at a given scale.
2021-04-24 10:21:34 +02:00
int ren_verify_font(const char *filename);
Initial commit
2019-12-28 12:16:32 +01:00
void ren_free_font(RenFont *font);
Fix problem with tab size and subpixel positioning Solve github issue https://github.com/franko/lite-xl/issues/109
2021-03-18 13:54:33 +01:00
void ren_set_font_tab_size(RenFont *font, int n);
int ren_get_font_tab_size(RenFont *font);
First implementation of scaling for retina display Introduce a new approach that discriminate coordinates in points and pixels. Now all the logic from the Lua side and in rencache is to always use points. The coordinates are converted to pixels only within the renderer, in the file renderer.c. In this way the application logic does not need to care about the scaling of the retina displays. For non-retina display the scaling between points and pixels is equal to one so nothing will change. There is nevertheless a change that leak into the Lua side. The subpixel coordinates are in sub-pixel, not sub-points so they are scaled by the retina scaling factor. But no change in the code is required because the subpixel scaling factor take into account the retina scaling, when present. Because the retina scaling factor is not know when the application starts but only when a window is actually available we introduce a mechanism to render the font with a given scaling factor only from the renderer when they are needed. We use therefore FontDesc to describe the font information but without actually rasterizing the font at a given scale.
2021-04-24 10:21:34 +02:00
int ren_get_font_width(FontDesc *font_desc, const char *text, int *subpixel_scale);
int ren_get_font_height(FontDesc *font_desc);
int ren_get_font_subpixel_scale(FontDesc *font_desc);
Mostly fix problem of offset with cursor positioning when using mouse In order to get right the cursor position on text on mouse clicks it is needed to take into account text's subpixel positioning. This fix mostly corrects the problem but cursor positioning is still somewhat inaccurate for long lines due to repeated commands to draw a text along a line. Repeated draw text calls make the subpixel information lost and small errors will add-up.
2021-03-06 16:18:24 +01:00
int ren_font_subpixel_round(int width, int subpixel_scale, int orientation);
Initial commit
2019-12-28 12:16:32 +01:00
void ren_draw_rect(RenRect rect, RenColor color);
First implementation of scaling for retina display Introduce a new approach that discriminate coordinates in points and pixels. Now all the logic from the Lua side and in rencache is to always use points. The coordinates are converted to pixels only within the renderer, in the file renderer.c. In this way the application logic does not need to care about the scaling of the retina displays. For non-retina display the scaling between points and pixels is equal to one so nothing will change. There is nevertheless a change that leak into the Lua side. The subpixel coordinates are in sub-pixel, not sub-points so they are scaled by the retina scaling factor. But no change in the code is required because the subpixel scaling factor take into account the retina scaling, when present. Because the retina scaling factor is not know when the application starts but only when a window is actually available we introduce a mechanism to render the font with a given scaling factor only from the renderer when they are needed. We use therefore FontDesc to describe the font information but without actually rasterizing the font at a given scale.
2021-04-24 10:21:34 +02:00
void ren_draw_text(FontDesc *font_desc, const char *text, int x, int y, RenColor color, CPReplaceTable *replacements, RenColor replace_color);
void ren_draw_text_subpixel(FontDesc *font_desc, const char *text, int x_subpixel, int y, RenColor color, CPReplaceTable *replacements, RenColor replace_color);
Implement unicode character replacements Useful to draw whitespaces with alternate characters and colors without slowing down the text rendering. A new API is implemented. A renderer.replacements object can be created to list the replacements. In turns the function renderer.draw_text and draw_text_subpixel now accept two optional arguments for replacements.
2021-03-31 17:33:35 +02:00
void ren_cp_replace_init(CPReplaceTable *rep_table);
void ren_cp_replace_free(CPReplaceTable *rep_table);
void ren_cp_replace_add(CPReplaceTable *rep_table, const char *src, const char *dst);
void ren_cp_replace_clear(CPReplaceTable *rep_table);
Initial commit
2019-12-28 12:16:32 +01:00
#endif