lv_draw.h

Defines

LV_DRAW_UNIT_NONE

Enums

enum lv_draw_task_type_t

Values:

enumerator LV_DRAW_TASK_TYPE_FILL
enumerator LV_DRAW_TASK_TYPE_BORDER
enumerator LV_DRAW_TASK_TYPE_BOX_SHADOW
enumerator LV_DRAW_TASK_TYPE_LABEL
enumerator LV_DRAW_TASK_TYPE_IMAGE
enumerator LV_DRAW_TASK_TYPE_LAYER
enumerator LV_DRAW_TASK_TYPE_LINE
enumerator LV_DRAW_TASK_TYPE_ARC
enumerator LV_DRAW_TASK_TYPE_TRIANGLE
enumerator LV_DRAW_TASK_TYPE_MASK_RECTANGLE
enumerator LV_DRAW_TASK_TYPE_MASK_BITMAP
enumerator LV_DRAW_TASK_TYPE_VECTOR
enum lv_draw_task_state_t

Values:

enumerator LV_DRAW_TASK_STATE_WAITING
enumerator LV_DRAW_TASK_STATE_QUEUED
enumerator LV_DRAW_TASK_STATE_IN_PROGRESS
enumerator LV_DRAW_TASK_STATE_READY

Functions

void lv_draw_init(void)

Used internally to initialize the drawing module

void lv_draw_deinit(void)

Deinitialize the drawing module

void *lv_draw_create_unit(size_t size)

Allocate a new draw unit with the given size and appends it to the list of draw units

Parameters:

size -- the size to allocate. E.g. sizeof(my_draw_unit_t), where the first element of my_draw_unit_t is lv_draw_unit_t.

lv_draw_task_t *lv_draw_add_task(lv_layer_t *layer, const lv_area_t *coords)

Add an empty draw task to the draw task list of a layer.

Parameters:
  • layer -- pointer to a layer

  • coords -- the coordinates of the draw task

Returns:

the created draw task which needs to be further configured e.g. by added a draw descriptor

void lv_draw_finalize_task_creation(lv_layer_t *layer, lv_draw_task_t *t)

Needs to be called when a draw task is created and configured. It will send an event about the new draw task to the widget and assign it to a draw unit.

Parameters:
  • layer -- pointer to a layer

  • t -- poinr to a draw task

void lv_draw_dispatch(void)

Try dispatching draw tasks to draw units

bool lv_draw_dispatch_layer(lv_display_t *disp, lv_layer_t *layer)

Used internally to try dispatching draw tasks of a specific layer

Parameters:
  • disp -- pointer to a display on which the dispatching was requested

  • layer -- pointer to a layer

Returns:

at least one draw task is being rendered (maybe it was taken earlier)

void lv_draw_dispatch_wait_for_request(void)

Wait for a new dispatch request. It's blocking if LV_USE_OS == 0 else it yields

void lv_draw_dispatch_request(void)

When a draw unit finished a draw task it needs to request dispatching to let LVGL assign a new draw task to it

lv_draw_task_t *lv_draw_get_next_available_task(lv_layer_t *layer, lv_draw_task_t *t_prev, uint8_t draw_unit_id)

Find and available draw task

Parameters:
  • layer -- the draw ctx to search in

  • t_prev -- continue searching from this task

  • draw_unit_id -- check the task where preferred_draw_unit_id equals this value or LV_DRAW_UNIT_NONE

Returns:

tan available draw task or NULL if there is no any

uint32_t lv_draw_get_dependent_count(lv_draw_task_t *t_check)

Tell how many draw task are waiting to be drawn on the area of t_check. It can be used to determine if a GPU shall combine many draw tasks in to one or not. If a lot of tasks are waiting for the current ones it makes sense to draw them one-by-one to not block the dependent tasks' rendering

Parameters:

t_check -- the task whose dependent tasks shall be counted

Returns:

number of tasks depending on t_check

lv_layer_t *lv_draw_layer_create(lv_layer_t *parent_layer, lv_color_format_t color_format, const lv_area_t *area)

Create a new layer on a parent layer

Parameters:
  • parent_layer -- the parent layer to which the layer will be merged when it's rendered

  • color_format -- the color format of the layer

  • area -- the areas of the layer (absolute coordinates)

Returns:

the new target_layer or NULL on error

void *lv_draw_layer_alloc_buf(lv_layer_t *layer)

Try to allocate a buffer for the layer.

Parameters:

layer -- pointer to a layer

Returns:

pointer to the allocated aligned buffer or NULL on failure

void *lv_draw_layer_go_to_xy(lv_layer_t *layer, int32_t x, int32_t y)

Got to a pixel at X and Y coordinate on a layer

Parameters:
  • layer -- pointer to a layer

  • x -- the target X coordinate

  • y -- the target X coordinate

Returns:

buf offset to point to the given X and Y coordinate

struct _lv_draw_task_t

Public Members

lv_draw_task_t *next
lv_draw_task_type_t type
lv_area_t area

The area where to draw

lv_area_t _real_area

The real draw area. E.g. for shadow, outline, or transformed images it's different from area

lv_area_t clip_area_original

The original area which is updated

lv_area_t clip_area

The clip area of the layer is saved here when the draw task is created. As the clip area of the layer can be changed as new draw tasks are added its current value needs to be saved. Therefore during drawing the layer's clip area shouldn't be used as it might be already changed for other draw tasks.

int state
void *draw_dsc
uint8_t preferred_draw_unit_id

The ID of the draw_unit which should take this task

uint8_t preference_score

Set to which extent preferred_draw_unit_id is good at this task. 80: means 20% better (faster) than software rendering 100: the default value 110: means 10% worse (slower) than software rendering

struct lv_draw_mask_t

Public Members

void *user_data
struct _lv_draw_unit_t

Public Members

lv_draw_unit_t *next
lv_layer_t *target_layer

The target_layer on which drawing should happen

const lv_area_t *clip_area
int32_t (*dispatch_cb)(lv_draw_unit_t *draw_unit, lv_layer_t *layer)

Called to try to assign a draw task to itself. lv_draw_get_next_available_task can be used to get an independent draw task. A draw task should be assign only if the draw unit can draw it too

Param draw_unit:

pointer to the draw unit

Param layer:

pointer to a layer on which the draw task should be drawn

Return:

>=0: The number of taken draw task: 0 means the task has not yet been completed. 1 means a new task has been accepted. -1: The draw unit wanted to work on a task but couldn't do that due to some errors (e.g. out of memory). It signals that LVGL should call the dispatcher later again to let draw unit try to start the rendering again.

int32_t (*evaluate_cb)(lv_draw_unit_t *draw_unit, lv_draw_task_t *task)
Param draw_unit:

Param task:

Return:

int32_t (*delete_cb)(lv_draw_unit_t *draw_unit)

Called to delete draw unit.

Param draw_unit:

Return:

struct _lv_layer_t

Public Members

lv_draw_buf_t *draw_buf

Target draw buffer of the layer

lv_area_t buf_area

The absolute coordinates of the buffer

lv_color_format_t color_format

The color format of the layer. LV_COLOR_FORMAT_...

lv_area_t _clip_area

NEVER USE IT DRAW UNITS. USED INTERNALLY DURING DRAW TASK CREATION. The current clip area with absolute coordinates, always the same or smaller than buf_area Can be set before new draw tasks are added to indicate the clip area of the draw tasks. Therefore lv_draw_add_task() always saves it in the new draw task to know the clip area when the draw task was added. During drawing the draw units also sees the saved clip_area and should use it during drawing. During drawing the layer's clip area shouldn't be used as it might be already changed for other draw tasks.

lv_draw_task_t *draw_task_head

Linked list of draw tasks

lv_layer_t *parent
lv_layer_t *next
bool all_tasks_added
void *user_data
struct lv_draw_dsc_base_t

Public Members

lv_obj_t *obj
lv_part_t part
uint32_t id1
uint32_t id2
lv_layer_t *layer
size_t dsc_size
void *user_data
struct lv_draw_global_info_t

Public Members

lv_draw_unit_t *unit_head
uint32_t used_memory_for_layers_kb
int dispatch_req
lv_mutex_t circle_cache_mutex
bool task_running