github-code/lvgl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

arch(sdl) migrated to use new backend architecture (#2840)

Browse Source 
* migrated to use new backend architecture

* formatted code

* with direct_mode blend coordinates are working now

* added draw_img_core to backend

* moving from gpu/sdl to draw/sdl

* updated format

* updated format

* fixed include path

* fixing build issue
This commit is contained in:
Mariotaku
2021-11-29 22:53:06 +09:00
committed by GitHub
parent 163deb3dfb
commit 1281abef9e
25 changed files with 364 additions and 570 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/draw/lv_draw.h
View File

@@ -50,6 +50,9 @@ typedef struct _lv_draw_backend_t {
const lv_draw_img_dsc_t * draw_dsc,
bool chroma_key, bool alpha_byte);
lv_res_t (*draw_img_core)(const lv_area_t * coords, const lv_area_t * clip_area, const void * src,
const lv_draw_img_dsc_t * draw_dsc);
void (*draw_letter)(const lv_point_t * pos_p, const lv_area_t * clip_area,
const lv_font_t * font_p, uint32_t letter,
lv_color_t color, lv_opa_t opa, lv_blend_mode_t blend_mode);

9
src/draw/lv_draw_img.c
View File

@@ -70,8 +70,15 @@ void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void *
if(dsc->opa <= LV_OPA_MIN) return;
const lv_draw_backend_t * backend = lv_draw_backend_get();
lv_res_t res;
res = lv_img_draw_core(coords, mask, src, dsc);
if(backend->draw_img_core) {
res = backend->draw_img_core(coords, mask, src, dsc);
}
else {
res = lv_img_draw_core(coords, mask, src, dsc);
}
if(res == LV_RES_INV) {
LV_LOG_WARN("Image draw error");

4
src/gpu/sdl/README.md → src/draw/sdl/README.md
View File

@@ -18,11 +18,11 @@ such as OpenGL.
## Notices for files
### `lv_gpu_sdl_stack_blur.c`
### `lv_draw_sdl_stack_blur.c`
Contains modified code from [android-stackblur](https://github.com/kikoso/android-stackblur) project.
Apache License 2.0
### `lv_gpu_sdl_lru.c`/`lv_gpu_sdl_lru.h`
### `lv_draw_sdl_lru.c`/`lv_draw_sdl_lru.h`
Contains modified code from [C-LRU-Cache](https://github.com/willcannings/C-LRU-Cache) project. No license defined.

14
src/draw/sdl/lv_draw_sdl.mk Normal file
View File

@@ -0,0 +1,14 @@
CSRCS += lv_draw_sdl_draw_blend.c
CSRCS += lv_draw_sdl_draw_img.c
CSRCS += lv_draw_sdl_draw_label.c
CSRCS += lv_draw_sdl_draw_rect.c
CSRCS += lv_draw_sdl_lru.c
CSRCS += lv_draw_sdl_mask.c
CSRCS += lv_draw_sdl_stack_blur.c
CSRCS += lv_draw_sdl_texture_cache.c
CSRCS += lv_draw_sdl_utils.c
DEPPATH += --dep-path $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/gpu/sdl
VPATH += :$(LVGL_DIR)/$(LVGL_DIR_NAME)/src/gpu/sdl
CFLAGS += "-I$(LVGL_DIR)/$(LVGL_DIR_NAME)/src/gpu/sdl"

147
src/draw/sdl/lv_draw_sdl_blend.c Normal file
View File

@@ -0,0 +1,147 @@
/**
* @file lv_draw_sdl_draw_blend.c
*
*/
/*********************
* INCLUDES
*********************/
#include "../../lv_conf_internal.h"
#if LV_USE_GPU_SDL
#include "../../draw/lv_draw_blend.h"
#include "lv_draw_sdl_texture_cache.h"
#include "lv_draw_sdl_utils.h"
#include "lv_draw_sdl_mask.h"
#include LV_GPU_SDL_INCLUDE_PATH
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* STATIC PROTOTYPES
**********************/
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
void lv_draw_sdl_draw_blend_fill(lv_color_t * dest_buf, lv_coord_t dest_stride, const lv_area_t * fill_area,
lv_color_t color, lv_opa_t * mask, lv_opa_t opa, lv_blend_mode_t blend_mode)
{
LV_UNUSED(dest_buf);
/*Do not draw transparent things*/
if(opa < LV_OPA_MIN) return;
lv_draw_sdl_backend_context_t * ctx = lv_draw_sdl_get_context();
SDL_Renderer * renderer = ctx->renderer;
/*Get clipped fill area which is the real draw area.
*It is always the same or inside `fill_area`*/
lv_area_t draw_area = *fill_area;
// if(!_lv_area_intersect(&draw_area, clip_area, fill_area)) return;
SDL_Rect draw_area_rect;
lv_area_to_sdl_rect(&draw_area, &draw_area_rect);
if(mask) {
SDL_Surface * mask_surface = lv_sdl_create_mask_surface(mask, lv_area_get_width(&draw_area),
lv_area_get_height(&draw_area),
lv_area_get_width(&draw_area));
SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, mask_surface);
SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
SDL_SetTextureAlphaMod(texture, opa);
SDL_SetTextureColorMod(texture, color.ch.red, color.ch.green, color.ch.blue);
SDL_RenderSetClipRect(renderer, &draw_area_rect);
SDL_RenderCopy(renderer, texture, NULL, &draw_area_rect);
SDL_DestroyTexture(texture);
SDL_FreeSurface(mask_surface);
}
else {
SDL_SetRenderDrawColor(renderer, color.ch.red, color.ch.green, color.ch.blue, opa);
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
SDL_RenderSetClipRect(renderer, &draw_area_rect);
SDL_RenderFillRect(renderer, &draw_area_rect);
}
}
void lv_draw_sdl_draw_blend_map(lv_color_t * dest_buf, lv_coord_t dest_stride, const lv_area_t * clip_area,
const lv_color_t * src_buf, const lv_area_t * src_area,
lv_opa_t * mask, lv_opa_t opa, lv_blend_mode_t blend_mode)
{
LV_UNUSED(dest_buf);
/*Do not draw transparent things*/
if(opa < LV_OPA_MIN) return;
lv_draw_sdl_backend_context_t * ctx = lv_draw_sdl_get_context();
SDL_Renderer * renderer = ctx->renderer;
SDL_Rect draw_area_rect;
lv_area_to_sdl_rect(clip_area, &draw_area_rect);
Uint32 rmask = 0x00FF0000;
Uint32 gmask = 0x0000FF00;
Uint32 bmask = 0x000000FF;
Uint32 amask = 0x00000000;
SDL_Surface * surface = SDL_CreateRGBSurfaceFrom((void *) src_buf, lv_area_get_width(src_area),
lv_area_get_height(src_area), LV_COLOR_DEPTH,
lv_area_get_width(src_area) * LV_COLOR_DEPTH / 8,
rmask, gmask, bmask, amask);
if(mask) {
SDL_Texture * masked = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET,
lv_area_get_width(src_area), lv_area_get_height(src_area));
SDL_Texture * mask_texture = lv_sdl_create_mask_texture(renderer, mask, lv_area_get_width(src_area),
lv_area_get_height(src_area),
lv_area_get_width(src_area));
SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, surface);
SDL_SetRenderTarget(renderer, masked);
SDL_RenderSetClipRect(renderer, NULL);
SDL_SetTextureAlphaMod(mask_texture, opa);
SDL_SetTextureBlendMode(mask_texture, SDL_BLENDMODE_NONE);
SDL_RenderCopy(renderer, mask_texture, NULL, NULL);
SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_MOD);
SDL_RenderCopy(renderer, texture, NULL, NULL);
SDL_SetRenderTarget(renderer, ctx->texture);
SDL_RenderSetClipRect(renderer, &draw_area_rect);
SDL_SetTextureBlendMode(masked, SDL_BLENDMODE_BLEND);
SDL_SetTextureAlphaMod(masked, 0xFF);
SDL_SetTextureColorMod(masked, 0xFF, 0xFF, 0xFF);
SDL_RenderCopy(renderer, masked, NULL, &draw_area_rect);
SDL_DestroyTexture(texture);
SDL_DestroyTexture(mask_texture);
SDL_DestroyTexture(masked);
}
else {
SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, surface);
SDL_SetTextureAlphaMod(texture, opa);
SDL_SetRenderTarget(renderer, ctx->texture);
SDL_RenderSetClipRect(renderer, &draw_area_rect);
SDL_RenderCopy(renderer, texture, NULL, &draw_area_rect);
SDL_DestroyTexture(texture);
}
SDL_FreeSurface(surface);
}
/**********************
* STATIC FUNCTIONS
**********************/
#endif /*LV_USE_GPU_SDL*/

40
src/gpu/sdl/lv_gpu_sdl_draw_img.c → src/draw/sdl/lv_draw_sdl_img.c
View File

@@ -1,5 +1,5 @@
/**
* @file lv_gpu_sdl_draw_img.c
* @file lv_draw_sdl_draw_img.c
*
*/
@@ -11,10 +11,13 @@
#if LV_USE_GPU_SDL
#include "../../core/lv_refr.h"
#include "lv_gpu_sdl_utils.h"
#include "lv_gpu_sdl_lru.h"
#include "lv_gpu_sdl_texture_cache.h"
#include "../../draw/lv_draw_img.h"
#include "../../draw/lv_img_cache.h"
#include "../../draw/lv_draw_mask.h"
#include "lv_draw_sdl_utils.h"
#include "lv_draw_sdl_lru.h"
#include "lv_draw_sdl_texture_cache.h"
/*********************
* DEFINES
@@ -45,26 +48,24 @@ static SDL_Texture * upload_img_texture_fallback(SDL_Renderer * renderer, lv_img
* GLOBAL FUNCTIONS
**********************/
void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void * src,
const lv_draw_img_dsc_t * draw_dsc)
lv_res_t lv_draw_sdl_img_core(const lv_area_t * coords, const lv_area_t * mask, const void * src,
const lv_draw_img_dsc_t * draw_dsc)
{
if(draw_dsc->opa <= LV_OPA_MIN) return;
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
lv_draw_sdl_backend_context_t * ctx = lv_draw_sdl_get_context();
SDL_Renderer * renderer = ctx->renderer;
size_t key_size;
lv_gpu_sdl_cache_key_head_img_t * key = lv_gpu_sdl_img_cache_key_create(src, draw_dsc->frame_id, &key_size);
lv_draw_sdl_cache_key_head_img_t * key = lv_draw_sdl_img_cache_key_create(src, draw_dsc->frame_id, &key_size);
bool texture_found = false;
SDL_Texture * texture = lv_gpu_draw_cache_get(key, key_size, &texture_found);
if(!texture_found) {
_lv_img_cache_entry_t * cdsc = _lv_img_cache_open(src, draw_dsc->recolor, draw_dsc->frame_id);
lv_gpu_sdl_cache_flag_t tex_flags = 0;
lv_draw_sdl_cache_flag_t tex_flags = 0;
if(cdsc) {
lv_img_decoder_dsc_t * dsc = &cdsc->dec_dsc;
if(dsc->user_data && SDL_memcmp(dsc->user_data, LV_GPU_SDL_DEC_DSC_TEXTURE_HEAD, 8) == 0) {
texture = ((lv_gpu_sdl_dec_dsc_userdata_t *) dsc->user_data)->texture;
tex_flags |= LV_GPU_SDL_CACHE_FLAG_MANAGED;
if(dsc->user_data && SDL_memcmp(dsc->user_data, LV_DRAW_SDL_DEC_DSC_TEXTURE_HEAD, 8) == 0) {
texture = ((lv_draw_sdl_dec_dsc_userdata_t *) dsc->user_data)->texture;
tex_flags |= LV_DRAW_SDL_CACHE_FLAG_MANAGED;
}
else {
texture = upload_img_texture(renderer, dsc);
@@ -76,15 +77,15 @@ void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void *
if(texture && cdsc) {
lv_img_header_t * header = SDL_malloc(sizeof(lv_img_header_t));
SDL_memcpy(header, &cdsc->dec_dsc.header, sizeof(lv_img_header_t));
lv_gpu_draw_cache_put_advanced(key, key_size, texture, header, SDL_free, tex_flags);
lv_draw_sdl_draw_cache_put_advanced(key, key_size, texture, header, SDL_free, tex_flags);
}
else {
lv_gpu_draw_cache_put(key, key_size, NULL);
lv_draw_sdl_draw_cache_put(key, key_size, NULL);
}
}
SDL_free(key);
if(!texture) {
return;
return LV_RES_INV;
}
SDL_Rect mask_rect, coords_rect;
@@ -116,6 +117,7 @@ void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void *
SDL_SetTextureAlphaMod(texture, draw_dsc->recolor_opa);
SDL_RenderCopyEx(renderer, texture, NULL, &coords_rect, draw_dsc->angle, &pivot, SDL_FLIP_NONE);
}
return LV_RES_OK;
}
/**********************

23
src/gpu/sdl/lv_gpu_sdl_draw_label.c → src/draw/sdl/lv_draw_sdl_label.c
View File

@@ -1,5 +1,5 @@
/**
* @file lv_gpu_sdl_draw_label.c
* @file lv_draw_sdl_draw_label.c
*
*/
@@ -12,15 +12,14 @@
#if LV_USE_GPU_SDL
#include "../../draw/lv_draw_label.h"
#include "../../font/lv_font_fmt_txt.h"
#include "../../core/lv_refr.h"
#include "../../draw/lv_draw_mask.h"
#include "../../misc/lv_utils.h"
#include LV_GPU_SDL_INCLUDE_PATH
#include "lv_gpu_sdl_utils.h"
#include "lv_gpu_sdl_texture_cache.h"
#include "lv_gpu_sdl_mask.h"
#include "lv_draw_sdl_utils.h"
#include "lv_draw_sdl_texture_cache.h"
#include "lv_draw_sdl_mask.h"
/*********************
* DEFINES
@@ -58,9 +57,9 @@ static lv_font_glyph_key_t font_key_glyph_create(const lv_font_t * font_p, uint3
* GLOBAL FUNCTIONS
**********************/
void lv_draw_letter(const lv_point_t * pos_p, const lv_area_t * clip_area,
const lv_font_t * font_p, uint32_t letter, lv_color_t color, lv_opa_t opa,
lv_blend_mode_t blend_mode)
void lv_draw_sdl_draw_letter(const lv_point_t * pos_p, const lv_area_t * clip_area,
const lv_font_t * font_p, uint32_t letter, lv_color_t color, lv_opa_t opa,
lv_blend_mode_t blend_mode)
{
if(opa < LV_OPA_MIN) return;
if(opa > LV_OPA_MAX) opa = LV_OPA_COVER;
@@ -97,8 +96,8 @@ void lv_draw_letter(const lv_point_t * pos_p, const lv_area_t * clip_area,
return;
}
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
lv_draw_sdl_backend_context_t * ctx = lv_draw_sdl_get_context();
SDL_Renderer * renderer = ctx->renderer;
lv_font_glyph_key_t glyph_key = font_key_glyph_create(font_p, letter);
bool glyph_found = false;
@@ -114,7 +113,7 @@ void lv_draw_letter(const lv_point_t * pos_p, const lv_area_t * clip_area,
texture = SDL_CreateTextureFromSurface(renderer, mask);
SDL_FreeSurface(mask);
lv_mem_free(buf);
lv_gpu_draw_cache_put(&glyph_key, sizeof(glyph_key), texture);
lv_draw_sdl_draw_cache_put(&glyph_key, sizeof(glyph_key), texture);
}
if(!texture) {
return;

4
src/gpu/sdl/lv_gpu_sdl_lru.c → src/draw/sdl/lv_draw_sdl_lru.c
View File

@@ -1,5 +1,5 @@
/**
* @file lv_gpu_sdl_lru.c
* @file lv_draw_sdl_lru.c
*
*/
@@ -11,7 +11,7 @@
#if LV_USE_GPU_SDL
#include "../../misc/lv_log.h"
#include "lv_gpu_sdl_lru.h"
#include "lv_draw_sdl_lru.h"
#include <stdlib.h>
#include <string.h>

2
src/gpu/sdl/lv_gpu_sdl_lru.h → src/draw/sdl/lv_draw_sdl_lru.h
View File

@@ -1,5 +1,5 @@
/**
* @file lv_gpu_sdl_lru.h
* @file lv_draw_sdl_lru.h
*
*/

7
src/gpu/sdl/lv_gpu_sdl_mask.c → src/draw/sdl/lv_draw_sdl_mask.c
View File

@@ -1,5 +1,5 @@
/**
* @file lv_gpu_sdl_mask.c
* @file lv_draw_sdl_mask.c
*
*/
@@ -12,9 +12,8 @@
#if LV_USE_GPU_SDL
#include "../../draw/lv_draw_mask.h"
#include "../../misc/lv_mem.h"
#include "lv_gpu_sdl_mask.h"
#include "lv_gpu_sdl_utils.h"
#include "lv_draw_sdl_mask.h"
#include "lv_draw_sdl_utils.h"
/*********************
* DEFINES

8
src/gpu/sdl/lv_gpu_sdl_mask.h → src/draw/sdl/lv_draw_sdl_mask.h
View File

@@ -1,10 +1,10 @@
/**
* @file lv_gpu_sdl_mask.h
* @file lv_draw_sdl_mask.h
*
*/
#ifndef LV_GPU_SDL_MASK_H
#define LV_GPU_SDL_MASK_H
#ifndef LV_DRAW_SDL_MASK_H
#define LV_DRAW_SDL_MASK_H
#ifdef __cplusplus
extern "C" {
@@ -54,4 +54,4 @@ lv_sdl_gen_mask_texture(SDL_Renderer * renderer, const lv_area_t * coords, const
} /*extern "C"*/
#endif
#endif /*LV_GPU_SDL_MASK_H*/
#endif /*LV_DRAW_SDL_MASK_H*/

46
src/gpu/sdl/lv_gpu_sdl_draw_rect.c → src/draw/sdl/lv_draw_sdl_rect.c
View File

@@ -1,5 +1,5 @@
/**
* @file lv_gpu_sdl_draw_rect.c
* @file lv_draw_sdl_draw_rect.c
*
*/
@@ -12,13 +12,13 @@
#if LV_USE_GPU_SDL
#include "../../draw/lv_draw_rect.h"
#include "../../hal/lv_hal_disp.h"
#include "../../core/lv_refr.h"
#include "lv_gpu_sdl_utils.h"
#include "lv_gpu_sdl_lru.h"
#include "lv_gpu_sdl_texture_cache.h"
#include "lv_gpu_sdl_mask.h"
#include "lv_gpu_sdl_stack_blur.h"
#include "../../draw/lv_draw_img.h"
#include "../../draw/lv_draw_label.h"
#include "../../draw/lv_draw_mask.h"
#include "lv_draw_sdl_utils.h"
#include "lv_draw_sdl_texture_cache.h"
#include "lv_draw_sdl_mask.h"
#include "lv_draw_sdl_stack_blur.h"
/*********************
* DEFINES
@@ -107,7 +107,7 @@ static lv_draw_rect_border_key_t rect_border_key_create(lv_coord_t rout, lv_coor
* GLOBAL FUNCTIONS
**********************/
void lv_draw_rect(const lv_area_t * coords, const lv_area_t * clip, const lv_draw_rect_dsc_t * dsc)
void lv_draw_sdl_draw_rect(const lv_area_t * coords, const lv_area_t * clip, const lv_draw_rect_dsc_t * dsc)
{
lv_area_t draw_area;
bool has_draw_content = _lv_area_intersect(&draw_area, coords, clip);
@@ -117,8 +117,8 @@ void lv_draw_rect(const lv_area_t * coords, const lv_area_t * clip, const lv_dra
return;
}
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
lv_draw_sdl_backend_context_t * ctx = lv_draw_sdl_get_context();
SDL_Renderer * renderer = ctx->renderer;
SDL_Rect clip_rect;
@@ -162,7 +162,7 @@ static void draw_bg_color(SDL_Renderer * renderer, const lv_area_t * coords, con
texture = lv_sdl_gen_mask_texture(renderer, &coords_frag, &mask_id, 1);
lv_draw_mask_remove_id(mask_id);
SDL_assert(texture);
lv_gpu_draw_cache_put(&key, sizeof(key), texture);
lv_draw_sdl_draw_cache_put(&key, sizeof(key), texture);
}
SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
@@ -205,7 +205,7 @@ static void draw_bg_img(const lv_area_t * coords, const lv_area_t * clip, const
else {
lv_img_header_t header;
size_t key_size;
lv_gpu_sdl_cache_key_head_img_t * key = lv_gpu_sdl_img_cache_key_create(dsc->bg_img_src, 0, &key_size);
lv_draw_sdl_cache_key_head_img_t * key = lv_draw_sdl_img_cache_key_create(dsc->bg_img_src, 0, &key_size);
bool key_found;
lv_img_header_t * cache_header = NULL;
SDL_Texture * texture = lv_gpu_draw_cache_get_with_userdata(key, key_size, &key_found, (void **) &cache_header);
@@ -314,7 +314,7 @@ static void draw_shadow(SDL_Renderer * renderer, const lv_area_t * coords, const
lv_mem_buf_release(mask_buf);
lv_draw_mask_remove_id(mask_id);
SDL_assert(texture);
lv_gpu_draw_cache_put(&key, sizeof(key), texture);
lv_draw_sdl_draw_cache_put(&key, sizeof(key), texture);
}
SDL_Color shadow_color;
@@ -429,8 +429,8 @@ static void draw_border_generic(const lv_area_t * outer_area, const lv_area_t *
return;
}
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
lv_draw_sdl_backend_context_t * ctx = lv_draw_sdl_get_context();
SDL_Renderer * renderer = ctx->renderer;
lv_coord_t border_width = lv_area_get_width(outer_area);
lv_coord_t border_height = lv_area_get_height(outer_area);
@@ -465,7 +465,7 @@ static void draw_border_generic(const lv_area_t * outer_area, const lv_area_t *
lv_draw_mask_remove_id(mask_ids[1]);
lv_draw_mask_remove_id(mask_ids[0]);
SDL_assert(texture);
lv_gpu_draw_cache_put(&key, sizeof(key), texture);
lv_draw_sdl_draw_cache_put(&key, sizeof(key), texture);
}
SDL_Rect outer_rect;
@@ -485,8 +485,8 @@ static void draw_border_simple(const lv_area_t * outer_area, const lv_area_t * i
lv_opa_t opa)
{
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
lv_draw_sdl_backend_context_t * ctx = lv_draw_sdl_get_context();
SDL_Renderer * renderer = ctx->renderer;
SDL_Color color_sdl;
lv_color_to_sdl_color(&color, &color_sdl);
@@ -613,8 +613,8 @@ static void draw_rect_masked(const lv_area_t * coords, const lv_area_t * clip, c
draw_rect_masked_simple(coords, clip, dsc);
return;
}
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
lv_draw_sdl_backend_context_t * ctx = lv_draw_sdl_get_context();
SDL_Renderer * renderer = ctx->renderer;
SDL_Texture * screen = SDL_GetRenderTarget(renderer);
@@ -673,8 +673,8 @@ static void draw_rect_masked_simple(const lv_area_t * coords, const lv_area_t *
SDL_Color bg_color;
lv_color_to_sdl_color(&dsc->bg_color, &bg_color);
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
lv_draw_sdl_backend_context_t * ctx = lv_draw_sdl_get_context();
SDL_Renderer * renderer = ctx->renderer;
SDL_Surface * indexed = lv_sdl_apply_mask_surface(coords, NULL, 0);
SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, indexed);

4
src/gpu/sdl/lv_gpu_sdl_stack_blur.c → src/draw/sdl/lv_draw_sdl_stack_blur.c
View File

@@ -1,12 +1,12 @@
/**
* @file lv_gpu_sdl_stack_blur.c
* @file lv_draw_sdl_stack_blur.c
*
*/
/*********************
* INCLUDES
*********************/
#include "lv_gpu_sdl_stack_blur.h"
#include "lv_draw_sdl_stack_blur.h"
/*********************
* DEFINES

8
src/gpu/sdl/lv_gpu_sdl_stack_blur.h → src/draw/sdl/lv_draw_sdl_stack_blur.h
View File

@@ -1,9 +1,9 @@
/**
* @file lv_gpu_sdl_stack_blur.h
* @file lv_draw_sdl_stack_blur.h
*
*/
#ifndef LV_GPU_SDL_STACK_BLUR_H
#define LV_GPU_SDL_STACK_BLUR_H
#ifndef LV_DRAW_SDL_STACK_BLUR_H
#define LV_DRAW_SDL_STACK_BLUR_H
#ifdef __cplusplus
extern "C" {
@@ -39,4 +39,4 @@ void lv_stack_blur_grayscale(lv_opa_t * buf, uint16_t w, uint16_t h, uint16_t r)
} /*extern "C"*/
#endif
#endif /*LV_GPU_SDL_STACK_BLUR_H*/
#endif /*LV_DRAW_SDL_STACK_BLUR_H*/

30
src/gpu/sdl/lv_gpu_sdl_texture_cache.c → src/draw/sdl/lv_draw_sdl_texture_cache.c
View File

@@ -1,5 +1,5 @@
/**
* @file lv_gpu_sdl_texture_cache.c
* @file lv_draw_sdl_texture_cache.c
*
*/
@@ -11,7 +11,7 @@
#if LV_USE_GPU_SDL
#include "lv_gpu_sdl_texture_cache.h"
#include "lv_draw_sdl_texture_cache.h"
#include "../../misc/lv_log.h"
#include "../../draw/lv_draw_label.h"
@@ -29,7 +29,7 @@ typedef struct {
SDL_Texture * texture;
void * userdata;
lv_lru_free_t * userdata_free;
lv_gpu_sdl_cache_flag_t flags;
lv_draw_sdl_cache_flag_t flags;
} draw_cache_value_t;
typedef struct {
@@ -60,13 +60,13 @@ static lv_lru_t * lv_sdl_texture_cache;
* GLOBAL FUNCTIONS
**********************/
void _lv_gpu_sdl_texture_cache_init()
void _lv_draw_sdl_texture_cache_init()
{
lv_sdl_texture_cache = lv_lru_new(1024 * 1024 * 8, 65536, (lv_lru_free_t *) draw_cache_free_value,
NULL);
}
void _lv_gpu_sdl_texture_cache_deinit()
void _lv_draw_sdl_texture_cache_deinit()
{
lv_lru_free(lv_sdl_texture_cache);
}
@@ -97,13 +97,13 @@ SDL_Texture * lv_gpu_draw_cache_get_with_userdata(const void * key, size_t key_l
return value->texture;
}
void lv_gpu_draw_cache_put(const void * key, size_t key_length, SDL_Texture * texture)
void lv_draw_sdl_draw_cache_put(const void * key, size_t key_length, SDL_Texture * texture)
{
lv_gpu_draw_cache_put_advanced(key, key_length, texture, NULL, NULL, 0);
lv_draw_sdl_draw_cache_put_advanced(key, key_length, texture, NULL, NULL, 0);
}
void lv_gpu_draw_cache_put_advanced(const void * key, size_t key_length, SDL_Texture * texture, void * userdata,
lv_lru_free_t userdata_free, lv_gpu_sdl_cache_flag_t flags)
void lv_draw_sdl_draw_cache_put_advanced(const void * key, size_t key_length, SDL_Texture * texture, void * userdata,
lv_lru_free_t userdata_free, lv_draw_sdl_cache_flag_t flags)
{
draw_cache_value_t * value = SDL_malloc(sizeof(draw_cache_value_t));
value->texture = texture;
@@ -114,7 +114,7 @@ void lv_gpu_draw_cache_put_advanced(const void * key, size_t key_length, SDL_Tex
lv_lru_set(lv_sdl_texture_cache, key, key_length, value, 1);
return;
}
if(flags & LV_GPU_SDL_CACHE_FLAG_MANAGED) {
if(flags & LV_DRAW_SDL_CACHE_FLAG_MANAGED) {
/* Managed texture doesn't count into cache size */
LV_LOG_INFO("cache texture %p, %d*%d@%dbpp", texture, width, height, SDL_BITSPERPIXEL(format));
lv_lru_set(lv_sdl_texture_cache, key, key_length, value, 1);
@@ -143,13 +143,13 @@ SDL_Texture * lv_gpu_temp_texture_obtain(SDL_Renderer * renderer, lv_coord_t wid
userdata = SDL_malloc(sizeof(temp_texture_userdata_t));
userdata->width = width;
userdata->height = height;
lv_gpu_draw_cache_put_advanced(&key, sizeof(key), texture, userdata, SDL_free, 0);
lv_draw_sdl_draw_cache_put_advanced(&key, sizeof(key), texture, userdata, SDL_free, 0);
return texture;
}
lv_gpu_sdl_cache_key_head_img_t * lv_gpu_sdl_img_cache_key_create(const void * src, int32_t frame_id, size_t * size)
lv_draw_sdl_cache_key_head_img_t * lv_draw_sdl_img_cache_key_create(const void * src, int32_t frame_id, size_t * size)
{
lv_gpu_sdl_cache_key_head_img_t header;
lv_draw_sdl_cache_key_head_img_t header;
/* VERY IMPORTANT! Padding between members is uninitialized, so we have to wipe them manually */
SDL_memset(&header, 0, sizeof(header));
header.magic = LV_GPU_CACHE_KEY_MAGIC_IMG;
@@ -173,7 +173,7 @@ lv_gpu_sdl_cache_key_head_img_t * lv_gpu_sdl_img_cache_key_create(const void * s
SDL_memcpy(key + sizeof(header), &src, sizeof(void *));
}
*size = key_size;
return (lv_gpu_sdl_cache_key_head_img_t *) key;
return (lv_draw_sdl_cache_key_head_img_t *) key;
}
/**********************
@@ -182,7 +182,7 @@ lv_gpu_sdl_cache_key_head_img_t * lv_gpu_sdl_img_cache_key_create(const void * s
static void draw_cache_free_value(draw_cache_value_t * value)
{
if(value->texture && !(value->flags & LV_GPU_SDL_CACHE_FLAG_MANAGED)) {
if(value->texture && !(value->flags & LV_DRAW_SDL_CACHE_FLAG_MANAGED)) {
LV_LOG_INFO("destroy texture %p", value->texture);
SDL_DestroyTexture(value->texture);
}

34
src/gpu/sdl/lv_gpu_sdl_texture_cache.h → src/draw/sdl/lv_draw_sdl_texture_cache.h
View File

@@ -1,10 +1,10 @@
/**
* @file lv_gpu_sdl_texture_cache.h
* @file lv_draw_sdl_texture_cache.h
*
*/
#ifndef LV_GPU_SDL_TEXTURE_CACHE_H
#define LV_GPU_SDL_TEXTURE_CACHE_H
#ifndef LV_DRAW_SDL_TEXTURE_CACHE_H
#define LV_DRAW_SDL_TEXTURE_CACHE_H
#ifdef __cplusplus
extern "C" {
@@ -19,13 +19,13 @@ extern "C" {
#include LV_GPU_SDL_INCLUDE_PATH
#include "../../draw/lv_img_decoder.h"
#include "../../misc/lv_area.h"
#include "lv_gpu_sdl_lru.h"
#include "lv_draw_sdl_lru.h"
/*********************
* DEFINES
*********************/
#define LV_GPU_SDL_DEC_DSC_TEXTURE_HEAD "@LVSDLTex"
#define LV_DRAW_SDL_DEC_DSC_TEXTURE_HEAD "@LVSDLTex"
/**********************
* TYPEDEFS
@@ -34,7 +34,7 @@ extern "C" {
typedef struct {
char head[8];
SDL_Texture * texture;
} lv_gpu_sdl_dec_dsc_userdata_t;
} lv_draw_sdl_dec_dsc_userdata_t;
typedef enum {
LV_GPU_CACHE_KEY_MAGIC_ARC = 0x01,
@@ -48,36 +48,36 @@ typedef enum {
} lv_gpu_cache_key_magic_t;
typedef enum {
LV_GPU_SDL_CACHE_FLAG_NONE = 0,
LV_GPU_SDL_CACHE_FLAG_MANAGED = 1,
} lv_gpu_sdl_cache_flag_t;
LV_DRAW_SDL_CACHE_FLAG_NONE = 0,
LV_DRAW_SDL_CACHE_FLAG_MANAGED = 1,
} lv_draw_sdl_cache_flag_t;
typedef struct {
lv_gpu_cache_key_magic_t magic;
lv_img_src_t type;
int32_t frame_id;
} lv_gpu_sdl_cache_key_head_img_t;
} lv_draw_sdl_cache_key_head_img_t;
/**********************
* GLOBAL PROTOTYPES
**********************/
void _lv_gpu_sdl_texture_cache_init();
void _lv_draw_sdl_texture_cache_init();
void _lv_gpu_sdl_texture_cache_deinit();
void _lv_draw_sdl_texture_cache_deinit();
SDL_Texture * lv_gpu_draw_cache_get(const void * key, size_t key_length, bool * found);
SDL_Texture * lv_gpu_draw_cache_get_with_userdata(const void * key, size_t key_length, bool * found, void ** userdata);
void lv_gpu_draw_cache_put(const void * key, size_t key_length, SDL_Texture * texture);
void lv_draw_sdl_draw_cache_put(const void * key, size_t key_length, SDL_Texture * texture);
void lv_gpu_draw_cache_put_advanced(const void * key, size_t key_length, SDL_Texture * texture, void * userdata,
lv_lru_free_t userdata_free, lv_gpu_sdl_cache_flag_t flags);
void lv_draw_sdl_draw_cache_put_advanced(const void * key, size_t key_length, SDL_Texture * texture, void * userdata,
lv_lru_free_t userdata_free, lv_draw_sdl_cache_flag_t flags);
SDL_Texture * lv_gpu_temp_texture_obtain(SDL_Renderer * renderer, lv_coord_t width, lv_coord_t height);
lv_gpu_sdl_cache_key_head_img_t * lv_gpu_sdl_img_cache_key_create(const void * src, int32_t frame_id, size_t * size);
lv_draw_sdl_cache_key_head_img_t * lv_draw_sdl_img_cache_key_create(const void * src, int32_t frame_id, size_t * size);
/**********************
* MACROS
@@ -87,4 +87,4 @@ lv_gpu_sdl_cache_key_head_img_t * lv_gpu_sdl_img_cache_key_create(const void * s
} /*extern "C"*/
#endif
#endif /*LV_GPU_SDL_TEXTURE_CACHE_H*/
#endif /*LV_DRAW_SDL_TEXTURE_CACHE_H*/

40
src/gpu/sdl/lv_gpu_sdl_utils.c → src/draw/sdl/lv_draw_sdl_utils.c
View File

@@ -1,5 +1,5 @@
/**
* @file lv_gpu_sdl_utils.c
* @file lv_draw_sdl_utils.c
*
*/
@@ -10,8 +10,9 @@
#if LV_USE_GPU_SDL
#include "lv_gpu_sdl_utils.h"
#include "lv_draw_sdl_utils.h"
#include "../../draw/lv_draw.h"
#include "../../draw/lv_draw_label.h"
/*********************
@@ -29,6 +30,11 @@
/**********************
* STATIC VARIABLES
**********************/
extern const uint8_t _lv_bpp1_opa_table[2];
extern const uint8_t _lv_bpp2_opa_table[4];
extern const uint8_t _lv_bpp3_opa_table[8];
extern const uint8_t _lv_bpp4_opa_table[16];
extern const uint8_t _lv_bpp8_opa_table[256];
static SDL_Palette * lv_sdl_palette_grayscale1 = NULL;
static SDL_Palette * lv_sdl_palette_grayscale2 = NULL;
@@ -44,7 +50,7 @@ static SDL_Palette * lv_sdl_palette_grayscale8 = NULL;
* GLOBAL FUNCTIONS
**********************/
void _lv_gpu_sdl_utils_init()
void _lv_draw_sdl_utils_init()
{
lv_sdl_palette_grayscale1 = lv_sdl_alloc_palette_for_bpp(_lv_bpp1_opa_table, 1);
lv_sdl_palette_grayscale2 = lv_sdl_alloc_palette_for_bpp(_lv_bpp2_opa_table, 2);
@@ -53,7 +59,7 @@ void _lv_gpu_sdl_utils_init()
lv_sdl_palette_grayscale8 = lv_sdl_alloc_palette_for_bpp(_lv_bpp8_opa_table, 8);
}
void _lv_gpu_sdl_utils_deinit()
void _lv_draw_sdl_utils_deinit()
{
SDL_FreePalette(lv_sdl_palette_grayscale1);
SDL_FreePalette(lv_sdl_palette_grayscale2);
@@ -117,19 +123,28 @@ SDL_Palette * lv_sdl_alloc_palette_for_bpp(const uint8_t * mapping, uint8_t bpp)
SDL_Palette * lv_sdl_get_grayscale_palette(uint8_t bpp)
{
SDL_Palette * palette;
switch(bpp) {
case 1:
return lv_sdl_palette_grayscale1;
palette = lv_sdl_palette_grayscale1;
break;
case 2:
return lv_sdl_palette_grayscale2;
palette = lv_sdl_palette_grayscale2;
break;
case 3:
return lv_sdl_palette_grayscale3;
palette = lv_sdl_palette_grayscale3;
break;
case 4:
return lv_sdl_palette_grayscale4;
palette = lv_sdl_palette_grayscale4;
break;
case 8:
return lv_sdl_palette_grayscale8;
palette = lv_sdl_palette_grayscale8;
break;
default:
return NULL;
}
return NULL;
LV_ASSERT_MSG(lv_sdl_palette_grayscale8, "lv_draw_sdl was not initialized properly");
return palette;
}
void lv_sdl_to_8bpp(uint8_t * dest, const uint8_t * src, int width, int height, int stride, uint8_t bpp)
@@ -172,6 +187,11 @@ void lv_sdl_to_8bpp(uint8_t * dest, const uint8_t * src, int width, int height,
}
}
lv_draw_sdl_backend_context_t * lv_draw_sdl_get_context()
{
return lv_draw_backend_get()->ctx;
}
/**********************
* STATIC FUNCTIONS
**********************/

19
src/gpu/sdl/lv_gpu_sdl_utils.h → src/draw/sdl/lv_draw_sdl_utils.h
View File

@@ -1,9 +1,9 @@
/**
* @file lv_gpu_sdl_utils.h
* @file lv_draw_sdl_utils.h
*
*/
#ifndef LV_GPU_SDL_UTILS_H
#define LV_GPU_SDL_UTILS_H
#ifndef LV_DRAW_SDL_UTILS_H
#define LV_DRAW_SDL_UTILS_H
#ifdef __cplusplus
extern "C" {
@@ -27,14 +27,17 @@ extern "C" {
/**********************
* TYPEDEFS
**********************/
typedef struct lv_draw_sdl_backend_context_t {
SDL_Renderer * renderer;
SDL_Texture * texture;
} lv_draw_sdl_backend_context_t;
/**********************
* GLOBAL PROTOTYPES
**********************/
void _lv_gpu_sdl_utils_init();
void _lv_draw_sdl_utils_init();
void _lv_gpu_sdl_utils_deinit();
void _lv_draw_sdl_utils_deinit();
void lv_area_to_sdl_rect(const lv_area_t * in, SDL_Rect * out);
@@ -50,6 +53,8 @@ SDL_Palette * lv_sdl_get_grayscale_palette(uint8_t bpp);
void lv_sdl_to_8bpp(uint8_t * dest, const uint8_t * src, int width, int height, int stride, uint8_t bpp);
lv_draw_sdl_backend_context_t * lv_draw_sdl_get_context();
/**********************
* MACROS
**********************/
@@ -58,4 +63,4 @@ void lv_sdl_to_8bpp(uint8_t * dest, const uint8_t * src, int width, int height,
} /*extern "C"*/
#endif
#endif /*LV_GPU_SDL_UTILS_H*/
#endif /*LV_DRAW_SDL_UTILS_H*/

2
src/draw/sw/lv_draw_sw_rect.c
View File

@@ -26,7 +26,6 @@
/**********************
* STATIC PROTOTYPES
**********************/
#if LV_USE_EXTERNAL_RENDERER == 0
LV_ATTRIBUTE_FAST_MEM static void draw_bg(const lv_area_t * coords, const lv_area_t * clip_area,
const lv_draw_rect_dsc_t * dsc);
LV_ATTRIBUTE_FAST_MEM static void draw_bg_img(const lv_area_t * coords, const lv_area_t * clip,
@@ -53,7 +52,6 @@ static void draw_border_simple(const lv_area_t * clip, const lv_area_t * outer_a
#if LV_DRAW_COMPLEX
LV_ATTRIBUTE_FAST_MEM static inline lv_color_t grad_get(const lv_draw_rect_dsc_t * dsc, lv_coord_t s, lv_coord_t i);
#endif
#endif
/**********************
* STATIC VARIABLES

47
src/gpu/lv_gpu_sdl.c
View File

@@ -13,13 +13,29 @@
#if LV_USE_GPU_SDL
#include "lv_gpu_sdl.h"
#include "sdl/lv_gpu_sdl_utils.h"
#include "sdl/lv_gpu_sdl_texture_cache.h"
#include "../draw/sdl/lv_draw_sdl_utils.h"
#include "../draw/sdl/lv_draw_sdl_texture_cache.h"
#include "../draw/sw/lv_draw_sw.h"
/*********************
* DEFINES
*********************/
void lv_draw_sdl_draw_rect(const lv_area_t * coords, const lv_area_t * clip, const lv_draw_rect_dsc_t * dsc);
lv_res_t lv_draw_sdl_img_core(const lv_area_t * coords, const lv_area_t * mask, const void * src,
const lv_draw_img_dsc_t * draw_dsc);
void lv_draw_sdl_draw_letter(const lv_point_t * pos_p, const lv_area_t * clip_area,
const lv_font_t * font_p, uint32_t letter, lv_color_t color, lv_opa_t opa,
lv_blend_mode_t blend_mode);
void lv_draw_sdl_draw_blend_fill(lv_color_t * dest_buf, lv_coord_t dest_stride, const lv_area_t * fill_area,
lv_color_t color, lv_opa_t * mask, lv_opa_t opa, lv_blend_mode_t blend_mode);
void lv_draw_sdl_draw_blend_map(lv_color_t * dest_buf, lv_coord_t dest_stride, const lv_area_t * clip_area,
const lv_color_t * src_buf, const lv_area_t * src_area,
lv_opa_t * mask, lv_opa_t opa, lv_blend_mode_t blend_mode);
/**********************
* TYPEDEFS
**********************/
@@ -42,15 +58,34 @@
void lv_gpu_sdl_init()
{
_lv_gpu_sdl_utils_init();
_lv_gpu_sdl_texture_cache_init();
_lv_draw_sdl_utils_init();
_lv_draw_sdl_texture_cache_init();
}
void lv_gpu_sdl_deinit()
{
_lv_gpu_sdl_texture_cache_deinit();
_lv_gpu_sdl_utils_deinit();
_lv_draw_sdl_texture_cache_deinit();
_lv_draw_sdl_utils_deinit();
}
void lv_gpu_sdl_backend_init(lv_draw_backend_t * backend, SDL_Renderer * renderer, SDL_Texture * texture)
{
lv_draw_backend_init(backend);
lv_draw_sdl_backend_context_t * ctx = lv_mem_alloc(sizeof(lv_draw_sdl_backend_context_t));
lv_memset_00(ctx, sizeof(lv_draw_sdl_backend_context_t));
ctx->renderer = renderer;
ctx->texture = texture;
backend->ctx = ctx;
backend->draw_rect = lv_draw_sdl_draw_rect;
backend->draw_arc = lv_draw_sw_arc;
backend->draw_img_core = lv_draw_sdl_img_core;
backend->draw_letter = lv_draw_sdl_draw_letter;
backend->draw_line = lv_draw_sw_line;
backend->draw_polygon = lv_draw_sw_polygon;
backend->blend_fill = lv_draw_sdl_draw_blend_fill;
backend->blend_map = lv_draw_sdl_draw_blend_map;
}
/**********************
* STATIC FUNCTIONS
**********************/

4
src/gpu/lv_gpu_sdl.h
View File

@@ -24,6 +24,8 @@ extern "C" {
#include LV_GPU_SDL_INCLUDE_PATH
#include "../draw/lv_draw.h"
/*********************
* DEFINES
*********************/
@@ -44,6 +46,8 @@ void lv_gpu_sdl_init();
*/
void lv_gpu_sdl_deinit();
void lv_gpu_sdl_backend_init(lv_draw_backend_t * backend, SDL_Renderer * renderer, SDL_Texture * texture);
/*======================
* Add/remove functions
*=====================*/

16
src/gpu/sdl/lv_gpu_sdl.mk
View File

@@ -1,16 +0,0 @@
CSRCS += lv_gpu_sdl_draw_arc.c
CSRCS += lv_gpu_sdl_draw_blend.c
CSRCS += lv_gpu_sdl_draw_img.c
CSRCS += lv_gpu_sdl_draw_label.c
CSRCS += lv_gpu_sdl_draw_line.c
CSRCS += lv_gpu_sdl_draw_rect.c
CSRCS += lv_gpu_sdl_lru.c
CSRCS += lv_gpu_sdl_mask.c
CSRCS += lv_gpu_sdl_stack_blur.c
CSRCS += lv_gpu_sdl_texture_cache.c
CSRCS += lv_gpu_sdl_utils.c
DEPPATH += --dep-path $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/gpu/sdl
VPATH += :$(LVGL_DIR)/$(LVGL_DIR_NAME)/src/gpu/sdl
CFLAGS += "-I$(LVGL_DIR)/$(LVGL_DIR_NAME)/src/gpu/sdl"

163
src/gpu/sdl/lv_gpu_sdl_draw_arc.c
View File

@@ -1,163 +0,0 @@
/**
* @file lv_gpu_sdl_draw_arc.c
*
* This implementation does not functioning properly so it's not enabled
*
*/
/*********************
* INCLUDES
*********************/
#include "../../lv_conf_internal.h"
#if LV_USE_GPU_SDL
#include "../../hal/lv_hal_disp.h"
#include "../../core/lv_refr.h"
#include "../../draw/lv_draw_arc.h"
#include "lv_gpu_sdl_utils.h"
#include "lv_gpu_sdl_lru.h"
#include "lv_gpu_sdl_texture_cache.h"
#include "lv_gpu_sdl_mask.h"
#ifndef M_PI
#include <math.h>
#endif
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
typedef struct {
lv_gpu_cache_key_magic_t magic;
uint16_t radius;
uint16_t angle;
lv_coord_t width;
uint8_t rounded;
} lv_draw_arc_key_t;
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
void lv_draw_arc2(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius, uint16_t start_angle, uint16_t end_angle,
const lv_area_t * clip_area, const lv_draw_arc_dsc_t * dsc)
{
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
lv_disp_drv_t * driver = disp->driver;
SDL_Renderer * renderer = (SDL_Renderer *) driver->user_data;
lv_area_t area_out;
area_out.x1 = center_x - radius;
area_out.y1 = center_y - radius;
area_out.x2 = center_x + radius - 1; /*-1 because the center already belongs to the left/bottom part*/
area_out.y2 = center_y + radius - 1;
lv_area_t area_in;
lv_area_copy(&area_in, &area_out);
area_in.x1 += dsc->width;
area_in.y1 += dsc->width;
area_in.x2 -= dsc->width;
area_in.y2 -= dsc->width;
/*Increase 1 px each side to texture, to have better rotation result*/
lv_area_t texture_area_out;
lv_area_copy(&texture_area_out, &area_out);
lv_area_increase(&texture_area_out, 1, 1);
SDL_Rect area_out_rect, clip_rect;
lv_area_to_sdl_rect(&texture_area_out, &area_out_rect);
lv_area_to_sdl_rect(clip_area, &clip_rect);
lv_draw_arc_key_t key = {
.magic = LV_GPU_CACHE_KEY_MAGIC_ARC,
.radius = radius,
.angle = ((end_angle - start_angle) % 360 + 360) % 360,
.width = dsc->width,
.rounded = dsc->rounded,
};
// SDL_Texture *texture = lv_gpu_draw_cache_get(&key, sizeof(key));
SDL_Texture * texture = NULL;
if(texture == NULL) {
/*Create inner the mask*/
lv_draw_mask_radius_param_t mask_in_param;
lv_draw_mask_radius_init(&mask_in_param, &area_in, LV_RADIUS_CIRCLE, true);
int16_t mask_in_id = lv_draw_mask_add(&mask_in_param, NULL);
lv_draw_mask_radius_param_t mask_out_param;
lv_draw_mask_radius_init(&mask_out_param, &area_out, LV_RADIUS_CIRCLE, false);
int16_t mask_out_id = lv_draw_mask_add(&mask_out_param, NULL);
SDL_Surface * ark_mask;
if(key.angle < 360) {
while(start_angle >= 360) start_angle -= 360;
while(end_angle >= 360) end_angle -= 360;
lv_draw_mask_angle_param_t mask_angle_param;
lv_draw_mask_angle_init(&mask_angle_param, center_x, center_y, 0, key.angle);
int16_t mask_angle_id = lv_draw_mask_add(&mask_angle_param, NULL);
ark_mask = lv_sdl_apply_mask_surface(&texture_area_out, NULL, 0);
lv_draw_mask_remove_id(mask_angle_id);
}
else {
ark_mask = lv_sdl_apply_mask_surface(&texture_area_out, NULL, 0);
}
lv_draw_mask_remove_id(mask_out_id);
lv_draw_mask_remove_id(mask_in_id);
if(dsc->rounded) {
SDL_Renderer * mask_renderer = SDL_CreateSoftwareRenderer(ark_mask);
lv_area_t cap_area = {.x1 = 0, .y1 = 0};
lv_area_set_width(&cap_area, dsc->width);
lv_area_set_height(&cap_area, dsc->width);
lv_draw_mask_radius_param_t mask_rout_param;
lv_draw_mask_radius_init(&mask_rout_param, &cap_area, LV_RADIUS_CIRCLE, false);
int16_t mask_rout_id = lv_draw_mask_add(&mask_rout_param, NULL);
SDL_Texture * round_texture = lv_sdl_gen_mask_texture(mask_renderer, &cap_area, &mask_rout_id, 1);
lv_draw_mask_remove_id(mask_rout_id);
SDL_SetTextureBlendMode(round_texture, SDL_BLENDMODE_BLEND);
float mid_point = radius - key.width / 2.0f;
SDL_Rect cap_dst;
cap_dst.w = lv_area_get_width(&cap_area);
cap_dst.h = lv_area_get_height(&cap_area);
cap_dst.x = mid_point + lv_sdl_round(SDL_cos(0) * mid_point);
cap_dst.y = mid_point + lv_sdl_round(SDL_sin(0) * mid_point);
SDL_RenderCopy(mask_renderer, round_texture, NULL, &cap_dst);
cap_dst.x = mid_point + lv_sdl_round(SDL_cos(key.angle * M_PI / 180.0f) * mid_point);
cap_dst.y = mid_point + lv_sdl_round(SDL_sin(key.angle * M_PI / 180.0f) * mid_point);
SDL_RenderCopy(mask_renderer, round_texture, NULL, &cap_dst);
SDL_DestroyTexture(round_texture);
SDL_DestroyRenderer(mask_renderer);
}
texture = SDL_CreateTextureFromSurface(renderer, ark_mask);
SDL_FreeSurface(ark_mask);
SDL_assert(texture);
// lv_gpu_draw_cache_put(&key, sizeof(key), texture);
}
SDL_Color arc_color;
lv_color_to_sdl_color(&dsc->color, &arc_color);
SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
SDL_SetTextureAlphaMod(texture, dsc->opa);
SDL_SetTextureColorMod(texture, arc_color.r, arc_color.g, arc_color.b);
SDL_RenderSetClipRect(renderer, &clip_rect);
SDL_RenderCopyEx(renderer, texture, NULL, &area_out_rect, start_angle, NULL, SDL_FLIP_NONE);
SDL_DestroyTexture(texture);
}
#endif /*LV_USE_GPU_SDL*/

102
src/gpu/sdl/lv_gpu_sdl_draw_blend.c
View File

@@ -1,102 +0,0 @@
/**
* @file lv_gpu_sdl_draw_blend.c
*
*/
/*********************
* INCLUDES
*********************/
#include "../../lv_conf_internal.h"
#if LV_USE_GPU_SDL
#include "../../draw/lv_draw_blend.h"
#include "../../core/lv_refr.h"
#include "lv_gpu_sdl_texture_cache.h"
#include "lv_gpu_sdl_utils.h"
#include "lv_gpu_sdl_mask.h"
#include LV_GPU_SDL_INCLUDE_PATH
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* STATIC PROTOTYPES
**********************/
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
void lv_draw_blend_fill(const lv_area_t * clip_area, const lv_area_t * fill_area, lv_color_t color,
lv_opa_t * mask, lv_draw_mask_res_t mask_res, lv_opa_t opa, lv_blend_mode_t mode)
{
/*Do not draw transparent things*/
if(opa < LV_OPA_MIN) return;
if(mask_res == LV_DRAW_MASK_RES_TRANSP) return;
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
/*Get clipped fill area which is the real draw area.
*It is always the same or inside `fill_area`*/
lv_area_t draw_area;
if(!_lv_area_intersect(&draw_area, clip_area, fill_area)) return;
SDL_Rect draw_area_rect;
lv_area_to_sdl_rect(&draw_area, &draw_area_rect);
if(mask) {
SDL_Surface * mask_surface = lv_sdl_create_mask_surface(mask, lv_area_get_width(&draw_area),
lv_area_get_height(&draw_area),
lv_area_get_width(&draw_area));
SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, mask_surface);
SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
SDL_SetTextureAlphaMod(texture, opa);
SDL_SetTextureColorMod(texture, color.ch.red, color.ch.green, color.ch.blue);
SDL_RenderSetClipRect(renderer, &draw_area_rect);
SDL_RenderCopy(renderer, texture, NULL, &draw_area_rect);
SDL_DestroyTexture(texture);
SDL_FreeSurface(mask_surface);
}
else {
SDL_SetRenderDrawColor(renderer, color.ch.red, color.ch.green, color.ch.blue, opa);
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
SDL_RenderSetClipRect(renderer, &draw_area_rect);
SDL_RenderFillRect(renderer, &draw_area_rect);
}
}
void lv_draw_blend_map(const lv_area_t * clip_area, const lv_area_t * map_area,
const lv_color_t * map_buf, lv_opa_t * mask, lv_draw_mask_res_t mask_res, lv_opa_t opa,
lv_blend_mode_t mode)
{
LV_UNUSED(clip_area);
LV_UNUSED(map_area);
LV_UNUSED(map_buf);
LV_UNUSED(mask);
LV_UNUSED(mask_res);
LV_UNUSED(opa);
LV_UNUSED(mode);
}
/**********************
* STATIC FUNCTIONS
**********************/
#endif /*LV_USE_GPU_SDL*/

158
src/gpu/sdl/lv_gpu_sdl_draw_line.c
View File

@@ -1,158 +0,0 @@
/**
* @file lv_gpu_sdl_draw_line.c
*
* This implementation does not functioning properly so it's not enabled
*
*/
/*********************
* INCLUDES
*********************/
#include "../../lv_conf_internal.h"
#if LV_USE_GPU_SDL
#include LV_GPU_SDL_INCLUDE_PATH
#include "../../core/lv_refr.h"
#include "lv_gpu_sdl_utils.h"
#include "lv_gpu_sdl_lru.h"
#include "lv_gpu_sdl_texture_cache.h"
#include "lv_gpu_sdl_mask.h"
#ifndef M_PI
#include <math.h>
#endif
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
typedef struct {
lv_gpu_cache_key_magic_t magic;
lv_coord_t length;
lv_coord_t thickness;
} lv_draw_line_key_t;
static lv_draw_line_key_t line_key_create(lv_coord_t length, lv_coord_t thickness);
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
void lv_draw_line2(const lv_point_t * point1, const lv_point_t * point2, const lv_area_t * clip,
const lv_draw_line_dsc_t * dsc)
{
if(dsc->width == 0) return;
if(dsc->opa <= LV_OPA_MIN) return;
if(point1->x == point2->x && point1->y == point2->y) return;
lv_area_t clip_line;
clip_line.x1 = LV_MIN(point1->x, point2->x) - dsc->width / 2;
clip_line.x2 = LV_MAX(point1->x, point2->x) + dsc->width / 2;
clip_line.y1 = LV_MIN(point1->y, point2->y) - dsc->width / 2;
clip_line.y2 = LV_MAX(point1->y, point2->y) + dsc->width / 2;
if(!_lv_area_intersect(&clip_line, &clip_line, clip)) return;
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
SDL_Color line_color;
lv_color_to_sdl_color(&dsc->color, &line_color);
int length = lv_sdl_round(SDL_sqrt(SDL_pow(point2->y - point1->y + 1, 2) + SDL_pow(point2->x - point1->x + 1, 2)));
lv_coord_t thickness = dsc->width;
lv_draw_line_key_t key = line_key_create(length, thickness);
lv_area_t coords = {1, 1, length, dsc->width};
lv_area_t tex_coords;
lv_area_copy(&tex_coords, &coords);
lv_area_increase(&tex_coords, 1, 1);
SDL_Texture * texture = lv_gpu_draw_cache_get(&key, sizeof(key), NULL);
if(texture == NULL) {
lv_draw_mask_radius_param_t mask_rout_param;
lv_draw_mask_radius_init(&mask_rout_param, &coords, 0, false);
int16_t mask_rout_id = lv_draw_mask_add(&mask_rout_param, NULL);
texture = lv_sdl_gen_mask_texture(renderer, &tex_coords, &mask_rout_id, 1);
lv_draw_mask_remove_id(mask_rout_id);
SDL_assert(texture);
lv_gpu_draw_cache_put(&key, sizeof(key), texture);
}
double angle = SDL_atan2(point2->y - point1->y, point2->x - point1->x) * 180 / M_PI;
SDL_Rect clip_rect;
lv_area_to_sdl_rect(&clip_line, &clip_rect);
SDL_Texture * screen = SDL_GetRenderTarget(renderer);
SDL_Texture * content = lv_gpu_temp_texture_obtain(renderer, clip_rect.w, clip_rect.h);
SDL_SetTextureBlendMode(content, SDL_BLENDMODE_BLEND);
SDL_SetRenderTarget(renderer, content);
SDL_RenderSetClipRect(renderer, NULL);
// /* Replace texture with clip mask */
SDL_Rect mask_rect = {.w = clip_rect.w, .h = clip_rect.h, .x = 0, .y = 0};
// SDL_Texture *mask = lv_sdl_gen_mask_texture(renderer, &clip_line, NULL, 0);
// SDL_SetTextureBlendMode(mask, SDL_BLENDMODE_NONE);
//// SDL_RenderCopy(renderer, mask, NULL, &mask_rect);
//
// SDL_SetTextureAlphaMod(texture, 0xFF);
// SDL_SetTextureColorMod(texture, 0xFF, 0xFF, 0xFF);
//#if SDL_VERSION_ATLEAST(2, 0, 6)
// SDL_BlendMode mode = SDL_ComposeCustomBlendMode(SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ZERO,
// SDL_BLENDOPERATION_ADD, SDL_BLENDFACTOR_ZERO,
// SDL_BLENDFACTOR_SRC_ALPHA, SDL_BLENDOPERATION_ADD);
// SDL_SetTextureBlendMode(texture, mode);
// SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_NONE);
//#else
SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_NONE);
//#endif
SDL_Rect coords_rect;
lv_area_to_sdl_rect(&tex_coords, &coords_rect);
coords_rect.x = 0 - coords_rect.h / 2;
coords_rect.y = 0 - coords_rect.h / 2;
SDL_Point center = {coords_rect.h / 2, coords_rect.h / 2};
SDL_RenderCopyEx(renderer, texture, NULL, &coords_rect, angle, &center, SDL_FLIP_NONE);
//
// /* Draw composited part on screen */
SDL_SetTextureBlendMode(content, SDL_BLENDMODE_NONE);
SDL_SetTextureAlphaMod(content, dsc->opa);
SDL_SetTextureColorMod(content, line_color.r, line_color.g, line_color.b);
//
SDL_SetRenderTarget(renderer, screen);
// SDL_RenderSetClipRect(renderer, &clip_rect);
SDL_RenderSetClipRect(renderer, NULL);
SDL_RenderCopy(renderer, content, &mask_rect, &clip_rect);
// SDL_DestroyTexture(mask);
}
static lv_draw_line_key_t line_key_create(lv_coord_t length, lv_coord_t thickness)
{
lv_draw_line_key_t key;
/* VERY IMPORTANT! Padding between members is uninitialized, so we have to wipe them manually */
SDL_memset(&key, 0, sizeof(key));
key.magic = LV_GPU_CACHE_KEY_MAGIC_LINE;
key.length = length;
key.thickness = thickness;
return key;
}
#endif /*LV_USE_GPU_SDL*/