diff --git a/Kconfig b/Kconfig index b79268fc65c6..254fe2170be0 100644 --- a/Kconfig +++ b/Kconfig @@ -1510,10 +1510,16 @@ menu "LVGL configuration" default 1 if LV_SDL_SINGLE_BUFFER default 2 if LV_SDL_DOUBLE_BUFFER + config LV_SDL_ACCELERATED + bool "Use hardware acceleration" + depends on LV_USE_SDL + default y + config LV_SDL_FULLSCREEN bool "SDL fullscreen" depends on LV_USE_SDL default n + config LV_SDL_DIRECT_EXIT bool "Exit the application when all SDL windows are closed" depends on LV_USE_SDL diff --git a/demos/widgets/lv_demo_widgets.c b/demos/widgets/lv_demo_widgets.c index a8ee61764a4d..21a366d834f2 100644 --- a/demos/widgets/lv_demo_widgets.c +++ b/demos/widgets/lv_demo_widgets.c @@ -253,7 +253,6 @@ static void profile_create(lv_obj_t * parent) LV_IMAGE_DECLARE(img_demo_widgets_avatar); lv_obj_t * avatar = lv_image_create(panel1); lv_image_set_src(avatar, &img_demo_widgets_avatar); - // lv_image_set_src(avatar, "A:lvgl/demos/widgets/assets/avatar.png") lv_obj_t * name = lv_label_create(panel1); lv_label_set_text(name, "Elena Smith"); @@ -998,11 +997,11 @@ void shop_create(lv_obj_t * parent) lv_obj_add_style(title, &style_title, 0); LV_IMAGE_DECLARE(img_clothes); - create_shop_item(list, &img_clothes, "Blue jeans", "Clothes", "$722"); - create_shop_item(list, &img_clothes, "Blue jeans", "Clothes", "$411"); - create_shop_item(list, &img_clothes, "Blue jeans", "Clothes", "$917"); - create_shop_item(list, &img_clothes, "Blue jeans", "Clothes", "$64"); - create_shop_item(list, &img_clothes, "Blue jeans", "Clothes", "$805"); + create_shop_item(list, &img_clothes, "Blue T-shirt", "Clothes", "$722"); + create_shop_item(list, &img_clothes, "Blue T-shirt", "Clothes", "$411"); + create_shop_item(list, &img_clothes, "Blue T-shirt", "Clothes", "$917"); + create_shop_item(list, &img_clothes, "Blue T-shirt", "Clothes", "$64"); + create_shop_item(list, &img_clothes, "Blue T-shirt", "Clothes", "$805"); lv_obj_t * notifications = lv_obj_create(parent); if(disp_size == DISP_SMALL) { diff --git a/lv_conf_template.h b/lv_conf_template.h index bef23926c68e..ad9bc988aa1d 100644 --- a/lv_conf_template.h +++ b/lv_conf_template.h @@ -941,6 +941,7 @@ #define LV_SDL_INCLUDE_PATH #define LV_SDL_RENDER_MODE LV_DISPLAY_RENDER_MODE_DIRECT /*LV_DISPLAY_RENDER_MODE_DIRECT is recommended for best performance*/ #define LV_SDL_BUF_COUNT 1 /*1 or 2*/ + #define LV_SDL_ACCELERATED 1 /*1: Use hardware acceleration*/ #define LV_SDL_FULLSCREEN 0 /*1: Make the window full screen by default*/ #define LV_SDL_DIRECT_EXIT 1 /*1: Exit the application when all SDL windows are closed*/ #define LV_SDL_MOUSEWHEEL_MODE LV_SDL_MOUSEWHEEL_MODE_ENCODER /*LV_SDL_MOUSEWHEEL_MODE_ENCODER/CROWN*/ diff --git a/scripts/install-prerequisites.sh b/scripts/install-prerequisites.sh index 05d1f1a44e34..98a008f33354 100755 --- a/scripts/install-prerequisites.sh +++ b/scripts/install-prerequisites.sh @@ -9,7 +9,7 @@ sudo dpkg --add-architecture i386 sudo apt update sudo apt install gcc gcc-multilib g++-multilib ninja-build \ libpng-dev libjpeg-turbo8-dev libfreetype6-dev \ - libglew-dev libglfw3-dev libsdl2-dev libsdl2-image-dev \ + libglew-dev libglfw3-dev libsdl2-dev \ libpng-dev:i386 libjpeg-dev:i386 libfreetype6-dev:i386 \ ruby-full gcovr cmake python3 pngquant libinput-dev libxkbcommon-dev libdrm-dev pkg-config pip3 install pypng lz4 diff --git a/src/draw/lv_draw_arc.c b/src/draw/lv_draw_arc.c index 670aedec4e04..f092ea73ff15 100644 --- a/src/draw/lv_draw_arc.c +++ b/src/draw/lv_draw_arc.c @@ -42,6 +42,7 @@ void lv_draw_arc_dsc_init(lv_draw_arc_dsc_t * dsc) dsc->width = 1; dsc->opa = LV_OPA_COVER; dsc->color = lv_color_black(); + dsc->base.dsc_size = sizeof(lv_draw_arc_dsc_t); } lv_draw_arc_dsc_t * lv_draw_task_get_arc_dsc(lv_draw_task_t * task) diff --git a/src/draw/lv_draw_line.c b/src/draw/lv_draw_line.c index 51d3040b2b4a..00fc203b10d9 100644 --- a/src/draw/lv_draw_line.c +++ b/src/draw/lv_draw_line.c @@ -42,6 +42,7 @@ void LV_ATTRIBUTE_FAST_MEM lv_draw_line_dsc_init(lv_draw_line_dsc_t * dsc) dsc->width = 1; dsc->opa = LV_OPA_COVER; dsc->color = lv_color_black(); + dsc->base.dsc_size = sizeof(lv_draw_line_dsc_t); } lv_draw_line_dsc_t * lv_draw_task_get_line_dsc(lv_draw_task_t * task) diff --git a/src/draw/lv_draw_triangle.c b/src/draw/lv_draw_triangle.c index 44d5be3ffd1e..6bf1c7c21cc0 100644 --- a/src/draw/lv_draw_triangle.c +++ b/src/draw/lv_draw_triangle.c @@ -48,6 +48,7 @@ void lv_draw_triangle_dsc_init(lv_draw_triangle_dsc_t * dsc) dsc->bg_grad.stops[1].frac = 0xFF; dsc->bg_grad.stops_count = 2; dsc->bg_opa = LV_OPA_COVER; + dsc->base.dsc_size = sizeof(lv_draw_triangle_dsc_t); LV_PROFILER_END; } diff --git a/src/draw/sdl/lv_draw_sdl.c b/src/draw/sdl/lv_draw_sdl.c index 58d700c0b953..c155ac1140ce 100644 --- a/src/draw/sdl/lv_draw_sdl.c +++ b/src/draw/sdl/lv_draw_sdl.c @@ -9,13 +9,13 @@ #include "../lv_draw_private.h" #if LV_USE_DRAW_SDL #include LV_SDL_INCLUDE_PATH -#include - #include "lv_draw_sdl.h" #include "../../core/lv_refr_private.h" #include "../../display/lv_display_private.h" #include "../../stdlib/lv_string.h" #include "../../drivers/sdl/lv_sdl_window.h" +#include "../../misc/cache/lv_cache_entry_private.h" +#include "../../misc/lv_area_private.h" /********************* * DEFINES @@ -40,7 +40,7 @@ static void execute_drawing(lv_draw_sdl_unit_t * u); static int32_t dispatch(lv_draw_unit_t * draw_unit, lv_layer_t * layer); static int32_t evaluate(lv_draw_unit_t * draw_unit, lv_draw_task_t * task); -static bool draw_to_texture(lv_draw_sdl_unit_t * u, cache_data_t * data); +static bool draw_to_texture(lv_draw_sdl_unit_t * u, cache_data_t * cache_data); /********************** * GLOBAL PROTOTYPES @@ -92,7 +92,12 @@ static lv_cache_compare_res_t sdl_texture_cache_compare_cb(const cache_data_t * return lhs_dsc_size > rhs_dsc_size ? 1 : -1; } - int cmp_res = memcmp(lhs->draw_dsc, rhs->draw_dsc, lhs->draw_dsc->dsc_size); + const uint8_t * left_draw_dsc = (const uint8_t *)lhs->draw_dsc; + const uint8_t * right_draw_dsc = (const uint8_t *)rhs->draw_dsc; + left_draw_dsc += sizeof(lv_draw_dsc_base_t); + right_draw_dsc += sizeof(lv_draw_dsc_base_t); + + int cmp_res = lv_memcmp(left_draw_dsc, right_draw_dsc, lhs->draw_dsc->dsc_size - sizeof(lv_draw_dsc_base_t)); if(cmp_res != 0) { return cmp_res > 0 ? 1 : -1; @@ -169,25 +174,36 @@ static int32_t evaluate(lv_draw_unit_t * draw_unit, lv_draw_task_t * task) return 0; } -static bool draw_to_texture(lv_draw_sdl_unit_t * u, cache_data_t * data) +static bool draw_to_texture(lv_draw_sdl_unit_t * u, cache_data_t * cache_data) { lv_draw_task_t * task = u->task_act; lv_layer_t dest_layer; lv_memzero(&dest_layer, sizeof(dest_layer)); + + int32_t texture_w = lv_area_get_width(&task->_real_area); + int32_t texture_h = lv_area_get_height(&task->_real_area); + lv_draw_buf_t draw_buf; dest_layer.draw_buf = &draw_buf; - lv_draw_buf_init(dest_layer.draw_buf, lv_area_get_width(&task->area), lv_area_get_height(&task->area), + lv_draw_buf_init(dest_layer.draw_buf, texture_w, texture_h, LV_COLOR_FORMAT_ARGB8888, LV_STRIDE_AUTO, sdl_render_buf, sizeof(sdl_render_buf)); dest_layer.color_format = LV_COLOR_FORMAT_ARGB8888; - dest_layer.buf_area = task->area; - dest_layer._clip_area = task->area; - dest_layer.phy_clip_area = task->area; + + dest_layer.buf_area = task->_real_area; + dest_layer._clip_area = task->_real_area; + dest_layer.phy_clip_area = task->_real_area; lv_memzero(sdl_render_buf, lv_area_get_size(&dest_layer.buf_area) * 4 + 100); lv_display_t * disp = lv_refr_get_disp_refreshing(); - SDL_Texture * texture = NULL; + lv_obj_t * obj = ((lv_draw_dsc_base_t *)task->draw_dsc)->obj; + bool original_send_draw_task_event = false; + if(obj) { + original_send_draw_task_event = lv_obj_has_flag(obj, LV_OBJ_FLAG_SEND_DRAW_TASK_EVENTS); + lv_obj_remove_flag(obj, LV_OBJ_FLAG_SEND_DRAW_TASK_EVENTS); + } + switch(task->type) { case LV_DRAW_TASK_TYPE_FILL: { lv_draw_fill_dsc_t * fill_dsc = task->draw_dsc; @@ -203,7 +219,7 @@ static bool draw_to_texture(lv_draw_sdl_unit_t * u, cache_data_t * data) } break; case LV_DRAW_TASK_TYPE_BORDER: { - lv_draw_border_dsc_t * border_dsc = task->draw_dsc;; + lv_draw_border_dsc_t * border_dsc = task->draw_dsc; lv_draw_rect_dsc_t rect_dsc; lv_draw_rect_dsc_init(&rect_dsc); rect_dsc.base.user_data = lv_sdl_window_get_renderer(disp); @@ -216,56 +232,55 @@ static bool draw_to_texture(lv_draw_sdl_unit_t * u, cache_data_t * data) lv_draw_rect(&dest_layer, &rect_dsc, &task->area); break; } + case LV_DRAW_TASK_TYPE_BOX_SHADOW: { + lv_draw_box_shadow_dsc_t * box_shadow_dsc = task->draw_dsc; + lv_draw_rect_dsc_t rect_dsc; + lv_draw_rect_dsc_init(&rect_dsc); + rect_dsc.base.user_data = lv_sdl_window_get_renderer(disp); + rect_dsc.bg_opa = LV_OPA_0; + rect_dsc.radius = box_shadow_dsc->radius; + rect_dsc.bg_color = box_shadow_dsc->color; + rect_dsc.shadow_opa = box_shadow_dsc->opa; + rect_dsc.shadow_width = box_shadow_dsc->width; + rect_dsc.shadow_spread = box_shadow_dsc->spread; + rect_dsc.shadow_offset_x = box_shadow_dsc->ofs_x; + rect_dsc.shadow_offset_y = box_shadow_dsc->ofs_y; + lv_draw_rect(&dest_layer, &rect_dsc, &task->area); + break; + } case LV_DRAW_TASK_TYPE_LABEL: { lv_draw_label_dsc_t label_dsc; - lv_draw_label_dsc_init(&label_dsc); lv_memcpy(&label_dsc, task->draw_dsc, sizeof(label_dsc)); label_dsc.base.user_data = lv_sdl_window_get_renderer(disp); lv_draw_label(&dest_layer, &label_dsc, &task->area); } break; + case LV_DRAW_TASK_TYPE_ARC: { + lv_draw_arc_dsc_t arc_dsc; + lv_memcpy(&arc_dsc, task->draw_dsc, sizeof(arc_dsc)); + arc_dsc.base.user_data = lv_sdl_window_get_renderer(disp); + lv_draw_arc(&dest_layer, &arc_dsc); + } + break; + case LV_DRAW_TASK_TYPE_LINE: { + lv_draw_line_dsc_t line_dsc; + lv_memcpy(&line_dsc, task->draw_dsc, sizeof(line_dsc)); + line_dsc.base.user_data = lv_sdl_window_get_renderer(disp); + lv_draw_line(&dest_layer, &line_dsc); + } + break; + case LV_DRAW_TASK_TYPE_TRIANGLE: { + lv_draw_triangle_dsc_t triangle_dsc; + lv_memcpy(&triangle_dsc, task->draw_dsc, sizeof(triangle_dsc)); + triangle_dsc.base.user_data = lv_sdl_window_get_renderer(disp); + lv_draw_triangle(&dest_layer, &triangle_dsc); + } + break; case LV_DRAW_TASK_TYPE_IMAGE: { - lv_draw_image_dsc_t * image_dsc = task->draw_dsc; - lv_image_src_t type = lv_image_src_get_type(image_dsc->src); - SDL_Surface * surface = NULL; - if(type == LV_IMAGE_SRC_FILE) { - const char * path = image_dsc->src; - surface = IMG_Load(&path[2]); - if(surface == NULL) { - LV_LOG_ERROR("could not load image from file: %s", IMG_GetError()); - return false; - } - } - else if(type == LV_IMAGE_SRC_VARIABLE) { - lv_image_dsc_t * lvd = (lv_image_dsc_t *)image_dsc->src; - surface = SDL_CreateRGBSurfaceFrom((void *)lvd->data, - lvd->header.w, lvd->header.h, - LV_COLOR_FORMAT_GET_BPP(lvd->header.cf), - lvd->header.stride, -#if SDL_BYTEORDER == SDL_LIL_ENDIAN - 0x00FF0000, - 0x0000FF00, - 0x000000FF, - 0xFF000000 -#else - 0x0000FF00, - 0x00FF0000, - 0xFF000000, - 0x000000FF -#endif - ); - if(surface == NULL) { - LV_LOG_ERROR("could not load image from variable"); - return false; - } - } - else { - LV_LOG_WARN("image source type unknown"); - return false; - } - - SDL_Renderer * renderer = lv_sdl_window_get_renderer(disp); - texture = SDL_CreateTextureFromSurface(renderer, surface); + lv_draw_image_dsc_t image_dsc; + lv_memcpy(&image_dsc, task->draw_dsc, sizeof(image_dsc)); + image_dsc.base.user_data = lv_sdl_window_get_renderer(disp); + lv_draw_image(&dest_layer, &image_dsc, &task->area); break; } default: @@ -279,29 +294,22 @@ static bool draw_to_texture(lv_draw_sdl_unit_t * u, cache_data_t * data) } } - SDL_Rect rect; - rect.x = dest_layer.buf_area.x1; - rect.y = dest_layer.buf_area.y1; - rect.w = lv_area_get_width(&dest_layer.buf_area); - rect.h = lv_area_get_height(&dest_layer.buf_area); - - if(texture == NULL) { - texture = SDL_CreateTexture(lv_sdl_window_get_renderer(disp), SDL_PIXELFORMAT_ARGB8888, - SDL_TEXTUREACCESS_STATIC, rect.w, rect.h); - SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND); - SDL_UpdateTexture(texture, NULL, sdl_render_buf, rect.w * 4); - } - else { - SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND); - } + SDL_Texture * texture = SDL_CreateTexture(lv_sdl_window_get_renderer(disp), SDL_PIXELFORMAT_ARGB8888, + SDL_TEXTUREACCESS_STATIC, texture_w, texture_h); + SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND); + SDL_UpdateTexture(texture, NULL, sdl_render_buf, texture_w * 4); lv_draw_dsc_base_t * base_dsc = task->draw_dsc; - data->draw_dsc = lv_malloc(base_dsc->dsc_size); - lv_memcpy((void *)data->draw_dsc, base_dsc, base_dsc->dsc_size); - data->w = lv_area_get_width(&task->area); - data->h = lv_area_get_height(&task->area); - data->texture = texture; + cache_data->draw_dsc = lv_malloc(base_dsc->dsc_size); + lv_memcpy((void *)cache_data->draw_dsc, base_dsc, base_dsc->dsc_size); + cache_data->w = texture_w; + cache_data->h = texture_h; + cache_data->texture = texture; + + if(obj) { + lv_obj_update_flag(obj, LV_OBJ_FLAG_SEND_DRAW_TASK_EVENTS, original_send_draw_task_event); + } return true; } @@ -318,13 +326,18 @@ static void blend_texture_layer(lv_draw_sdl_unit_t * u) clip_rect.h = lv_area_get_height(u->base_unit.clip_area); lv_draw_task_t * t = u->task_act; + lv_draw_image_dsc_t * draw_dsc = t->draw_dsc; SDL_Rect rect; - rect.x = t->area.x1; - rect.y = t->area.y1; - rect.w = lv_area_get_width(&t->area); - rect.h = lv_area_get_height(&t->area); + rect.w = (lv_area_get_width(&t->area) * draw_dsc->scale_x) / 256; + rect.h = (lv_area_get_height(&t->area) * draw_dsc->scale_y) / 256; + + rect.x = -draw_dsc->pivot.x; + rect.y = -draw_dsc->pivot.y; + rect.x = (rect.x * draw_dsc->scale_x) / 256; + rect.y = (rect.y * draw_dsc->scale_y) / 256; + rect.x += t->area.x1 + draw_dsc->pivot.x; + rect.y += t->area.y1 + draw_dsc->pivot.y; - lv_draw_image_dsc_t * draw_dsc = t->draw_dsc; lv_layer_t * src_layer = (lv_layer_t *)draw_dsc->src; SDL_Texture * src_texture = layer_get_texture(src_layer); @@ -332,21 +345,24 @@ static void blend_texture_layer(lv_draw_sdl_unit_t * u) SDL_SetTextureBlendMode(src_texture, SDL_BLENDMODE_BLEND); SDL_SetRenderTarget(renderer, layer_get_texture(u->base_unit.target_layer)); SDL_RenderSetClipRect(renderer, &clip_rect); - SDL_RenderCopy(renderer, src_texture, NULL, &rect); + + SDL_Point center = {draw_dsc->pivot.x, draw_dsc->pivot.y}; + SDL_RenderCopyEx(renderer, src_texture, NULL, &rect, draw_dsc->rotation / 10, ¢er, SDL_FLIP_NONE); + // SDL_RenderCopy(renderer, src_texture, NULL, &rect); + SDL_DestroyTexture(src_texture); SDL_RenderSetClipRect(renderer, NULL); } static void draw_from_cached_texture(lv_draw_sdl_unit_t * u) { - lv_draw_task_t * t = u->task_act; cache_data_t data_to_find; data_to_find.draw_dsc = (lv_draw_dsc_base_t *)t->draw_dsc; - data_to_find.w = lv_area_get_width(&t->area); - data_to_find.h = lv_area_get_height(&t->area); + data_to_find.w = lv_area_get_width(&t->_real_area); + data_to_find.h = lv_area_get_height(&t->_real_area); data_to_find.texture = NULL; /*user_data stores the renderer to differentiate it from SW rendered tasks. @@ -354,11 +370,24 @@ static void draw_from_cached_texture(lv_draw_sdl_unit_t * u) void * user_data_saved = data_to_find.draw_dsc->user_data; data_to_find.draw_dsc->user_data = NULL; + /*img_dsc->image_area is an absolute coordinate so it's different + *for the same image on a different position. So make it relative before using for cache. */ + if(t->type == LV_DRAW_TASK_TYPE_IMAGE) { + lv_draw_image_dsc_t * img_dsc = (lv_draw_image_dsc_t *)data_to_find.draw_dsc; + lv_area_move(&img_dsc->image_area, -t->area.x1, -t->area.y1); + } + lv_cache_entry_t * entry_cached = lv_cache_acquire_or_create(u->texture_cache, &data_to_find, u); + if(t->type == LV_DRAW_TASK_TYPE_IMAGE) { + lv_draw_image_dsc_t * img_dsc = (lv_draw_image_dsc_t *)data_to_find.draw_dsc; + lv_area_move(&img_dsc->image_area, t->area.x1, t->area.y1); + } + if(!entry_cached) { return; } + data_to_find.draw_dsc->user_data = user_data_saved; cache_data_t * data_cached = lv_cache_entry_get_data(entry_cached); @@ -377,52 +406,59 @@ static void draw_from_cached_texture(lv_draw_sdl_unit_t * u) SDL_SetRenderTarget(renderer, layer_get_texture(dest_layer)); - lv_draw_image_dsc_t * draw_dsc = lv_draw_task_get_image_dsc(t); - if(draw_dsc) { - lv_area_t image_area; - image_area.x1 = 0; - image_area.y1 = 0; - image_area.x2 = draw_dsc->header.w - 1; - image_area.y2 = draw_dsc->header.h - 1; - - lv_area_move(&image_area, t->area.x1 - dest_layer->buf_area.x1, t->area.y1 - dest_layer->buf_area.y1); - rect.x = image_area.x1; - rect.y = image_area.y1; - rect.w = lv_area_get_width(&image_area); - rect.h = lv_area_get_height(&image_area); - - SDL_RenderSetClipRect(renderer, &clip_rect); - SDL_RenderCopy(renderer, texture, NULL, &rect); - } - else { - rect.x = t->area.x1 - dest_layer->buf_area.x1; - rect.y = t->area.y1 - dest_layer->buf_area.y1; - rect.w = lv_area_get_width(&t->area); - rect.h = lv_area_get_height(&t->area); - - SDL_RenderSetClipRect(renderer, &clip_rect); - SDL_RenderCopy(renderer, texture, NULL, &rect); - } + rect.x = t->_real_area.x1 - dest_layer->buf_area.x1; + rect.y = t->_real_area.y1 - dest_layer->buf_area.y1; + rect.w = data_cached->w; + rect.h = data_cached->h; + + SDL_RenderSetClipRect(renderer, &clip_rect); + SDL_RenderCopy(renderer, texture, NULL, &rect); SDL_RenderSetClipRect(renderer, NULL); lv_cache_release(u->texture_cache, entry_cached, u); + + /*Do not cache label's with local text as the text will be freed*/ + if(t->type == LV_DRAW_TASK_TYPE_LABEL) { + lv_draw_label_dsc_t * label_dsc = t->draw_dsc; + if(label_dsc->text_local) { + lv_cache_drop(u->texture_cache, &data_to_find, NULL); + } + } } static void execute_drawing(lv_draw_sdl_unit_t * u) { lv_draw_task_t * t = u->task_act; - if(t->type == LV_DRAW_TASK_TYPE_BOX_SHADOW) return; - if(t->type == LV_DRAW_TASK_TYPE_LINE) return; - if(t->type == LV_DRAW_TASK_TYPE_TRIANGLE) return; + if(t->type == LV_DRAW_TASK_TYPE_FILL) { + lv_draw_fill_dsc_t * fill_dsc = t->draw_dsc; + if(fill_dsc->radius == 0 && fill_dsc->grad.dir == LV_GRAD_DIR_NONE) { + SDL_Rect rect; + lv_layer_t * layer = u->base_unit.target_layer; + lv_area_t fill_area = t->area; + lv_area_intersect(&fill_area, &fill_area, u->base_unit.clip_area); + + rect.x = fill_area.x1 - layer->buf_area.x1; + rect.y = fill_area.y1 - layer->buf_area.y1; + rect.w = lv_area_get_width(&fill_area); + rect.h = lv_area_get_height(&fill_area); + lv_display_t * disp = lv_refr_get_disp_refreshing(); + SDL_Renderer * renderer = lv_sdl_window_get_renderer(disp); + SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND); + SDL_SetRenderDrawColor(renderer, fill_dsc->color.red, fill_dsc->color.green, fill_dsc->color.blue, fill_dsc->opa); + SDL_RenderSetClipRect(renderer, NULL); + SDL_RenderFillRect(renderer, &rect); + return; + } + } if(t->type == LV_DRAW_TASK_TYPE_LAYER) { blend_texture_layer(u); + return; } - else { - draw_from_cached_texture(u); - } + + draw_from_cached_texture(u); } static SDL_Texture * layer_get_texture(lv_layer_t * layer) diff --git a/src/drivers/sdl/lv_sdl_window.c b/src/drivers/sdl/lv_sdl_window.c index 2844112679ae..8448e79d4744 100644 --- a/src/drivers/sdl/lv_sdl_window.c +++ b/src/drivers/sdl/lv_sdl_window.c @@ -14,6 +14,7 @@ #include "../../core/lv_global.h" #include "../../display/lv_display_private.h" #include "../../lv_init.h" +#include "../../draw/lv_draw_buf.h" /* for aligned_alloc */ #ifndef __USE_ISOC11 @@ -24,10 +25,6 @@ #define SDL_MAIN_HANDLED /*To fix SDL's "undefined reference to WinMain" issue*/ #include "lv_sdl_private.h" -#if LV_USE_DRAW_SDL - #include -#endif - /********************* * DEFINES *********************/ @@ -91,13 +88,6 @@ lv_display_t * lv_sdl_window_create(int32_t hor_res, int32_t ver_res) event_handler_timer = lv_timer_create(sdl_event_handler, 5, NULL); lv_tick_set_cb(SDL_GetTicks); -#if LV_USE_DRAW_SDL - if(!(IMG_Init(IMG_INIT_PNG) & IMG_INIT_PNG)) { - fprintf(stderr, "could not initialize sdl2_image: %s\n", IMG_GetError()); - return NULL; - } -#endif - inited = true; } @@ -133,15 +123,19 @@ lv_display_t * lv_sdl_window_create(int32_t hor_res, int32_t ver_res) LV_SDL_RENDER_MODE); } #else /*/*LV_USE_DRAW_SDL == 1*/ - uint32_t stride = lv_draw_buf_width_to_stride(disp->hor_res, - lv_display_get_color_format(disp)); /*It will render directly to default Texture, so the buffer is not used, so just set something*/ - static uint8_t dummy_buf[1]; - lv_display_set_buffers(disp, dummy_buf, NULL, stride * disp->ver_res, - LV_SDL_RENDER_MODE); + static lv_draw_buf_t draw_buf; + static uint8_t dummy_buf; /*It won't be used as it will render to the SDL textures directly*/ + lv_draw_buf_init(&draw_buf, 4096, 4096, LV_COLOR_FORMAT_ARGB8888, 4096 * 4, &dummy_buf, 4096 * 4096 * 4); + + lv_display_set_draw_buffers(disp, &draw_buf, NULL); + lv_display_set_render_mode(disp, LV_DISPLAY_RENDER_MODE_DIRECT); #endif /*LV_USE_DRAW_SDL == 0*/ lv_display_add_event_cb(disp, res_chg_event_cb, LV_EVENT_RESOLUTION_CHANGED, NULL); + /*Process the initial events*/ + sdl_event_handler(NULL); + return disp; } @@ -313,7 +307,6 @@ static void sdl_event_handler(lv_timer_t * t) lv_display_t * disp = lv_sdl_get_disp_from_win_id(event.window.windowID); if(disp == NULL) continue; lv_sdl_window_t * dsc = lv_display_get_driver_data(disp); - switch(event.window.event) { #if SDL_VERSION_ATLEAST(2, 0, 5) case SDL_WINDOWEVENT_TAKE_FOCUS: @@ -361,7 +354,8 @@ static void window_create(lv_display_t * disp) SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, hor_res * dsc->zoom, ver_res * dsc->zoom, flag); /*last param. SDL_WINDOW_BORDERLESS to hide borders*/ - dsc->renderer = SDL_CreateRenderer(dsc->window, -1, SDL_RENDERER_SOFTWARE); + dsc->renderer = SDL_CreateRenderer(dsc->window, -1, + LV_SDL_ACCELERATED ? SDL_RENDERER_ACCELERATED : SDL_RENDERER_SOFTWARE); #if LV_USE_DRAW_SDL == 0 texture_resize(disp); diff --git a/src/lv_conf_internal.h b/src/lv_conf_internal.h index 8be76d0c9c3f..487e204a06bf 100644 --- a/src/lv_conf_internal.h +++ b/src/lv_conf_internal.h @@ -3068,6 +3068,17 @@ #define LV_SDL_BUF_COUNT 1 /*1 or 2*/ #endif #endif + #ifndef LV_SDL_ACCELERATED + #ifdef LV_KCONFIG_PRESENT + #ifdef CONFIG_LV_SDL_ACCELERATED + #define LV_SDL_ACCELERATED CONFIG_LV_SDL_ACCELERATED + #else + #define LV_SDL_ACCELERATED 0 + #endif + #else + #define LV_SDL_ACCELERATED 1 /*1: Use hardware acceleration*/ + #endif + #endif #ifndef LV_SDL_FULLSCREEN #ifdef CONFIG_LV_SDL_FULLSCREEN #define LV_SDL_FULLSCREEN CONFIG_LV_SDL_FULLSCREEN diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 3651ac07adec..7da23321fe08 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -338,10 +338,7 @@ include_directories(${FREETYPE_INCLUDE_DIRS}) if(OPTIONS_SDL) find_package(SDL2 REQUIRED) - find_library(NAME SDL2_image REQUIRED) - link_libraries(SDL2_image) include_directories(${SDL2_INCLUDE_DIRS}) - include_directories(${SDL2_IMAGE_INCLUDE_DIRS}) endif() # libinput is required for the libinput device driver test case @@ -461,9 +458,7 @@ foreach( test_case_fname ${TEST_CASE_FILES} ) ${TEST_LIBS}) if(OPTIONS_SDL) - target_link_libraries(${test_name} PRIVATE - ${SDL_LIBRARY} - ${SDL_IMAGE_LIBRARY}) + target_link_libraries(${test_name} PRIVATE ${SDL_LIBRARY}) endif() if (NOT $ENV{NON_AMD64_BUILD})