lv_draw.h

Defines

LV_DRAW_UNIT_ID_ANY

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_ID_ANY

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.