From: luozheng <1732036298@qq.com> Date: Wed, 23 Jul 2025 06:49:29 +0000 (+0800) Subject: middleware文件夹下services文件夹下gui文件夹合并提交 X-Git-Tag: leiniao_debug_1.0.0_20250922_020716~232 X-Git-Url: http://git.snicker.com.cn/css/static/gitweb.css?a=commitdiff_plain;h=541028f35d93868ed75f246294f045827926b172;p=mirrors%2FFD230.git middleware文件夹下services文件夹下gui文件夹合并提交 --- diff --git a/code/sdk/middleware/services/gui/hal/common/include/graphic_hardware_config.h b/code/sdk/middleware/services/gui/hal/common/include/graphic_hardware_config.h index f834f49ba..a84928bb2 100644 --- a/code/sdk/middleware/services/gui/hal/common/include/graphic_hardware_config.h +++ b/code/sdk/middleware/services/gui/hal/common/include/graphic_hardware_config.h @@ -125,6 +125,10 @@ #define DOUBLE_BUFFER 1 #endif +#ifndef HW_ROTATE_ANGLE +#define HW_ROTATE_ANGLE 0 +#endif + #if !defined(RESOLUTION_WIDTH) || !defined(RESOLUTION_HEIGHT) #define RESOLUTION_WIDTH 454 #define RESOLUTION_HEIGHT 454 @@ -180,10 +184,10 @@ #define MEM_POOL_UI_OTHER (MEM_POOL_UI_FONT + MEM_POOL_UI_FONT_SIZE) #define MEM_POOL_UI_OTHER_SIZE (MEM_POOL_UI_POOL_SIZE - MEM_POOL_UI_FONT_SIZE) #else // FB(psram) is physical addr, GUI dynamic allocation -#define MEM_POOL_UI_FB (MEM_POOL_UI_FONT + MEM_POOL_UI_FONT_SIZE) -#define MEM_POOL_UI_FB_SIZE ((ALIGN_UP(RESOLUTION_WIDTH, 16) * RESOLUTION_HEIGHT * LAYER_BPP / 8) * 2) -#define MEM_POOL_UI_OTHER (MEM_POOL_UI_FB + MEM_POOL_UI_FB_SIZE) -#define MEM_POOL_UI_OTHER_SIZE (MEM_POOL_UI_POOL_SIZE - MEM_POOL_UI_FONT_SIZE - MEM_POOL_UI_FB_SIZE) +#define MEM_POOL_UI_FB 0x60240000 +#define MEM_POOL_UI_FB_SIZE 0x151800 // max:480*3*480*2 +#define MEM_POOL_UI_OTHER (MEM_POOL_UI_FONT + MEM_POOL_UI_FONT_SIZE) +#define MEM_POOL_UI_OTHER_SIZE (MEM_POOL_UI_POOL_SIZE - MEM_POOL_UI_FONT_SIZE) #endif #endif diff --git a/code/sdk/middleware/services/gui/hal/display/brandy-auto-ota-cli/libdisplay_gfx.a b/code/sdk/middleware/services/gui/hal/display/brandy-auto-ota-cli/libdisplay_gfx.a index 1c555aba8..846db31e4 100644 Binary files a/code/sdk/middleware/services/gui/hal/display/brandy-auto-ota-cli/libdisplay_gfx.a and b/code/sdk/middleware/services/gui/hal/display/brandy-auto-ota-cli/libdisplay_gfx.a differ diff --git a/code/sdk/middleware/services/gui/hal/display/brandy-auto-ota-ser/libdisplay_gfx.a b/code/sdk/middleware/services/gui/hal/display/brandy-auto-ota-ser/libdisplay_gfx.a index 55d15300a..366791ebf 100644 Binary files a/code/sdk/middleware/services/gui/hal/display/brandy-auto-ota-ser/libdisplay_gfx.a and b/code/sdk/middleware/services/gui/hal/display/brandy-auto-ota-ser/libdisplay_gfx.a differ diff --git a/code/sdk/middleware/services/gui/hal/display/brandy-native-js/libdisplay_gfx.a b/code/sdk/middleware/services/gui/hal/display/brandy-native-js/libdisplay_gfx.a index 5b7a5036a..8864f8e31 100644 Binary files a/code/sdk/middleware/services/gui/hal/display/brandy-native-js/libdisplay_gfx.a and b/code/sdk/middleware/services/gui/hal/display/brandy-native-js/libdisplay_gfx.a differ diff --git a/code/sdk/middleware/services/gui/hal/display/brandy-target1/libdisplay_gfx.a b/code/sdk/middleware/services/gui/hal/display/brandy-target1/libdisplay_gfx.a index 3325fc9ed..6c0dcece8 100644 Binary files a/code/sdk/middleware/services/gui/hal/display/brandy-target1/libdisplay_gfx.a and b/code/sdk/middleware/services/gui/hal/display/brandy-target1/libdisplay_gfx.a differ diff --git a/code/sdk/middleware/services/gui/hal/display/brandy-target3/libdisplay_gfx.a b/code/sdk/middleware/services/gui/hal/display/brandy-target3/libdisplay_gfx.a index 2df6c10d3..53a5e2d91 100644 Binary files a/code/sdk/middleware/services/gui/hal/display/brandy-target3/libdisplay_gfx.a and b/code/sdk/middleware/services/gui/hal/display/brandy-target3/libdisplay_gfx.a differ diff --git a/code/sdk/middleware/services/gui/hal/display/brandy-target5/libdisplay_gfx.a b/code/sdk/middleware/services/gui/hal/display/brandy-target5/libdisplay_gfx.a index 9e3a976f4..2066cb734 100644 Binary files a/code/sdk/middleware/services/gui/hal/display/brandy-target5/libdisplay_gfx.a and b/code/sdk/middleware/services/gui/hal/display/brandy-target5/libdisplay_gfx.a differ diff --git a/code/sdk/middleware/services/gui/hal/display/brandy-xts/libdisplay_gfx.a b/code/sdk/middleware/services/gui/hal/display/brandy-xts/libdisplay_gfx.a index 93d2d8d65..17aa14c37 100644 Binary files a/code/sdk/middleware/services/gui/hal/display/brandy-xts/libdisplay_gfx.a and b/code/sdk/middleware/services/gui/hal/display/brandy-xts/libdisplay_gfx.a differ diff --git a/code/sdk/middleware/services/gui/hal/display/src/display_gralloc.c b/code/sdk/middleware/services/gui/hal/display/src/display_gralloc.c index 11a0af64f..ac1fe2f33 100644 --- a/code/sdk/middleware/services/gui/hal/display/src/display_gralloc.c +++ b/code/sdk/middleware/services/gui/hal/display/src/display_gralloc.c @@ -92,8 +92,7 @@ static bool InitMemPool(void) } #if CAPABILITY_HWDRAW_LETTER_VECTOR || CAPABILITY_HWDRAW_ALPHA_BITMAP - // 400: same minimum font cache size with ui_font_allocator, 20 x 20 - g_fontPoolId = LosRegisterMemPool((uint8_t *)MEM_POOL_UI_FONT, MEM_POOL_UI_FONT_SIZE, 0, 400); + g_fontPoolId = LosRegisterMemPool((uint8_t *)MEM_POOL_UI_FONT, MEM_POOL_UI_FONT_SIZE, 0, 0); if (g_fontPoolId == MEMORY_POOL_ID_INVALID) { return false; } diff --git a/code/sdk/middleware/services/gui/lvgl/brandy-target1/liblvgl_proprietary_mini.a b/code/sdk/middleware/services/gui/lvgl/brandy-target1/liblvgl_proprietary_mini.a index c065a9fe6..600178042 100644 Binary files a/code/sdk/middleware/services/gui/lvgl/brandy-target1/liblvgl_proprietary_mini.a and b/code/sdk/middleware/services/gui/lvgl/brandy-target1/liblvgl_proprietary_mini.a differ diff --git a/code/sdk/middleware/services/gui/lvgl/brandy-target5/liblvgl_proprietary.a b/code/sdk/middleware/services/gui/lvgl/brandy-target5/liblvgl_proprietary.a index 597c388ab..800c51ce8 100644 Binary files a/code/sdk/middleware/services/gui/lvgl/brandy-target5/liblvgl_proprietary.a and b/code/sdk/middleware/services/gui/lvgl/brandy-target5/liblvgl_proprietary.a differ diff --git a/code/sdk/middleware/services/gui/uikit/CMakeLists.txt b/code/sdk/middleware/services/gui/uikit/CMakeLists.txt index 4cd76ecd1..62fb0780f 100644 --- a/code/sdk/middleware/services/gui/uikit/CMakeLists.txt +++ b/code/sdk/middleware/services/gui/uikit/CMakeLists.txt @@ -148,6 +148,8 @@ set(PRIVATE_HEADER ${ROOTDIR}/open_source/openharmony/third_party/libjpeg ${ROOTDIR}/open_source/openharmony/third_party/libpng ${ROOTDIR}/open_source/openharmony/foundation/graphic/ui/frameworks/imgdecode + ${ROOTDIR}/application/wearable/service/dial_market + ${ROOTDIR}/open_source/openharmony/drivers/peripheral/format/interfaces/include ) set(PRIVATE_DEFINES @@ -179,6 +181,7 @@ build_component() # build uikit ext set(COMPONENT_NAME "uikit_ext") set(PROP_UI_SRC ${UIKIT_ROOT_DIR}/proprietary/src/ui/frameworks) +file(GLOB_RECURSE lottie ${PROP_UI_SRC}/lottie/*.cpp) set(COMPONENT_SRC ${PROP_UI_SRC}/engines/gfx/lite_m_gfx_engine.cpp ${PROP_UI_SRC}/font/ui_font_hw_cache.cpp @@ -209,6 +212,7 @@ set(COMPONENT_SRC ${PROP_UI_SRC}/components_ext/ui_sphere_view.cpp ${PROP_UI_SRC}/components_ext/particle_cell.cpp ${PROP_UI_SRC}/components_ext/ui_particle_view.cpp + ${lottie} ) set(SOURCES @@ -224,6 +228,7 @@ set(PRIVATE_HEADER ${ROOTDIR}/open_source/openharmony/third_party/freetype/include ${ROOTDIR}/open_source/openharmony/third_party/icu/icu4c/source/common ${ROOTDIR}/open_source/openharmony/third_party/harfbuzz/src + ${ROOTDIR}/open_source/flatbuffers/include ) set(PRIVATE_DEFINES diff --git a/code/sdk/middleware/services/gui/uikit/brandy-auto-ota-cli/libuikit_ext.a b/code/sdk/middleware/services/gui/uikit/brandy-auto-ota-cli/libuikit_ext.a index 093848246..7b71cd544 100644 Binary files a/code/sdk/middleware/services/gui/uikit/brandy-auto-ota-cli/libuikit_ext.a and b/code/sdk/middleware/services/gui/uikit/brandy-auto-ota-cli/libuikit_ext.a differ diff --git a/code/sdk/middleware/services/gui/uikit/brandy-auto-ota-ser/libuikit_ext.a b/code/sdk/middleware/services/gui/uikit/brandy-auto-ota-ser/libuikit_ext.a index 2856f3df5..f8be69a63 100644 Binary files a/code/sdk/middleware/services/gui/uikit/brandy-auto-ota-ser/libuikit_ext.a and b/code/sdk/middleware/services/gui/uikit/brandy-auto-ota-ser/libuikit_ext.a differ diff --git a/code/sdk/middleware/services/gui/uikit/brandy-native-js/libuikit_ext.a b/code/sdk/middleware/services/gui/uikit/brandy-native-js/libuikit_ext.a index aa77c6800..9d278be5b 100644 Binary files a/code/sdk/middleware/services/gui/uikit/brandy-native-js/libuikit_ext.a and b/code/sdk/middleware/services/gui/uikit/brandy-native-js/libuikit_ext.a differ diff --git a/code/sdk/middleware/services/gui/uikit/brandy-target3/libuikit_ext.a b/code/sdk/middleware/services/gui/uikit/brandy-target3/libuikit_ext.a index fbaddb64a..aa4d13d59 100644 Binary files a/code/sdk/middleware/services/gui/uikit/brandy-target3/libuikit_ext.a and b/code/sdk/middleware/services/gui/uikit/brandy-target3/libuikit_ext.a differ diff --git a/code/sdk/middleware/services/gui/uikit/brandy-xts/libuikit_ext.a b/code/sdk/middleware/services/gui/uikit/brandy-xts/libuikit_ext.a index 13ebf2c9b..2cef9968f 100644 Binary files a/code/sdk/middleware/services/gui/uikit/brandy-xts/libuikit_ext.a and b/code/sdk/middleware/services/gui/uikit/brandy-xts/libuikit_ext.a differ diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/common/image_cache_manager.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/common/image_cache_manager.h index a7e8fa6b1..72085c00b 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/include/common/image_cache_manager.h +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/common/image_cache_manager.h @@ -63,7 +63,7 @@ public: * @param file: the path of the image binary. * userFP: file pointer(witch opend outside), if userFP is not nullptr, we will use it firstly. * isLongTerm: whether the image should be kept in long term. - * offset: the offset of the multi image start point, mainly used with input userFP(not nullptr). + * offset: the offset of the multi image start point. */ bool LoadAllInMultiRes(const std::string& file, FILE* userFP = nullptr, bool isLongTerm = false, int offset = 0); diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/components/ui_canvas_ext.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/components/ui_canvas_ext.h index 105b471e2..0b2000286 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/include/components/ui_canvas_ext.h +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/components/ui_canvas_ext.h @@ -272,7 +272,7 @@ public: * @brief Begin a path. * This method would init a new path in the context. * @param paint Indicates the path style of the newly-created path in the context. - * @return Returns index value that relates to a path object. Returns -1 when any error occurs. + * @return Returns index value that relates to an object. Returns -1 when any error occurs. */ int16_t BeginPath(const PaintExt &paint); @@ -321,7 +321,7 @@ public: * @param startPoint Indicates the coordinates of the start point. * @param endPoint Indicates the coordinates of the end point. * @param paint Indicates the straight line style. For details, see {@link PaintExt}. - * @return Returns index value that relates to a path object. Returns -1 when any error occurs. + * @return Returns index value that relates to an object. Returns -1 when any error occurs. */ int16_t DrawLine(const Point& startPoint, const Point& endPoint, const PaintExt& paint); @@ -333,7 +333,7 @@ public: * @param control2 Indicates the coordinates of the second control point of the cubic Bezier curve. * @param endPoint Indicates the coordinates of the end point of the cubic Bezier curve. * @param paint Indicates the curve style. For details, see {@link PaintExt}. - * @return Returns index value that relates to a path object. Returns -1 when any error occurs. + * @return Returns index value that relates to an object. Returns -1 when any error occurs. */ int16_t DrawCurve(const Point& startPoint, const Point& control1, const Point& control2, const Point& endPoint, const PaintExt& paint); @@ -345,9 +345,10 @@ public: * @param height Indicates the height of the rectangle. * @param width Indicates the width of the rectangle. * @param paint Indicates the rectangle style. For details, see {@link PaintExt}. - * @return Returns index value that relates to a path object. Returns -1 when any error occurs. + * @return Returns index value that relates to an object. Returns -1 when any error occurs. */ - int16_t DrawRect(const Point& startPoint, int16_t height, int16_t width, const PaintExt& paint); + int16_t DrawRect(const Point& startPoint, int16_t height, int16_t width, const PaintExt& paint, + uint16_t radius = 0); /** * @brief Draws a circle. @@ -355,7 +356,7 @@ public: * @param center Indicates the coordinates of the circle center. * @param radius Indicates the radius of the circle. * @param paint Indicates the circle style. For details, see {@link PaintExt}. - * @return Returns index value that relates to a path object. Returns -1 when any error occurs. + * @return Returns index value that relates to an object. Returns -1 when any error occurs. */ int16_t DrawCircle(const Point& center, uint16_t radius, const PaintExt& paint); @@ -372,7 +373,7 @@ public: * @param endAngle Indicates the end angle of the sector. Value 0 indicates the 12-o'clock direction, * and 90 indicates the 3-o'clock direction. * @param paint Indicates the sector style. For details, see {@link PaintExt}. - * @return Returns index value that relates to a path object. Returns -1 when any error occurs. + * @return Returns index value that relates to an object. Returns -1 when any error occurs. */ int16_t DrawSector(const Point& center, uint16_t radius, float startAngle, float endAngle, const PaintExt& paint); @@ -380,7 +381,6 @@ public: /** * @brief Draws an arc. * - * Only stroke is supported. * When the start angle is smaller than the end angle, the sector is drawn clockwise. * Otherwise, the sector is drawn counterclockwise. * @@ -391,11 +391,51 @@ public: * @param endAngle Indicates the end angle of the arc. Value 0 indicates the 12-o'clock direction, * and 90 indicates the 3-o'clock direction. * @param paint Indicates the arc style. For details, see {@link PaintExt}. - * @return Returns index value that relates to a path object. Returns -1 when any error occurs. + * @return Returns index value that relates to an object. Returns -1 when any error occurs. */ int16_t DrawArc(const Point& center, uint16_t radius, float startAngle, float endAngle, const PaintExt& paint); + /** + * @brief Draws an image. + * + * @param startPoint Indicates the coordinates of the point at the upper left corner of the image. + * @param image Indicates the image bin path. + * @param paint Indicates the image style. For details, see {@link PaintExt}. + * @return Returns index value that relates to an object. Returns -1 when any error occurs. + */ + int16_t DrawImage(const Point& startPoint, const char* image, const PaintExt& paint); + + /** + * @brief Defines the font style. + */ + struct FontStyle { + /** Text direction. For details, see {@link UITextLanguageDirect}. */ + UITextLanguageDirect direct; + /** Text alignment mode. For details, see {@link UITextLanguageAlignment}. */ + UITextLanguageAlignment align; + /** Font size */ + uint8_t fontSize; + /** Letter-spacing */ + int16_t letterSpace; + /** Font name */ + const char* fontName; + }; + + /** + * @brief Draws text. + * + * @param startPoint Indicates the coordinates of the start point. + * @param text Indicates the pointer to the text content. + * @param maxWidth Indicates the maximum width of the text that can be displayed. If the maximum width is + * exceeded, the text is truncated. + * @param fontStyle Indicates the text layout and font style. For details, see {@link FontStyle}. + * @param paint Indicates the text style. For details, see {@link Paint}. + * @return Returns index value that relates to an object. Returns -1 when any error occurs. + */ + int16_t DrawLabel(const Point& startPoint, const char* text, uint16_t maxWidth, const FontStyle& fontStyle, + const PaintExt& paint); + /** * @brief Callback for root view to draw the current content. * @@ -405,20 +445,35 @@ public: void OnDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea) override; private: - List paths_; - List paints_; + struct DrawCmd : public HeapBase { + PaintExt* paint; + void* param; + uint16_t index; + void(UICanvasExt::*DrawGraphics)(BufferInfo&, void*, PaintExt*, const Rect&, const Rect&, Matrix3&); + void(UICanvasExt::*DeleteParam)(void *); + }; + + List drawCmdList_; + Path* curPath_; Graphic::Vector svgObjList_; Graphic::Vector svgPaths_; Graphic::Vector> matrices_; bool isPathDrawable_; - void ClearInnerPaths(); - void ClearInnerPaints(); void ClearSvgData(); int16_t InitGraphicPathInner(Path* path, const PaintExt& paint); - void PushPaintToList(const PaintExt& paint); - void DoDrawPath(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea, + void AddPaintToCmd(const PaintExt& paint, DrawCmd& cmd); + void DrawPathInner(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea, Path* path, PaintExt* paint, Matrix3* matrix); + void DoDrawPath(BufferInfo& gfxDstBuffer, void* param, PaintExt* paint, const Rect& rect, + const Rect& invalidatedArea, Matrix3& matrix); + void DoDrawImage(BufferInfo& gfxDstBuffer, void* param, PaintExt* paint, const Rect& rect, + const Rect& invalidatedArea, Matrix3& matrix); + void DoDrawLabel(BufferInfo& gfxDstBuffer, void* param, PaintExt* paint, const Rect& rect, + const Rect& invalidatedArea, Matrix3& matrix); + void DeletePath(void* param); + void DeleteImageView(void* param); + void DeleteLabel(void* param); SvgData* GetSvgData(const char* path); void PaintSetGradient(SvgData* svg, int16_t gradientIndex, PaintExt& paint, uint16_t index); diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/components/ui_card_page.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/components/ui_card_page.h index 34a0a76e1..6ae88e7e0 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/include/components/ui_card_page.h +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/components/ui_card_page.h @@ -74,7 +74,8 @@ public: virtual void PreLoad(void) {} /* * - * @brief Unload resource callback function, it will be called at the end of swipe animator. + * @brief Unload resource callback function, it will be called at the end of swipe animator or the function + * SetHorCurrentPage is called. * @since 1.0 * @version 1.0 */ diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/components/ui_fragment.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/components/ui_fragment.h new file mode 100644 index 000000000..d9a5c4ab4 --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/components/ui_fragment.h @@ -0,0 +1,114 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025-2025. All rights reserved. + * Description: UI fragment + * Author: Hisi Graphic Team + * Created: 2025-5 + */ +#ifndef UI_FRAGMENT_H +#define UI_FRAGMENT_H + +#include +#include "components/ui_view_group.h" + +namespace OHOS { +// UIFragment represents a reusable fragment of UI content, it has its own life cycle, and can handle its own event +enum class FragmentState : uint8_t { + INITIALIZED, + CREATED, + RESUMED +}; + +class UIFragment : public HeapBase { +public: + /** + * @brief Constructor of UIFragment without parameter, it will not be added into UIFragmentManager + */ + UIFragment() : id_(), state_(FragmentState::INITIALIZED) {} + + /** + * @brief Constructor of UIFragment with parameter, it will be added into UIFragmentManager if strlen(id) > 0 + * @param id Used to distinguish and get different UIFragment Instance from UIFragmentManager + */ + UIFragment(const std::string& id); + + virtual ~UIFragment(); + + /** + * @brief Invoked to call OnCreateView if state is INITIALIZED. + */ + UIView* CreateView(void *data = nullptr); + + /** + * @brief Invoked to call OnResumeView if state is CREATED + */ + void ResumeView(); + + /** + * @brief Invoked to call OnPauseView if state is RESUMED + */ + void PauseView(); + + /** + * @brief Invoked to call OnDestroyView if state is RESUMED or CREATED. + */ + void DestroyView(); + + UIView* GetFragmentView() + { + return &fragmentView_; + } + + FragmentState GetState() + { + return state_; + } + + UIFragment(const UIFragment&) = delete; + UIFragment& operator=(const UIFragment&) = delete; + UIFragment(UIFragment&&) = delete; + UIFragment& operator=(UIFragment&&) = delete; + +protected: + /** + * @brief Recommended for creating views and add them into UIViewGroup fragmentView_. + */ + virtual void OnCreateView(void* data) = 0; + + /** + * @brief Recommended for setting input event listener, requesting focus, or starting animator here. + */ + virtual void OnResumeView() {} + + /** + * @brief Recommended for clearing input event listener, clearing focus, or stopping animator here. + */ + virtual void OnPauseView() {} + + /** + * @brief Recommended for destroying UIView or UIViewGroup which belong to UIFragment. + */ + virtual void OnDestroyView() = 0; + UIViewGroup fragmentView_; + +private: + std::string id_; + FragmentState state_; +}; + +// UIFragmentManager can be used to fetch fragment by id +class UIFragmentManager : public HeapBase { +public: + static UIFragmentManager& GetInstance(); + void AddFragment(const std::string& id, UIFragment* fragment); + void RemoveFragment(const std::string& id); + UIFragment* GetFragmentById(const std::string& id); + uint32_t GetFragmentsCount() + { + return fragments_.size(); + } +private: + UIFragmentManager() = default; + std::unordered_map fragments_; +}; +} +#endif \ No newline at end of file diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/dfx/dfx_frame_trace.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/dfx/dfx_frame_trace.h index bd9f056d2..e1e1edba3 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/include/dfx/dfx_frame_trace.h +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/dfx/dfx_frame_trace.h @@ -40,6 +40,7 @@ #define EVENT_TRACE_END() DfxFrameTrace::GetInstance().EventTraceEnd() #define TASK_TRACE_START() DfxFrameTrace::GetInstance().TaskTraceStart() #define TASK_TRACE_END() DfxFrameTrace::GetInstance().TaskTraceEnd() +#define SET_TRACE_PATH_TYPE(type) DfxFrameTrace::GetInstance().SetPathType(type) #else #define FRAME_TRACE_START(type) #define FRAME_TRACE_END(type, prect) @@ -52,6 +53,7 @@ #define EVENT_TRACE_END() #define TASK_TRACE_START() #define TASK_TRACE_END() +#define SET_TRACE_PATH_TYPE(type) #endif namespace OHOS { @@ -75,6 +77,7 @@ enum class FrameTraceType { HW_DRAW_LINE, HW_DRAW_ARC, HW_DRAW_CUBICBEZIER, + HW_DRAW_ELLIPSE, DRAW_MAX }; @@ -111,6 +114,7 @@ public: } } + void SetPathType(FrameTraceType type); void FrameTraceStart(FrameTraceType type); void FrameTraceEnd(FrameTraceType type, const Rect *rect = nullptr); void ShowFrameTrace(); @@ -234,6 +238,7 @@ private: EventRecord *tailEvt_ = nullptr; bool eventRecording_ = false; bool taskRecording_ = false; + FrameTraceType pathType_ = FrameTraceType::HW_DRAW_PATH; }; } // OHOS #endif // GRAPHIC_LITE_DFX_FRAME_TRACE_H diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_comp.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_comp.h new file mode 100644 index 000000000..1b1472f86 --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_comp.h @@ -0,0 +1,35 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025. All rights reserved. + * Description: Lottie + * Author: Hisi Graphic Team + * Created: 2025-6 + */ + +#ifndef LOTT_COMP_H +#define LOTT_COMP_H + +#include +#include "gfx_utils/vector.h" +#include "gfx_utils/graphic_buffer.h" +#include "lottie/lott_layer.h" + +namespace OHOS { +class LottComp : public HeapBase { +public: + LottComp(); + virtual ~LottComp(); + void UpdateLottComp(float frameNo); + void DrawLottComp(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea, const Matrix3& mat, uint8_t opa); + float GetFrameCnt(); + + float width_ = 0.0f; + float height_ = 0.0f; + float frameRate_ = 0.0f; + float inFrame_ = 0.0f; + float outFrame_ = 0.0f; + std::string version_; + std::string name_; + Graphic::Vector layers_; +}; +} +#endif // LOTT_COMP_H \ No newline at end of file diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_ellipse.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_ellipse.h new file mode 100644 index 000000000..4350cca77 --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_ellipse.h @@ -0,0 +1,28 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025. All rights reserved. + * Description: Lottie + * Author: Hisi Graphic Team + * Created: 2025-6 + */ + +#ifndef LOTT_ELLIPSE +#define LOTT_ELLIPSE + +#include "lottie/lott_shape.h" +#include "lottie/lott_property.h" + +namespace OHOS { + +class LottEllipse : public LottShape { +public: + LottEllipse(); + virtual ~LottEllipse(); + + void Update(LottShape* parent, float frameNo) override; + bool GetPathData(Path& path) override; + + LottPositionProp position_; + LottVectorProp size_; +}; +} +#endif // LOTT_ELLIPSE \ No newline at end of file diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_flatbuffer.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_flatbuffer.h new file mode 100644 index 000000000..e2a21c429 --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_flatbuffer.h @@ -0,0 +1,5945 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025. All rights reserved. + * Description: Lottie + * Author: Hisi Graphic Team + * Created: 2025-6 + */ + +#ifndef LOTT_FLATBUFFER_H +#define LOTT_FLATBUFFER_H + +#include "flatbuffers/flatbuffers.h" + +// Ensure the included flatbuffers.h is the same version as when this file was +// generated, otherwise it may not be compatible. +static_assert(FLATBUFFERS_VERSION_MAJOR == 24 && FLATBUFFERS_VERSION_MINOR == 3 && FLATBUFFERS_VERSION_REVISION == 25, + "Non-compatible flatbuffers version included"); + +namespace LottieFlatBuffer { + +struct Point; + +struct Color32; + +struct Color24; + +struct ColorStop; + +struct Gradient; +struct GradientBuilder; + +struct FloatFrame; +struct FloatFrameBuilder; + +struct FloatFrameArray; +struct FloatFrameArrayBuilder; + +struct FloatScalar; +struct FloatScalarBuilder; + +struct IntegerFrame; +struct IntegerFrameBuilder; + +struct IntegerFrameArray; +struct IntegerFrameArrayBuilder; + +struct IntegerScalar; +struct IntegerScalarBuilder; + +struct BezierData; +struct BezierDataBuilder; + +struct VectorFrame; +struct VectorFrameBuilder; + +struct VectorFrameArray; +struct VectorFrameArrayBuilder; + +struct ColorFrame; +struct ColorFrameBuilder; + +struct ColorFrameArray; +struct ColorFrameArrayBuilder; + +struct Color24Scalar; +struct Color24ScalarBuilder; + +struct GradientFrame; +struct GradientFrameBuilder; + +struct GradientFrameArray; +struct GradientFrameArrayBuilder; + +struct BezierDataFrame; +struct BezierDataFrameBuilder; + +struct BezierDataFrameArray; +struct BezierDataFrameArrayBuilder; + +struct PositionFrame; +struct PositionFrameBuilder; + +struct PositionFrameArray; +struct PositionFrameArrayBuilder; + +struct SplitProp; +struct SplitPropBuilder; + +struct Transform; +struct TransformBuilder; + +struct EllipseShape; +struct EllipseShapeBuilder; + +struct RectShape; +struct RectShapeBuilder; + +struct PathShape; +struct PathShapeBuilder; + +struct FillStyle; +struct FillStyleBuilder; + +struct StrokeStyle; +struct StrokeStyleBuilder; + +struct GradientFillStyle; +struct GradientFillStyleBuilder; + +struct GradientStrokeStyle; +struct GradientStrokeStyleBuilder; + +struct TrimPath; +struct TrimPathBuilder; + +struct TransformShape; +struct TransformShapeBuilder; + +struct GroupShape; +struct GroupShapeBuilder; + +struct BaseLayer; +struct BaseLayerBuilder; + +struct ShapeLayer; +struct ShapeLayerBuilder; + +struct PrecompositionLayer; +struct PrecompositionLayerBuilder; + +struct NullLayer; +struct NullLayerBuilder; + +struct Rect; + +struct TextDocument; +struct TextDocumentBuilder; + +struct TextDocumentFrame; +struct TextDocumentFrameBuilder; + +struct TextData; +struct TextDataBuilder; + +struct TextLayer; +struct TextLayerBuilder; + +struct ImageLayer; +struct ImageLayerBuilder; + +struct SolidLayer; +struct SolidLayerBuilder; + +struct Asset; +struct AssetBuilder; + +struct Animations; +struct AnimationsBuilder; + +enum FloatProp : uint8_t { + FloatProp_NONE = 0, + FloatProp_frames = 1, + FloatProp_value = 2, + FloatProp_MIN = FloatProp_NONE, + FloatProp_MAX = FloatProp_value +}; + +inline const FloatProp (&EnumValuesFloatProp())[3] +{ + static const FloatProp values[] = {FloatProp_NONE, FloatProp_frames, FloatProp_value}; + return values; +} + +inline const char *const *EnumNamesFloatProp() +{ + static const char *const names[4] = {"NONE", "frames", "value", nullptr}; + return names; +} + +inline const char *EnumNameFloatProp(FloatProp e) +{ + if (::flatbuffers::IsOutRange(e, FloatProp_NONE, FloatProp_value)) + return ""; + const size_t index = static_cast(e); + return EnumNamesFloatProp()[index]; +} + +template +struct FloatPropTraits { + static const FloatProp enum_value = FloatProp_NONE; +}; + +template <> +struct FloatPropTraits { + static const FloatProp enum_value = FloatProp_frames; +}; + +template <> +struct FloatPropTraits { + static const FloatProp enum_value = FloatProp_value; +}; + +bool VerifyFloatProp(::flatbuffers::Verifier &verifier, const void *obj, FloatProp type); +bool VerifyFloatPropVector(::flatbuffers::Verifier &verifier, + const ::flatbuffers::Vector<::flatbuffers::Offset> *values, + const ::flatbuffers::Vector *types); + +enum IntegerProp : uint8_t { + IntegerProp_NONE = 0, + IntegerProp_frames = 1, + IntegerProp_value = 2, + IntegerProp_MIN = IntegerProp_NONE, + IntegerProp_MAX = IntegerProp_value +}; + +inline const IntegerProp (&EnumValuesIntegerProp())[3] +{ + static const IntegerProp values[] = {IntegerProp_NONE, IntegerProp_frames, IntegerProp_value}; + return values; +} + +inline const char *const *EnumNamesIntegerProp() +{ + static const char *const names[4] = {"NONE", "frames", "value", nullptr}; + return names; +} + +inline const char *EnumNameIntegerProp(IntegerProp e) +{ + if (::flatbuffers::IsOutRange(e, IntegerProp_NONE, IntegerProp_value)) + return ""; + const size_t index = static_cast(e); + return EnumNamesIntegerProp()[index]; +} + +template +struct IntegerPropTraits { + static const IntegerProp enum_value = IntegerProp_NONE; +}; + +template <> +struct IntegerPropTraits { + static const IntegerProp enum_value = IntegerProp_frames; +}; + +template <> +struct IntegerPropTraits { + static const IntegerProp enum_value = IntegerProp_value; +}; + +bool VerifyIntegerProp(::flatbuffers::Verifier &verifier, const void *obj, IntegerProp type); +bool VerifyIntegerPropVector(::flatbuffers::Verifier &verifier, + const ::flatbuffers::Vector<::flatbuffers::Offset> *values, + const ::flatbuffers::Vector *types); + +enum VectorProp : uint8_t { + VectorProp_NONE = 0, + VectorProp_frames = 1, + VectorProp_value = 2, + VectorProp_MIN = VectorProp_NONE, + VectorProp_MAX = VectorProp_value +}; + +inline const VectorProp (&EnumValuesVectorProp())[3] +{ + static const VectorProp values[] = {VectorProp_NONE, VectorProp_frames, VectorProp_value}; + return values; +} + +inline const char *const *EnumNamesVectorProp() +{ + static const char *const names[4] = {"NONE", "frames", "value", nullptr}; + return names; +} + +inline const char *EnumNameVectorProp(VectorProp e) +{ + if (::flatbuffers::IsOutRange(e, VectorProp_NONE, VectorProp_value)) + return ""; + const size_t index = static_cast(e); + return EnumNamesVectorProp()[index]; +} + +template +struct VectorPropTraits { + static const VectorProp enum_value = VectorProp_NONE; +}; + +template <> +struct VectorPropTraits { + static const VectorProp enum_value = VectorProp_frames; +}; + +template <> +struct VectorPropTraits { + static const VectorProp enum_value = VectorProp_value; +}; + +bool VerifyVectorProp(::flatbuffers::Verifier &verifier, const void *obj, VectorProp type); +bool VerifyVectorPropVector(::flatbuffers::Verifier &verifier, + const ::flatbuffers::Vector<::flatbuffers::Offset> *values, + const ::flatbuffers::Vector *types); + +enum ColorProp : uint8_t { + ColorProp_NONE = 0, + ColorProp_frames = 1, + ColorProp_color = 2, + ColorProp_MIN = ColorProp_NONE, + ColorProp_MAX = ColorProp_color +}; + +inline const ColorProp (&EnumValuesColorProp())[3] +{ + static const ColorProp values[] = {ColorProp_NONE, ColorProp_frames, ColorProp_color}; + return values; +} + +inline const char *const *EnumNamesColorProp() +{ + static const char *const names[4] = {"NONE", "frames", "color", nullptr}; + return names; +} + +inline const char *EnumNameColorProp(ColorProp e) +{ + if (::flatbuffers::IsOutRange(e, ColorProp_NONE, ColorProp_color)) + return ""; + const size_t index = static_cast(e); + return EnumNamesColorProp()[index]; +} + +template +struct ColorPropTraits { + static const ColorProp enum_value = ColorProp_NONE; +}; + +template <> +struct ColorPropTraits { + static const ColorProp enum_value = ColorProp_frames; +}; + +template <> +struct ColorPropTraits { + static const ColorProp enum_value = ColorProp_color; +}; + +bool VerifyColorProp(::flatbuffers::Verifier &verifier, const void *obj, ColorProp type); +bool VerifyColorPropVector(::flatbuffers::Verifier &verifier, + const ::flatbuffers::Vector<::flatbuffers::Offset> *values, + const ::flatbuffers::Vector *types); + +enum GradientProp : uint8_t { + GradientProp_NONE = 0, + GradientProp_frames = 1, + GradientProp_value = 2, + GradientProp_MIN = GradientProp_NONE, + GradientProp_MAX = GradientProp_value +}; + +inline const GradientProp (&EnumValuesGradientProp())[3] +{ + static const GradientProp values[] = {GradientProp_NONE, GradientProp_frames, GradientProp_value}; + return values; +} + +inline const char *const *EnumNamesGradientProp() +{ + static const char *const names[4] = {"NONE", "frames", "value", nullptr}; + return names; +} + +inline const char *EnumNameGradientProp(GradientProp e) +{ + if (::flatbuffers::IsOutRange(e, GradientProp_NONE, GradientProp_value)) + return ""; + const size_t index = static_cast(e); + return EnumNamesGradientProp()[index]; +} + +template +struct GradientPropTraits { + static const GradientProp enum_value = GradientProp_NONE; +}; + +template <> +struct GradientPropTraits { + static const GradientProp enum_value = GradientProp_frames; +}; + +template <> +struct GradientPropTraits { + static const GradientProp enum_value = GradientProp_value; +}; + +bool VerifyGradientProp(::flatbuffers::Verifier &verifier, const void *obj, GradientProp type); +bool VerifyGradientPropVector(::flatbuffers::Verifier &verifier, + const ::flatbuffers::Vector<::flatbuffers::Offset> *values, + const ::flatbuffers::Vector *types); + +enum BezierDataProp : uint8_t { + BezierDataProp_NONE = 0, + BezierDataProp_frames = 1, + BezierDataProp_value = 2, + BezierDataProp_MIN = BezierDataProp_NONE, + BezierDataProp_MAX = BezierDataProp_value +}; + +inline const BezierDataProp (&EnumValuesBezierDataProp())[3] +{ + static const BezierDataProp values[] = {BezierDataProp_NONE, BezierDataProp_frames, BezierDataProp_value}; + return values; +} + +inline const char *const *EnumNamesBezierDataProp() +{ + static const char *const names[4] = {"NONE", "frames", "value", nullptr}; + return names; +} + +inline const char *EnumNameBezierDataProp(BezierDataProp e) +{ + if (::flatbuffers::IsOutRange(e, BezierDataProp_NONE, BezierDataProp_value)) + return ""; + const size_t index = static_cast(e); + return EnumNamesBezierDataProp()[index]; +} + +template +struct BezierDataPropTraits { + static const BezierDataProp enum_value = BezierDataProp_NONE; +}; + +template <> +struct BezierDataPropTraits { + static const BezierDataProp enum_value = BezierDataProp_frames; +}; + +template <> +struct BezierDataPropTraits { + static const BezierDataProp enum_value = BezierDataProp_value; +}; + +bool VerifyBezierDataProp(::flatbuffers::Verifier &verifier, const void *obj, BezierDataProp type); +bool VerifyBezierDataPropVector(::flatbuffers::Verifier &verifier, + const ::flatbuffers::Vector<::flatbuffers::Offset> *values, + const ::flatbuffers::Vector *types); + +enum PositionProp : uint8_t { + PositionProp_NONE = 0, + PositionProp_frames = 1, + PositionProp_value = 2, + PositionProp_MIN = PositionProp_NONE, + PositionProp_MAX = PositionProp_value +}; + +inline const PositionProp (&EnumValuesPositionProp())[3] +{ + static const PositionProp values[] = {PositionProp_NONE, PositionProp_frames, PositionProp_value}; + return values; +} + +inline const char *const *EnumNamesPositionProp() +{ + static const char *const names[4] = {"NONE", "frames", "value", nullptr}; + return names; +} + +inline const char *EnumNamePositionProp(PositionProp e) +{ + if (::flatbuffers::IsOutRange(e, PositionProp_NONE, PositionProp_value)) + return ""; + const size_t index = static_cast(e); + return EnumNamesPositionProp()[index]; +} + +template +struct PositionPropTraits { + static const PositionProp enum_value = PositionProp_NONE; +}; + +template <> +struct PositionPropTraits { + static const PositionProp enum_value = PositionProp_frames; +}; + +template <> +struct PositionPropTraits { + static const PositionProp enum_value = PositionProp_value; +}; + +bool VerifyPositionProp(::flatbuffers::Verifier &verifier, const void *obj, PositionProp type); +bool VerifyPositionPropVector(::flatbuffers::Verifier &verifier, + const ::flatbuffers::Vector<::flatbuffers::Offset> *values, + const ::flatbuffers::Vector *types); + +enum FillRule : int8_t { + FillRule_NON_ZERO = 0, + FillRule_EVEN_ODD = 1, + FillRule_MIN = FillRule_NON_ZERO, + FillRule_MAX = FillRule_EVEN_ODD +}; + +inline const FillRule (&EnumValuesFillRule())[2] +{ + static const FillRule values[] = {FillRule_NON_ZERO, FillRule_EVEN_ODD}; + return values; +} + +inline const char *const *EnumNamesFillRule() +{ + static const char *const names[3] = {"NON_ZERO", "EVEN_ODD", nullptr}; + return names; +} + +inline const char *EnumNameFillRule(FillRule e) +{ + if (::flatbuffers::IsOutRange(e, FillRule_NON_ZERO, FillRule_EVEN_ODD)) + return ""; + const size_t index = static_cast(e); + return EnumNamesFillRule()[index]; +} + +enum LineCap : int8_t { + LineCap_CAP_BUTT = 0, + LineCap_CAP_ROUND = 1, + LineCap_CAP_SQUARE = 2, + LineCap_MIN = LineCap_CAP_BUTT, + LineCap_MAX = LineCap_CAP_SQUARE +}; + +inline const LineCap (&EnumValuesLineCap())[3] +{ + static const LineCap values[] = {LineCap_CAP_BUTT, LineCap_CAP_ROUND, LineCap_CAP_SQUARE}; + return values; +} + +inline const char *const *EnumNamesLineCap() +{ + static const char *const names[4] = {"CAP_BUTT", "CAP_ROUND", "CAP_SQUARE", nullptr}; + return names; +} + +inline const char *EnumNameLineCap(LineCap e) +{ + if (::flatbuffers::IsOutRange(e, LineCap_CAP_BUTT, LineCap_CAP_SQUARE)) + return ""; + const size_t index = static_cast(e); + return EnumNamesLineCap()[index]; +} + +enum LineJoin : int8_t { + LineJoin_JOIN_MITER = 0, + LineJoin_JOIN_ROUND = 1, + LineJoin_JOIN_BEVEL = 2, + LineJoin_MIN = LineJoin_JOIN_MITER, + LineJoin_MAX = LineJoin_JOIN_BEVEL +}; + +inline const LineJoin (&EnumValuesLineJoin())[3] +{ + static const LineJoin values[] = {LineJoin_JOIN_MITER, LineJoin_JOIN_ROUND, LineJoin_JOIN_BEVEL}; + return values; +} + +inline const char *const *EnumNamesLineJoin() +{ + static const char *const names[4] = {"JOIN_MITER", "JOIN_ROUND", "JOIN_BEVEL", nullptr}; + return names; +} + +inline const char *EnumNameLineJoin(LineJoin e) +{ + if (::flatbuffers::IsOutRange(e, LineJoin_JOIN_MITER, LineJoin_JOIN_BEVEL)) + return ""; + const size_t index = static_cast(e); + return EnumNamesLineJoin()[index]; +} + +enum GradientType : int8_t { + GradientType_GRADIENT_LINEAR = 0, + GradientType_GRADIENT_RADIAL = 1, + GradientType_MIN = GradientType_GRADIENT_LINEAR, + GradientType_MAX = GradientType_GRADIENT_RADIAL +}; + +inline const GradientType (&EnumValuesGradientType())[2] +{ + static const GradientType values[] = {GradientType_GRADIENT_LINEAR, GradientType_GRADIENT_RADIAL}; + return values; +} + +inline const char *const *EnumNamesGradientType() +{ + static const char *const names[3] = {"GRADIENT_LINEAR", "GRADIENT_RADIAL", nullptr}; + return names; +} + +inline const char *EnumNameGradientType(GradientType e) +{ + if (::flatbuffers::IsOutRange(e, GradientType_GRADIENT_LINEAR, GradientType_GRADIENT_RADIAL)) + return ""; + const size_t index = static_cast(e); + return EnumNamesGradientType()[index]; +} + +enum TrimType : int8_t { + TrimType_Simultaneous = 0, + TrimType_Individual = 1, + TrimType_MIN = TrimType_Simultaneous, + TrimType_MAX = TrimType_Individual +}; + +inline const TrimType (&EnumValuesTrimType())[2] +{ + static const TrimType values[] = {TrimType_Simultaneous, TrimType_Individual}; + return values; +} + +inline const char *const *EnumNamesTrimType() +{ + static const char *const names[3] = {"Simultaneous", "Individual", nullptr}; + return names; +} + +inline const char *EnumNameTrimType(TrimType e) +{ + if (::flatbuffers::IsOutRange(e, TrimType_Simultaneous, TrimType_Individual)) + return ""; + const size_t index = static_cast(e); + return EnumNamesTrimType()[index]; +} + +enum GraphicElement : uint8_t { + GraphicElement_NONE = 0, + GraphicElement_EllipseShape = 1, + GraphicElement_RectShape = 2, + GraphicElement_PathShape = 3, + GraphicElement_FillStyle = 4, + GraphicElement_StrokeStyle = 5, + GraphicElement_GradientFillStyle = 6, + GraphicElement_GradientStrokeStyle = 7, + GraphicElement_TransformShape = 8, + GraphicElement_TrimPath = 9, + GraphicElement_GroupShape = 10, + GraphicElement_MIN = GraphicElement_NONE, + GraphicElement_MAX = GraphicElement_GroupShape +}; + +inline const GraphicElement (&EnumValuesGraphicElement())[11] +{ + static const GraphicElement values[] = {GraphicElement_NONE, + GraphicElement_EllipseShape, + GraphicElement_RectShape, + GraphicElement_PathShape, + GraphicElement_FillStyle, + GraphicElement_StrokeStyle, + GraphicElement_GradientFillStyle, + GraphicElement_GradientStrokeStyle, + GraphicElement_TransformShape, + GraphicElement_TrimPath, + GraphicElement_GroupShape}; + return values; +} + +inline const char *const *EnumNamesGraphicElement() +{ + static const char *const names[12] = {"NONE", "EllipseShape", "RectShape", "PathShape", + "FillStyle", "StrokeStyle", "GradientFillStyle", "GradientStrokeStyle", + "TransformShape", "TrimPath", "GroupShape", nullptr}; + return names; +} + +inline const char *EnumNameGraphicElement(GraphicElement e) +{ + if (::flatbuffers::IsOutRange(e, GraphicElement_NONE, GraphicElement_GroupShape)) + return ""; + const size_t index = static_cast(e); + return EnumNamesGraphicElement()[index]; +} + +template +struct GraphicElementTraits { + static const GraphicElement enum_value = GraphicElement_NONE; +}; + +template <> +struct GraphicElementTraits { + static const GraphicElement enum_value = GraphicElement_EllipseShape; +}; + +template <> +struct GraphicElementTraits { + static const GraphicElement enum_value = GraphicElement_RectShape; +}; + +template <> +struct GraphicElementTraits { + static const GraphicElement enum_value = GraphicElement_PathShape; +}; + +template <> +struct GraphicElementTraits { + static const GraphicElement enum_value = GraphicElement_FillStyle; +}; + +template <> +struct GraphicElementTraits { + static const GraphicElement enum_value = GraphicElement_StrokeStyle; +}; + +template <> +struct GraphicElementTraits { + static const GraphicElement enum_value = GraphicElement_GradientFillStyle; +}; + +template <> +struct GraphicElementTraits { + static const GraphicElement enum_value = GraphicElement_GradientStrokeStyle; +}; + +template <> +struct GraphicElementTraits { + static const GraphicElement enum_value = GraphicElement_TransformShape; +}; + +template <> +struct GraphicElementTraits { + static const GraphicElement enum_value = GraphicElement_TrimPath; +}; + +template <> +struct GraphicElementTraits { + static const GraphicElement enum_value = GraphicElement_GroupShape; +}; + +bool VerifyGraphicElement(::flatbuffers::Verifier &verifier, const void *obj, GraphicElement type); +bool VerifyGraphicElementVector(::flatbuffers::Verifier &verifier, + const ::flatbuffers::Vector<::flatbuffers::Offset> *values, + const ::flatbuffers::Vector *types); + +enum BlendMode : int8_t { + BlendMode_Normal = 0, + BlendMode_Overlay = 1, + BlendMode_Multiply = 2, + BlendMode_Add = 3, + BlendMode_MIN = BlendMode_Normal, + BlendMode_MAX = BlendMode_Add +}; + +inline const BlendMode (&EnumValuesBlendMode())[4] +{ + static const BlendMode values[] = {BlendMode_Normal, BlendMode_Overlay, BlendMode_Multiply, BlendMode_Add}; + return values; +} + +inline const char *const *EnumNamesBlendMode() +{ + static const char *const names[5] = {"Normal", "Overlay", "Multiply", "Add", nullptr}; + return names; +} + +inline const char *EnumNameBlendMode(BlendMode e) +{ + if (::flatbuffers::IsOutRange(e, BlendMode_Normal, BlendMode_Add)) + return ""; + const size_t index = static_cast(e); + return EnumNamesBlendMode()[index]; +} + +enum TextAlign : int8_t { + TextAlign_AlignLeft = 1, + TextAlign_AlignRight = 2, + TextAlign_AlignCenter = 3, + TextAlign_MIN = TextAlign_AlignLeft, + TextAlign_MAX = TextAlign_AlignCenter +}; + +inline const TextAlign (&EnumValuesTextAlign())[3] +{ + static const TextAlign values[] = {TextAlign_AlignLeft, TextAlign_AlignRight, TextAlign_AlignCenter}; + return values; +} + +inline const char *const *EnumNamesTextAlign() +{ + static const char *const names[4] = {"AlignLeft", "AlignRight", "AlignCenter", nullptr}; + return names; +} + +inline const char *EnumNameTextAlign(TextAlign e) +{ + if (::flatbuffers::IsOutRange(e, TextAlign_AlignLeft, TextAlign_AlignCenter)) + return ""; + const size_t index = static_cast(e) - static_cast(TextAlign_AlignLeft); + return EnumNamesTextAlign()[index]; +} + +enum Layer : uint8_t { + Layer_NONE = 0, + Layer_PrecompositionLayer = 1, + Layer_SolidLayer = 2, + Layer_ImageLayer = 3, + Layer_NullLayer = 4, + Layer_ShapeLayer = 5, + Layer_TextLayer = 6, + Layer_MIN = Layer_NONE, + Layer_MAX = Layer_TextLayer +}; + +inline const Layer (&EnumValuesLayer())[7] +{ + static const Layer values[] = {Layer_NONE, Layer_PrecompositionLayer, Layer_SolidLayer, Layer_ImageLayer, + Layer_NullLayer, Layer_ShapeLayer, Layer_TextLayer}; + return values; +} + +inline const char *const *EnumNamesLayer() +{ + static const char *const names[8] = {"NONE", "PrecompositionLayer", "SolidLayer", "ImageLayer", + "NullLayer", "ShapeLayer", "TextLayer", nullptr}; + return names; +} + +inline const char *EnumNameLayer(Layer e) +{ + if (::flatbuffers::IsOutRange(e, Layer_NONE, Layer_TextLayer)) + return ""; + const size_t index = static_cast(e); + return EnumNamesLayer()[index]; +} + +template +struct LayerTraits { + static const Layer enum_value = Layer_NONE; +}; + +template <> +struct LayerTraits { + static const Layer enum_value = Layer_PrecompositionLayer; +}; + +template <> +struct LayerTraits { + static const Layer enum_value = Layer_SolidLayer; +}; + +template <> +struct LayerTraits { + static const Layer enum_value = Layer_ImageLayer; +}; + +template <> +struct LayerTraits { + static const Layer enum_value = Layer_NullLayer; +}; + +template <> +struct LayerTraits { + static const Layer enum_value = Layer_ShapeLayer; +}; + +template <> +struct LayerTraits { + static const Layer enum_value = Layer_TextLayer; +}; + +bool VerifyLayer(::flatbuffers::Verifier &verifier, const void *obj, Layer type); +bool VerifyLayerVector(::flatbuffers::Verifier &verifier, + const ::flatbuffers::Vector<::flatbuffers::Offset> *values, + const ::flatbuffers::Vector *types); + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Point FLATBUFFERS_FINAL_CLASS +{ +private: + float x_; + float y_; + +public: + Point() : x_(0), y_(0) {} + Point(float _x, float _y) : x_(::flatbuffers::EndianScalar(_x)), y_(::flatbuffers::EndianScalar(_y)) {} + float x() const + { + return ::flatbuffers::EndianScalar(x_); + } + float y() const + { + return ::flatbuffers::EndianScalar(y_); + } +}; +FLATBUFFERS_STRUCT_END(Point, 8); + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) Color32 FLATBUFFERS_FINAL_CLASS +{ +private: + uint8_t r_; + uint8_t g_; + uint8_t b_; + uint8_t a_; + +public: + Color32() : r_(0), g_(0), b_(0), a_(0) {} + Color32(uint8_t _r, uint8_t _g, uint8_t _b, uint8_t _a) + : r_(::flatbuffers::EndianScalar(_r)), + g_(::flatbuffers::EndianScalar(_g)), + b_(::flatbuffers::EndianScalar(_b)), + a_(::flatbuffers::EndianScalar(_a)) + { + } + uint8_t r() const + { + return ::flatbuffers::EndianScalar(r_); + } + uint8_t g() const + { + return ::flatbuffers::EndianScalar(g_); + } + uint8_t b() const + { + return ::flatbuffers::EndianScalar(b_); + } + uint8_t a() const + { + return ::flatbuffers::EndianScalar(a_); + } +}; +FLATBUFFERS_STRUCT_END(Color32, 4); + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) Color24 FLATBUFFERS_FINAL_CLASS +{ +private: + uint8_t r_; + uint8_t g_; + uint8_t b_; + +public: + Color24() : r_(0), g_(0), b_(0) {} + Color24(uint8_t _r, uint8_t _g, uint8_t _b) + : r_(::flatbuffers::EndianScalar(_r)), + g_(::flatbuffers::EndianScalar(_g)), + b_(::flatbuffers::EndianScalar(_b)) + { + } + uint8_t r() const + { + return ::flatbuffers::EndianScalar(r_); + } + uint8_t g() const + { + return ::flatbuffers::EndianScalar(g_); + } + uint8_t b() const + { + return ::flatbuffers::EndianScalar(b_); + } +}; +FLATBUFFERS_STRUCT_END(Color24, 3); + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) ColorStop FLATBUFFERS_FINAL_CLASS +{ +private: + float stop_; + LottieFlatBuffer::Color32 color_; + +public: + ColorStop() : stop_(0), color_() {} + ColorStop(float _stop, const LottieFlatBuffer::Color32 &_color) + : stop_(::flatbuffers::EndianScalar(_stop)), + color_(_color) + { + } + float stop() const + { + return ::flatbuffers::EndianScalar(stop_); + } + const LottieFlatBuffer::Color32 &color() const + { + return color_; + } +}; +FLATBUFFERS_STRUCT_END(ColorStop, 8); + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rect FLATBUFFERS_FINAL_CLASS +{ +private: + LottieFlatBuffer::Point pos_; + LottieFlatBuffer::Point size_; + +public: + Rect() : pos_(), size_() {} + Rect(const LottieFlatBuffer::Point &_pos, const LottieFlatBuffer::Point &_size) : pos_(_pos), size_(_size) {} + const LottieFlatBuffer::Point &pos() const + { + return pos_; + } + const LottieFlatBuffer::Point &size() const + { + return size_; + } +}; +FLATBUFFERS_STRUCT_END(Rect, 16); + +struct Gradient FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef GradientBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_STOPS = 4 }; + const ::flatbuffers::Vector *stops() const + { + return GetPointer *>(VT_STOPS); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_STOPS) && + verifier.VerifyVector(stops()) && verifier.EndTable(); + } +}; + +struct GradientBuilder { + typedef Gradient Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_stops(::flatbuffers::Offset<::flatbuffers::Vector> stops) + { + fbb_.AddOffset(Gradient::VT_STOPS, stops); + } + explicit GradientBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, Gradient::VT_STOPS); + return o; + } +}; + +inline ::flatbuffers::Offset CreateGradient( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> stops = 0) +{ + GradientBuilder builder_(_fbb); + builder_.add_stops(stops); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateGradientDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *stops = nullptr) +{ + auto stops__ = stops ? _fbb.CreateVectorOfStructs(*stops) : 0; + return LottieFlatBuffer::CreateGradient(_fbb, stops__); +} + +struct FloatFrame FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef FloatFrameBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TIME = 4, + VT_START = 6, + VT_HOLD = 8, + VT_TIME_EASING = 10, + VT_VALUE_EASING = 12 + }; + float time() const + { + return GetField(VT_TIME, 0.0f); + } + float start() const + { + return GetField(VT_START, 0.0f); + } + bool hold() const + { + return GetField(VT_HOLD, 0) != 0; + } + const ::flatbuffers::Vector *time_easing() const + { + return GetPointer *>(VT_TIME_EASING); + } + const ::flatbuffers::Vector *value_easing() const + { + return GetPointer *>(VT_VALUE_EASING); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_TIME, 4) && + VerifyField(verifier, VT_START, 4) && VerifyField(verifier, VT_HOLD, 1) && + VerifyOffset(verifier, VT_TIME_EASING) && verifier.VerifyVector(time_easing()) && + VerifyOffset(verifier, VT_VALUE_EASING) && verifier.VerifyVector(value_easing()) && verifier.EndTable(); + } +}; + +struct FloatFrameBuilder { + typedef FloatFrame Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_time(float time) + { + fbb_.AddElement(FloatFrame::VT_TIME, time, 0.0f); + } + void add_start(float start) + { + fbb_.AddElement(FloatFrame::VT_START, start, 0.0f); + } + void add_hold(bool hold) + { + fbb_.AddElement(FloatFrame::VT_HOLD, static_cast(hold), 0); + } + void add_time_easing(::flatbuffers::Offset<::flatbuffers::Vector> time_easing) + { + fbb_.AddOffset(FloatFrame::VT_TIME_EASING, time_easing); + } + void add_value_easing(::flatbuffers::Offset<::flatbuffers::Vector> value_easing) + { + fbb_.AddOffset(FloatFrame::VT_VALUE_EASING, value_easing); + } + explicit FloatFrameBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateFloatFrame( + ::flatbuffers::FlatBufferBuilder &_fbb, float time = 0.0f, float start = 0.0f, bool hold = false, + ::flatbuffers::Offset<::flatbuffers::Vector> time_easing = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> value_easing = 0) +{ + FloatFrameBuilder builder_(_fbb); + builder_.add_value_easing(value_easing); + builder_.add_time_easing(time_easing); + builder_.add_start(start); + builder_.add_time(time); + builder_.add_hold(hold); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateFloatFrameDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, float time = 0.0f, float start = 0.0f, bool hold = false, + const std::vector *time_easing = nullptr, + const std::vector *value_easing = nullptr) +{ + auto time_easing__ = time_easing ? _fbb.CreateVectorOfStructs(*time_easing) : 0; + auto value_easing__ = value_easing ? _fbb.CreateVectorOfStructs(*value_easing) : 0; + return LottieFlatBuffer::CreateFloatFrame(_fbb, time, start, hold, time_easing__, value_easing__); +} + +struct FloatFrameArray FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef FloatFrameArrayBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_FRAMES = 4 }; + const ::flatbuffers::Vector<::flatbuffers::Offset> *frames() const + { + return GetPointer> *>( + VT_FRAMES); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_FRAMES) && verifier.VerifyVector(frames()) && + verifier.VerifyVectorOfTables(frames()) && verifier.EndTable(); + } +}; + +struct FloatFrameArrayBuilder { + typedef FloatFrameArray Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_frames( + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> frames) + { + fbb_.AddOffset(FloatFrameArray::VT_FRAMES, frames); + } + explicit FloatFrameArrayBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateFloatFrameArray( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> frames = 0) +{ + FloatFrameArrayBuilder builder_(_fbb); + builder_.add_frames(frames); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateFloatFrameArrayDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<::flatbuffers::Offset> *frames = nullptr) +{ + auto frames__ = frames ? _fbb.CreateVector<::flatbuffers::Offset>(*frames) : 0; + return LottieFlatBuffer::CreateFloatFrameArray(_fbb, frames__); +} + +struct FloatScalar FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef FloatScalarBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_VALUE = 4 }; + float value() const + { + return GetField(VT_VALUE, 0.0f); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_VALUE, 4) && verifier.EndTable(); + } +}; + +struct FloatScalarBuilder { + typedef FloatScalar Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_value(float value) + { + fbb_.AddElement(FloatScalar::VT_VALUE, value, 0.0f); + } + explicit FloatScalarBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateFloatScalar(::flatbuffers::FlatBufferBuilder &_fbb, float value = 0.0f) +{ + FloatScalarBuilder builder_(_fbb); + builder_.add_value(value); + return builder_.Finish(); +} + +struct IntegerFrame FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef IntegerFrameBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TIME = 4, + VT_START = 6, + VT_HOLD = 8, + VT_TIME_EASING = 10, + VT_VALUE_EASING = 12 + }; + float time() const + { + return GetField(VT_TIME, 0.0f); + } + uint32_t start() const + { + return GetField(VT_START, 0); + } + bool hold() const + { + return GetField(VT_HOLD, 0) != 0; + } + const ::flatbuffers::Vector *time_easing() const + { + return GetPointer *>(VT_TIME_EASING); + } + const ::flatbuffers::Vector *value_easing() const + { + return GetPointer *>(VT_VALUE_EASING); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_TIME, 4) && + VerifyField(verifier, VT_START, 4) && VerifyField(verifier, VT_HOLD, 1) && + VerifyOffset(verifier, VT_TIME_EASING) && verifier.VerifyVector(time_easing()) && + VerifyOffset(verifier, VT_VALUE_EASING) && verifier.VerifyVector(value_easing()) && verifier.EndTable(); + } +}; + +struct IntegerFrameBuilder { + typedef IntegerFrame Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_time(float time) + { + fbb_.AddElement(IntegerFrame::VT_TIME, time, 0.0f); + } + void add_start(uint32_t start) + { + fbb_.AddElement(IntegerFrame::VT_START, start, 0); + } + void add_hold(bool hold) + { + fbb_.AddElement(IntegerFrame::VT_HOLD, static_cast(hold), 0); + } + void add_time_easing(::flatbuffers::Offset<::flatbuffers::Vector> time_easing) + { + fbb_.AddOffset(IntegerFrame::VT_TIME_EASING, time_easing); + } + void add_value_easing(::flatbuffers::Offset<::flatbuffers::Vector> value_easing) + { + fbb_.AddOffset(IntegerFrame::VT_VALUE_EASING, value_easing); + } + explicit IntegerFrameBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateIntegerFrame( + ::flatbuffers::FlatBufferBuilder &_fbb, float time = 0.0f, uint32_t start = 0, bool hold = false, + ::flatbuffers::Offset<::flatbuffers::Vector> time_easing = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> value_easing = 0) +{ + IntegerFrameBuilder builder_(_fbb); + builder_.add_value_easing(value_easing); + builder_.add_time_easing(time_easing); + builder_.add_start(start); + builder_.add_time(time); + builder_.add_hold(hold); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateIntegerFrameDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, float time = 0.0f, uint32_t start = 0, bool hold = false, + const std::vector *time_easing = nullptr, + const std::vector *value_easing = nullptr) +{ + auto time_easing__ = time_easing ? _fbb.CreateVectorOfStructs(*time_easing) : 0; + auto value_easing__ = value_easing ? _fbb.CreateVectorOfStructs(*value_easing) : 0; + return LottieFlatBuffer::CreateIntegerFrame(_fbb, time, start, hold, time_easing__, value_easing__); +} + +struct IntegerFrameArray FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef IntegerFrameArrayBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_FRAMES = 4 }; + const ::flatbuffers::Vector<::flatbuffers::Offset> *frames() const + { + return GetPointer> *>( + VT_FRAMES); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_FRAMES) && verifier.VerifyVector(frames()) && + verifier.VerifyVectorOfTables(frames()) && verifier.EndTable(); + } +}; + +struct IntegerFrameArrayBuilder { + typedef IntegerFrameArray Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_frames( + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> frames) + { + fbb_.AddOffset(IntegerFrameArray::VT_FRAMES, frames); + } + explicit IntegerFrameArrayBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateIntegerFrameArray( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> frames = 0) +{ + IntegerFrameArrayBuilder builder_(_fbb); + builder_.add_frames(frames); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateIntegerFrameArrayDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<::flatbuffers::Offset> *frames = nullptr) +{ + auto frames__ = frames ? _fbb.CreateVector<::flatbuffers::Offset>(*frames) : 0; + return LottieFlatBuffer::CreateIntegerFrameArray(_fbb, frames__); +} + +struct IntegerScalar FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef IntegerScalarBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_VALUE = 4 }; + uint32_t value() const + { + return GetField(VT_VALUE, 0); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_VALUE, 4) && verifier.EndTable(); + } +}; + +struct IntegerScalarBuilder { + typedef IntegerScalar Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_value(uint32_t value) + { + fbb_.AddElement(IntegerScalar::VT_VALUE, value, 0); + } + explicit IntegerScalarBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateIntegerScalar(::flatbuffers::FlatBufferBuilder &_fbb, + uint32_t value = 0) +{ + IntegerScalarBuilder builder_(_fbb); + builder_.add_value(value); + return builder_.Finish(); +} + +struct BezierData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef BezierDataBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_CMD = 4, VT_DATA = 6 }; + const ::flatbuffers::Vector *cmd() const + { + return GetPointer *>(VT_CMD); + } + const ::flatbuffers::Vector *data() const + { + return GetPointer *>(VT_DATA); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_CMD) && verifier.VerifyVector(cmd()) && + VerifyOffsetRequired(verifier, VT_DATA) && verifier.VerifyVector(data()) && verifier.EndTable(); + } +}; + +struct BezierDataBuilder { + typedef BezierData Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_cmd(::flatbuffers::Offset<::flatbuffers::Vector> cmd) + { + fbb_.AddOffset(BezierData::VT_CMD, cmd); + } + void add_data(::flatbuffers::Offset<::flatbuffers::Vector> data) + { + fbb_.AddOffset(BezierData::VT_DATA, data); + } + explicit BezierDataBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, BezierData::VT_CMD); + fbb_.Required(o, BezierData::VT_DATA); + return o; + } +}; + +inline ::flatbuffers::Offset CreateBezierData(::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector> cmd = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> data = 0) +{ + BezierDataBuilder builder_(_fbb); + builder_.add_data(data); + builder_.add_cmd(cmd); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateBezierDataDirect(::flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *cmd = nullptr, + const std::vector *data = nullptr) +{ + auto cmd__ = cmd ? _fbb.CreateVector(*cmd) : 0; + auto data__ = data ? _fbb.CreateVector(*data) : 0; + return LottieFlatBuffer::CreateBezierData(_fbb, cmd__, data__); +} + +struct VectorFrame FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef VectorFrameBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TIME = 4, + VT_START = 6, + VT_HOLD = 8, + VT_TIME_EASING = 10, + VT_VALUE_EASING = 12 + }; + float time() const + { + return GetField(VT_TIME, 0.0f); + } + const LottieFlatBuffer::Point *start() const + { + return GetStruct(VT_START); + } + bool hold() const + { + return GetField(VT_HOLD, 0) != 0; + } + const ::flatbuffers::Vector *time_easing() const + { + return GetPointer *>(VT_TIME_EASING); + } + const ::flatbuffers::Vector *value_easing() const + { + return GetPointer *>(VT_VALUE_EASING); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_TIME, 4) && + VerifyField(verifier, VT_START, 4) && + VerifyField(verifier, VT_HOLD, 1) && VerifyOffset(verifier, VT_TIME_EASING) && + verifier.VerifyVector(time_easing()) && VerifyOffset(verifier, VT_VALUE_EASING) && + verifier.VerifyVector(value_easing()) && verifier.EndTable(); + } +}; + +struct VectorFrameBuilder { + typedef VectorFrame Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_time(float time) + { + fbb_.AddElement(VectorFrame::VT_TIME, time, 0.0f); + } + void add_start(const LottieFlatBuffer::Point *start) + { + fbb_.AddStruct(VectorFrame::VT_START, start); + } + void add_hold(bool hold) + { + fbb_.AddElement(VectorFrame::VT_HOLD, static_cast(hold), 0); + } + void add_time_easing(::flatbuffers::Offset<::flatbuffers::Vector> time_easing) + { + fbb_.AddOffset(VectorFrame::VT_TIME_EASING, time_easing); + } + void add_value_easing(::flatbuffers::Offset<::flatbuffers::Vector> value_easing) + { + fbb_.AddOffset(VectorFrame::VT_VALUE_EASING, value_easing); + } + explicit VectorFrameBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateVectorFrame( + ::flatbuffers::FlatBufferBuilder &_fbb, float time = 0.0f, const LottieFlatBuffer::Point *start = nullptr, + bool hold = false, ::flatbuffers::Offset<::flatbuffers::Vector> time_easing = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> value_easing = 0) +{ + VectorFrameBuilder builder_(_fbb); + builder_.add_value_easing(value_easing); + builder_.add_time_easing(time_easing); + builder_.add_start(start); + builder_.add_time(time); + builder_.add_hold(hold); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateVectorFrameDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, float time = 0.0f, const LottieFlatBuffer::Point *start = nullptr, + bool hold = false, const std::vector *time_easing = nullptr, + const std::vector *value_easing = nullptr) +{ + auto time_easing__ = time_easing ? _fbb.CreateVectorOfStructs(*time_easing) : 0; + auto value_easing__ = value_easing ? _fbb.CreateVectorOfStructs(*value_easing) : 0; + return LottieFlatBuffer::CreateVectorFrame(_fbb, time, start, hold, time_easing__, value_easing__); +} + +struct VectorFrameArray FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef VectorFrameArrayBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_FRAMES = 4 }; + const ::flatbuffers::Vector<::flatbuffers::Offset> *frames() const + { + return GetPointer> *>( + VT_FRAMES); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_FRAMES) && + verifier.VerifyVector(frames()) && verifier.VerifyVectorOfTables(frames()) && verifier.EndTable(); + } +}; + +struct VectorFrameArrayBuilder { + typedef VectorFrameArray Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_frames( + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> frames) + { + fbb_.AddOffset(VectorFrameArray::VT_FRAMES, frames); + } + explicit VectorFrameArrayBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, VectorFrameArray::VT_FRAMES); + return o; + } +}; + +inline ::flatbuffers::Offset CreateVectorFrameArray( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> frames = 0) +{ + VectorFrameArrayBuilder builder_(_fbb); + builder_.add_frames(frames); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateVectorFrameArrayDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<::flatbuffers::Offset> *frames = nullptr) +{ + auto frames__ = frames ? _fbb.CreateVector<::flatbuffers::Offset>(*frames) : 0; + return LottieFlatBuffer::CreateVectorFrameArray(_fbb, frames__); +} + +struct ColorFrame FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef ColorFrameBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TIME = 4, + VT_START = 6, + VT_HOLD = 8, + VT_TIME_EASING = 10, + VT_VALUE_EASING = 12 + }; + float time() const + { + return GetField(VT_TIME, 0.0f); + } + const LottieFlatBuffer::Color24 *start() const + { + return GetStruct(VT_START); + } + bool hold() const + { + return GetField(VT_HOLD, 0) != 0; + } + const ::flatbuffers::Vector *time_easing() const + { + return GetPointer *>(VT_TIME_EASING); + } + const ::flatbuffers::Vector *value_easing() const + { + return GetPointer *>(VT_VALUE_EASING); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_TIME, 4) && + VerifyField(verifier, VT_START, 1) && + VerifyField(verifier, VT_HOLD, 1) && VerifyOffset(verifier, VT_TIME_EASING) && + verifier.VerifyVector(time_easing()) && VerifyOffset(verifier, VT_VALUE_EASING) && + verifier.VerifyVector(value_easing()) && verifier.EndTable(); + } +}; + +struct ColorFrameBuilder { + typedef ColorFrame Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_time(float time) + { + fbb_.AddElement(ColorFrame::VT_TIME, time, 0.0f); + } + void add_start(const LottieFlatBuffer::Color24 *start) + { + fbb_.AddStruct(ColorFrame::VT_START, start); + } + void add_hold(bool hold) + { + fbb_.AddElement(ColorFrame::VT_HOLD, static_cast(hold), 0); + } + void add_time_easing(::flatbuffers::Offset<::flatbuffers::Vector> time_easing) + { + fbb_.AddOffset(ColorFrame::VT_TIME_EASING, time_easing); + } + void add_value_easing(::flatbuffers::Offset<::flatbuffers::Vector> value_easing) + { + fbb_.AddOffset(ColorFrame::VT_VALUE_EASING, value_easing); + } + explicit ColorFrameBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateColorFrame( + ::flatbuffers::FlatBufferBuilder &_fbb, float time = 0.0f, const LottieFlatBuffer::Color24 *start = nullptr, + bool hold = false, ::flatbuffers::Offset<::flatbuffers::Vector> time_easing = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> value_easing = 0) +{ + ColorFrameBuilder builder_(_fbb); + builder_.add_value_easing(value_easing); + builder_.add_time_easing(time_easing); + builder_.add_start(start); + builder_.add_time(time); + builder_.add_hold(hold); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateColorFrameDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, float time = 0.0f, const LottieFlatBuffer::Color24 *start = nullptr, + bool hold = false, const std::vector *time_easing = nullptr, + const std::vector *value_easing = nullptr) +{ + auto time_easing__ = time_easing ? _fbb.CreateVectorOfStructs(*time_easing) : 0; + auto value_easing__ = value_easing ? _fbb.CreateVectorOfStructs(*value_easing) : 0; + return LottieFlatBuffer::CreateColorFrame(_fbb, time, start, hold, time_easing__, value_easing__); +} + +struct ColorFrameArray FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef ColorFrameArrayBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_FRAMES = 4 }; + const ::flatbuffers::Vector<::flatbuffers::Offset> *frames() const + { + return GetPointer> *>( + VT_FRAMES); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_FRAMES) && + verifier.VerifyVector(frames()) && verifier.VerifyVectorOfTables(frames()) && verifier.EndTable(); + } +}; + +struct ColorFrameArrayBuilder { + typedef ColorFrameArray Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_frames( + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> frames) + { + fbb_.AddOffset(ColorFrameArray::VT_FRAMES, frames); + } + explicit ColorFrameArrayBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, ColorFrameArray::VT_FRAMES); + return o; + } +}; + +inline ::flatbuffers::Offset CreateColorFrameArray( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> frames = 0) +{ + ColorFrameArrayBuilder builder_(_fbb); + builder_.add_frames(frames); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateColorFrameArrayDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<::flatbuffers::Offset> *frames = nullptr) +{ + auto frames__ = frames ? _fbb.CreateVector<::flatbuffers::Offset>(*frames) : 0; + return LottieFlatBuffer::CreateColorFrameArray(_fbb, frames__); +} + +struct Color24Scalar FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef Color24ScalarBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_VALUE = 4 }; + const LottieFlatBuffer::Color24 *value() const + { + return GetStruct(VT_VALUE); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_VALUE, 1) && + verifier.EndTable(); + } +}; + +struct Color24ScalarBuilder { + typedef Color24Scalar Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_value(const LottieFlatBuffer::Color24 *value) + { + fbb_.AddStruct(Color24Scalar::VT_VALUE, value); + } + explicit Color24ScalarBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateColor24Scalar(::flatbuffers::FlatBufferBuilder &_fbb, + const LottieFlatBuffer::Color24 *value = nullptr) +{ + Color24ScalarBuilder builder_(_fbb); + builder_.add_value(value); + return builder_.Finish(); +} + +struct GradientFrame FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef GradientFrameBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TIME = 4, + VT_START = 6, + VT_HOLD = 8, + VT_TIME_EASING = 10, + VT_VALUE_EASING = 12 + }; + float time() const + { + return GetField(VT_TIME, 0.0f); + } + const LottieFlatBuffer::Gradient *start() const + { + return GetPointer(VT_START); + } + bool hold() const + { + return GetField(VT_HOLD, 0) != 0; + } + const ::flatbuffers::Vector *time_easing() const + { + return GetPointer *>(VT_TIME_EASING); + } + const ::flatbuffers::Vector *value_easing() const + { + return GetPointer *>(VT_VALUE_EASING); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_TIME, 4) && + VerifyOffsetRequired(verifier, VT_START) && verifier.VerifyTable(start()) && + VerifyField(verifier, VT_HOLD, 1) && VerifyOffset(verifier, VT_TIME_EASING) && + verifier.VerifyVector(time_easing()) && VerifyOffset(verifier, VT_VALUE_EASING) && + verifier.VerifyVector(value_easing()) && verifier.EndTable(); + } +}; + +struct GradientFrameBuilder { + typedef GradientFrame Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_time(float time) + { + fbb_.AddElement(GradientFrame::VT_TIME, time, 0.0f); + } + void add_start(::flatbuffers::Offset start) + { + fbb_.AddOffset(GradientFrame::VT_START, start); + } + void add_hold(bool hold) + { + fbb_.AddElement(GradientFrame::VT_HOLD, static_cast(hold), 0); + } + void add_time_easing(::flatbuffers::Offset<::flatbuffers::Vector> time_easing) + { + fbb_.AddOffset(GradientFrame::VT_TIME_EASING, time_easing); + } + void add_value_easing(::flatbuffers::Offset<::flatbuffers::Vector> value_easing) + { + fbb_.AddOffset(GradientFrame::VT_VALUE_EASING, value_easing); + } + explicit GradientFrameBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, GradientFrame::VT_START); + return o; + } +}; + +inline ::flatbuffers::Offset CreateGradientFrame( + ::flatbuffers::FlatBufferBuilder &_fbb, float time = 0.0f, + ::flatbuffers::Offset start = 0, bool hold = false, + ::flatbuffers::Offset<::flatbuffers::Vector> time_easing = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> value_easing = 0) +{ + GradientFrameBuilder builder_(_fbb); + builder_.add_value_easing(value_easing); + builder_.add_time_easing(time_easing); + builder_.add_start(start); + builder_.add_time(time); + builder_.add_hold(hold); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateGradientFrameDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, float time = 0.0f, + ::flatbuffers::Offset start = 0, bool hold = false, + const std::vector *time_easing = nullptr, + const std::vector *value_easing = nullptr) +{ + auto time_easing__ = time_easing ? _fbb.CreateVectorOfStructs(*time_easing) : 0; + auto value_easing__ = value_easing ? _fbb.CreateVectorOfStructs(*value_easing) : 0; + return LottieFlatBuffer::CreateGradientFrame(_fbb, time, start, hold, time_easing__, value_easing__); +} + +struct GradientFrameArray FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef GradientFrameArrayBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_FRAMES = 4 }; + const ::flatbuffers::Vector<::flatbuffers::Offset> *frames() const + { + return GetPointer> *>( + VT_FRAMES); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_FRAMES) && + verifier.VerifyVector(frames()) && verifier.VerifyVectorOfTables(frames()) && verifier.EndTable(); + } +}; + +struct GradientFrameArrayBuilder { + typedef GradientFrameArray Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_frames( + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> frames) + { + fbb_.AddOffset(GradientFrameArray::VT_FRAMES, frames); + } + explicit GradientFrameArrayBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, GradientFrameArray::VT_FRAMES); + return o; + } +}; + +inline ::flatbuffers::Offset CreateGradientFrameArray( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> frames = 0) +{ + GradientFrameArrayBuilder builder_(_fbb); + builder_.add_frames(frames); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateGradientFrameArrayDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<::flatbuffers::Offset> *frames = nullptr) +{ + auto frames__ = frames ? _fbb.CreateVector<::flatbuffers::Offset>(*frames) : 0; + return LottieFlatBuffer::CreateGradientFrameArray(_fbb, frames__); +} + +struct BezierDataFrame FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef BezierDataFrameBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TIME = 4, + VT_START = 6, + VT_HOLD = 8, + VT_TIME_EASING = 10, + VT_VALUE_EASING = 12 + }; + float time() const + { + return GetField(VT_TIME, 0.0f); + } + const LottieFlatBuffer::BezierData *start() const + { + return GetPointer(VT_START); + } + bool hold() const + { + return GetField(VT_HOLD, 0) != 0; + } + const ::flatbuffers::Vector *time_easing() const + { + return GetPointer *>(VT_TIME_EASING); + } + const ::flatbuffers::Vector *value_easing() const + { + return GetPointer *>(VT_VALUE_EASING); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_TIME, 4) && + VerifyOffsetRequired(verifier, VT_START) && verifier.VerifyTable(start()) && + VerifyField(verifier, VT_HOLD, 1) && VerifyOffset(verifier, VT_TIME_EASING) && + verifier.VerifyVector(time_easing()) && VerifyOffset(verifier, VT_VALUE_EASING) && + verifier.VerifyVector(value_easing()) && verifier.EndTable(); + } +}; + +struct BezierDataFrameBuilder { + typedef BezierDataFrame Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_time(float time) + { + fbb_.AddElement(BezierDataFrame::VT_TIME, time, 0.0f); + } + void add_start(::flatbuffers::Offset start) + { + fbb_.AddOffset(BezierDataFrame::VT_START, start); + } + void add_hold(bool hold) + { + fbb_.AddElement(BezierDataFrame::VT_HOLD, static_cast(hold), 0); + } + void add_time_easing(::flatbuffers::Offset<::flatbuffers::Vector> time_easing) + { + fbb_.AddOffset(BezierDataFrame::VT_TIME_EASING, time_easing); + } + void add_value_easing(::flatbuffers::Offset<::flatbuffers::Vector> value_easing) + { + fbb_.AddOffset(BezierDataFrame::VT_VALUE_EASING, value_easing); + } + explicit BezierDataFrameBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, BezierDataFrame::VT_START); + return o; + } +}; + +inline ::flatbuffers::Offset CreateBezierDataFrame( + ::flatbuffers::FlatBufferBuilder &_fbb, float time = 0.0f, + ::flatbuffers::Offset start = 0, bool hold = false, + ::flatbuffers::Offset<::flatbuffers::Vector> time_easing = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> value_easing = 0) +{ + BezierDataFrameBuilder builder_(_fbb); + builder_.add_value_easing(value_easing); + builder_.add_time_easing(time_easing); + builder_.add_start(start); + builder_.add_time(time); + builder_.add_hold(hold); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateBezierDataFrameDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, float time = 0.0f, + ::flatbuffers::Offset start = 0, bool hold = false, + const std::vector *time_easing = nullptr, + const std::vector *value_easing = nullptr) +{ + auto time_easing__ = time_easing ? _fbb.CreateVectorOfStructs(*time_easing) : 0; + auto value_easing__ = value_easing ? _fbb.CreateVectorOfStructs(*value_easing) : 0; + return LottieFlatBuffer::CreateBezierDataFrame(_fbb, time, start, hold, time_easing__, value_easing__); +} + +struct BezierDataFrameArray FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef BezierDataFrameArrayBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_FRAMES = 4 }; + const ::flatbuffers::Vector<::flatbuffers::Offset> *frames() const + { + return GetPointer> *>( + VT_FRAMES); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_FRAMES) && + verifier.VerifyVector(frames()) && verifier.VerifyVectorOfTables(frames()) && verifier.EndTable(); + } +}; + +struct BezierDataFrameArrayBuilder { + typedef BezierDataFrameArray Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_frames( + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> frames) + { + fbb_.AddOffset(BezierDataFrameArray::VT_FRAMES, frames); + } + explicit BezierDataFrameArrayBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, BezierDataFrameArray::VT_FRAMES); + return o; + } +}; + +inline ::flatbuffers::Offset CreateBezierDataFrameArray( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> frames = 0) +{ + BezierDataFrameArrayBuilder builder_(_fbb); + builder_.add_frames(frames); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateBezierDataFrameArrayDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<::flatbuffers::Offset> *frames = nullptr) +{ + auto frames__ = frames ? _fbb.CreateVector<::flatbuffers::Offset>(*frames) : 0; + return LottieFlatBuffer::CreateBezierDataFrameArray(_fbb, frames__); +} + +struct PositionFrame FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef PositionFrameBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TIME = 4, + VT_START = 6, + VT_HOLD = 8, + VT_TIME_EASING = 10, + VT_VALUE_EASING = 12, + VT_IN_TAN = 14, + VT_OUT_TAN = 16 + }; + uint16_t time() const + { + return GetField(VT_TIME, 0); + } + const LottieFlatBuffer::Point *start() const + { + return GetStruct(VT_START); + } + bool hold() const + { + return GetField(VT_HOLD, 0) != 0; + } + const ::flatbuffers::Vector *time_easing() const + { + return GetPointer *>(VT_TIME_EASING); + } + const ::flatbuffers::Vector *value_easing() const + { + return GetPointer *>(VT_VALUE_EASING); + } + const ::flatbuffers::Vector *in_tan() const + { + return GetPointer *>(VT_IN_TAN); + } + const ::flatbuffers::Vector *out_tan() const + { + return GetPointer *>(VT_OUT_TAN); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_TIME, 2) && + VerifyField(verifier, VT_START, 4) && + VerifyField(verifier, VT_HOLD, 1) && VerifyOffset(verifier, VT_TIME_EASING) && + verifier.VerifyVector(time_easing()) && VerifyOffset(verifier, VT_VALUE_EASING) && + verifier.VerifyVector(value_easing()) && VerifyOffset(verifier, VT_IN_TAN) && + verifier.VerifyVector(in_tan()) && VerifyOffset(verifier, VT_OUT_TAN) && + verifier.VerifyVector(out_tan()) && verifier.EndTable(); + } +}; + +struct PositionFrameBuilder { + typedef PositionFrame Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_time(uint16_t time) + { + fbb_.AddElement(PositionFrame::VT_TIME, time, 0); + } + void add_start(const LottieFlatBuffer::Point *start) + { + fbb_.AddStruct(PositionFrame::VT_START, start); + } + void add_hold(bool hold) + { + fbb_.AddElement(PositionFrame::VT_HOLD, static_cast(hold), 0); + } + void add_time_easing(::flatbuffers::Offset<::flatbuffers::Vector> time_easing) + { + fbb_.AddOffset(PositionFrame::VT_TIME_EASING, time_easing); + } + void add_value_easing(::flatbuffers::Offset<::flatbuffers::Vector> value_easing) + { + fbb_.AddOffset(PositionFrame::VT_VALUE_EASING, value_easing); + } + void add_in_tan(::flatbuffers::Offset<::flatbuffers::Vector> in_tan) + { + fbb_.AddOffset(PositionFrame::VT_IN_TAN, in_tan); + } + void add_out_tan(::flatbuffers::Offset<::flatbuffers::Vector> out_tan) + { + fbb_.AddOffset(PositionFrame::VT_OUT_TAN, out_tan); + } + explicit PositionFrameBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreatePositionFrame( + ::flatbuffers::FlatBufferBuilder &_fbb, uint16_t time = 0, const LottieFlatBuffer::Point *start = nullptr, + bool hold = false, ::flatbuffers::Offset<::flatbuffers::Vector> time_easing = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> value_easing = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> in_tan = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> out_tan = 0) +{ + PositionFrameBuilder builder_(_fbb); + builder_.add_out_tan(out_tan); + builder_.add_in_tan(in_tan); + builder_.add_value_easing(value_easing); + builder_.add_time_easing(time_easing); + builder_.add_start(start); + builder_.add_time(time); + builder_.add_hold(hold); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreatePositionFrameDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, uint16_t time = 0, const LottieFlatBuffer::Point *start = nullptr, + bool hold = false, const std::vector *time_easing = nullptr, + const std::vector *value_easing = nullptr, + const std::vector *in_tan = nullptr, + const std::vector *out_tan = nullptr) +{ + auto time_easing__ = time_easing ? _fbb.CreateVectorOfStructs(*time_easing) : 0; + auto value_easing__ = value_easing ? _fbb.CreateVectorOfStructs(*value_easing) : 0; + auto in_tan__ = in_tan ? _fbb.CreateVectorOfStructs(*in_tan) : 0; + auto out_tan__ = out_tan ? _fbb.CreateVectorOfStructs(*out_tan) : 0; + return LottieFlatBuffer::CreatePositionFrame(_fbb, time, start, hold, time_easing__, value_easing__, in_tan__, + out_tan__); +} + +struct PositionFrameArray FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef PositionFrameArrayBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_FRAMES = 4 }; + const ::flatbuffers::Vector<::flatbuffers::Offset> *frames() const + { + return GetPointer> *>( + VT_FRAMES); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_FRAMES) && + verifier.VerifyVector(frames()) && verifier.VerifyVectorOfTables(frames()) && verifier.EndTable(); + } +}; + +struct PositionFrameArrayBuilder { + typedef PositionFrameArray Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_frames( + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> frames) + { + fbb_.AddOffset(PositionFrameArray::VT_FRAMES, frames); + } + explicit PositionFrameArrayBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, PositionFrameArray::VT_FRAMES); + return o; + } +}; + +inline ::flatbuffers::Offset CreatePositionFrameArray( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> frames = 0) +{ + PositionFrameArrayBuilder builder_(_fbb); + builder_.add_frames(frames); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreatePositionFrameArrayDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<::flatbuffers::Offset> *frames = nullptr) +{ + auto frames__ = frames ? _fbb.CreateVector<::flatbuffers::Offset>(*frames) : 0; + return LottieFlatBuffer::CreatePositionFrameArray(_fbb, frames__); +} + +struct SplitProp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef SplitPropBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_X_TYPE = 4, + VT_X = 6, + VT_Y_TYPE = 8, + VT_Y = 10 + }; + LottieFlatBuffer::FloatProp x_type() const + { + return static_cast(GetField(VT_X_TYPE, 0)); + } + const void *x() const + { + return GetPointer(VT_X); + } + template + const T *x_as() const; + const LottieFlatBuffer::FloatFrameArray *x_as_frames() const + { + return x_type() == LottieFlatBuffer::FloatProp_frames ? + static_cast(x()) : + nullptr; + } + const LottieFlatBuffer::FloatScalar *x_as_value() const + { + return x_type() == LottieFlatBuffer::FloatProp_value ? static_cast(x()) : + nullptr; + } + LottieFlatBuffer::FloatProp y_type() const + { + return static_cast(GetField(VT_Y_TYPE, 0)); + } + const void *y() const + { + return GetPointer(VT_Y); + } + template + const T *y_as() const; + const LottieFlatBuffer::FloatFrameArray *y_as_frames() const + { + return y_type() == LottieFlatBuffer::FloatProp_frames ? + static_cast(y()) : + nullptr; + } + const LottieFlatBuffer::FloatScalar *y_as_value() const + { + return y_type() == LottieFlatBuffer::FloatProp_value ? static_cast(y()) : + nullptr; + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_X_TYPE, 1) && + VerifyOffsetRequired(verifier, VT_X) && VerifyFloatProp(verifier, x(), x_type()) && + VerifyField(verifier, VT_Y_TYPE, 1) && VerifyOffsetRequired(verifier, VT_Y) && + VerifyFloatProp(verifier, y(), y_type()) && verifier.EndTable(); + } +}; + +template <> +inline const LottieFlatBuffer::FloatFrameArray *SplitProp::x_as() const +{ + return x_as_frames(); +} + +template <> +inline const LottieFlatBuffer::FloatScalar *SplitProp::x_as() const +{ + return x_as_value(); +} + +template <> +inline const LottieFlatBuffer::FloatFrameArray *SplitProp::y_as() const +{ + return y_as_frames(); +} + +template <> +inline const LottieFlatBuffer::FloatScalar *SplitProp::y_as() const +{ + return y_as_value(); +} + +struct SplitPropBuilder { + typedef SplitProp Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_x_type(LottieFlatBuffer::FloatProp x_type) + { + fbb_.AddElement(SplitProp::VT_X_TYPE, static_cast(x_type), 0); + } + void add_x(::flatbuffers::Offset x) + { + fbb_.AddOffset(SplitProp::VT_X, x); + } + void add_y_type(LottieFlatBuffer::FloatProp y_type) + { + fbb_.AddElement(SplitProp::VT_Y_TYPE, static_cast(y_type), 0); + } + void add_y(::flatbuffers::Offset y) + { + fbb_.AddOffset(SplitProp::VT_Y, y); + } + explicit SplitPropBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, SplitProp::VT_X); + fbb_.Required(o, SplitProp::VT_Y); + return o; + } +}; + +inline ::flatbuffers::Offset CreateSplitProp( + ::flatbuffers::FlatBufferBuilder &_fbb, LottieFlatBuffer::FloatProp x_type = LottieFlatBuffer::FloatProp_NONE, + ::flatbuffers::Offset x = 0, LottieFlatBuffer::FloatProp y_type = LottieFlatBuffer::FloatProp_NONE, + ::flatbuffers::Offset y = 0) +{ + SplitPropBuilder builder_(_fbb); + builder_.add_y(y); + builder_.add_x(x); + builder_.add_y_type(y_type); + builder_.add_x_type(x_type); + return builder_.Finish(); +} + +struct Transform FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef TransformBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ANCHOR_TYPE = 4, + VT_ANCHOR = 6, + VT_POSITION_TYPE = 8, + VT_POSITION = 10, + VT_SPLIT_POSITION = 12, + VT_SCALE_TYPE = 14, + VT_SCALE = 16, + VT_ROTATION_TYPE = 18, + VT_ROTATION = 20, + VT_OPACITY_TYPE = 22, + VT_OPACITY = 24, + VT_SKEW_ANGLE_TYPE = 26, + VT_SKEW_ANGLE = 28, + VT_SKEW_AXIS_TYPE = 30, + VT_SKEW_AXIS = 32 + }; + LottieFlatBuffer::VectorProp anchor_type() const + { + return static_cast(GetField(VT_ANCHOR_TYPE, 0)); + } + const void *anchor() const + { + return GetPointer(VT_ANCHOR); + } + template + const T *anchor_as() const; + const LottieFlatBuffer::VectorFrameArray *anchor_as_frames() const + { + return anchor_type() == LottieFlatBuffer::VectorProp_frames ? + static_cast(anchor()) : + nullptr; + } + const LottieFlatBuffer::Point *anchor_as_value() const + { + return anchor_type() == LottieFlatBuffer::VectorProp_value ? + static_cast(anchor()) : + nullptr; + } + LottieFlatBuffer::PositionProp position_type() const + { + return static_cast(GetField(VT_POSITION_TYPE, 0)); + } + const void *position() const + { + return GetPointer(VT_POSITION); + } + template + const T *position_as() const; + const LottieFlatBuffer::PositionFrameArray *position_as_frames() const + { + return position_type() == LottieFlatBuffer::PositionProp_frames ? + static_cast(position()) : + nullptr; + } + const LottieFlatBuffer::Point *position_as_value() const + { + return position_type() == LottieFlatBuffer::PositionProp_value ? + static_cast(position()) : + nullptr; + } + const LottieFlatBuffer::SplitProp *split_position() const + { + return GetPointer(VT_SPLIT_POSITION); + } + LottieFlatBuffer::VectorProp scale_type() const + { + return static_cast(GetField(VT_SCALE_TYPE, 0)); + } + const void *scale() const + { + return GetPointer(VT_SCALE); + } + template + const T *scale_as() const; + const LottieFlatBuffer::VectorFrameArray *scale_as_frames() const + { + return scale_type() == LottieFlatBuffer::VectorProp_frames ? + static_cast(scale()) : + nullptr; + } + const LottieFlatBuffer::Point *scale_as_value() const + { + return scale_type() == LottieFlatBuffer::VectorProp_value ? + static_cast(scale()) : + nullptr; + } + LottieFlatBuffer::FloatProp rotation_type() const + { + return static_cast(GetField(VT_ROTATION_TYPE, 0)); + } + const void *rotation() const + { + return GetPointer(VT_ROTATION); + } + template + const T *rotation_as() const; + const LottieFlatBuffer::FloatFrameArray *rotation_as_frames() const + { + return rotation_type() == LottieFlatBuffer::FloatProp_frames ? + static_cast(rotation()) : + nullptr; + } + const LottieFlatBuffer::FloatScalar *rotation_as_value() const + { + return rotation_type() == LottieFlatBuffer::FloatProp_value ? + static_cast(rotation()) : + nullptr; + } + LottieFlatBuffer::IntegerProp opacity_type() const + { + return static_cast(GetField(VT_OPACITY_TYPE, 0)); + } + const void *opacity() const + { + return GetPointer(VT_OPACITY); + } + template + const T *opacity_as() const; + const LottieFlatBuffer::IntegerFrameArray *opacity_as_frames() const + { + return opacity_type() == LottieFlatBuffer::IntegerProp_frames ? + static_cast(opacity()) : + nullptr; + } + const LottieFlatBuffer::IntegerScalar *opacity_as_value() const + { + return opacity_type() == LottieFlatBuffer::IntegerProp_value ? + static_cast(opacity()) : + nullptr; + } + LottieFlatBuffer::FloatProp skew_angle_type() const + { + return static_cast(GetField(VT_SKEW_ANGLE_TYPE, 0)); + } + const void *skew_angle() const + { + return GetPointer(VT_SKEW_ANGLE); + } + template + const T *skew_angle_as() const; + const LottieFlatBuffer::FloatFrameArray *skew_angle_as_frames() const + { + return skew_angle_type() == LottieFlatBuffer::FloatProp_frames ? + static_cast(skew_angle()) : + nullptr; + } + const LottieFlatBuffer::FloatScalar *skew_angle_as_value() const + { + return skew_angle_type() == LottieFlatBuffer::FloatProp_value ? + static_cast(skew_angle()) : + nullptr; + } + LottieFlatBuffer::FloatProp skew_axis_type() const + { + return static_cast(GetField(VT_SKEW_AXIS_TYPE, 0)); + } + const void *skew_axis() const + { + return GetPointer(VT_SKEW_AXIS); + } + template + const T *skew_axis_as() const; + const LottieFlatBuffer::FloatFrameArray *skew_axis_as_frames() const + { + return skew_axis_type() == LottieFlatBuffer::FloatProp_frames ? + static_cast(skew_axis()) : + nullptr; + } + const LottieFlatBuffer::FloatScalar *skew_axis_as_value() const + { + return skew_axis_type() == LottieFlatBuffer::FloatProp_value ? + static_cast(skew_axis()) : + nullptr; + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_ANCHOR_TYPE, 1) && + VerifyOffset(verifier, VT_ANCHOR) && VerifyVectorProp(verifier, anchor(), anchor_type()) && + VerifyField(verifier, VT_POSITION_TYPE, 1) && VerifyOffset(verifier, VT_POSITION) && + VerifyPositionProp(verifier, position(), position_type()) && VerifyOffset(verifier, VT_SPLIT_POSITION) && + verifier.VerifyTable(split_position()) && VerifyField(verifier, VT_SCALE_TYPE, 1) && + VerifyOffset(verifier, VT_SCALE) && VerifyVectorProp(verifier, scale(), scale_type()) && + VerifyField(verifier, VT_ROTATION_TYPE, 1) && VerifyOffset(verifier, VT_ROTATION) && + VerifyFloatProp(verifier, rotation(), rotation_type()) && + VerifyField(verifier, VT_OPACITY_TYPE, 1) && VerifyOffset(verifier, VT_OPACITY) && + VerifyIntegerProp(verifier, opacity(), opacity_type()) && + VerifyField(verifier, VT_SKEW_ANGLE_TYPE, 1) && VerifyOffset(verifier, VT_SKEW_ANGLE) && + VerifyFloatProp(verifier, skew_angle(), skew_angle_type()) && + VerifyField(verifier, VT_SKEW_AXIS_TYPE, 1) && VerifyOffset(verifier, VT_SKEW_AXIS) && + VerifyFloatProp(verifier, skew_axis(), skew_axis_type()) && verifier.EndTable(); + } +}; + +template <> +inline const LottieFlatBuffer::VectorFrameArray *Transform::anchor_as() const +{ + return anchor_as_frames(); +} + +template <> +inline const LottieFlatBuffer::Point *Transform::anchor_as() const +{ + return anchor_as_value(); +} + +template <> +inline const LottieFlatBuffer::PositionFrameArray *Transform::position_as() const +{ + return position_as_frames(); +} + +template <> +inline const LottieFlatBuffer::Point *Transform::position_as() const +{ + return position_as_value(); +} + +template <> +inline const LottieFlatBuffer::VectorFrameArray *Transform::scale_as() const +{ + return scale_as_frames(); +} + +template <> +inline const LottieFlatBuffer::Point *Transform::scale_as() const +{ + return scale_as_value(); +} + +template <> +inline const LottieFlatBuffer::FloatFrameArray *Transform::rotation_as() const +{ + return rotation_as_frames(); +} + +template <> +inline const LottieFlatBuffer::FloatScalar *Transform::rotation_as() const +{ + return rotation_as_value(); +} + +template <> +inline const LottieFlatBuffer::IntegerFrameArray *Transform::opacity_as() const +{ + return opacity_as_frames(); +} + +template <> +inline const LottieFlatBuffer::IntegerScalar *Transform::opacity_as() const +{ + return opacity_as_value(); +} + +template <> +inline const LottieFlatBuffer::FloatFrameArray *Transform::skew_angle_as() const +{ + return skew_angle_as_frames(); +} + +template <> +inline const LottieFlatBuffer::FloatScalar *Transform::skew_angle_as() const +{ + return skew_angle_as_value(); +} + +template <> +inline const LottieFlatBuffer::FloatFrameArray *Transform::skew_axis_as() const +{ + return skew_axis_as_frames(); +} + +template <> +inline const LottieFlatBuffer::FloatScalar *Transform::skew_axis_as() const +{ + return skew_axis_as_value(); +} + +struct TransformBuilder { + typedef Transform Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_anchor_type(LottieFlatBuffer::VectorProp anchor_type) + { + fbb_.AddElement(Transform::VT_ANCHOR_TYPE, static_cast(anchor_type), 0); + } + void add_anchor(::flatbuffers::Offset anchor) + { + fbb_.AddOffset(Transform::VT_ANCHOR, anchor); + } + void add_position_type(LottieFlatBuffer::PositionProp position_type) + { + fbb_.AddElement(Transform::VT_POSITION_TYPE, static_cast(position_type), 0); + } + void add_position(::flatbuffers::Offset position) + { + fbb_.AddOffset(Transform::VT_POSITION, position); + } + void add_split_position(::flatbuffers::Offset split_position) + { + fbb_.AddOffset(Transform::VT_SPLIT_POSITION, split_position); + } + void add_scale_type(LottieFlatBuffer::VectorProp scale_type) + { + fbb_.AddElement(Transform::VT_SCALE_TYPE, static_cast(scale_type), 0); + } + void add_scale(::flatbuffers::Offset scale) + { + fbb_.AddOffset(Transform::VT_SCALE, scale); + } + void add_rotation_type(LottieFlatBuffer::FloatProp rotation_type) + { + fbb_.AddElement(Transform::VT_ROTATION_TYPE, static_cast(rotation_type), 0); + } + void add_rotation(::flatbuffers::Offset rotation) + { + fbb_.AddOffset(Transform::VT_ROTATION, rotation); + } + void add_opacity_type(LottieFlatBuffer::IntegerProp opacity_type) + { + fbb_.AddElement(Transform::VT_OPACITY_TYPE, static_cast(opacity_type), 0); + } + void add_opacity(::flatbuffers::Offset opacity) + { + fbb_.AddOffset(Transform::VT_OPACITY, opacity); + } + void add_skew_angle_type(LottieFlatBuffer::FloatProp skew_angle_type) + { + fbb_.AddElement(Transform::VT_SKEW_ANGLE_TYPE, static_cast(skew_angle_type), 0); + } + void add_skew_angle(::flatbuffers::Offset skew_angle) + { + fbb_.AddOffset(Transform::VT_SKEW_ANGLE, skew_angle); + } + void add_skew_axis_type(LottieFlatBuffer::FloatProp skew_axis_type) + { + fbb_.AddElement(Transform::VT_SKEW_AXIS_TYPE, static_cast(skew_axis_type), 0); + } + void add_skew_axis(::flatbuffers::Offset skew_axis) + { + fbb_.AddOffset(Transform::VT_SKEW_AXIS, skew_axis); + } + explicit TransformBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateTransform( + ::flatbuffers::FlatBufferBuilder &_fbb, + LottieFlatBuffer::VectorProp anchor_type = LottieFlatBuffer::VectorProp_NONE, + ::flatbuffers::Offset anchor = 0, + LottieFlatBuffer::PositionProp position_type = LottieFlatBuffer::PositionProp_NONE, + ::flatbuffers::Offset position = 0, ::flatbuffers::Offset split_position = 0, + LottieFlatBuffer::VectorProp scale_type = LottieFlatBuffer::VectorProp_NONE, ::flatbuffers::Offset scale = 0, + LottieFlatBuffer::FloatProp rotation_type = LottieFlatBuffer::FloatProp_NONE, + ::flatbuffers::Offset rotation = 0, + LottieFlatBuffer::IntegerProp opacity_type = LottieFlatBuffer::IntegerProp_NONE, + ::flatbuffers::Offset opacity = 0, + LottieFlatBuffer::FloatProp skew_angle_type = LottieFlatBuffer::FloatProp_NONE, + ::flatbuffers::Offset skew_angle = 0, + LottieFlatBuffer::FloatProp skew_axis_type = LottieFlatBuffer::FloatProp_NONE, + ::flatbuffers::Offset skew_axis = 0) +{ + TransformBuilder builder_(_fbb); + builder_.add_skew_axis(skew_axis); + builder_.add_skew_angle(skew_angle); + builder_.add_opacity(opacity); + builder_.add_rotation(rotation); + builder_.add_scale(scale); + builder_.add_split_position(split_position); + builder_.add_position(position); + builder_.add_anchor(anchor); + builder_.add_skew_axis_type(skew_axis_type); + builder_.add_skew_angle_type(skew_angle_type); + builder_.add_opacity_type(opacity_type); + builder_.add_rotation_type(rotation_type); + builder_.add_scale_type(scale_type); + builder_.add_position_type(position_type); + builder_.add_anchor_type(anchor_type); + return builder_.Finish(); +} + +struct EllipseShape FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef EllipseShapeBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_CLOCKWISE = 4, + VT_POS_TYPE = 6, + VT_POS = 8, + VT_SIZE_TYPE = 10, + VT_SIZE = 12 + }; + bool clockwise() const + { + return GetField(VT_CLOCKWISE, 1) != 0; + } + LottieFlatBuffer::PositionProp pos_type() const + { + return static_cast(GetField(VT_POS_TYPE, 0)); + } + const void *pos() const + { + return GetPointer(VT_POS); + } + template + const T *pos_as() const; + const LottieFlatBuffer::PositionFrameArray *pos_as_frames() const + { + return pos_type() == LottieFlatBuffer::PositionProp_frames ? + static_cast(pos()) : + nullptr; + } + const LottieFlatBuffer::Point *pos_as_value() const + { + return pos_type() == LottieFlatBuffer::PositionProp_value ? + static_cast(pos()) : + nullptr; + } + LottieFlatBuffer::VectorProp size_type() const + { + return static_cast(GetField(VT_SIZE_TYPE, 0)); + } + const void *size() const + { + return GetPointer(VT_SIZE); + } + template + const T *size_as() const; + const LottieFlatBuffer::VectorFrameArray *size_as_frames() const + { + return size_type() == LottieFlatBuffer::VectorProp_frames ? + static_cast(size()) : + nullptr; + } + const LottieFlatBuffer::Point *size_as_value() const + { + return size_type() == LottieFlatBuffer::VectorProp_value ? + static_cast(size()) : + nullptr; + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_CLOCKWISE, 1) && + VerifyField(verifier, VT_POS_TYPE, 1) && VerifyOffsetRequired(verifier, VT_POS) && + VerifyPositionProp(verifier, pos(), pos_type()) && VerifyField(verifier, VT_SIZE_TYPE, 1) && + VerifyOffsetRequired(verifier, VT_SIZE) && VerifyVectorProp(verifier, size(), size_type()) && + verifier.EndTable(); + } +}; + +template <> +inline const LottieFlatBuffer::PositionFrameArray *EllipseShape::pos_as() const +{ + return pos_as_frames(); +} + +template <> +inline const LottieFlatBuffer::Point *EllipseShape::pos_as() const +{ + return pos_as_value(); +} + +template <> +inline const LottieFlatBuffer::VectorFrameArray *EllipseShape::size_as() const +{ + return size_as_frames(); +} + +template <> +inline const LottieFlatBuffer::Point *EllipseShape::size_as() const +{ + return size_as_value(); +} + +struct EllipseShapeBuilder { + typedef EllipseShape Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_clockwise(bool clockwise) + { + fbb_.AddElement(EllipseShape::VT_CLOCKWISE, static_cast(clockwise), 1); + } + void add_pos_type(LottieFlatBuffer::PositionProp pos_type) + { + fbb_.AddElement(EllipseShape::VT_POS_TYPE, static_cast(pos_type), 0); + } + void add_pos(::flatbuffers::Offset pos) + { + fbb_.AddOffset(EllipseShape::VT_POS, pos); + } + void add_size_type(LottieFlatBuffer::VectorProp size_type) + { + fbb_.AddElement(EllipseShape::VT_SIZE_TYPE, static_cast(size_type), 0); + } + void add_size(::flatbuffers::Offset size) + { + fbb_.AddOffset(EllipseShape::VT_SIZE, size); + } + explicit EllipseShapeBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, EllipseShape::VT_POS); + fbb_.Required(o, EllipseShape::VT_SIZE); + return o; + } +}; + +inline ::flatbuffers::Offset CreateEllipseShape( + ::flatbuffers::FlatBufferBuilder &_fbb, bool clockwise = true, + LottieFlatBuffer::PositionProp pos_type = LottieFlatBuffer::PositionProp_NONE, ::flatbuffers::Offset pos = 0, + LottieFlatBuffer::VectorProp size_type = LottieFlatBuffer::VectorProp_NONE, ::flatbuffers::Offset size = 0) +{ + EllipseShapeBuilder builder_(_fbb); + builder_.add_size(size); + builder_.add_pos(pos); + builder_.add_size_type(size_type); + builder_.add_pos_type(pos_type); + builder_.add_clockwise(clockwise); + return builder_.Finish(); +} + +struct RectShape FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef RectShapeBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_CLOCKWISE = 4, + VT_POS_TYPE = 6, + VT_POS = 8, + VT_SIZE_TYPE = 10, + VT_SIZE = 12, + VT_RADIUS_TYPE = 14, + VT_RADIUS = 16 + }; + bool clockwise() const + { + return GetField(VT_CLOCKWISE, 1) != 0; + } + LottieFlatBuffer::PositionProp pos_type() const + { + return static_cast(GetField(VT_POS_TYPE, 0)); + } + const void *pos() const + { + return GetPointer(VT_POS); + } + template + const T *pos_as() const; + const LottieFlatBuffer::PositionFrameArray *pos_as_frames() const + { + return pos_type() == LottieFlatBuffer::PositionProp_frames ? + static_cast(pos()) : + nullptr; + } + const LottieFlatBuffer::Point *pos_as_value() const + { + return pos_type() == LottieFlatBuffer::PositionProp_value ? + static_cast(pos()) : + nullptr; + } + LottieFlatBuffer::VectorProp size_type() const + { + return static_cast(GetField(VT_SIZE_TYPE, 0)); + } + const void *size() const + { + return GetPointer(VT_SIZE); + } + template + const T *size_as() const; + const LottieFlatBuffer::VectorFrameArray *size_as_frames() const + { + return size_type() == LottieFlatBuffer::VectorProp_frames ? + static_cast(size()) : + nullptr; + } + const LottieFlatBuffer::Point *size_as_value() const + { + return size_type() == LottieFlatBuffer::VectorProp_value ? + static_cast(size()) : + nullptr; + } + LottieFlatBuffer::FloatProp radius_type() const + { + return static_cast(GetField(VT_RADIUS_TYPE, 0)); + } + const void *radius() const + { + return GetPointer(VT_RADIUS); + } + template + const T *radius_as() const; + const LottieFlatBuffer::FloatFrameArray *radius_as_frames() const + { + return radius_type() == LottieFlatBuffer::FloatProp_frames ? + static_cast(radius()) : + nullptr; + } + const LottieFlatBuffer::FloatScalar *radius_as_value() const + { + return radius_type() == LottieFlatBuffer::FloatProp_value ? + static_cast(radius()) : + nullptr; + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_CLOCKWISE, 1) && + VerifyField(verifier, VT_POS_TYPE, 1) && VerifyOffsetRequired(verifier, VT_POS) && + VerifyPositionProp(verifier, pos(), pos_type()) && VerifyField(verifier, VT_SIZE_TYPE, 1) && + VerifyOffsetRequired(verifier, VT_SIZE) && VerifyVectorProp(verifier, size(), size_type()) && + VerifyField(verifier, VT_RADIUS_TYPE, 1) && VerifyOffsetRequired(verifier, VT_RADIUS) && + VerifyFloatProp(verifier, radius(), radius_type()) && verifier.EndTable(); + } +}; + +template <> +inline const LottieFlatBuffer::PositionFrameArray *RectShape::pos_as() const +{ + return pos_as_frames(); +} + +template <> +inline const LottieFlatBuffer::Point *RectShape::pos_as() const +{ + return pos_as_value(); +} + +template <> +inline const LottieFlatBuffer::VectorFrameArray *RectShape::size_as() const +{ + return size_as_frames(); +} + +template <> +inline const LottieFlatBuffer::Point *RectShape::size_as() const +{ + return size_as_value(); +} + +template <> +inline const LottieFlatBuffer::FloatFrameArray *RectShape::radius_as() const +{ + return radius_as_frames(); +} + +template <> +inline const LottieFlatBuffer::FloatScalar *RectShape::radius_as() const +{ + return radius_as_value(); +} + +struct RectShapeBuilder { + typedef RectShape Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_clockwise(bool clockwise) + { + fbb_.AddElement(RectShape::VT_CLOCKWISE, static_cast(clockwise), 1); + } + void add_pos_type(LottieFlatBuffer::PositionProp pos_type) + { + fbb_.AddElement(RectShape::VT_POS_TYPE, static_cast(pos_type), 0); + } + void add_pos(::flatbuffers::Offset pos) + { + fbb_.AddOffset(RectShape::VT_POS, pos); + } + void add_size_type(LottieFlatBuffer::VectorProp size_type) + { + fbb_.AddElement(RectShape::VT_SIZE_TYPE, static_cast(size_type), 0); + } + void add_size(::flatbuffers::Offset size) + { + fbb_.AddOffset(RectShape::VT_SIZE, size); + } + void add_radius_type(LottieFlatBuffer::FloatProp radius_type) + { + fbb_.AddElement(RectShape::VT_RADIUS_TYPE, static_cast(radius_type), 0); + } + void add_radius(::flatbuffers::Offset radius) + { + fbb_.AddOffset(RectShape::VT_RADIUS, radius); + } + explicit RectShapeBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, RectShape::VT_POS); + fbb_.Required(o, RectShape::VT_SIZE); + fbb_.Required(o, RectShape::VT_RADIUS); + return o; + } +}; + +inline ::flatbuffers::Offset CreateRectShape( + ::flatbuffers::FlatBufferBuilder &_fbb, bool clockwise = true, + LottieFlatBuffer::PositionProp pos_type = LottieFlatBuffer::PositionProp_NONE, ::flatbuffers::Offset pos = 0, + LottieFlatBuffer::VectorProp size_type = LottieFlatBuffer::VectorProp_NONE, ::flatbuffers::Offset size = 0, + LottieFlatBuffer::FloatProp radius_type = LottieFlatBuffer::FloatProp_NONE, ::flatbuffers::Offset radius = 0) +{ + RectShapeBuilder builder_(_fbb); + builder_.add_radius(radius); + builder_.add_size(size); + builder_.add_pos(pos); + builder_.add_radius_type(radius_type); + builder_.add_size_type(size_type); + builder_.add_pos_type(pos_type); + builder_.add_clockwise(clockwise); + return builder_.Finish(); +} + +struct PathShape FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef PathShapeBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_CLOCKWISE = 4, + VT_BEZIER_TYPE = 6, + VT_BEZIER = 8 + }; + bool clockwise() const + { + return GetField(VT_CLOCKWISE, 1) != 0; + } + LottieFlatBuffer::BezierDataProp bezier_type() const + { + return static_cast(GetField(VT_BEZIER_TYPE, 0)); + } + const void *bezier() const + { + return GetPointer(VT_BEZIER); + } + template + const T *bezier_as() const; + const LottieFlatBuffer::BezierDataFrameArray *bezier_as_frames() const + { + return bezier_type() == LottieFlatBuffer::BezierDataProp_frames ? + static_cast(bezier()) : + nullptr; + } + const LottieFlatBuffer::BezierData *bezier_as_value() const + { + return bezier_type() == LottieFlatBuffer::BezierDataProp_value ? + static_cast(bezier()) : + nullptr; + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_CLOCKWISE, 1) && + VerifyField(verifier, VT_BEZIER_TYPE, 1) && VerifyOffsetRequired(verifier, VT_BEZIER) && + VerifyBezierDataProp(verifier, bezier(), bezier_type()) && verifier.EndTable(); + } +}; + +template <> +inline const LottieFlatBuffer::BezierDataFrameArray * +PathShape::bezier_as() const +{ + return bezier_as_frames(); +} + +template <> +inline const LottieFlatBuffer::BezierData *PathShape::bezier_as() const +{ + return bezier_as_value(); +} + +struct PathShapeBuilder { + typedef PathShape Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_clockwise(bool clockwise) + { + fbb_.AddElement(PathShape::VT_CLOCKWISE, static_cast(clockwise), 1); + } + void add_bezier_type(LottieFlatBuffer::BezierDataProp bezier_type) + { + fbb_.AddElement(PathShape::VT_BEZIER_TYPE, static_cast(bezier_type), 0); + } + void add_bezier(::flatbuffers::Offset bezier) + { + fbb_.AddOffset(PathShape::VT_BEZIER, bezier); + } + explicit PathShapeBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, PathShape::VT_BEZIER); + return o; + } +}; + +inline ::flatbuffers::Offset CreatePathShape( + ::flatbuffers::FlatBufferBuilder &_fbb, bool clockwise = true, + LottieFlatBuffer::BezierDataProp bezier_type = LottieFlatBuffer::BezierDataProp_NONE, + ::flatbuffers::Offset bezier = 0) +{ + PathShapeBuilder builder_(_fbb); + builder_.add_bezier(bezier); + builder_.add_bezier_type(bezier_type); + builder_.add_clockwise(clockwise); + return builder_.Finish(); +} + +struct FillStyle FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef FillStyleBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_OPACITY_TYPE = 4, + VT_OPACITY = 6, + VT_COLOR_TYPE = 8, + VT_COLOR = 10, + VT_RULE = 12 + }; + LottieFlatBuffer::IntegerProp opacity_type() const + { + return static_cast(GetField(VT_OPACITY_TYPE, 0)); + } + const void *opacity() const + { + return GetPointer(VT_OPACITY); + } + template + const T *opacity_as() const; + const LottieFlatBuffer::IntegerFrameArray *opacity_as_frames() const + { + return opacity_type() == LottieFlatBuffer::IntegerProp_frames ? + static_cast(opacity()) : + nullptr; + } + const LottieFlatBuffer::IntegerScalar *opacity_as_value() const + { + return opacity_type() == LottieFlatBuffer::IntegerProp_value ? + static_cast(opacity()) : + nullptr; + } + LottieFlatBuffer::ColorProp color_type() const + { + return static_cast(GetField(VT_COLOR_TYPE, 0)); + } + const void *color() const + { + return GetPointer(VT_COLOR); + } + template + const T *color_as() const; + const LottieFlatBuffer::ColorFrameArray *color_as_frames() const + { + return color_type() == LottieFlatBuffer::ColorProp_frames ? + static_cast(color()) : + nullptr; + } + const LottieFlatBuffer::Color24Scalar *color_as_color() const + { + return color_type() == LottieFlatBuffer::ColorProp_color ? + static_cast(color()) : + nullptr; + } + LottieFlatBuffer::FillRule rule() const + { + return static_cast(GetField(VT_RULE, 0)); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_OPACITY_TYPE, 1) && + VerifyOffsetRequired(verifier, VT_OPACITY) && VerifyIntegerProp(verifier, opacity(), opacity_type()) && + VerifyField(verifier, VT_COLOR_TYPE, 1) && VerifyOffsetRequired(verifier, VT_COLOR) && + VerifyColorProp(verifier, color(), color_type()) && VerifyField(verifier, VT_RULE, 1) && + verifier.EndTable(); + } +}; + +template <> +inline const LottieFlatBuffer::IntegerFrameArray *FillStyle::opacity_as() const +{ + return opacity_as_frames(); +} + +template <> +inline const LottieFlatBuffer::IntegerScalar *FillStyle::opacity_as() const +{ + return opacity_as_value(); +} + +template <> +inline const LottieFlatBuffer::ColorFrameArray *FillStyle::color_as() const +{ + return color_as_frames(); +} + +template <> +inline const LottieFlatBuffer::Color24Scalar *FillStyle::color_as() const +{ + return color_as_color(); +} + +struct FillStyleBuilder { + typedef FillStyle Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_opacity_type(LottieFlatBuffer::IntegerProp opacity_type) + { + fbb_.AddElement(FillStyle::VT_OPACITY_TYPE, static_cast(opacity_type), 0); + } + void add_opacity(::flatbuffers::Offset opacity) + { + fbb_.AddOffset(FillStyle::VT_OPACITY, opacity); + } + void add_color_type(LottieFlatBuffer::ColorProp color_type) + { + fbb_.AddElement(FillStyle::VT_COLOR_TYPE, static_cast(color_type), 0); + } + void add_color(::flatbuffers::Offset color) + { + fbb_.AddOffset(FillStyle::VT_COLOR, color); + } + void add_rule(LottieFlatBuffer::FillRule rule) + { + fbb_.AddElement(FillStyle::VT_RULE, static_cast(rule), 0); + } + explicit FillStyleBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, FillStyle::VT_OPACITY); + fbb_.Required(o, FillStyle::VT_COLOR); + return o; + } +}; + +inline ::flatbuffers::Offset CreateFillStyle( + ::flatbuffers::FlatBufferBuilder &_fbb, + LottieFlatBuffer::IntegerProp opacity_type = LottieFlatBuffer::IntegerProp_NONE, + ::flatbuffers::Offset opacity = 0, LottieFlatBuffer::ColorProp color_type = LottieFlatBuffer::ColorProp_NONE, + ::flatbuffers::Offset color = 0, LottieFlatBuffer::FillRule rule = LottieFlatBuffer::FillRule_NON_ZERO) +{ + FillStyleBuilder builder_(_fbb); + builder_.add_color(color); + builder_.add_opacity(opacity); + builder_.add_rule(rule); + builder_.add_color_type(color_type); + builder_.add_opacity_type(opacity_type); + return builder_.Finish(); +} + +struct StrokeStyle FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef StrokeStyleBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_OPACITY_TYPE = 4, + VT_OPACITY = 6, + VT_COLOR_TYPE = 8, + VT_COLOR = 10, + VT_WIDTH_TYPE = 12, + VT_WIDTH = 14, + VT_CAP = 16, + VT_JOIN = 18, + VT_MITER_LIMIT = 20 + }; + LottieFlatBuffer::IntegerProp opacity_type() const + { + return static_cast(GetField(VT_OPACITY_TYPE, 0)); + } + const void *opacity() const + { + return GetPointer(VT_OPACITY); + } + template + const T *opacity_as() const; + const LottieFlatBuffer::IntegerFrameArray *opacity_as_frames() const + { + return opacity_type() == LottieFlatBuffer::IntegerProp_frames ? + static_cast(opacity()) : + nullptr; + } + const LottieFlatBuffer::IntegerScalar *opacity_as_value() const + { + return opacity_type() == LottieFlatBuffer::IntegerProp_value ? + static_cast(opacity()) : + nullptr; + } + LottieFlatBuffer::ColorProp color_type() const + { + return static_cast(GetField(VT_COLOR_TYPE, 0)); + } + const void *color() const + { + return GetPointer(VT_COLOR); + } + template + const T *color_as() const; + const LottieFlatBuffer::ColorFrameArray *color_as_frames() const + { + return color_type() == LottieFlatBuffer::ColorProp_frames ? + static_cast(color()) : + nullptr; + } + const LottieFlatBuffer::Color24Scalar *color_as_color() const + { + return color_type() == LottieFlatBuffer::ColorProp_color ? + static_cast(color()) : + nullptr; + } + LottieFlatBuffer::FloatProp width_type() const + { + return static_cast(GetField(VT_WIDTH_TYPE, 0)); + } + const void *width() const + { + return GetPointer(VT_WIDTH); + } + template + const T *width_as() const; + const LottieFlatBuffer::FloatFrameArray *width_as_frames() const + { + return width_type() == LottieFlatBuffer::FloatProp_frames ? + static_cast(width()) : + nullptr; + } + const LottieFlatBuffer::FloatScalar *width_as_value() const + { + return width_type() == LottieFlatBuffer::FloatProp_value ? + static_cast(width()) : + nullptr; + } + LottieFlatBuffer::LineCap cap() const + { + return static_cast(GetField(VT_CAP, 1)); + } + LottieFlatBuffer::LineJoin join() const + { + return static_cast(GetField(VT_JOIN, 1)); + } + float miter_limit() const + { + return GetField(VT_MITER_LIMIT, 0.0f); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_OPACITY_TYPE, 1) && + VerifyOffsetRequired(verifier, VT_OPACITY) && VerifyIntegerProp(verifier, opacity(), opacity_type()) && + VerifyField(verifier, VT_COLOR_TYPE, 1) && VerifyOffsetRequired(verifier, VT_COLOR) && + VerifyColorProp(verifier, color(), color_type()) && VerifyField(verifier, VT_WIDTH_TYPE, 1) && + VerifyOffsetRequired(verifier, VT_WIDTH) && VerifyFloatProp(verifier, width(), width_type()) && + VerifyField(verifier, VT_CAP, 1) && VerifyField(verifier, VT_JOIN, 1) && + VerifyField(verifier, VT_MITER_LIMIT, 4) && verifier.EndTable(); + } +}; + +template <> +inline const LottieFlatBuffer::IntegerFrameArray *StrokeStyle::opacity_as() const +{ + return opacity_as_frames(); +} + +template <> +inline const LottieFlatBuffer::IntegerScalar *StrokeStyle::opacity_as() const +{ + return opacity_as_value(); +} + +template <> +inline const LottieFlatBuffer::ColorFrameArray *StrokeStyle::color_as() const +{ + return color_as_frames(); +} + +template <> +inline const LottieFlatBuffer::Color24Scalar *StrokeStyle::color_as() const +{ + return color_as_color(); +} + +template <> +inline const LottieFlatBuffer::FloatFrameArray *StrokeStyle::width_as() const +{ + return width_as_frames(); +} + +template <> +inline const LottieFlatBuffer::FloatScalar *StrokeStyle::width_as() const +{ + return width_as_value(); +} + +struct StrokeStyleBuilder { + typedef StrokeStyle Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_opacity_type(LottieFlatBuffer::IntegerProp opacity_type) + { + fbb_.AddElement(StrokeStyle::VT_OPACITY_TYPE, static_cast(opacity_type), 0); + } + void add_opacity(::flatbuffers::Offset opacity) + { + fbb_.AddOffset(StrokeStyle::VT_OPACITY, opacity); + } + void add_color_type(LottieFlatBuffer::ColorProp color_type) + { + fbb_.AddElement(StrokeStyle::VT_COLOR_TYPE, static_cast(color_type), 0); + } + void add_color(::flatbuffers::Offset color) + { + fbb_.AddOffset(StrokeStyle::VT_COLOR, color); + } + void add_width_type(LottieFlatBuffer::FloatProp width_type) + { + fbb_.AddElement(StrokeStyle::VT_WIDTH_TYPE, static_cast(width_type), 0); + } + void add_width(::flatbuffers::Offset width) + { + fbb_.AddOffset(StrokeStyle::VT_WIDTH, width); + } + void add_cap(LottieFlatBuffer::LineCap cap) + { + fbb_.AddElement(StrokeStyle::VT_CAP, static_cast(cap), 1); + } + void add_join(LottieFlatBuffer::LineJoin join) + { + fbb_.AddElement(StrokeStyle::VT_JOIN, static_cast(join), 1); + } + void add_miter_limit(float miter_limit) + { + fbb_.AddElement(StrokeStyle::VT_MITER_LIMIT, miter_limit, 0.0f); + } + explicit StrokeStyleBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, StrokeStyle::VT_OPACITY); + fbb_.Required(o, StrokeStyle::VT_COLOR); + fbb_.Required(o, StrokeStyle::VT_WIDTH); + return o; + } +}; + +inline ::flatbuffers::Offset CreateStrokeStyle( + ::flatbuffers::FlatBufferBuilder &_fbb, + LottieFlatBuffer::IntegerProp opacity_type = LottieFlatBuffer::IntegerProp_NONE, + ::flatbuffers::Offset opacity = 0, LottieFlatBuffer::ColorProp color_type = LottieFlatBuffer::ColorProp_NONE, + ::flatbuffers::Offset color = 0, LottieFlatBuffer::FloatProp width_type = LottieFlatBuffer::FloatProp_NONE, + ::flatbuffers::Offset width = 0, LottieFlatBuffer::LineCap cap = LottieFlatBuffer::LineCap_CAP_ROUND, + LottieFlatBuffer::LineJoin join = LottieFlatBuffer::LineJoin_JOIN_ROUND, float miter_limit = 0.0f) +{ + StrokeStyleBuilder builder_(_fbb); + builder_.add_miter_limit(miter_limit); + builder_.add_width(width); + builder_.add_color(color); + builder_.add_opacity(opacity); + builder_.add_join(join); + builder_.add_cap(cap); + builder_.add_width_type(width_type); + builder_.add_color_type(color_type); + builder_.add_opacity_type(opacity_type); + return builder_.Finish(); +} + +struct GradientFillStyle FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef GradientFillStyleBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_OPACITY_TYPE = 4, + VT_OPACITY = 6, + VT_START_POS_TYPE = 8, + VT_START_POS = 10, + VT_END_POS_TYPE = 12, + VT_END_POS = 14, + VT_GRADIENT_TYPE = 16, + VT_GRADIENT = 18, + VT_TYPE = 20, + VT_RULE = 22 + }; + LottieFlatBuffer::IntegerProp opacity_type() const + { + return static_cast(GetField(VT_OPACITY_TYPE, 0)); + } + const void *opacity() const + { + return GetPointer(VT_OPACITY); + } + template + const T *opacity_as() const; + const LottieFlatBuffer::IntegerFrameArray *opacity_as_frames() const + { + return opacity_type() == LottieFlatBuffer::IntegerProp_frames ? + static_cast(opacity()) : + nullptr; + } + const LottieFlatBuffer::IntegerScalar *opacity_as_value() const + { + return opacity_type() == LottieFlatBuffer::IntegerProp_value ? + static_cast(opacity()) : + nullptr; + } + LottieFlatBuffer::VectorProp start_pos_type() const + { + return static_cast(GetField(VT_START_POS_TYPE, 0)); + } + const void *start_pos() const + { + return GetPointer(VT_START_POS); + } + template + const T *start_pos_as() const; + const LottieFlatBuffer::VectorFrameArray *start_pos_as_frames() const + { + return start_pos_type() == LottieFlatBuffer::VectorProp_frames ? + static_cast(start_pos()) : + nullptr; + } + const LottieFlatBuffer::Point *start_pos_as_value() const + { + return start_pos_type() == LottieFlatBuffer::VectorProp_value ? + static_cast(start_pos()) : + nullptr; + } + LottieFlatBuffer::VectorProp end_pos_type() const + { + return static_cast(GetField(VT_END_POS_TYPE, 0)); + } + const void *end_pos() const + { + return GetPointer(VT_END_POS); + } + template + const T *end_pos_as() const; + const LottieFlatBuffer::VectorFrameArray *end_pos_as_frames() const + { + return end_pos_type() == LottieFlatBuffer::VectorProp_frames ? + static_cast(end_pos()) : + nullptr; + } + const LottieFlatBuffer::Point *end_pos_as_value() const + { + return end_pos_type() == LottieFlatBuffer::VectorProp_value ? + static_cast(end_pos()) : + nullptr; + } + LottieFlatBuffer::GradientProp gradient_type() const + { + return static_cast(GetField(VT_GRADIENT_TYPE, 0)); + } + const void *gradient() const + { + return GetPointer(VT_GRADIENT); + } + template + const T *gradient_as() const; + const LottieFlatBuffer::GradientFrameArray *gradient_as_frames() const + { + return gradient_type() == LottieFlatBuffer::GradientProp_frames ? + static_cast(gradient()) : + nullptr; + } + const LottieFlatBuffer::Gradient *gradient_as_value() const + { + return gradient_type() == LottieFlatBuffer::GradientProp_value ? + static_cast(gradient()) : + nullptr; + } + LottieFlatBuffer::GradientType type() const + { + return static_cast(GetField(VT_TYPE, 0)); + } + LottieFlatBuffer::FillRule rule() const + { + return static_cast(GetField(VT_RULE, 0)); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_OPACITY_TYPE, 1) && + VerifyOffsetRequired(verifier, VT_OPACITY) && VerifyIntegerProp(verifier, opacity(), opacity_type()) && + VerifyField(verifier, VT_START_POS_TYPE, 1) && VerifyOffsetRequired(verifier, VT_START_POS) && + VerifyVectorProp(verifier, start_pos(), start_pos_type()) && + VerifyField(verifier, VT_END_POS_TYPE, 1) && VerifyOffsetRequired(verifier, VT_END_POS) && + VerifyVectorProp(verifier, end_pos(), end_pos_type()) && + VerifyField(verifier, VT_GRADIENT_TYPE, 1) && VerifyOffsetRequired(verifier, VT_GRADIENT) && + VerifyGradientProp(verifier, gradient(), gradient_type()) && VerifyField(verifier, VT_TYPE, 1) && + VerifyField(verifier, VT_RULE, 1) && verifier.EndTable(); + } +}; + +template <> +inline const LottieFlatBuffer::IntegerFrameArray * +GradientFillStyle::opacity_as() const +{ + return opacity_as_frames(); +} + +template <> +inline const LottieFlatBuffer::IntegerScalar *GradientFillStyle::opacity_as() const +{ + return opacity_as_value(); +} + +template <> +inline const LottieFlatBuffer::VectorFrameArray * +GradientFillStyle::start_pos_as() const +{ + return start_pos_as_frames(); +} + +template <> +inline const LottieFlatBuffer::Point *GradientFillStyle::start_pos_as() const +{ + return start_pos_as_value(); +} + +template <> +inline const LottieFlatBuffer::VectorFrameArray * +GradientFillStyle::end_pos_as() const +{ + return end_pos_as_frames(); +} + +template <> +inline const LottieFlatBuffer::Point *GradientFillStyle::end_pos_as() const +{ + return end_pos_as_value(); +} + +template <> +inline const LottieFlatBuffer::GradientFrameArray * +GradientFillStyle::gradient_as() const +{ + return gradient_as_frames(); +} + +template <> +inline const LottieFlatBuffer::Gradient *GradientFillStyle::gradient_as() const +{ + return gradient_as_value(); +} + +struct GradientFillStyleBuilder { + typedef GradientFillStyle Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_opacity_type(LottieFlatBuffer::IntegerProp opacity_type) + { + fbb_.AddElement(GradientFillStyle::VT_OPACITY_TYPE, static_cast(opacity_type), 0); + } + void add_opacity(::flatbuffers::Offset opacity) + { + fbb_.AddOffset(GradientFillStyle::VT_OPACITY, opacity); + } + void add_start_pos_type(LottieFlatBuffer::VectorProp start_pos_type) + { + fbb_.AddElement(GradientFillStyle::VT_START_POS_TYPE, static_cast(start_pos_type), 0); + } + void add_start_pos(::flatbuffers::Offset start_pos) + { + fbb_.AddOffset(GradientFillStyle::VT_START_POS, start_pos); + } + void add_end_pos_type(LottieFlatBuffer::VectorProp end_pos_type) + { + fbb_.AddElement(GradientFillStyle::VT_END_POS_TYPE, static_cast(end_pos_type), 0); + } + void add_end_pos(::flatbuffers::Offset end_pos) + { + fbb_.AddOffset(GradientFillStyle::VT_END_POS, end_pos); + } + void add_gradient_type(LottieFlatBuffer::GradientProp gradient_type) + { + fbb_.AddElement(GradientFillStyle::VT_GRADIENT_TYPE, static_cast(gradient_type), 0); + } + void add_gradient(::flatbuffers::Offset gradient) + { + fbb_.AddOffset(GradientFillStyle::VT_GRADIENT, gradient); + } + void add_type(LottieFlatBuffer::GradientType type) + { + fbb_.AddElement(GradientFillStyle::VT_TYPE, static_cast(type), 0); + } + void add_rule(LottieFlatBuffer::FillRule rule) + { + fbb_.AddElement(GradientFillStyle::VT_RULE, static_cast(rule), 0); + } + explicit GradientFillStyleBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, GradientFillStyle::VT_OPACITY); + fbb_.Required(o, GradientFillStyle::VT_START_POS); + fbb_.Required(o, GradientFillStyle::VT_END_POS); + fbb_.Required(o, GradientFillStyle::VT_GRADIENT); + return o; + } +}; + +inline ::flatbuffers::Offset CreateGradientFillStyle( + ::flatbuffers::FlatBufferBuilder &_fbb, + LottieFlatBuffer::IntegerProp opacity_type = LottieFlatBuffer::IntegerProp_NONE, + ::flatbuffers::Offset opacity = 0, + LottieFlatBuffer::VectorProp start_pos_type = LottieFlatBuffer::VectorProp_NONE, + ::flatbuffers::Offset start_pos = 0, + LottieFlatBuffer::VectorProp end_pos_type = LottieFlatBuffer::VectorProp_NONE, + ::flatbuffers::Offset end_pos = 0, + LottieFlatBuffer::GradientProp gradient_type = LottieFlatBuffer::GradientProp_NONE, + ::flatbuffers::Offset gradient = 0, + LottieFlatBuffer::GradientType type = LottieFlatBuffer::GradientType_GRADIENT_LINEAR, + LottieFlatBuffer::FillRule rule = LottieFlatBuffer::FillRule_NON_ZERO) +{ + GradientFillStyleBuilder builder_(_fbb); + builder_.add_gradient(gradient); + builder_.add_end_pos(end_pos); + builder_.add_start_pos(start_pos); + builder_.add_opacity(opacity); + builder_.add_rule(rule); + builder_.add_type(type); + builder_.add_gradient_type(gradient_type); + builder_.add_end_pos_type(end_pos_type); + builder_.add_start_pos_type(start_pos_type); + builder_.add_opacity_type(opacity_type); + return builder_.Finish(); +} + +struct GradientStrokeStyle FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef GradientStrokeStyleBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_WIDTH_TYPE = 4, + VT_WIDTH = 6, + VT_OPACITY_TYPE = 8, + VT_OPACITY = 10, + VT_START_POS_TYPE = 12, + VT_START_POS = 14, + VT_END_POS_TYPE = 16, + VT_END_POS = 18, + VT_GRADIENT_TYPE = 20, + VT_GRADIENT = 22, + VT_TYPE = 24, + VT_CAP = 26, + VT_JOIN = 28, + VT_MITER_LIMIT = 30 + }; + LottieFlatBuffer::FloatProp width_type() const + { + return static_cast(GetField(VT_WIDTH_TYPE, 0)); + } + const void *width() const + { + return GetPointer(VT_WIDTH); + } + template + const T *width_as() const; + const LottieFlatBuffer::FloatFrameArray *width_as_frames() const + { + return width_type() == LottieFlatBuffer::FloatProp_frames ? + static_cast(width()) : + nullptr; + } + const LottieFlatBuffer::FloatScalar *width_as_value() const + { + return width_type() == LottieFlatBuffer::FloatProp_value ? + static_cast(width()) : + nullptr; + } + LottieFlatBuffer::IntegerProp opacity_type() const + { + return static_cast(GetField(VT_OPACITY_TYPE, 0)); + } + const void *opacity() const + { + return GetPointer(VT_OPACITY); + } + template + const T *opacity_as() const; + const LottieFlatBuffer::IntegerFrameArray *opacity_as_frames() const + { + return opacity_type() == LottieFlatBuffer::IntegerProp_frames ? + static_cast(opacity()) : + nullptr; + } + const LottieFlatBuffer::IntegerScalar *opacity_as_value() const + { + return opacity_type() == LottieFlatBuffer::IntegerProp_value ? + static_cast(opacity()) : + nullptr; + } + LottieFlatBuffer::VectorProp start_pos_type() const + { + return static_cast(GetField(VT_START_POS_TYPE, 0)); + } + const void *start_pos() const + { + return GetPointer(VT_START_POS); + } + template + const T *start_pos_as() const; + const LottieFlatBuffer::VectorFrameArray *start_pos_as_frames() const + { + return start_pos_type() == LottieFlatBuffer::VectorProp_frames ? + static_cast(start_pos()) : + nullptr; + } + const LottieFlatBuffer::Point *start_pos_as_value() const + { + return start_pos_type() == LottieFlatBuffer::VectorProp_value ? + static_cast(start_pos()) : + nullptr; + } + LottieFlatBuffer::VectorProp end_pos_type() const + { + return static_cast(GetField(VT_END_POS_TYPE, 0)); + } + const void *end_pos() const + { + return GetPointer(VT_END_POS); + } + template + const T *end_pos_as() const; + const LottieFlatBuffer::VectorFrameArray *end_pos_as_frames() const + { + return end_pos_type() == LottieFlatBuffer::VectorProp_frames ? + static_cast(end_pos()) : + nullptr; + } + const LottieFlatBuffer::Point *end_pos_as_value() const + { + return end_pos_type() == LottieFlatBuffer::VectorProp_value ? + static_cast(end_pos()) : + nullptr; + } + LottieFlatBuffer::GradientProp gradient_type() const + { + return static_cast(GetField(VT_GRADIENT_TYPE, 0)); + } + const void *gradient() const + { + return GetPointer(VT_GRADIENT); + } + template + const T *gradient_as() const; + const LottieFlatBuffer::GradientFrameArray *gradient_as_frames() const + { + return gradient_type() == LottieFlatBuffer::GradientProp_frames ? + static_cast(gradient()) : + nullptr; + } + const LottieFlatBuffer::Gradient *gradient_as_value() const + { + return gradient_type() == LottieFlatBuffer::GradientProp_value ? + static_cast(gradient()) : + nullptr; + } + LottieFlatBuffer::GradientType type() const + { + return static_cast(GetField(VT_TYPE, 0)); + } + LottieFlatBuffer::LineCap cap() const + { + return static_cast(GetField(VT_CAP, 1)); + } + LottieFlatBuffer::LineJoin join() const + { + return static_cast(GetField(VT_JOIN, 1)); + } + float miter_limit() const + { + return GetField(VT_MITER_LIMIT, 0.0f); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_WIDTH_TYPE, 1) && + VerifyOffsetRequired(verifier, VT_WIDTH) && VerifyFloatProp(verifier, width(), width_type()) && + VerifyField(verifier, VT_OPACITY_TYPE, 1) && VerifyOffsetRequired(verifier, VT_OPACITY) && + VerifyIntegerProp(verifier, opacity(), opacity_type()) && + VerifyField(verifier, VT_START_POS_TYPE, 1) && VerifyOffsetRequired(verifier, VT_START_POS) && + VerifyVectorProp(verifier, start_pos(), start_pos_type()) && + VerifyField(verifier, VT_END_POS_TYPE, 1) && VerifyOffsetRequired(verifier, VT_END_POS) && + VerifyVectorProp(verifier, end_pos(), end_pos_type()) && + VerifyField(verifier, VT_GRADIENT_TYPE, 1) && VerifyOffsetRequired(verifier, VT_GRADIENT) && + VerifyGradientProp(verifier, gradient(), gradient_type()) && VerifyField(verifier, VT_TYPE, 1) && + VerifyField(verifier, VT_CAP, 1) && VerifyField(verifier, VT_JOIN, 1) && + VerifyField(verifier, VT_MITER_LIMIT, 4) && verifier.EndTable(); + } +}; + +template <> +inline const LottieFlatBuffer::FloatFrameArray *GradientStrokeStyle::width_as() const +{ + return width_as_frames(); +} + +template <> +inline const LottieFlatBuffer::FloatScalar *GradientStrokeStyle::width_as() const +{ + return width_as_value(); +} + +template <> +inline const LottieFlatBuffer::IntegerFrameArray * +GradientStrokeStyle::opacity_as() const +{ + return opacity_as_frames(); +} + +template <> +inline const LottieFlatBuffer::IntegerScalar *GradientStrokeStyle::opacity_as() const +{ + return opacity_as_value(); +} + +template <> +inline const LottieFlatBuffer::VectorFrameArray * +GradientStrokeStyle::start_pos_as() const +{ + return start_pos_as_frames(); +} + +template <> +inline const LottieFlatBuffer::Point *GradientStrokeStyle::start_pos_as() const +{ + return start_pos_as_value(); +} + +template <> +inline const LottieFlatBuffer::VectorFrameArray * +GradientStrokeStyle::end_pos_as() const +{ + return end_pos_as_frames(); +} + +template <> +inline const LottieFlatBuffer::Point *GradientStrokeStyle::end_pos_as() const +{ + return end_pos_as_value(); +} + +template <> +inline const LottieFlatBuffer::GradientFrameArray * +GradientStrokeStyle::gradient_as() const +{ + return gradient_as_frames(); +} + +template <> +inline const LottieFlatBuffer::Gradient *GradientStrokeStyle::gradient_as() const +{ + return gradient_as_value(); +} + +struct GradientStrokeStyleBuilder { + typedef GradientStrokeStyle Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_width_type(LottieFlatBuffer::FloatProp width_type) + { + fbb_.AddElement(GradientStrokeStyle::VT_WIDTH_TYPE, static_cast(width_type), 0); + } + void add_width(::flatbuffers::Offset width) + { + fbb_.AddOffset(GradientStrokeStyle::VT_WIDTH, width); + } + void add_opacity_type(LottieFlatBuffer::IntegerProp opacity_type) + { + fbb_.AddElement(GradientStrokeStyle::VT_OPACITY_TYPE, static_cast(opacity_type), 0); + } + void add_opacity(::flatbuffers::Offset opacity) + { + fbb_.AddOffset(GradientStrokeStyle::VT_OPACITY, opacity); + } + void add_start_pos_type(LottieFlatBuffer::VectorProp start_pos_type) + { + fbb_.AddElement(GradientStrokeStyle::VT_START_POS_TYPE, static_cast(start_pos_type), 0); + } + void add_start_pos(::flatbuffers::Offset start_pos) + { + fbb_.AddOffset(GradientStrokeStyle::VT_START_POS, start_pos); + } + void add_end_pos_type(LottieFlatBuffer::VectorProp end_pos_type) + { + fbb_.AddElement(GradientStrokeStyle::VT_END_POS_TYPE, static_cast(end_pos_type), 0); + } + void add_end_pos(::flatbuffers::Offset end_pos) + { + fbb_.AddOffset(GradientStrokeStyle::VT_END_POS, end_pos); + } + void add_gradient_type(LottieFlatBuffer::GradientProp gradient_type) + { + fbb_.AddElement(GradientStrokeStyle::VT_GRADIENT_TYPE, static_cast(gradient_type), 0); + } + void add_gradient(::flatbuffers::Offset gradient) + { + fbb_.AddOffset(GradientStrokeStyle::VT_GRADIENT, gradient); + } + void add_type(LottieFlatBuffer::GradientType type) + { + fbb_.AddElement(GradientStrokeStyle::VT_TYPE, static_cast(type), 0); + } + void add_cap(LottieFlatBuffer::LineCap cap) + { + fbb_.AddElement(GradientStrokeStyle::VT_CAP, static_cast(cap), 1); + } + void add_join(LottieFlatBuffer::LineJoin join) + { + fbb_.AddElement(GradientStrokeStyle::VT_JOIN, static_cast(join), 1); + } + void add_miter_limit(float miter_limit) + { + fbb_.AddElement(GradientStrokeStyle::VT_MITER_LIMIT, miter_limit, 0.0f); + } + explicit GradientStrokeStyleBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, GradientStrokeStyle::VT_WIDTH); + fbb_.Required(o, GradientStrokeStyle::VT_OPACITY); + fbb_.Required(o, GradientStrokeStyle::VT_START_POS); + fbb_.Required(o, GradientStrokeStyle::VT_END_POS); + fbb_.Required(o, GradientStrokeStyle::VT_GRADIENT); + return o; + } +}; + +inline ::flatbuffers::Offset CreateGradientStrokeStyle( + ::flatbuffers::FlatBufferBuilder &_fbb, LottieFlatBuffer::FloatProp width_type = LottieFlatBuffer::FloatProp_NONE, + ::flatbuffers::Offset width = 0, + LottieFlatBuffer::IntegerProp opacity_type = LottieFlatBuffer::IntegerProp_NONE, + ::flatbuffers::Offset opacity = 0, + LottieFlatBuffer::VectorProp start_pos_type = LottieFlatBuffer::VectorProp_NONE, + ::flatbuffers::Offset start_pos = 0, + LottieFlatBuffer::VectorProp end_pos_type = LottieFlatBuffer::VectorProp_NONE, + ::flatbuffers::Offset end_pos = 0, + LottieFlatBuffer::GradientProp gradient_type = LottieFlatBuffer::GradientProp_NONE, + ::flatbuffers::Offset gradient = 0, + LottieFlatBuffer::GradientType type = LottieFlatBuffer::GradientType_GRADIENT_LINEAR, + LottieFlatBuffer::LineCap cap = LottieFlatBuffer::LineCap_CAP_ROUND, + LottieFlatBuffer::LineJoin join = LottieFlatBuffer::LineJoin_JOIN_ROUND, float miter_limit = 0.0f) +{ + GradientStrokeStyleBuilder builder_(_fbb); + builder_.add_miter_limit(miter_limit); + builder_.add_gradient(gradient); + builder_.add_end_pos(end_pos); + builder_.add_start_pos(start_pos); + builder_.add_opacity(opacity); + builder_.add_width(width); + builder_.add_join(join); + builder_.add_cap(cap); + builder_.add_type(type); + builder_.add_gradient_type(gradient_type); + builder_.add_end_pos_type(end_pos_type); + builder_.add_start_pos_type(start_pos_type); + builder_.add_opacity_type(opacity_type); + builder_.add_width_type(width_type); + return builder_.Finish(); +} + +struct TrimPath FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef TrimPathBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_START_TYPE = 4, + VT_START = 6, + VT_END_TYPE = 8, + VT_END = 10, + VT_OFFSET_TYPE = 12, + VT_OFFSET = 14, + VT_TYPE = 16 + }; + LottieFlatBuffer::FloatProp start_type() const + { + return static_cast(GetField(VT_START_TYPE, 0)); + } + const void *start() const + { + return GetPointer(VT_START); + } + template + const T *start_as() const; + const LottieFlatBuffer::FloatFrameArray *start_as_frames() const + { + return start_type() == LottieFlatBuffer::FloatProp_frames ? + static_cast(start()) : + nullptr; + } + const LottieFlatBuffer::FloatScalar *start_as_value() const + { + return start_type() == LottieFlatBuffer::FloatProp_value ? + static_cast(start()) : + nullptr; + } + LottieFlatBuffer::FloatProp end_type() const + { + return static_cast(GetField(VT_END_TYPE, 0)); + } + const void *end() const + { + return GetPointer(VT_END); + } + template + const T *end_as() const; + const LottieFlatBuffer::FloatFrameArray *end_as_frames() const + { + return end_type() == LottieFlatBuffer::FloatProp_frames ? + static_cast(end()) : + nullptr; + } + const LottieFlatBuffer::FloatScalar *end_as_value() const + { + return end_type() == LottieFlatBuffer::FloatProp_value ? + static_cast(end()) : + nullptr; + } + LottieFlatBuffer::FloatProp offset_type() const + { + return static_cast(GetField(VT_OFFSET_TYPE, 0)); + } + const void *offset() const + { + return GetPointer(VT_OFFSET); + } + template + const T *offset_as() const; + const LottieFlatBuffer::FloatFrameArray *offset_as_frames() const + { + return offset_type() == LottieFlatBuffer::FloatProp_frames ? + static_cast(offset()) : + nullptr; + } + const LottieFlatBuffer::FloatScalar *offset_as_value() const + { + return offset_type() == LottieFlatBuffer::FloatProp_value ? + static_cast(offset()) : + nullptr; + } + LottieFlatBuffer::TrimType type() const + { + return static_cast(GetField(VT_TYPE, 0)); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_START_TYPE, 1) && + VerifyOffsetRequired(verifier, VT_START) && VerifyFloatProp(verifier, start(), start_type()) && + VerifyField(verifier, VT_END_TYPE, 1) && VerifyOffsetRequired(verifier, VT_END) && + VerifyFloatProp(verifier, end(), end_type()) && VerifyField(verifier, VT_OFFSET_TYPE, 1) && + VerifyOffsetRequired(verifier, VT_OFFSET) && VerifyFloatProp(verifier, offset(), offset_type()) && + VerifyField(verifier, VT_TYPE, 1) && verifier.EndTable(); + } +}; + +template <> +inline const LottieFlatBuffer::FloatFrameArray *TrimPath::start_as() const +{ + return start_as_frames(); +} + +template <> +inline const LottieFlatBuffer::FloatScalar *TrimPath::start_as() const +{ + return start_as_value(); +} + +template <> +inline const LottieFlatBuffer::FloatFrameArray *TrimPath::end_as() const +{ + return end_as_frames(); +} + +template <> +inline const LottieFlatBuffer::FloatScalar *TrimPath::end_as() const +{ + return end_as_value(); +} + +template <> +inline const LottieFlatBuffer::FloatFrameArray *TrimPath::offset_as() const +{ + return offset_as_frames(); +} + +template <> +inline const LottieFlatBuffer::FloatScalar *TrimPath::offset_as() const +{ + return offset_as_value(); +} + +struct TrimPathBuilder { + typedef TrimPath Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_start_type(LottieFlatBuffer::FloatProp start_type) + { + fbb_.AddElement(TrimPath::VT_START_TYPE, static_cast(start_type), 0); + } + void add_start(::flatbuffers::Offset start) + { + fbb_.AddOffset(TrimPath::VT_START, start); + } + void add_end_type(LottieFlatBuffer::FloatProp end_type) + { + fbb_.AddElement(TrimPath::VT_END_TYPE, static_cast(end_type), 0); + } + void add_end(::flatbuffers::Offset end) + { + fbb_.AddOffset(TrimPath::VT_END, end); + } + void add_offset_type(LottieFlatBuffer::FloatProp offset_type) + { + fbb_.AddElement(TrimPath::VT_OFFSET_TYPE, static_cast(offset_type), 0); + } + void add_offset(::flatbuffers::Offset offset) + { + fbb_.AddOffset(TrimPath::VT_OFFSET, offset); + } + void add_type(LottieFlatBuffer::TrimType type) + { + fbb_.AddElement(TrimPath::VT_TYPE, static_cast(type), 0); + } + explicit TrimPathBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, TrimPath::VT_START); + fbb_.Required(o, TrimPath::VT_END); + fbb_.Required(o, TrimPath::VT_OFFSET); + return o; + } +}; + +inline ::flatbuffers::Offset CreateTrimPath( + ::flatbuffers::FlatBufferBuilder &_fbb, LottieFlatBuffer::FloatProp start_type = LottieFlatBuffer::FloatProp_NONE, + ::flatbuffers::Offset start = 0, LottieFlatBuffer::FloatProp end_type = LottieFlatBuffer::FloatProp_NONE, + ::flatbuffers::Offset end = 0, LottieFlatBuffer::FloatProp offset_type = LottieFlatBuffer::FloatProp_NONE, + ::flatbuffers::Offset offset = 0, LottieFlatBuffer::TrimType type = LottieFlatBuffer::TrimType_Simultaneous) +{ + TrimPathBuilder builder_(_fbb); + builder_.add_offset(offset); + builder_.add_end(end); + builder_.add_start(start); + builder_.add_type(type); + builder_.add_offset_type(offset_type); + builder_.add_end_type(end_type); + builder_.add_start_type(start_type); + return builder_.Finish(); +} + +struct TransformShape FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef TransformShapeBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_TRANSFORM = 4 }; + const LottieFlatBuffer::Transform *transform() const + { + return GetPointer(VT_TRANSFORM); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_TRANSFORM) && + verifier.VerifyTable(transform()) && verifier.EndTable(); + } +}; + +struct TransformShapeBuilder { + typedef TransformShape Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_transform(::flatbuffers::Offset transform) + { + fbb_.AddOffset(TransformShape::VT_TRANSFORM, transform); + } + explicit TransformShapeBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateTransformShape( + ::flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::Offset transform = 0) +{ + TransformShapeBuilder builder_(_fbb); + builder_.add_transform(transform); + return builder_.Finish(); +} + +struct GroupShape FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef GroupShapeBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_SHAPES_TYPE = 4, VT_SHAPES = 6 }; + const ::flatbuffers::Vector *shapes_type() const + { + return GetPointer *>(VT_SHAPES_TYPE); + } + const ::flatbuffers::Vector<::flatbuffers::Offset> *shapes() const + { + return GetPointer> *>(VT_SHAPES); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_SHAPES_TYPE) && + verifier.VerifyVector(shapes_type()) && VerifyOffset(verifier, VT_SHAPES) && + verifier.VerifyVector(shapes()) && VerifyGraphicElementVector(verifier, shapes(), shapes_type()) && + verifier.EndTable(); + } +}; + +struct GroupShapeBuilder { + typedef GroupShape Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_shapes_type(::flatbuffers::Offset<::flatbuffers::Vector> shapes_type) + { + fbb_.AddOffset(GroupShape::VT_SHAPES_TYPE, shapes_type); + } + void add_shapes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> shapes) + { + fbb_.AddOffset(GroupShape::VT_SHAPES, shapes); + } + explicit GroupShapeBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateGroupShape( + ::flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::Offset<::flatbuffers::Vector> shapes_type = 0, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> shapes = 0) +{ + GroupShapeBuilder builder_(_fbb); + builder_.add_shapes(shapes); + builder_.add_shapes_type(shapes_type); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateGroupShapeDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *shapes_type = nullptr, + const std::vector<::flatbuffers::Offset> *shapes = nullptr) +{ + auto shapes_type__ = shapes_type ? _fbb.CreateVector(*shapes_type) : 0; + auto shapes__ = shapes ? _fbb.CreateVector<::flatbuffers::Offset>(*shapes) : 0; + return LottieFlatBuffer::CreateGroupShape(_fbb, shapes_type__, shapes__); +} + +struct BaseLayer FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef BaseLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_IN_FRAME = 4, + VT_OUT_FRAME = 6, + VT_START_FRAME = 8, + VT_INDEX = 10, + VT_PARENT = 12, + VT_NAME = 14, + VT_TRANSFORM = 16, + VT_BLEND_MODE = 18 + }; + float in_frame() const + { + return GetField(VT_IN_FRAME, 0.0f); + } + float out_frame() const + { + return GetField(VT_OUT_FRAME, 0.0f); + } + float start_frame() const + { + return GetField(VT_START_FRAME, 0.0f); + } + int32_t index() const + { + return GetField(VT_INDEX, -1); + } + int32_t parent() const + { + return GetField(VT_PARENT, -1); + } + const ::flatbuffers::String *name() const + { + return GetPointer(VT_NAME); + } + const LottieFlatBuffer::Transform *transform() const + { + return GetPointer(VT_TRANSFORM); + } + LottieFlatBuffer::BlendMode blend_mode() const + { + return static_cast(GetField(VT_BLEND_MODE, 0)); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_IN_FRAME, 4) && + VerifyField(verifier, VT_OUT_FRAME, 4) && VerifyField(verifier, VT_START_FRAME, 4) && + VerifyField(verifier, VT_INDEX, 4) && VerifyField(verifier, VT_PARENT, 4) && + VerifyOffset(verifier, VT_NAME) && verifier.VerifyString(name()) && + VerifyOffset(verifier, VT_TRANSFORM) && verifier.VerifyTable(transform()) && + VerifyField(verifier, VT_BLEND_MODE, 1) && verifier.EndTable(); + } +}; + +struct BaseLayerBuilder { + typedef BaseLayer Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_in_frame(float in_frame) + { + fbb_.AddElement(BaseLayer::VT_IN_FRAME, in_frame, 0.0f); + } + void add_out_frame(float out_frame) + { + fbb_.AddElement(BaseLayer::VT_OUT_FRAME, out_frame, 0.0f); + } + void add_start_frame(float start_frame) + { + fbb_.AddElement(BaseLayer::VT_START_FRAME, start_frame, 0.0f); + } + void add_index(int32_t index) + { + fbb_.AddElement(BaseLayer::VT_INDEX, index, -1); + } + void add_parent(int32_t parent) + { + fbb_.AddElement(BaseLayer::VT_PARENT, parent, -1); + } + void add_name(::flatbuffers::Offset<::flatbuffers::String> name) + { + fbb_.AddOffset(BaseLayer::VT_NAME, name); + } + void add_transform(::flatbuffers::Offset transform) + { + fbb_.AddOffset(BaseLayer::VT_TRANSFORM, transform); + } + void add_blend_mode(LottieFlatBuffer::BlendMode blend_mode) + { + fbb_.AddElement(BaseLayer::VT_BLEND_MODE, static_cast(blend_mode), 0); + } + explicit BaseLayerBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateBaseLayer( + ::flatbuffers::FlatBufferBuilder &_fbb, float in_frame = 0.0f, float out_frame = 0.0f, float start_frame = 0.0f, + int32_t index = -1, int32_t parent = -1, ::flatbuffers::Offset<::flatbuffers::String> name = 0, + ::flatbuffers::Offset transform = 0, + LottieFlatBuffer::BlendMode blend_mode = LottieFlatBuffer::BlendMode_Normal) +{ + BaseLayerBuilder builder_(_fbb); + builder_.add_transform(transform); + builder_.add_name(name); + builder_.add_parent(parent); + builder_.add_index(index); + builder_.add_start_frame(start_frame); + builder_.add_out_frame(out_frame); + builder_.add_in_frame(in_frame); + builder_.add_blend_mode(blend_mode); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateBaseLayerDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, float in_frame = 0.0f, float out_frame = 0.0f, float start_frame = 0.0f, + int32_t index = -1, int32_t parent = -1, const char *name = nullptr, + ::flatbuffers::Offset transform = 0, + LottieFlatBuffer::BlendMode blend_mode = LottieFlatBuffer::BlendMode_Normal) +{ + auto name__ = name ? _fbb.CreateString(name) : 0; + return LottieFlatBuffer::CreateBaseLayer(_fbb, in_frame, out_frame, start_frame, index, parent, name__, transform, + blend_mode); +} + +struct ShapeLayer FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef ShapeLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_BASE = 4, VT_SHAPES_TYPE = 6, VT_SHAPES = 8 }; + const LottieFlatBuffer::BaseLayer *base() const + { + return GetPointer(VT_BASE); + } + const ::flatbuffers::Vector *shapes_type() const + { + return GetPointer *>(VT_SHAPES_TYPE); + } + const ::flatbuffers::Vector<::flatbuffers::Offset> *shapes() const + { + return GetPointer> *>(VT_SHAPES); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_BASE) && verifier.VerifyTable(base()) && + VerifyOffsetRequired(verifier, VT_SHAPES_TYPE) && verifier.VerifyVector(shapes_type()) && + VerifyOffsetRequired(verifier, VT_SHAPES) && verifier.VerifyVector(shapes()) && + VerifyGraphicElementVector(verifier, shapes(), shapes_type()) && verifier.EndTable(); + } +}; + +struct ShapeLayerBuilder { + typedef ShapeLayer Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_base(::flatbuffers::Offset base) + { + fbb_.AddOffset(ShapeLayer::VT_BASE, base); + } + void add_shapes_type(::flatbuffers::Offset<::flatbuffers::Vector> shapes_type) + { + fbb_.AddOffset(ShapeLayer::VT_SHAPES_TYPE, shapes_type); + } + void add_shapes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> shapes) + { + fbb_.AddOffset(ShapeLayer::VT_SHAPES, shapes); + } + explicit ShapeLayerBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, ShapeLayer::VT_SHAPES_TYPE); + fbb_.Required(o, ShapeLayer::VT_SHAPES); + return o; + } +}; + +inline ::flatbuffers::Offset CreateShapeLayer( + ::flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::Offset base = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> shapes_type = 0, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> shapes = 0) +{ + ShapeLayerBuilder builder_(_fbb); + builder_.add_shapes(shapes); + builder_.add_shapes_type(shapes_type); + builder_.add_base(base); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateShapeLayerDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::Offset base = 0, + const std::vector *shapes_type = nullptr, const std::vector<::flatbuffers::Offset> *shapes = nullptr) +{ + auto shapes_type__ = shapes_type ? _fbb.CreateVector(*shapes_type) : 0; + auto shapes__ = shapes ? _fbb.CreateVector<::flatbuffers::Offset>(*shapes) : 0; + return LottieFlatBuffer::CreateShapeLayer(_fbb, base, shapes_type__, shapes__); +} + +struct PrecompositionLayer FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef PrecompositionLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_REF_ID = 6, + VT_WIDTH = 8, + VT_HEIGHT = 10 + }; + const LottieFlatBuffer::BaseLayer *base() const + { + return GetPointer(VT_BASE); + } + const ::flatbuffers::String *ref_id() const + { + return GetPointer(VT_REF_ID); + } + uint16_t width() const + { + return GetField(VT_WIDTH, 0); + } + uint16_t height() const + { + return GetField(VT_HEIGHT, 0); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_BASE) && verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_REF_ID) && verifier.VerifyString(ref_id()) && + VerifyField(verifier, VT_WIDTH, 2) && VerifyField(verifier, VT_HEIGHT, 2) && + verifier.EndTable(); + } +}; + +struct PrecompositionLayerBuilder { + typedef PrecompositionLayer Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_base(::flatbuffers::Offset base) + { + fbb_.AddOffset(PrecompositionLayer::VT_BASE, base); + } + void add_ref_id(::flatbuffers::Offset<::flatbuffers::String> ref_id) + { + fbb_.AddOffset(PrecompositionLayer::VT_REF_ID, ref_id); + } + void add_width(uint16_t width) + { + fbb_.AddElement(PrecompositionLayer::VT_WIDTH, width, 0); + } + void add_height(uint16_t height) + { + fbb_.AddElement(PrecompositionLayer::VT_HEIGHT, height, 0); + } + explicit PrecompositionLayerBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreatePrecompositionLayer( + ::flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::Offset base = 0, + ::flatbuffers::Offset<::flatbuffers::String> ref_id = 0, uint16_t width = 0, uint16_t height = 0) +{ + PrecompositionLayerBuilder builder_(_fbb); + builder_.add_ref_id(ref_id); + builder_.add_base(base); + builder_.add_height(height); + builder_.add_width(width); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreatePrecompositionLayerDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::Offset base = 0, + const char *ref_id = nullptr, uint16_t width = 0, uint16_t height = 0) +{ + auto ref_id__ = ref_id ? _fbb.CreateString(ref_id) : 0; + return LottieFlatBuffer::CreatePrecompositionLayer(_fbb, base, ref_id__, width, height); +} + +struct NullLayer FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef NullLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_BASE = 4 }; + const LottieFlatBuffer::BaseLayer *base() const + { + return GetPointer(VT_BASE); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_BASE) && verifier.VerifyTable(base()) && + verifier.EndTable(); + } +}; + +struct NullLayerBuilder { + typedef NullLayer Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_base(::flatbuffers::Offset base) + { + fbb_.AddOffset(NullLayer::VT_BASE, base); + } + explicit NullLayerBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateNullLayer(::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset base = 0) +{ + NullLayerBuilder builder_(_fbb); + builder_.add_base(base); + return builder_.Finish(); +} + +struct TextDocument FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef TextDocumentBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TEXT = 4, + VT_COLOR = 6, + VT_SIZE = 8, + VT_HEIGHT = 10, + VT_B_BOX = 12, + VT_ALIGN = 14 + }; + const ::flatbuffers::String *text() const + { + return GetPointer(VT_TEXT); + } + const LottieFlatBuffer::Color24 *color() const + { + return GetStruct(VT_COLOR); + } + uint16_t size() const + { + return GetField(VT_SIZE, 0); + } + uint16_t height() const + { + return GetField(VT_HEIGHT, 0); + } + const LottieFlatBuffer::Rect *b_box() const + { + return GetStruct(VT_B_BOX); + } + LottieFlatBuffer::TextAlign align() const + { + return static_cast(GetField(VT_ALIGN, 1)); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_TEXT) && verifier.VerifyString(text()) && + VerifyField(verifier, VT_COLOR, 1) && + VerifyField(verifier, VT_SIZE, 2) && VerifyField(verifier, VT_HEIGHT, 2) && + VerifyField(verifier, VT_B_BOX, 4) && + VerifyField(verifier, VT_ALIGN, 1) && verifier.EndTable(); + } +}; + +struct TextDocumentBuilder { + typedef TextDocument Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_text(::flatbuffers::Offset<::flatbuffers::String> text) + { + fbb_.AddOffset(TextDocument::VT_TEXT, text); + } + void add_color(const LottieFlatBuffer::Color24 *color) + { + fbb_.AddStruct(TextDocument::VT_COLOR, color); + } + void add_size(uint16_t size) + { + fbb_.AddElement(TextDocument::VT_SIZE, size, 0); + } + void add_height(uint16_t height) + { + fbb_.AddElement(TextDocument::VT_HEIGHT, height, 0); + } + void add_b_box(const LottieFlatBuffer::Rect *b_box) + { + fbb_.AddStruct(TextDocument::VT_B_BOX, b_box); + } + void add_align(LottieFlatBuffer::TextAlign align) + { + fbb_.AddElement(TextDocument::VT_ALIGN, static_cast(align), 1); + } + explicit TextDocumentBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateTextDocument( + ::flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::Offset<::flatbuffers::String> text = 0, + const LottieFlatBuffer::Color24 *color = nullptr, uint16_t size = 0, uint16_t height = 0, + const LottieFlatBuffer::Rect *b_box = nullptr, + LottieFlatBuffer::TextAlign align = LottieFlatBuffer::TextAlign_AlignLeft) +{ + TextDocumentBuilder builder_(_fbb); + builder_.add_b_box(b_box); + builder_.add_color(color); + builder_.add_text(text); + builder_.add_height(height); + builder_.add_size(size); + builder_.add_align(align); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateTextDocumentDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const char *text = nullptr, + const LottieFlatBuffer::Color24 *color = nullptr, uint16_t size = 0, uint16_t height = 0, + const LottieFlatBuffer::Rect *b_box = nullptr, + LottieFlatBuffer::TextAlign align = LottieFlatBuffer::TextAlign_AlignLeft) +{ + auto text__ = text ? _fbb.CreateString(text) : 0; + return LottieFlatBuffer::CreateTextDocument(_fbb, text__, color, size, height, b_box, align); +} + +struct TextDocumentFrame FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef TextDocumentFrameBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TIME = 4, + VT_START = 6, + VT_HOLD = 8, + VT_TIME_EASING = 10, + VT_VALUE_EASING = 12 + }; + float time() const + { + return GetField(VT_TIME, 0.0f); + } + const LottieFlatBuffer::TextDocument *start() const + { + return GetPointer(VT_START); + } + bool hold() const + { + return GetField(VT_HOLD, 0) != 0; + } + const ::flatbuffers::Vector *time_easing() const + { + return GetPointer *>(VT_TIME_EASING); + } + const ::flatbuffers::Vector *value_easing() const + { + return GetPointer *>(VT_VALUE_EASING); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyField(verifier, VT_TIME, 4) && + VerifyOffsetRequired(verifier, VT_START) && verifier.VerifyTable(start()) && + VerifyField(verifier, VT_HOLD, 1) && VerifyOffset(verifier, VT_TIME_EASING) && + verifier.VerifyVector(time_easing()) && VerifyOffset(verifier, VT_VALUE_EASING) && + verifier.VerifyVector(value_easing()) && verifier.EndTable(); + } +}; + +struct TextDocumentFrameBuilder { + typedef TextDocumentFrame Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_time(float time) + { + fbb_.AddElement(TextDocumentFrame::VT_TIME, time, 0.0f); + } + void add_start(::flatbuffers::Offset start) + { + fbb_.AddOffset(TextDocumentFrame::VT_START, start); + } + void add_hold(bool hold) + { + fbb_.AddElement(TextDocumentFrame::VT_HOLD, static_cast(hold), 0); + } + void add_time_easing(::flatbuffers::Offset<::flatbuffers::Vector> time_easing) + { + fbb_.AddOffset(TextDocumentFrame::VT_TIME_EASING, time_easing); + } + void add_value_easing(::flatbuffers::Offset<::flatbuffers::Vector> value_easing) + { + fbb_.AddOffset(TextDocumentFrame::VT_VALUE_EASING, value_easing); + } + explicit TextDocumentFrameBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, TextDocumentFrame::VT_START); + return o; + } +}; + +inline ::flatbuffers::Offset CreateTextDocumentFrame( + ::flatbuffers::FlatBufferBuilder &_fbb, float time = 0.0f, + ::flatbuffers::Offset start = 0, bool hold = false, + ::flatbuffers::Offset<::flatbuffers::Vector> time_easing = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> value_easing = 0) +{ + TextDocumentFrameBuilder builder_(_fbb); + builder_.add_value_easing(value_easing); + builder_.add_time_easing(time_easing); + builder_.add_start(start); + builder_.add_time(time); + builder_.add_hold(hold); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateTextDocumentFrameDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, float time = 0.0f, + ::flatbuffers::Offset start = 0, bool hold = false, + const std::vector *time_easing = nullptr, + const std::vector *value_easing = nullptr) +{ + auto time_easing__ = time_easing ? _fbb.CreateVectorOfStructs(*time_easing) : 0; + auto value_easing__ = value_easing ? _fbb.CreateVectorOfStructs(*value_easing) : 0; + return LottieFlatBuffer::CreateTextDocumentFrame(_fbb, time, start, hold, time_easing__, value_easing__); +} + +struct TextData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef TextDataBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_FRAMES = 4 }; + const ::flatbuffers::Vector<::flatbuffers::Offset> *frames() const + { + return GetPointer> *>( + VT_FRAMES); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_FRAMES) && + verifier.VerifyVector(frames()) && verifier.VerifyVectorOfTables(frames()) && verifier.EndTable(); + } +}; + +struct TextDataBuilder { + typedef TextData Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_frames( + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> frames) + { + fbb_.AddOffset(TextData::VT_FRAMES, frames); + } + explicit TextDataBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, TextData::VT_FRAMES); + return o; + } +}; + +inline ::flatbuffers::Offset CreateTextData( + ::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> frames = 0) +{ + TextDataBuilder builder_(_fbb); + builder_.add_frames(frames); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateTextDataDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<::flatbuffers::Offset> *frames = nullptr) +{ + auto frames__ = frames ? _fbb.CreateVector<::flatbuffers::Offset>(*frames) : 0; + return LottieFlatBuffer::CreateTextData(_fbb, frames__); +} + +struct TextLayer FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef TextLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_BASE = 4, VT_DATA = 6 }; + const LottieFlatBuffer::BaseLayer *base() const + { + return GetPointer(VT_BASE); + } + const LottieFlatBuffer::TextData *data() const + { + return GetPointer(VT_DATA); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_BASE) && verifier.VerifyTable(base()) && + VerifyOffset(verifier, VT_DATA) && verifier.VerifyTable(data()) && verifier.EndTable(); + } +}; + +struct TextLayerBuilder { + typedef TextLayer Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_base(::flatbuffers::Offset base) + { + fbb_.AddOffset(TextLayer::VT_BASE, base); + } + void add_data(::flatbuffers::Offset data) + { + fbb_.AddOffset(TextLayer::VT_DATA, data); + } + explicit TextLayerBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateTextLayer(::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset base = 0, + ::flatbuffers::Offset data = 0) +{ + TextLayerBuilder builder_(_fbb); + builder_.add_data(data); + builder_.add_base(base); + return builder_.Finish(); +} + +struct ImageLayer FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef ImageLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_BASE = 4, VT_INDEX = 6 }; + const LottieFlatBuffer::BaseLayer *base() const + { + return GetPointer(VT_BASE); + } + int32_t index() const + { + return GetField(VT_INDEX, 0); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_BASE) && verifier.VerifyTable(base()) && + VerifyField(verifier, VT_INDEX, 4) && verifier.EndTable(); + } +}; + +struct ImageLayerBuilder { + typedef ImageLayer Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_base(::flatbuffers::Offset base) + { + fbb_.AddOffset(ImageLayer::VT_BASE, base); + } + void add_index(int32_t index) + { + fbb_.AddElement(ImageLayer::VT_INDEX, index, 0); + } + explicit ImageLayerBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateImageLayer(::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset base = 0, + int32_t index = 0) +{ + ImageLayerBuilder builder_(_fbb); + builder_.add_index(index); + builder_.add_base(base); + return builder_.Finish(); +} + +struct SolidLayer FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef SolidLayerBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BASE = 4, + VT_WIDTH = 6, + VT_HEIGHT = 8, + VT_COLOR = 10 + }; + const LottieFlatBuffer::BaseLayer *base() const + { + return GetPointer(VT_BASE); + } + uint16_t width() const + { + return GetField(VT_WIDTH, 0); + } + uint16_t height() const + { + return GetField(VT_HEIGHT, 0); + } + const LottieFlatBuffer::Color24 *color() const + { + return GetStruct(VT_COLOR); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_BASE) && verifier.VerifyTable(base()) && + VerifyField(verifier, VT_WIDTH, 2) && VerifyField(verifier, VT_HEIGHT, 2) && + VerifyField(verifier, VT_COLOR, 1) && verifier.EndTable(); + } +}; + +struct SolidLayerBuilder { + typedef SolidLayer Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_base(::flatbuffers::Offset base) + { + fbb_.AddOffset(SolidLayer::VT_BASE, base); + } + void add_width(uint16_t width) + { + fbb_.AddElement(SolidLayer::VT_WIDTH, width, 0); + } + void add_height(uint16_t height) + { + fbb_.AddElement(SolidLayer::VT_HEIGHT, height, 0); + } + void add_color(const LottieFlatBuffer::Color24 *color) + { + fbb_.AddStruct(SolidLayer::VT_COLOR, color); + } + explicit SolidLayerBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateSolidLayer(::flatbuffers::FlatBufferBuilder &_fbb, + ::flatbuffers::Offset base = 0, + uint16_t width = 0, uint16_t height = 0, + const LottieFlatBuffer::Color24 *color = nullptr) +{ + SolidLayerBuilder builder_(_fbb); + builder_.add_color(color); + builder_.add_base(base); + builder_.add_height(height); + builder_.add_width(width); + return builder_.Finish(); +} + +struct Asset FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef AssetBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_ID = 4, VT_LAYERS_TYPE = 6, VT_LAYERS = 8 }; + const ::flatbuffers::String *id() const + { + return GetPointer(VT_ID); + } + const ::flatbuffers::Vector *layers_type() const + { + return GetPointer *>(VT_LAYERS_TYPE); + } + const ::flatbuffers::Vector<::flatbuffers::Offset> *layers() const + { + return GetPointer> *>(VT_LAYERS); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_ID) && verifier.VerifyString(id()) && + VerifyOffset(verifier, VT_LAYERS_TYPE) && verifier.VerifyVector(layers_type()) && + VerifyOffset(verifier, VT_LAYERS) && verifier.VerifyVector(layers()) && + VerifyLayerVector(verifier, layers(), layers_type()) && verifier.EndTable(); + } +}; + +struct AssetBuilder { + typedef Asset Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_id(::flatbuffers::Offset<::flatbuffers::String> id) + { + fbb_.AddOffset(Asset::VT_ID, id); + } + void add_layers_type(::flatbuffers::Offset<::flatbuffers::Vector> layers_type) + { + fbb_.AddOffset(Asset::VT_LAYERS_TYPE, layers_type); + } + void add_layers(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> layers) + { + fbb_.AddOffset(Asset::VT_LAYERS, layers); + } + explicit AssetBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateAsset( + ::flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::Offset<::flatbuffers::String> id = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> layers_type = 0, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> layers = 0) +{ + AssetBuilder builder_(_fbb); + builder_.add_layers(layers); + builder_.add_layers_type(layers_type); + builder_.add_id(id); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateAssetDirect(::flatbuffers::FlatBufferBuilder &_fbb, const char *id = nullptr, + const std::vector *layers_type = nullptr, + const std::vector<::flatbuffers::Offset> *layers = nullptr) +{ + auto id__ = id ? _fbb.CreateString(id) : 0; + auto layers_type__ = layers_type ? _fbb.CreateVector(*layers_type) : 0; + auto layers__ = layers ? _fbb.CreateVector<::flatbuffers::Offset>(*layers) : 0; + return LottieFlatBuffer::CreateAsset(_fbb, id__, layers_type__, layers__); +} + +struct Animations FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef AnimationsBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VERSION = 4, + VT_LAYERS_TYPE = 6, + VT_LAYERS = 8, + VT_FRAME_RATE = 10, + VT_START_FRAME = 12, + VT_END_FRAME = 14, + VT_WIDTH = 16, + VT_HEIGHT = 18, + VT_ASSETS = 20 + }; + const ::flatbuffers::String *version() const + { + return GetPointer(VT_VERSION); + } + const ::flatbuffers::Vector *layers_type() const + { + return GetPointer *>(VT_LAYERS_TYPE); + } + const ::flatbuffers::Vector<::flatbuffers::Offset> *layers() const + { + return GetPointer> *>(VT_LAYERS); + } + float frame_rate() const + { + return GetField(VT_FRAME_RATE, 0.0f); + } + float start_frame() const + { + return GetField(VT_START_FRAME, 0.0f); + } + float end_frame() const + { + return GetField(VT_END_FRAME, 0.0f); + } + float width() const + { + return GetField(VT_WIDTH, 0.0f); + } + float height() const + { + return GetField(VT_HEIGHT, 0.0f); + } + const ::flatbuffers::Vector<::flatbuffers::Offset> *assets() const + { + return GetPointer> *>(VT_ASSETS); + } + bool Verify(::flatbuffers::Verifier &verifier) const + { + return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_VERSION) && verifier.VerifyString(version()) && + VerifyOffsetRequired(verifier, VT_LAYERS_TYPE) && verifier.VerifyVector(layers_type()) && + VerifyOffsetRequired(verifier, VT_LAYERS) && verifier.VerifyVector(layers()) && + VerifyLayerVector(verifier, layers(), layers_type()) && VerifyField(verifier, VT_FRAME_RATE, 4) && + VerifyField(verifier, VT_START_FRAME, 4) && VerifyField(verifier, VT_END_FRAME, 4) && + VerifyField(verifier, VT_WIDTH, 4) && VerifyField(verifier, VT_HEIGHT, 4) && + VerifyOffset(verifier, VT_ASSETS) && verifier.VerifyVector(assets()) && + verifier.VerifyVectorOfTables(assets()) && verifier.EndTable(); + } +}; + +struct AnimationsBuilder { + typedef Animations Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_version(::flatbuffers::Offset<::flatbuffers::String> version) + { + fbb_.AddOffset(Animations::VT_VERSION, version); + } + void add_layers_type(::flatbuffers::Offset<::flatbuffers::Vector> layers_type) + { + fbb_.AddOffset(Animations::VT_LAYERS_TYPE, layers_type); + } + void add_layers(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> layers) + { + fbb_.AddOffset(Animations::VT_LAYERS, layers); + } + void add_frame_rate(float frame_rate) + { + fbb_.AddElement(Animations::VT_FRAME_RATE, frame_rate, 0.0f); + } + void add_start_frame(float start_frame) + { + fbb_.AddElement(Animations::VT_START_FRAME, start_frame, 0.0f); + } + void add_end_frame(float end_frame) + { + fbb_.AddElement(Animations::VT_END_FRAME, end_frame, 0.0f); + } + void add_width(float width) + { + fbb_.AddElement(Animations::VT_WIDTH, width, 0.0f); + } + void add_height(float height) + { + fbb_.AddElement(Animations::VT_HEIGHT, height, 0.0f); + } + void add_assets(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> assets) + { + fbb_.AddOffset(Animations::VT_ASSETS, assets); + } + explicit AnimationsBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) + { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() + { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + fbb_.Required(o, Animations::VT_LAYERS_TYPE); + fbb_.Required(o, Animations::VT_LAYERS); + return o; + } +}; + +inline ::flatbuffers::Offset CreateAnimations( + ::flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::Offset<::flatbuffers::String> version = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> layers_type = 0, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> layers = 0, float frame_rate = 0.0f, + float start_frame = 0.0f, float end_frame = 0.0f, float width = 0.0f, float height = 0.0f, + ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> assets = 0) +{ + AnimationsBuilder builder_(_fbb); + builder_.add_assets(assets); + builder_.add_height(height); + builder_.add_width(width); + builder_.add_end_frame(end_frame); + builder_.add_start_frame(start_frame); + builder_.add_frame_rate(frame_rate); + builder_.add_layers(layers); + builder_.add_layers_type(layers_type); + builder_.add_version(version); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateAnimationsDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, const char *version = nullptr, + const std::vector *layers_type = nullptr, const std::vector<::flatbuffers::Offset> *layers = nullptr, + float frame_rate = 0.0f, float start_frame = 0.0f, float end_frame = 0.0f, float width = 0.0f, float height = 0.0f, + const std::vector<::flatbuffers::Offset> *assets = nullptr) +{ + auto version__ = version ? _fbb.CreateString(version) : 0; + auto layers_type__ = layers_type ? _fbb.CreateVector(*layers_type) : 0; + auto layers__ = layers ? _fbb.CreateVector<::flatbuffers::Offset>(*layers) : 0; + auto assets__ = assets ? _fbb.CreateVector<::flatbuffers::Offset>(*assets) : 0; + return LottieFlatBuffer::CreateAnimations(_fbb, version__, layers_type__, layers__, frame_rate, start_frame, + end_frame, width, height, assets__); +} + +inline bool VerifyFloatProp(::flatbuffers::Verifier &verifier, const void *obj, FloatProp type) +{ + switch (type) { + case FloatProp_NONE: { + return true; + } + case FloatProp_frames: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case FloatProp_value: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: + return true; + } +} + +inline bool VerifyFloatPropVector(::flatbuffers::Verifier &verifier, + const ::flatbuffers::Vector<::flatbuffers::Offset> *values, + const ::flatbuffers::Vector *types) +{ + if (!values || !types) + return !values && !types; + if (values->size() != types->size()) + return false; + for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyFloatProp(verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline bool VerifyIntegerProp(::flatbuffers::Verifier &verifier, const void *obj, IntegerProp type) +{ + switch (type) { + case IntegerProp_NONE: { + return true; + } + case IntegerProp_frames: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case IntegerProp_value: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: + return true; + } +} + +inline bool VerifyIntegerPropVector(::flatbuffers::Verifier &verifier, + const ::flatbuffers::Vector<::flatbuffers::Offset> *values, + const ::flatbuffers::Vector *types) +{ + if (!values || !types) + return !values && !types; + if (values->size() != types->size()) + return false; + for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyIntegerProp(verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline bool VerifyVectorProp(::flatbuffers::Verifier &verifier, const void *obj, VectorProp type) +{ + switch (type) { + case VectorProp_NONE: { + return true; + } + case VectorProp_frames: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case VectorProp_value: { + return verifier.VerifyField(static_cast(obj), 0, 4); + } + default: + return true; + } +} + +inline bool VerifyVectorPropVector(::flatbuffers::Verifier &verifier, + const ::flatbuffers::Vector<::flatbuffers::Offset> *values, + const ::flatbuffers::Vector *types) +{ + if (!values || !types) + return !values && !types; + if (values->size() != types->size()) + return false; + for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyVectorProp(verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline bool VerifyColorProp(::flatbuffers::Verifier &verifier, const void *obj, ColorProp type) +{ + switch (type) { + case ColorProp_NONE: { + return true; + } + case ColorProp_frames: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case ColorProp_color: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: + return true; + } +} + +inline bool VerifyColorPropVector(::flatbuffers::Verifier &verifier, + const ::flatbuffers::Vector<::flatbuffers::Offset> *values, + const ::flatbuffers::Vector *types) +{ + if (!values || !types) + return !values && !types; + if (values->size() != types->size()) + return false; + for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyColorProp(verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline bool VerifyGradientProp(::flatbuffers::Verifier &verifier, const void *obj, GradientProp type) +{ + switch (type) { + case GradientProp_NONE: { + return true; + } + case GradientProp_frames: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case GradientProp_value: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: + return true; + } +} + +inline bool VerifyGradientPropVector(::flatbuffers::Verifier &verifier, + const ::flatbuffers::Vector<::flatbuffers::Offset> *values, + const ::flatbuffers::Vector *types) +{ + if (!values || !types) + return !values && !types; + if (values->size() != types->size()) + return false; + for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyGradientProp(verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline bool VerifyBezierDataProp(::flatbuffers::Verifier &verifier, const void *obj, BezierDataProp type) +{ + switch (type) { + case BezierDataProp_NONE: { + return true; + } + case BezierDataProp_frames: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case BezierDataProp_value: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: + return true; + } +} + +inline bool VerifyBezierDataPropVector(::flatbuffers::Verifier &verifier, + const ::flatbuffers::Vector<::flatbuffers::Offset> *values, + const ::flatbuffers::Vector *types) +{ + if (!values || !types) + return !values && !types; + if (values->size() != types->size()) + return false; + for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyBezierDataProp(verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline bool VerifyPositionProp(::flatbuffers::Verifier &verifier, const void *obj, PositionProp type) +{ + switch (type) { + case PositionProp_NONE: { + return true; + } + case PositionProp_frames: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case PositionProp_value: { + return verifier.VerifyField(static_cast(obj), 0, 4); + } + default: + return true; + } +} + +inline bool VerifyPositionPropVector(::flatbuffers::Verifier &verifier, + const ::flatbuffers::Vector<::flatbuffers::Offset> *values, + const ::flatbuffers::Vector *types) +{ + if (!values || !types) + return !values && !types; + if (values->size() != types->size()) + return false; + for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyPositionProp(verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline bool VerifyGraphicElement(::flatbuffers::Verifier &verifier, const void *obj, GraphicElement type) +{ + switch (type) { + case GraphicElement_NONE: { + return true; + } + case GraphicElement_EllipseShape: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case GraphicElement_RectShape: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case GraphicElement_PathShape: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case GraphicElement_FillStyle: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case GraphicElement_StrokeStyle: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case GraphicElement_GradientFillStyle: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case GraphicElement_GradientStrokeStyle: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case GraphicElement_TransformShape: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case GraphicElement_TrimPath: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case GraphicElement_GroupShape: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: + return true; + } +} + +inline bool VerifyGraphicElementVector(::flatbuffers::Verifier &verifier, + const ::flatbuffers::Vector<::flatbuffers::Offset> *values, + const ::flatbuffers::Vector *types) +{ + if (!values || !types) + return !values && !types; + if (values->size() != types->size()) + return false; + for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyGraphicElement(verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline bool VerifyLayer(::flatbuffers::Verifier &verifier, const void *obj, Layer type) +{ + switch (type) { + case Layer_NONE: { + return true; + } + case Layer_PrecompositionLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_SolidLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_ImageLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_NullLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_ShapeLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Layer_TextLayer: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: + return true; + } +} + +inline bool VerifyLayerVector(::flatbuffers::Verifier &verifier, + const ::flatbuffers::Vector<::flatbuffers::Offset> *values, + const ::flatbuffers::Vector *types) +{ + if (!values || !types) + return !values && !types; + if (values->size() != types->size()) + return false; + for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyLayer(verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline const LottieFlatBuffer::Animations *GetAnimations(const void *buf) +{ + return ::flatbuffers::GetRoot(buf); +} + +inline const LottieFlatBuffer::Animations *GetSizePrefixedAnimations(const void *buf) +{ + return ::flatbuffers::GetSizePrefixedRoot(buf); +} + +inline bool VerifyAnimationsBuffer(::flatbuffers::Verifier &verifier) +{ + return verifier.VerifyBuffer(nullptr); +} + +inline bool VerifySizePrefixedAnimationsBuffer(::flatbuffers::Verifier &verifier) +{ + return verifier.VerifySizePrefixedBuffer(nullptr); +} + +inline void FinishAnimationsBuffer(::flatbuffers::FlatBufferBuilder &fbb, + ::flatbuffers::Offset root) +{ + fbb.Finish(root); +} + +inline void FinishSizePrefixedAnimationsBuffer(::flatbuffers::FlatBufferBuilder &fbb, + ::flatbuffers::Offset root) +{ + fbb.FinishSizePrefixed(root); +} + +} // namespace LottieFlatBuffer + +#endif // LOTT_FLATBUFFER_H diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_image_layer.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_image_layer.h new file mode 100644 index 000000000..8d9f585e9 --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_image_layer.h @@ -0,0 +1,31 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025. All rights reserved. + * Description: Lottie + * Author: Hisi Graphic Team + * Created: 2025-6 + */ + +#ifndef LOTT_IMAGE_LAYER_H +#define LOTT_IMAGE_LAYER_H + +#include "lottie/lott_layer.h" +#include "gfx_utils/image_info.h" + +namespace OHOS { + +class LottImageLayer : public LottLayer { +public: + LottImageLayer(); + virtual ~LottImageLayer(); + + bool UpdateLottLayer(float frameNo) override; + void DrawLottLayer(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea, + const Matrix3& matrix, uint8_t opa) override; + + uint32_t resId_ = 0; + uint32_t offset_ = 0; + std::string filePath_; + ImageInfo* imgInfo_ = nullptr; +}; +} +#endif // LOTT_IMAGE_LAYER_H \ No newline at end of file diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_interpolator.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_interpolator.h new file mode 100644 index 000000000..8efd4b966 --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_interpolator.h @@ -0,0 +1,56 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025-2025. All rights reserved. + * Description: LottInterpolator + * Author: Hisi Graphic Team + * Created: 2025-5 + */ + +#ifndef LOTT_INTERPOLATOR_H +#define LOTT_INTERPOLATOR_H + +#include +#include "gfx_utils/graphic_math.h" +#include "gfx_utils/heap_base.h" +#include "gfx_utils/vector.h" +#include "lottie/lott_math.h" + +namespace OHOS { + +static constexpr int32_t SPLINE_TABLE_SIZE = 11; +static constexpr float NEWTON_MIN_SLOPE = 0.02f; +static constexpr int32_t NEWTON_ITERATIONS = 4; +static constexpr float SUBDIVISION_PRECISION = 0.0000001f; +static constexpr int32_t SUBDIVISION_MAX_ITERATIONS = 10; + +class LottInterpolator : public HeapBase { +public: + LottInterpolator() {} + float Progress(float time); + void SetTangent(Vector2& inTangent, Vector2& outTangent); + + Vector2 inTangent; + Vector2 outTangent; + +private: + static constexpr float SAMPLE_STEP_SIZE = 1.0f / float(SPLINE_TABLE_SIZE - 1); + float samples[SPLINE_TABLE_SIZE]; + + float GetTForX(float aX); + float BinarySubdivide(float aX, float aA, float aB); + float NewtonRaphsonIterate(float aX, float aGuessT); +}; + +class LottInterpolatorFactory : public HeapBase { +public: + LottInterpolatorFactory() {} + static LottInterpolatorFactory& GetInstance(void); + LottInterpolator* GetInterpolator(Vector2& in, Vector2& out); + void ClearAll(); + + Graphic::Vector interpolators_; +}; + +} + +#endif // LOTT_INTERPOLATOR_H + diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_layer.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_layer.h new file mode 100644 index 000000000..f1e98ff11 --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_layer.h @@ -0,0 +1,62 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025. All rights reserved. + * Description: Lottie + * Author: Hisi Graphic Team + * Created: 2025-6 + */ + +#ifndef LOTT_LAYER_H +#define LOTT_LAYER_H + +#include +#include "lottie/lott_paint.h" +#include "lottie/lott_property.h" +#include "lottie/lott_transform.h" +#include "engines/gfx/gfx_engine_manager.h" +#include "gfx_utils/rect.h" +#include "gfx_utils/graphic_buffer.h" + +namespace OHOS { +enum class LottLayerType { + PRECOMP_LAYER = 0, + SOLID_LAYER, + IMAGE_LAYER, + NULL_LAYER, + SHAPE_LAYER, + TEXT_LAYER, +}; + +class LottLayer : public HeapBase { +public: + LottLayer(); + virtual ~LottLayer(); + + virtual bool UpdateLottLayer(float frameNo); + virtual void DrawLottLayer(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea, + const Matrix3& matrix, uint8_t opa) {}; + LottLayerType GetType(); + + float width_ = 0.0f; + float height_ = 0.0f; + float inFrame_ = 0.0f; + float outFrame_ = 0.0f; + float startFrame_ = 0.0f; + int16_t id_ = -1; + int16_t pId_ = -1; + LottLayer* parent_ = nullptr; + + uint8_t opa_ = LOTT_OPA_MAX; + Matrix3 matrix_; + + std::string name_; + BlendMode blendMode_ = BlendMode::BLEND_MODE; + LottTransform* transform_ = nullptr; + +protected: + void ResetUpdateState(); + bool isUpdated_ = false; + bool isValidFrame_ = false; + LottLayerType type_ = LottLayerType::NULL_LAYER; +}; +} +#endif // LOTT_LAYER_H \ No newline at end of file diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_math.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_math.h new file mode 100644 index 000000000..fea0746da --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_math.h @@ -0,0 +1,118 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025-2025. All rights reserved. + * Description: Graphic Math Ext + * Author: Hisi Graphic Team + * Created: 2025-5 + */ + +#ifndef GRAPHIC_MATH_EXT_H +#define GRAPHIC_MATH_EXT_H + +#include +#include +#include "gfx_utils/heap_base.h" +#include "gfx_utils/graphic_math.h" + +namespace OHOS { + +static constexpr float MATH_PI = 3.14159265358979323846f; +static constexpr float BEZIER_EPSILON = 1e-2f; +static constexpr float ANT2_COEFF1 = -0.0464964749f; +static constexpr float ANT2_COEFF2 = 0.15931422f; +static constexpr float ANT2_COEFF3 = 0.327622764f; +static constexpr float ANT2_COEFF4 = 1.57079637f; +static constexpr float ANT2_COEFF5 = 3.14159274f; +static constexpr float CONST_COEFF_1 = 1.0f; +static constexpr float CONST_COEFF_2 = 2.0f; +static constexpr float CONST_COEFF_3 = 3.0f; +static constexpr float CONST_COEFF_6 = 6.0f; +static constexpr float RED2DEG_COEFF = 180.0f; + +class Bezier : public HeapBase { +public: + Bezier() {} + Bezier(Vector2 start, Vector2 ctrl1, Vector2 ctrl2, Vector2 end); + void Split(float t, Bezier& left); + void Split(Bezier& left, Bezier& right) const; + void Split(float at, Bezier& left, Bezier& right) const; + float Length() const; + float LengthApprox() const; + float At(float at, float length) const; + float AtApprox(float at, float length) const; + Vector2 At(float t) const; + float Angle(float t) const; + + Vector2 start_; + Vector2 ctrl1_; + Vector2 ctrl2_; + Vector2 end_; +}; + +template +inline T Lerp(const T &start, const T &end, float t) +{ + return static_cast(start + (end - start) * t); +} + +template +uint32_t Bsearch(T* frames, float frameNo) +{ + int32_t low = 0; + int32_t high = int32_t(frames->Size()) - 1; + + while (low <= high) { + auto mid = low + (high - low) / 2; + auto frame = frames->Begin()[mid]; + if (frameNo < frame->time) high = mid - 1; + else low = mid + 1; + } + if (high < low) low = high; + if (low < 0) low = 0; + return low; +} + +inline float ConstA(float aA1, float aA2) +{ + return CONST_COEFF_1 - CONST_COEFF_3 * aA2 + CONST_COEFF_3 * aA1; +} +inline float ConstB(float aA1, float aA2) +{ + return CONST_COEFF_3 * aA2 - CONST_COEFF_6 * aA1; +} +inline float ConstC(float aA1) +{ + return CONST_COEFF_3 * aA1; +} + +inline float GetSlope(float t, float aA1, float aA2) +{ + return CONST_COEFF_3 * ConstA(aA1, aA2) * t * t + CONST_COEFF_2 * ConstB(aA1, aA2) * t + ConstC(aA1); +} + +inline float CalcBezier(float t, float aA1, float aA2) +{ + return ((ConstA(aA1, aA2) * t + ConstB(aA1, aA2)) * t + ConstC(aA1)) * t; +} + +inline float Rad2deg(float radian) +{ + return radian * (RED2DEG_COEFF / MATH_PI); +} + +inline float Atan2(float y, float x) +{ + if (y == 0.0f && x == 0.0f) return 0.0f; + auto a = std::min(fabsf(x), fabsf(y)) / std::max(fabsf(x), fabsf(y)); + auto s = a * a; + auto r = ((ANT2_COEFF1 * s + ANT2_COEFF2) * s - ANT2_COEFF3) * s * a + a; + if (fabsf(y) > fabsf(x)) r = ANT2_COEFF4 - r; + if (x < 0) r = ANT2_COEFF5 - r; + if (y < 0) return -r; + return r; +} + +} // namespace OHOS +#endif // GRAPHIC_MATH_EXT_H +/** + * @} + */ diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_null_layer.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_null_layer.h new file mode 100644 index 000000000..2c1af5147 --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_null_layer.h @@ -0,0 +1,23 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025. All rights reserved. + * Description: Lottie + * Author: Hisi Graphic Team + * Created: 2025-6 + */ + +#ifndef LOTT_NULL_LAYER_H +#define LOTT_NULL_LAYER_H + +#include "lottie/lott_layer.h" + +namespace OHOS { + +class LottNullLayer : public LottLayer { +public: + LottNullLayer() + { + type_ = LottLayerType::NULL_LAYER; + } +}; +} +#endif // LOTT_NULL_LAYER_H \ No newline at end of file diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_paint.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_paint.h new file mode 100644 index 000000000..f552c0971 --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_paint.h @@ -0,0 +1,348 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025. All rights reserved. + * Description: Lottie + * Author: Hisi Graphic Team + * Created: 2025-6 + */ + +#ifndef LOTT_PAINT_H +#define LOTT_PAINT_H + +#include "components/ui_view.h" +#include "common/graphic_hardware_types.h" +#include "gfx_utils/style.h" +#include "gfx_utils/heap_base.h" +#include "lottie/lott_property.h" +#include "hals/gralloc_engines.h" + +namespace OHOS { +const uint8_t LOTT_OPA_MAX = 100; // lott opa range is [0, 100] +const float LOTT_OPA_PCT_MULTIPLIER = 0.01f; + +class LottGradient : public HeapBase { +public: + GradientSpread spread_; + LottVectorProp start_; + LottVectorProp end_; + LottFloatProp height_; + LottFloatProp angle_; + LottIntegerProp opa_; + LottColorStopsProp stops_; + GradientType type_; // only support linear and radial + + void Update(float frameNo); +}; + +class LottFill : public HeapBase { +public: + LottFill(); + virtual ~LottFill(); + + LottIntegerProp opa_; + LottColorProp color_; + FillRule fillRule_; + LottGradient* gradient_ = nullptr; + + void Update(float frameNo); +}; + +class LottStroke : public HeapBase { +public: + LottStroke(); + virtual ~LottStroke(); + + LottIntegerProp opa_; + LottColorProp color_; + LottFloatProp width_; + float miterLimit_; + JoinType join_; + CapType cap_; + LottGradient* gradient_ = nullptr; + + void Update(float frameNo); +}; + +class LottPaint : public HeapBase { +public: + LottPaint(); + virtual ~LottPaint(); + void Update(float frameNo); + + LottFill* fill_ = nullptr; + LottStroke* stroke_ = nullptr; +}; + +struct LottGradientValue { + float startX; + float startY; + float endX; + float endY; + float height; + float angle; + ColorStop* stops = nullptr; + uint16_t stopNum; + GradientType type; + + ~LottGradientValue() + { + if (stops != nullptr) { + UIFree(stops); + } + } +}; + +struct LottFillValue { + uint32_t color; + FillRule fillRule; + LottGradientValue* gradient = nullptr; + + ~LottFillValue() + { + if (gradient != nullptr) { + delete gradient; + } + } +}; + +struct LottStrokeValue { + uint32_t color; + float width; + float miterLimit; + JoinType join; + CapType cap; + LottGradientValue* gradient = nullptr; + + ~LottStrokeValue() + { + if (gradient != nullptr) { + delete gradient; + } + } +}; + +struct LottPaintValue { + LottFillValue* fill = nullptr; + LottStrokeValue* stroke = nullptr; + + ~LottPaintValue() + { + if (fill != nullptr) { + delete fill; + } + + if (stroke != nullptr) { + delete stroke; + } + } + + uint32_t GetMixedColor(uint32_t color, uint8_t opa) + { + const uint8_t alphaShift = 24; // 24: alpha shift + uint8_t alpha = (color >> alphaShift) * (opa * LOTT_OPA_PCT_MULTIPLIER); + uint32_t mixedColor = (alpha << alphaShift) | (color & 0x00FFFFFF); + return mixedColor; + } + + void ConvertGradient(LottGradientValue* value, LottGradient* gradient, uint8_t opa) + { + value->startX = gradient->start_.value_.x_; + value->startY = gradient->start_.value_.y_; + value->endX = gradient->end_.value_.x_; + value->endY = gradient->end_.value_.y_; + value->height = gradient->height_.value_; + value->angle = gradient->angle_.value_; + + if (gradient->stops_.value_.Size() == 0) { + return; + } + + Graphic::Vector* colorStops = &gradient->stops_.value_; + + if (value->stops != nullptr && value->stopNum != colorStops->Size()) { + UIFree(value->stops); + value->stops = nullptr; + value->stopNum = 0; + } + + uint32_t size = sizeof(ColorStop) * colorStops->Size(); + if (value->stops == nullptr) { + value->stops = static_cast(UIMalloc(size)); + if (value->stops == nullptr) { + return; + } + } + + memcpy_s(value->stops, size, colorStops->Begin(), size); + value->stopNum = colorStops->Size(); + + for (uint32_t i = 0; i < value->stopNum; i++) { + value->stops[i].color = GetMixedColor(value->stops[i].color, opa); + } + value->type = gradient->type_; + } + + bool FillValue(LottFill* lottFill, uint8_t opa) + { + if (lottFill == nullptr) { + return false; + } + + if (fill == nullptr) { + fill = new LottFillValue; + if (fill == nullptr) { + return false; + } + fill->gradient = nullptr; + } + + uint8_t lottOpa = lottFill->opa_.value_ * opa * LOTT_OPA_PCT_MULTIPLIER; + fill->color = GetMixedColor(lottFill->color_.value_.full, lottOpa); + fill->fillRule = lottFill->fillRule_; + + if (lottFill->gradient_ != nullptr) { + if (fill->gradient == nullptr) { + fill->gradient = new LottGradientValue; + if (fill->gradient == nullptr) { + delete fill; + fill = nullptr; + return false; + } + fill->gradient->stops = nullptr; + fill->gradient->stopNum = 0; + } + ConvertGradient(fill->gradient, lottFill->gradient_, opa); + } + return true; + } + + bool StrokeValue(LottStroke* lottStroke, uint8_t opa) + { + if (lottStroke == nullptr) { + return false; + } + + if (stroke == nullptr) { + stroke = new LottStrokeValue; + if (stroke == nullptr) { + return false; + } + stroke->gradient = nullptr; + } + + uint8_t lottOpa = lottStroke->opa_.value_ * opa * LOTT_OPA_PCT_MULTIPLIER; + stroke->color = GetMixedColor(lottStroke->color_.value_.full, lottOpa); + stroke->width = lottStroke->width_.value_; + stroke->miterLimit = lottStroke->miterLimit_; + stroke->join = lottStroke->join_; + stroke->cap = lottStroke->cap_; + + if (lottStroke->gradient_ != nullptr) { + if (stroke->gradient == nullptr) { + stroke->gradient = new LottGradientValue; + if (stroke->gradient == nullptr) { + delete stroke; + stroke = nullptr; + return false; + } + stroke->gradient->stops = nullptr; + stroke->gradient->stopNum = 0; + } + ConvertGradient(stroke->gradient, lottStroke->gradient_, opa); + } + return true; + } + + bool UpdatePaint(LottPaint* paint, uint8_t opa) + { + if (paint == nullptr) { + return false; + } + FillValue(paint->fill_, opa); + StrokeValue(paint->stroke_, opa); + return true; + } + + bool DeepCopyGradient(const LottGradientValue* src, LottGradientValue*& dst) + { + if (src->stops == nullptr) { + return false; + } + if (dst == nullptr) { + dst = new LottGradientValue; + if (dst == nullptr) { + return false; + } + dst->stops = nullptr; + dst->stopNum = 0; + } + + dst->startX = src->startX; + dst->startY = src->startY; + dst->endX = src->endX; + dst->endY = src->endY; + dst->height = src->height; + dst->angle = src->angle; + dst->type = src->type; + + if ((dst->stops != nullptr) && (dst->stopNum != src->stopNum)) { + UIFree(dst->stops); + dst->stops = nullptr; + dst->stopNum = 0; + } + + uint32_t size = sizeof(ColorStop) * src->stopNum; + if (dst->stops == nullptr) { + dst->stops = static_cast(UIMalloc(size)); + if (dst->stops == nullptr) { + return false; + } + } + memcpy_s(dst->stops, size, src->stops, size); + dst->stopNum = src->stopNum; + return true; + } + + bool DeepCopy(LottPaintValue& value) + { + if (value.fill != nullptr) { + if (fill == nullptr) { + fill = new LottFillValue; + if (fill == nullptr) { + return false; + } + fill->gradient = nullptr; + } + + fill->color = value.fill->color; + fill->fillRule = value.fill->fillRule; + + if (value.fill->gradient != nullptr) { + DeepCopyGradient(value.fill->gradient, fill->gradient); + } + } + + if (value.stroke != nullptr) { + if (stroke == nullptr) { + stroke = new LottStrokeValue; + if (stroke == nullptr) { + return false; + } + stroke->gradient = nullptr; + } + + stroke->color = value.stroke->color; + stroke->width = value.stroke->width; + stroke->miterLimit = value.stroke->miterLimit; + stroke->join = value.stroke->join; + stroke->cap = value.stroke->cap; + + if (value.stroke->gradient != nullptr) { + DeepCopyGradient(value.stroke->gradient, stroke->gradient); + } + } + return true; + } +}; + +} +#endif // LOTT_PAINT_H \ No newline at end of file diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_parser.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_parser.h new file mode 100644 index 000000000..ecc095cf7 --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_parser.h @@ -0,0 +1,88 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025. All rights reserved. + * Description: Lottie + * Author: Hisi Graphic Team + * Created: 2025-6 + */ + +#ifndef LOTT_PARSER_H +#define LOTT_PARSER_H +#include "gfx_utils/heap_base.h" +#include "lott_comp.h" +#include "lott_flatbuffer.h" +#include "lott_shape_group.h" + +namespace OHOS { + +class LottParser : public HeapBase { +public: + LottParser() : buffer_(nullptr), offset_(0), fp_(nullptr), comp_(nullptr), hasError_(false) {} + ~LottParser() {} + + LottComp* Parse(std::string file); + +private: + struct LottHeader { + uint32_t startFlag; + uint32_t version; + uint32_t bufferSize; + }; + + struct shapeGroup { + uint32_t fillIndex = 0; + uint32_t strokeindex = 0; + uint32_t transIndex = 0; + Graphic::Vector shapes; + }; + + void* buffer_; + uint32_t offset_; + std::string file_; + FILE* fp_; + LottComp* comp_; + bool hasError_; + const ::flatbuffers::Vector< ::flatbuffers::Offset>* assets_; + + void LoadFile(); + void ParseLayers(const flatbuffers::Vector<::flatbuffers::Offset>* layers, + const flatbuffers::Vector* layers_type, Graphic::Vector& parent); + void ParseBaseLayer(const void* layer, LottLayer* lottLayer); + LottLayer* ParsePreComLayer(const void* layer); + LottLayer* ParseImageLayer(const void* layer); + LottLayer* ParseShapeLayer(const void* layer); + LottLayer* ParseNullLayer(const void* layer); + LottLayer* ParseSolidLayer(const void* layer); + LottLayer* ParseTextLayer(const void* layer); + LottTransform* ParseTransform(const LottieFlatBuffer::Transform* trans); + + Graphic::Vector* BuildGroups( + const flatbuffers::Vector<::flatbuffers::Offset>* shapes, + const flatbuffers::Vector* shapes_type); + + LottShapeGroup* BuildGroup(shapeGroup* group, const flatbuffers::Vector<::flatbuffers::Offset>* shapes, + const flatbuffers::Vector* shapes_type); + LottShape* ParseShape(const void* shape, uint8_t type); + LottShape* ParseGroup(const void* shape); + LottShape* ParseEllipse(const void* shape); + LottShape* ParseRect(const void* shape); + LottShape* ParsePath(const void* shape); + LottFill* ParseFill(const void* shape, uint8_t type); + LottStroke* ParseStroke(const void* shape, uint8_t type); + LottTransform* ParseTransShape(const void* shape); + + void ParseSplitProp(const void* split, LottTransform::LottSplitPosition& lottSplit); + void ParsePositionProp(const void* value, LottieFlatBuffer::PositionProp type, LottPositionProp& lottPosition); + void ParseFloatProp(const void* value, LottieFlatBuffer::FloatProp type, LottFloatProp& lottFloat); + void ParseIntegerProp(const void* value, LottieFlatBuffer::IntegerProp type, LottIntegerProp& lottInt); + void ParseBezierProp(const void* value, LottieFlatBuffer::BezierDataProp type, LottPathDataProp& lottBez); + void ParseVectorProp(const void* value, LottieFlatBuffer::VectorProp type, LottVectorProp& lottVec); + void ParseColorProp(const void* value, LottieFlatBuffer::ColorProp type, LottColorProp& lottColor); + void ParseGradientProp(const void* value, LottieFlatBuffer::GradientProp type, LottColorStopsProp& lottGradient); + void ParseBezierData(const LottieFlatBuffer::BezierData* bezData, Path& path); + void ParseColorStops(const LottieFlatBuffer::Gradient* gradient, Graphic::Vector& colorStops); + + void BuildHierarchy(Graphic::Vector& parent); +}; +} +#endif // LOTT_PARSER_H + diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_path.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_path.h new file mode 100644 index 000000000..cce29b08c --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_path.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025. All rights reserved. + * Description: Lottie + * Author: Hisi Graphic Team + * Created: 2025-6 + */ + +#ifndef LOTT_PATH_H +#define LOTT_PATH_H + +#include "lottie/lott_shape.h" +#include "lottie/lott_property.h" + +namespace OHOS { + +class LottPath : public LottShape { +public: + LottPath(); + virtual ~LottPath(); + + void Update(LottShape* parent, float frameNo) override; + bool GetPathData(Path& path) override; + + LottPathDataProp pathData_; +}; +} +#endif // LOTT_PATH_H \ No newline at end of file diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_precomp_layer.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_precomp_layer.h new file mode 100644 index 000000000..493e0c890 --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_precomp_layer.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025. All rights reserved. + * Description: Lottie + * Author: Hisi Graphic Team + * Created: 2025-6 + */ + +#ifndef LOTT_PRECOMP_LAYER_H +#define LOTT_PRECOMP_LAYER_H + +#include "lottie/lott_layer.h" +namespace OHOS { + +class LottPrecompLayer : public LottLayer { +public: + LottPrecompLayer(); + virtual ~LottPrecompLayer(); + + bool UpdateLottLayer(float frameNo) override; + void DrawLottLayer(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea, + const Matrix3& matrix, uint8_t opa) override; + + Graphic::Vector layers_; +}; +} +#endif // LOTT_PRECOMP_LAYER_H \ No newline at end of file diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_property.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_property.h new file mode 100644 index 000000000..68c509d58 --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_property.h @@ -0,0 +1,190 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025-2025. All rights reserved. + * Description: LottProperty + * Author: Hisi Graphic Team + * Created: 2025-5 + */ + +#ifndef LOTT_PROPERTY_H +#define LOTT_PROPERTY_H + +#include "common/graphic_hardware_types.h" +#include "gfx_utils/color.h" +#include "gfx_utils/graphic_log.h" +#include "gfx_utils/graphic_math.h" +#include "gfx_utils/heap_base.h" +#include "gfx_utils/vector.h" +#include "lottie/lott_math.h" +#include "lottie/lott_interpolator.h" + +namespace OHOS { + +struct LottFloatFrame { + float start; // keyframe value + float time; // frame number + LottInterpolator* interpolator; + bool hold = false; // do not interpolate +}; + +class LottFloatProp : public HeapBase { +public: + LottFloatProp(float v) : value_(v), frames_(nullptr) {} + LottFloatProp() : value_(0.0f), frames_(nullptr) {} + ~LottFloatProp(); + LottFloatFrame* CreateFrame(); + void UpdateValue(float frameNo); + + float value_; + +private: + Graphic::Vector* frames_; + + float Interpolate(LottFloatFrame* frame, LottFloatFrame* nextFrame, float frameNo); +}; + +struct LottIntegerFrame { + int start; // keyframe value + float time; // frame number + LottInterpolator* interpolator; + bool hold = false; // do not interpolate +}; + +class LottIntegerProp : public HeapBase { +public: + LottIntegerProp(int v) : value_(v), frames_(nullptr) {} + LottIntegerProp() : value_(0), frames_(nullptr) {} + ~LottIntegerProp(); + LottIntegerFrame* CreateFrame(); + void UpdateValue(float frameNo); + + int value_; + +private: + Graphic::Vector* frames_; + + int Interpolate(LottIntegerFrame* frame, LottIntegerFrame* nextFrame, float frameNo); +}; + +struct LottColorFrame { + Color32 start; // keyframe value + float time; // frame number + LottInterpolator* interpolator; + bool hold = false; // do not interpolate +}; + +class LottColorProp : public HeapBase { +public: + LottColorProp(Color32 v) : value_(v), frames_(nullptr) {} + LottColorProp() : value_(Color::Black()), frames_(nullptr) {} + ~LottColorProp(); + LottColorFrame* CreateFrame(); + void UpdateValue(float frameNo); + + Color32 value_; + +private: + Graphic::Vector* frames_; + + Color32 Interpolate(LottColorFrame* frame, LottColorFrame* nextFrame, float frameNo); +}; + +struct LottVectorFrame { + Vector2 start; // keyframe value + float time; // frame number + LottInterpolator* interpolator; + bool hold = false; // do not interpolate +}; + +class LottVectorProp : public HeapBase { +public: + LottVectorProp(Vector2 v) : value_(v), frames_(nullptr) {} + LottVectorProp() : value_(Vector2(0.0f, 0.0f)), frames_(nullptr) {} + ~LottVectorProp(); + LottVectorFrame* CreateFrame(); + void UpdateValue(float frameNo); + + Vector2 value_; + +private: + Graphic::Vector* frames_; + + Vector2 Interpolate(LottVectorFrame* frame, LottVectorFrame* nextFrame, float frameNo); +}; + +struct LottColorStopsFrame { + Graphic::Vector start; // keyframe value + float time; // frame number + LottInterpolator* interpolator; + bool hold = false; // do not interpolate +}; + +class LottColorStopsProp : public HeapBase { +public: + LottColorStopsProp(Graphic::Vector v) : value_(v), frames_(nullptr) {} + LottColorStopsProp() : frames_(nullptr) {} + ~LottColorStopsProp(); + LottColorStopsFrame* CreateFrame(); + void UpdateValue(float frameNo); + + Graphic::Vector value_; + +private: + Graphic::Vector* frames_; +}; + +struct LottPositionFrame { + Vector2 start; // keyframe value + float time; // frame number + LottInterpolator* interpolator; + float length; + bool hasTangent = false; + Vector2 outTangent, inTangent; + bool hold = false; // do not interpolate +}; + +class LottPositionProp : public HeapBase { +public: + LottPositionProp(Vector2 v) : value_(v), frames_(nullptr) {} + LottPositionProp() : value_(Vector2(0.0f, 0.0f)), frames_(nullptr) {} + ~LottPositionProp(); + LottPositionFrame* CreateFrame(); + float GetAngle(float frameNo); + void UpdateValue(float frameNo); + void PrepareLength(); + + Vector2 value_; + +private: + Graphic::Vector* frames_; + + Vector2 Interpolate(LottPositionFrame* frame, LottPositionFrame* nextFrame, float frameNo); + float Angle(LottPositionFrame* frame, LottPositionFrame* nextFrame, float frameNo); +}; + +struct LottPathDataFrame { + Path start; // keyframe value + float time; // frame number + LottInterpolator* interpolator; + bool hold = false; // do not interpolate +}; + +class LottPathDataProp : public HeapBase { +public: + LottPathDataProp(Path v) : value_(v), innerPath_(Path{0, nullptr, 0, nullptr}), frames_(nullptr) {} + LottPathDataProp() : value_(Path{0, nullptr, 0, nullptr}), + innerPath_(Path{0, nullptr, 0, nullptr}), frames_(nullptr) {} + ~LottPathDataProp(); + LottPathDataFrame* CreateFrame(); + void UpdateValue(float frameNo); + + Path value_; + +private: + Path innerPath_; // Store temporary path data to avoid allocate memory frequently + Graphic::Vector* frames_; + + bool UpdatePath(LottPathDataFrame* curFrame, LottPathDataFrame* nextFrame, float time); +}; + +} +#endif // LOTT_PROPERTY_H diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_rect.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_rect.h new file mode 100644 index 000000000..5714588eb --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_rect.h @@ -0,0 +1,32 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025. All rights reserved. + * Description: Lottie + * Author: Hisi Graphic Team + * Created: 2025-6 + */ + +#ifndef LOTT_RECT_H +#define LOTT_RECT_H + +#include "lottie/lott_shape.h" +#include "lottie/lott_property.h" +#include "lottie/lott_shape_group.h" + +namespace OHOS { +class LottRect : public LottShape { +public: + LottRect(); + virtual ~LottRect(); + + void Update(LottShape* parent, float frameNo) override; + bool GetPathData(Path& path) override; + + LottPositionProp position_; + LottVectorProp size_; + LottFloatProp radius_; + +private: + bool GetRectPathWithoutRadius(float x, float y, float width, float height); +}; +} +#endif // LOTT_RECT_H \ No newline at end of file diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_shape.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_shape.h new file mode 100644 index 000000000..ea80e2ef2 --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_shape.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025. All rights reserved. + * Description: Lottie + * Author: Hisi Graphic Team + * Created: 2025-6 + */ + +#ifndef LOTT_SHAPE_H +#define LOTT_SHAPE_H + +#include "common/graphic_hardware_types.h" +#include "hals/gralloc_engines.h" + +namespace OHOS { +enum class LottShapeType { + INVALID, + RECT, + ELLIPSE, + PATH, + SHAPE_GROUP, +}; + +class LottShape : public HeapBase { +public: + LottShape(); + virtual ~LottShape(); + + virtual void Update(LottShape* parent, float frameNo) {}; + virtual bool GetPathData(Path& path); + LottShapeType GetType(); + +protected: + void ClearPathInner(); + + Path path_ = {0}; + LottShapeType type_ = LottShapeType::INVALID; +}; +} +#endif // LOTT_SHAPE_H \ No newline at end of file diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_shape_group.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_shape_group.h new file mode 100644 index 000000000..219de0b56 --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_shape_group.h @@ -0,0 +1,56 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025. All rights reserved. + * Description: Lottie + * Author: Hisi Graphic Team + * Created: 2025-6 + */ + +#ifndef LOTT_SHAPE_GROUP_H +#define LOTT_SHAPE_GROUP_H + +#include "lottie/lott_shape.h" +#include "lottie/lott_paint.h" +#include "lottie/lott_transform.h" +#include "common/graphic_hardware_types.h" +#include "gfx_utils/graphic_types.h" +#include "display_vgu.h" + +namespace OHOS { + +struct LottRenderContext { + uint8_t opa; + Matrix3 matrix; + LottPaintValue paint; + + void DeepCopy(LottRenderContext& ctx) + { + matrix = ctx.matrix; + paint.DeepCopy(ctx.paint); + opa = ctx.opa; + } +}; + +class LottShapeGroup : public LottShape { +public: + LottShapeGroup(); + virtual ~LottShapeGroup(); + + void Update(LottShape* parent, float frameNo) override; + void DrawLottShape(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea, LottRenderContext& ctx); + void Prepare(); + + Graphic::Vector shapes_; + LottTransform* transform_ = nullptr; + Matrix3 matrix_; + bool mergeable_ = false; + LottPaint* paint_ = nullptr; + +private: + void DrawMerged(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea, VGUStrokeAttr& strokeAttr, + VGUFillAttr& fillAttr, VGUMatrix3& vguMat, bool strokeEnabled, bool fillEnabled); + bool UpdatePathInner(); + Graphic::Vector datas_; + Graphic::Vector cmds_; +}; +} +#endif // LOTT_SHAPE_GROUP_H \ No newline at end of file diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_shape_layer.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_shape_layer.h new file mode 100644 index 000000000..65b32b92a --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_shape_layer.h @@ -0,0 +1,28 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025. All rights reserved. + * Description: Lottie + * Author: Hisi Graphic Team + * Created: 2025-6 + */ + +#ifndef LOTT_SHAPE_LAYER_H +#define LOTT_SHAPE_LAYER_H + +#include "lottie/lott_layer.h" +#include "lottie/lott_shape_group.h" + +namespace OHOS { + +class LottShapeLayer : public LottLayer { +public: + LottShapeLayer(); + virtual ~LottShapeLayer(); + + bool UpdateLottLayer(float frameNo) override; + void DrawLottLayer(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea, + const Matrix3& matrix, uint8_t opa) override; + + Graphic::Vector shapeGroups_; +}; +} +#endif // LOTT_SHAPE_LAYER_H \ No newline at end of file diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_solid_layer.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_solid_layer.h new file mode 100644 index 000000000..356891dd9 --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_solid_layer.h @@ -0,0 +1,28 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025. All rights reserved. + * Description: Lottie + * Author: Hisi Graphic Team + * Created: 2025-6 + */ + +#ifndef LOTT_SOLID_LAYER_H +#define LOTT_SOLID_LAYER_H + +#include "lottie/lott_layer.h" +#include "common/graphic_hardware_types.h" + +namespace OHOS { + +class LottSolidLayer : public LottLayer { +public: + LottSolidLayer(); + virtual ~LottSolidLayer(); + + void DrawLottLayer(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea, + const Matrix3& matrix, uint8_t opa) override; + + uint32_t color_ = 0; + Path path_ = {0}; +}; +} +#endif // LOTT_SOLID_LAYER_H \ No newline at end of file diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_transform.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_transform.h new file mode 100644 index 000000000..540d40916 --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/lott_transform.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025. All rights reserved. + * Description: Lottie + * Author: Hisi Graphic Team + * Created: 2025-6 + */ + +#ifndef LOTT_TRANSFORM_H +#define LOTT_TRANSFORM_H + +#include "lottie/lott_property.h" +#include "display_vgu.h" +#include "gfx_utils/graphic_math.h" +#include "gfx_utils/heap_base.h" + +namespace OHOS { +class LottTransform : public HeapBase { +public: + LottTransform(); + ~LottTransform(); + + struct LottSplitPosition { + LottFloatProp x; + LottFloatProp y; + }; + + LottSplitPosition* splitPosition_ = nullptr; + LottPositionProp position_; + LottFloatProp rotation_; + LottFloatProp skewAngle_; + LottFloatProp skewAxis_; + LottVectorProp scale_; + LottVectorProp anchor_; + LottIntegerProp opa_; + + void Update(float frameNo, uint8_t& opa, Matrix3& mat); + Matrix3 GetTransformMatrix(); +}; +} +#endif // LOTT_TRANSFORM_H \ No newline at end of file diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/ui_lott_view.h b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/ui_lott_view.h new file mode 100644 index 000000000..476c8b840 --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/include/lottie/ui_lott_view.h @@ -0,0 +1,90 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025. All rights reserved. + * Description: Lottie + * Author: Hisi Graphic Team + * Created: 2025-6 + */ + +#ifndef UI_LOTT_VIEW_H +#define UI_LOTT_VIEW_H + +#include +#include "lottie/lott_comp.h" +#include "animator/animator.h" +#include "gfx_utils/vector.h" +#include "gfx_utils/rect.h" +#include "gfx_utils/graphic_buffer.h" + +namespace OHOS { + +class UILottView : public UIView { +public: + UILottView(); + virtual ~UILottView(); + void OnDraw(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea) override; + + /** + * @brief Set lottie source file. + * @param file lottie source file. + * @return Returns true if set file successfully; returns false otherwise. + */ + bool SetSrc(std::string file); + + /** + * @brief Start lottie animation. + */ + void Start(); + + /** + * @brief Pause lottie animation. + */ + void Pause(); + + /** + * @brief Resume lottie animation. + */ + void Resume(); + + /** + * @brief Stop lottie animation. + */ + void Stop(); + +private: + + class LottAnimCb : public AnimatorCallback { + public: + LottAnimCb() {} + virtual ~LottAnimCb() {} + void Callback(UIView* view) override; + + void SetEndValue(float value) + { + endValue_ = value; + } + + void BindAnimator(Animator* anim) + { + anim_ = anim; + } + + void Reset() + { + endValue_ = 0; + anim_ = nullptr; + } + + private: + float endValue_ = 0; + Animator* anim_ = nullptr; + }; + + friend class LottAnimCb; + + LottAnimCb lottAnimCb_; + Animator animator_; + LottComp* lottComp_ = nullptr; + std::string filePath_; +}; +} +#endif diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/src/service/src/graphic_service.cpp b/code/sdk/middleware/services/gui/uikit/proprietary/src/service/src/graphic_service.cpp index 2d79d5467..f358979e3 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/src/service/src/graphic_service.cpp +++ b/code/sdk/middleware/services/gui/uikit/proprietary/src/service/src/graphic_service.cpp @@ -33,7 +33,7 @@ #include "common/screen.h" #include "components/root_view.h" #ifdef SUPPORT_OHOSFWK -#include "ui_screennotify.h" +#include "screennotify/ui_screennotify.h" #endif #ifdef SUPPORT_GPU_JPEG #include "drv_jpeg_intf.h" @@ -102,7 +102,6 @@ void GraphicService::SetNativeUIRunning(bool isRunning) osal_atomic_set(&isNativeRunning_, 1); } else { osal_atomic_set(&isNativeRunning_, 0); - OHOS::GraphicEventHandler::GetInstance()->ClearGraphicEvent(); osal_atomic_set(&graphicTaskTriggeredCount_, 0); } switchMutex_.Unlock(); diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/common/lite_surface.cpp b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/common/lite_surface.cpp index 332ffe523..3fb158572 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/common/lite_surface.cpp +++ b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/common/lite_surface.cpp @@ -76,11 +76,9 @@ void LiteSurface::AddBuffer() return; } - AllocInfo info; - info.expectedSize = size_; - info.usage = HBM_USE_ASSIGN_SIZE | HBM_USE_MEM_YUV; - GrallocBuffer buffer; - if (!GrallocEngines::GetInstance()->AllocBuffer(info, buffer)) { + uint8_t* addr = GrallocEngines::GetInstance()->AllocBufferBySize(size_, + HBM_USE_ASSIGN_SIZE | HBM_USE_MEM_YUV); + if (addr == nullptr) { GRAPHIC_LOGE("Alloc memory for buffer failed.\n"); delete bufferItem; return; @@ -89,13 +87,14 @@ void LiteSurface::AddBuffer() SurfaceBuffer* surfaceBuffer = new SurfaceBuffer(); if (surfaceBuffer == nullptr) { GRAPHIC_LOGE("new surfaceBuffer failed."); + GrallocEngines::GetInstance()->FreeBuffer(addr); delete bufferItem; return; } bufferItem->buffer = surfaceBuffer; - surfaceBuffer->addr = reinterpret_cast(buffer.virAddr); + surfaceBuffer->addr = reinterpret_cast(addr); surfaceBuffer->width = width_; surfaceBuffer->height = height_; surfaceBuffer->stride = GetStride(); diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components/ui_fragment.cpp b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components/ui_fragment.cpp new file mode 100644 index 000000000..ecc2316e4 --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components/ui_fragment.cpp @@ -0,0 +1,96 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025-2025. All rights reserved. + * Description: UI fragment + * Author: Hisi Graphic Team + * Created: 2025-5 + */ +#include "components/ui_fragment.h" +#include "gfx_utils/graphic_log.h" + +namespace OHOS { + +UIFragment::UIFragment(const std::string& id) : id_(id), state_(FragmentState::INITIALIZED) +{ + if (!id_.empty()) { + UIFragmentManager::GetInstance().AddFragment(id_, this); + } +} + +UIFragment::~UIFragment() +{ + if (!id_.empty()) { + UIFragmentManager::GetInstance().RemoveFragment(id_); + } +} + +UIView* UIFragment::CreateView(void* data) +{ + if (state_ == FragmentState::INITIALIZED) { + OnCreateView(data); + } + + state_ = FragmentState::CREATED; + return &fragmentView_; +} + +void UIFragment::ResumeView() +{ + if (state_ == FragmentState::CREATED) { + OnResumeView(); + } + state_ = FragmentState::RESUMED; +} + +void UIFragment::PauseView() +{ + if (state_ == FragmentState::RESUMED) { + OnPauseView(); + } + state_ = FragmentState::CREATED; +} + +void UIFragment::DestroyView() +{ + if ((state_ == FragmentState::CREATED || state_ == FragmentState::RESUMED)) { + OnDestroyView(); + } + state_ = FragmentState::INITIALIZED; +} + +UIFragmentManager& UIFragmentManager::GetInstance() +{ + static UIFragmentManager instance; + return instance; +} + +void UIFragmentManager::AddFragment(const std::string& id, UIFragment* fragment) +{ + auto it = fragments_.find(id); + if (it == fragments_.end()) { + fragments_[id] = fragment; + } else { + GRAPHIC_LOGE("fragment %s already exist", id.c_str()); + } +} + +void UIFragmentManager::RemoveFragment(const std::string& id) +{ + auto it = fragments_.find(id); + if (it != fragments_.end()) { + fragments_.erase(it); + } else { + GRAPHIC_LOGE("fragment %s does not exist", id.c_str()); + } +} + +UIFragment* UIFragmentManager::GetFragmentById(const std::string& id) +{ + auto it = fragments_.find(id); + if (it != fragments_.end()) { + return it->second; + } else { + GRAPHIC_LOGE("fragment %s does not exist", id.c_str()); + return nullptr; + } +} +} \ No newline at end of file diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components/ui_list_nested.cpp b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components/ui_list_nested.cpp index 5bbd1cc97..d830487f8 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components/ui_list_nested.cpp +++ b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components/ui_list_nested.cpp @@ -34,7 +34,7 @@ bool UIListNested::OnDragStartEvent(const DragEvent& event) } else { dragDirection = VERTICAL; } - isConsumed_ = (direction_ == dragDirection); + isConsumed_ = (direction_ == dragDirection) && (childrenHead_ != nullptr); UIView::OnDragStartEvent(event); return isConsumed_; @@ -47,8 +47,8 @@ bool UIListNested::OnDragEvent(const DragEvent& event) return false; } UIList::OnDragEvent(event); - if (GetLoopState() || childrenHead_ == nullptr) { - return false; + if (GetLoopState()) { + return true; } bool outOfBounds[4] = {false, false, false, false}; // 4: the number of direction int16_t listHeight = GetHeight(); diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components/ui_lite_surface_view.cpp b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components/ui_lite_surface_view.cpp index ec777b1b5..b3406e870 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components/ui_lite_surface_view.cpp +++ b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components/ui_lite_surface_view.cpp @@ -360,6 +360,9 @@ void UILiteSurfaceView::OnBufferAvailable() void UILiteSurfaceView::SetPreview(ImageInfo* info) { + if (info == nullptr) { + return; + } if (preView_ == nullptr) { preView_ = new Image(); } diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components/ui_scroll_view_nested.cpp b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components/ui_scroll_view_nested.cpp index 6687ff02e..33f50ddfe 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components/ui_scroll_view_nested.cpp +++ b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components/ui_scroll_view_nested.cpp @@ -34,7 +34,7 @@ bool UIScrollViewNested::OnDragStartEvent(const DragEvent& event) } else { dragDirection = VERTICAL; } - isConsumed_ = (direction_ == dragDirection); + isConsumed_ = (direction_ == dragDirection) && (childrenHead_ != nullptr); UIView::OnDragStartEvent(event); return isConsumed_; diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components/ui_swipe_view_nested.cpp b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components/ui_swipe_view_nested.cpp index 58219d3a3..27a36101d 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components/ui_swipe_view_nested.cpp +++ b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/components/ui_swipe_view_nested.cpp @@ -26,7 +26,7 @@ bool UISwipeViewNested::OnDragStartEvent(const DragEvent& event) } else { dragDirection = VERTICAL; } - isConsumed_ = (direction_ == dragDirection); + isConsumed_ = (direction_ == dragDirection) && (childrenHead_ != nullptr); UIView::OnDragStartEvent(event); return isConsumed_; @@ -40,8 +40,8 @@ bool UISwipeViewNested::OnDragEvent(const DragEvent& event) } UISwipeView::OnDragEvent(event); - if (loop_ || childrenHead_ == nullptr) { - return false; + if (loop_) { + return true; } bool outOfBounds[4] = {false, false, false, false}; // 4: the number of direction int16_t height = GetHeight(); diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/dfx/dfx_cmd.cpp b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/dfx/dfx_cmd.cpp index d2f908ef3..16155d890 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/dfx/dfx_cmd.cpp +++ b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/dfx/dfx_cmd.cpp @@ -43,6 +43,9 @@ #include "dock/input_device.h" #include "events/key_event.h" #endif +#if defined (SUPPORT_DIAL_DEBUG) +#include "main/dial/WatchInterface.h" +#endif // defined (SUPPORT_DIAL_DEBUG) namespace OHOS { constexpr int DEFAULT_FILE_PERMISSION = 0666; @@ -427,6 +430,143 @@ void PrintFPS(int argc, char *argv[]) } } +#if defined (SUPPORT_DIAL_DEBUG) +void PrintWatchDialInfo(const watch_dial_info &info) +{ + printf("uuid %u, install state %u, is current %u, pro ver %s, internal ver %s\n", + info.uuid, + info.install_state, + info.is_current_watch, + info.watch_protocol_version, + info.watch_version); +} + +void DebugGetAllWatchFaceInfo(int argc, char *argv[]) +{ + GraphicService::GetInstance()->PostGraphicEvent([]() { + watch_dial_info *info = nullptr; + uint8_t num = 0; + bool ret = GetAllWatchFaceInfo(&info, &num); + if (!ret) { + printf("error in get allwatch info\n"); + return; + } + for (uint8_t i = 0; i < num; ++i) { + PrintWatchDialInfo(info[i]); + } + free(info); + }); +} + +void DebugGetWatchFaceInfo(int argc, char *argv[]) +{ + uint32_t uuid[] = {1, 2, 3}; // 1, 2, 3: uuid + for (uint8_t i = 0; i < 3; ++i) { // 3: num + watch_dial_info info; + bool ret = GetWatchFaceInfo(uuid[i], &info); + if (!ret) { + printf("error in DebugGetWatchFaceInfo uuid %u\n", uuid[i]); + continue; + } + PrintWatchDialInfo(info); + } +} + +void DebugGetWatchCapability(int argc, char *argv[]) +{ + watch_dev_cap_info dev; + bool ret = GetWatchCapability(&dev); + if (!ret) { + printf("error in DebugGetWatchCapability\n"); + return; + } + printf("kaleidoscope %u, 3d %u, interaction %u, video %u, fmt %u\n", + dev.kaleidoscope, + dev.effect_3D, + dev.interaction, + dev.video, + dev.video_format); +} + +void DebugGetWatchSystemInfo(int argc, char *argv[]) +{ + watch_sys_info sys; + bool ret = GetWatchSystemInfo(&sys); + if (!ret) { + printf("error in DebugGetWatchSystemInfo\n"); + return; + } + printf("resolution %s watch_proto_support_cnt %u\n", sys.resolution, sys.watch_proto_support_cnt); + for (uint8_t i = 0; i < sys.watch_proto_support_cnt; ++i) { + printf("version %s\n", sys.watch_protocol_verion[i]); + } +} + +void DebugGetCurrentWatchFaceInfo(int argc, char *argv[]) +{ + watch_dial_info cur; + if (!GetCurrentWatchFaceInfo(&cur)) { + printf("current is not 3.0 dial\n"); + return; + } + PrintWatchDialInfo(cur); +} + +void DebugSetCurrentWatchFace(int argc, char *argv[]) +{ + uint16_t i = 0; + if (argc != 1) { + printf("fmt: AT^UIKIT_DFX=debug_set_cur \n"); + return; + } + ConvertToInt(argv[0], i); + printf("function %s, line %d, uuid %u\n", __PRETTY_FUNCTION__, __LINE__, i); + if (!SetCurrentWatchFace(i)) { + printf("set uuid %u error\n", i); + } +} + +void DebugUninstallWatch(int argc, char *argv[]) +{ + if (argc != 1) { + printf("fmt: AT^UIKIT_DFX=debug_uninstall \n"); + return; + } + uint16_t i = 3; + ConvertToInt(argv[0], i); + + if (!UninstallWatch(i)) { + printf("uninstall uuid %u error\n", i); + return; + } + printf("uninstall %u successfully\n", i); +} + +void DebugGetUuidByPath(int argc, char *argv[]) +{ + if (argc != 1) { + printf("fmt: AT^UIKIT_DFX=debug_get_uuid \n"); + return; + } + uint16_t i = 0; + ConvertToInt(argv[0], i); + if (i < 1 || i > 4) { // 4: max uuid + printf("wrong id %u\n", i); + return; + } + std::string dir = "/user/dial/"; + std::string files[] = { + "test_interface_1.bin", "test_interface_2.bin", "test_interface_3.bin", "test_interface_4.bin"}; + std::string path = dir + files[i - 1]; + uint32_t uuid = 0; + if (!GetUuidByPath(path.c_str(), &uuid)) { + printf("get uuid %s error\n", path.c_str()); + return; + } + printf("Succuss to get file %s, uuid %u\n", path.c_str(), uuid); +} +#endif // defined (SUPPORT_DIAL_DEBUG) + #if ENABLE_DEBUG void InjectRotateEvent(int argc, char *argv[]) { @@ -561,8 +701,7 @@ struct DfxCmd { void (*func)(int argc, char *argv[]); }; -struct DfxCmd g_dfxCmdList[] = { - {"screencap", OHOS::ScreencapCmd}, +struct DfxCmd g_dfxCmdList[] = {{"screencap", OHOS::ScreencapCmd}, {"dump_view_id", OHOS::DumpViewIdCmd}, {"dump_root_view", OHOS::DumpRootView}, {"printfps", OHOS::PrintFPS}, @@ -570,6 +709,16 @@ struct DfxCmd g_dfxCmdList[] = { {"showfps", OHOS::ShowFPS}, {"showtime", OHOS::ShowTime}, {"refresh", OHOS::ForceRefresh}, +#if defined (SUPPORT_DIAL_DEBUG) + {"debug_get_all", OHOS::DebugGetAllWatchFaceInfo}, + {"debug_get_watch", OHOS::DebugGetWatchFaceInfo}, + {"debug_get_ability", OHOS::DebugGetWatchCapability}, + {"debug_get_sys", OHOS::DebugGetWatchSystemInfo}, + {"debug_get_cur", OHOS::DebugGetCurrentWatchFaceInfo}, + {"debug_set_cur", OHOS::DebugSetCurrentWatchFace}, + {"debug_uninstall", OHOS::DebugUninstallWatch}, + {"debug_get_uuid", OHOS::DebugGetUuidByPath}, +#endif // defined (SUPPORT_DIAL_DEBUG) #if ENABLE_MEMORY_CHECK {"dumpstate", OHOS::DumpState}, {"dumpmem", OHOS::DumpMemoryCmd}, diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/dfx/dfx_frame_trace.cpp b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/dfx/dfx_frame_trace.cpp index 2201b6b3d..3565fc5a8 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/dfx/dfx_frame_trace.cpp +++ b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/dfx/dfx_frame_trace.cpp @@ -40,6 +40,7 @@ static struct { {FrameTraceType::HW_DRAW_LINE, "hw_line"}, {FrameTraceType::HW_DRAW_ARC, "hw_arc"}, {FrameTraceType::HW_DRAW_CUBICBEZIER, "hw_bezier"}, + {FrameTraceType::HW_DRAW_ELLIPSE, "hw_ellipse"}, }; int DfxFrameTrace::evtCnt_ = 0; @@ -58,12 +59,20 @@ DfxFrameTrace& DfxFrameTrace::GetInstance() return dfx; } +void DfxFrameTrace::SetPathType(FrameTraceType type) +{ + pathType_ = type; +} + void DfxFrameTrace::FrameTraceStart(FrameTraceType type) { if (!CanTrace()) { return; } if (drawStack_ == 0) { + if (type == FrameTraceType::HW_DRAW_PATH) { + type = pathType_; + } RecordStart(type); } ++drawStack_; @@ -79,6 +88,10 @@ void DfxFrameTrace::FrameTraceEnd(FrameTraceType type, const Rect *rect) return; } + if (type == FrameTraceType::HW_DRAW_PATH) { + type = pathType_; + pathType_ = FrameTraceType::HW_DRAW_PATH; + } RecordEnd(type, rect); } @@ -241,20 +254,26 @@ void DfxFrameTrace::ShowEventRecord() const int evtIndex = 0; int taskIndex = 0; printf("Total: E %d, T %d, F %d\n", evtCnt_, tskCnt_, frmCnt_); + EventRecord *preE = events_; for (EventRecord *it = events_; it != nullptr; it = it->next) { EventRecord &evt = *it; - printf("\nE %d: %llu, (%llu, %llu)\n", evtIndex, GetDuration(evt.startTime, evt.endTime), - evt.startTime, evt.endTime); + uint64_t preEvtTime = evtIndex == 0 ? preE->startTime : preE->endTime; + printf("\nE %d: %llu, %llu\n", + evtIndex, GetDuration(preEvtTime, evt.startTime), GetDuration(evt.startTime, evt.endTime)); taskIndex = 0; + TaskRecord *preT = evt.tasks; for (TaskRecord *it1 = evt.tasks; it1 != nullptr; it1 = it1->next) { TaskRecord &tsk = *it1; - printf(" T %d: %llu, (%llu, %llu)\n", taskIndex, GetDuration(tsk.startTime, tsk.endTime), - tsk.startTime, tsk.endTime); + uint64_t preTskTime = taskIndex == 0 ? evt.startTime : preT->endTime; + printf(" T %d: %llu, %llu\n", + taskIndex, GetDuration(preTskTime, tsk.startTime), GetDuration(tsk.startTime, tsk.endTime)); if (tsk.frameInfo != nullptr) { ShowFrameRecord(tsk.frameInfo); } + preT = it1; taskIndex++; } + preE = it; evtIndex++; } } diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/draw/clip_img.cpp b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/draw/clip_img.cpp index 13e48015c..485dd311d 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/draw/clip_img.cpp +++ b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/draw/clip_img.cpp @@ -13,14 +13,6 @@ #include "clip_img.h" namespace OHOS { -static void ClearPath(Path* path) -{ - GrallocEngines::GetInstance()->FreeBuffer(reinterpret_cast(path->cmds)); - GrallocEngines::GetInstance()->FreeBuffer(reinterpret_cast(path->data)); - path->cmds = nullptr; - path->data = nullptr; -} - static bool AllocImageInfo(ImageInfo& info, uint16_t width, uint16_t height, ColorMode mod) { info.header.width = width; @@ -61,7 +53,7 @@ ImageInfo ClipImg::ClipImgByCircle(ImageInfo& srcInfo, Point center, int16_t rad } if (!AllocImageInfo(dstInfo, 2 * radius, 2 * radius, mode)) { // 2: the diameter of the circle - ClearPath(&path); + HWDrawUtils::GetInstance()->FreeBufferForPath(&path); return dstInfo; } @@ -69,7 +61,7 @@ ImageInfo ClipImg::ClipImgByCircle(ImageInfo& srcInfo, Point center, int16_t rad if (immediatelySync) { LiteMGfxEngine::GetInstance()->SyncHwDraw(); } - ClearPath(&path); + HWDrawUtils::GetInstance()->FreeBufferForPath(&path); return dstInfo; } @@ -77,26 +69,17 @@ ImageInfo ClipImg::ClipImgByRect(ImageInfo& srcInfo, Rect* srcImgArea, Rect clip { ImageInfo dstInfo = {{0}}; Path path = {0}; - path.dataNum = 5; // 5: data num - if (!HWDrawUtils::GetInstance()->AllocBufferForData(path.dataNum, path.data)) { - return dstInfo; - } - path.cmdNum = 5; // 5: cmd num - AllocInfo cmdInfo; - cmdInfo.expectedSize = sizeof(uint8_t) * path.cmdNum; - cmdInfo.usage = HBM_USE_ASSIGN_SIZE | HBM_USE_MEM_PATH; - GrallocBuffer cmdBuffer; - if (!GrallocEngines::GetInstance()->AllocBuffer(cmdInfo, cmdBuffer)) { - GrallocEngines::GetInstance()->FreeBuffer(reinterpret_cast(path.data)); + if (!HWDrawUtils::GetInstance()->AllocBufferForPath(&path, 5, 5)) { // 5: cmd and data num return dstInfo; } + path.data[0] = clipArea.GetX(); path.data[1] = clipArea.GetY(); path.data[2] = clipArea.GetRight(); // 2: index path.data[3] = clipArea.GetBottom(); // 3: index path.data[4] = clipArea.GetX(); // 4: index - path.cmds = (uint8_t *)cmdBuffer.virAddr; + path.cmds[0] = CMD_MOVE_TO; path.cmds[1] = CMD_HLINE_TO; path.cmds[2] = CMD_VLINE_TO; // 2: index @@ -104,12 +87,12 @@ ImageInfo ClipImg::ClipImgByRect(ImageInfo& srcInfo, Rect* srcImgArea, Rect clip path.cmds[4] = CMD_CLOSE; // 4: index if (!AllocImageInfo(dstInfo, clipArea.GetWidth(), clipArea.GetHeight(), mode)) { - ClearPath(&path); + HWDrawUtils::GetInstance()->FreeBufferForPath(&path); return dstInfo; } ClipImgByPath(dstInfo, srcInfo, &path, nullptr, nullptr, nullptr); - ClearPath(&path); + HWDrawUtils::GetInstance()->FreeBufferForPath(&path); return dstInfo; } } diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/draw/hw_draw_utils.cpp b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/draw/hw_draw_utils.cpp index d7feafbf1..d44c2fd44 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/draw/hw_draw_utils.cpp +++ b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/draw/hw_draw_utils.cpp @@ -20,7 +20,7 @@ #include "gfx_utils/graphic_log.h" #include "hals/gralloc_engines.h" -#if ENABLE_VGU_ENGINE && CAPABILITY_HWDRAW_PATH +#if ENABLE_VGU_ENGINE namespace OHOS { constexpr float ARC_TO_BEZIER_90_DEG = 0.551915024494f; constexpr int16_t DATA_NUM_PER_BEZ = 6; @@ -28,32 +28,64 @@ constexpr float PRECISION_ANGLE = 0.01f; bool HWDrawUtils::AllocBufferForCmd(uint16_t cmdNum, uint8_t*& addr) { - AllocInfo dataInfo; - dataInfo.expectedSize = sizeof(uint8_t) * cmdNum; - dataInfo.usage = HBM_USE_ASSIGN_SIZE | HBM_USE_MEM_PATH; - GrallocBuffer dataBuffer; - if (!GrallocEngines::GetInstance()->AllocBuffer(dataInfo, dataBuffer)) { - GRAPHIC_LOGE("Alloc buffer for data failed."); + uint8_t* cmdAddr = GrallocEngines::GetInstance()->AllocBufferBySize(sizeof(uint8_t) * cmdNum, + HBM_USE_ASSIGN_SIZE | HBM_USE_MEM_PATH); + if (cmdAddr == nullptr) { + GRAPHIC_LOGE("Alloc buffer for cmd failed."); + addr = nullptr; return false; } - addr = reinterpret_cast(dataBuffer.virAddr); + addr = cmdAddr; return true; } bool HWDrawUtils::AllocBufferForData(uint16_t dataNum, float*& addr) { - AllocInfo dataInfo; - dataInfo.expectedSize = sizeof(float) * dataNum; - dataInfo.usage = HBM_USE_ASSIGN_SIZE | HBM_USE_MEM_PATH; - GrallocBuffer dataBuffer; - if (!GrallocEngines::GetInstance()->AllocBuffer(dataInfo, dataBuffer)) { + uint8_t* dataAddr = GrallocEngines::GetInstance()->AllocBufferBySize(sizeof(float) * dataNum, + HBM_USE_ASSIGN_SIZE | HBM_USE_MEM_PATH); + if (dataAddr == nullptr) { GRAPHIC_LOGE("Alloc buffer for data failed."); + addr = nullptr; return false; } - addr = reinterpret_cast(dataBuffer.virAddr); + addr = reinterpret_cast(dataAddr); return true; } +bool HWDrawUtils::AllocBufferForPath(Path* path, uint16_t cmdNum, uint16_t dataNum) +{ + if (path == nullptr) { + return false; + } + + if (!AllocBufferForCmd(cmdNum, path->cmds)) { + return false; + } + + if (!AllocBufferForData(dataNum, path->data)) { + GrallocEngines::GetInstance()->FreeBuffer(path->cmds); + path->cmds = nullptr; + return false; + } + + path->cmdNum = cmdNum; + path->dataNum = dataNum; + return true; +} + +void HWDrawUtils::FreeBufferForPath(Path* path) +{ + if (path == nullptr) { + return; + } + GrallocEngines::GetInstance()->FreeBuffer(path->cmds); + GrallocEngines::GetInstance()->FreeBuffer(reinterpret_cast(path->data)); + path->cmds = nullptr; + path->data = nullptr; + path->cmdNum = 0; + path->dataNum = 0; +} + void HWDrawUtils::GetArcControlPoint(float* arcData, float centerX, float centerY, float mangicNum, int8_t neg) { arcData[2] = arcData[0] - (neg * mangicNum * (arcData[1] - centerY)); // 2: index @@ -244,10 +276,16 @@ bool HWDrawUtils::ObtainCirclePath(const ArcInfo& arc, uint32_t& cmdNum, bool HWDrawUtils::ObtainRectPathWithRadius(const Rect& rect, Path& path, int16_t radius) { - path.cmdNum = 10; // 10: Circle path command number is 10 - if (!AllocBufferForCmd(path.cmdNum, path.cmds)) { - return false; + uint32_t cmdNum = 10; // 10: Circle path command number is 10 + if (path.cmdNum < cmdNum) { + GrallocEngines::GetInstance()->FreeBuffer(path.cmds); + path.cmds = nullptr; + if (!AllocBufferForCmd(cmdNum, path.cmds)) { + return false; + } } + path.cmdNum = cmdNum; + path.cmds[0] = CMD_MOVE_TO; path.cmds[1] = CMD_LINE_TO; path.cmds[2] = CMD_CUBIC_TO; // 2: cmd index @@ -259,12 +297,18 @@ bool HWDrawUtils::ObtainRectPathWithRadius(const Rect& rect, Path& path, int16_t path.cmds[8] = CMD_CUBIC_TO; // 8: cmd index path.cmds[9] = CMD_CLOSE; // 9: cmd index - path.dataNum = 34; // Circle path data number is 34 - if (!AllocBufferForData(path.dataNum, path.data)) { - GrallocEngines::GetInstance()->FreeBuffer(path.cmds); - path.cmds = nullptr; - return false; + uint32_t dataNum = 34; // Circle path data number is 34 + if (path.dataNum < dataNum) { + GrallocEngines::GetInstance()->FreeBuffer(reinterpret_cast(path.data)); + path.data = nullptr; + if (!AllocBufferForData(dataNum, path.data)) { + GrallocEngines::GetInstance()->FreeBuffer(path.cmds); + path.cmds = nullptr; + return false; + } } + path.dataNum = dataNum; + GetFilledRoundRectData(path.data, radius, rect); return true; } @@ -312,5 +356,117 @@ void HWDrawUtils::GetFilledRoundRectData(float* data, uint16_t radius, const Rec GetArcControlPoint(&data[26], x1 + r, y1 + r, ARC_TO_BEZIER_90_DEG, -1); // 26: index } + +static void GetEllipsePathData(const Point& center, uint16_t rx, uint16_t ry, Path& path) +{ + path.cmds[0] = CMD_MOVE_TO; + path.cmds[1] = CMD_CUBIC_TO; + path.cmds[2] = CMD_CUBIC_TO; // 2: cmd index + path.cmds[3] = CMD_CUBIC_TO; // 3: cmd index + path.cmds[4] = CMD_CUBIC_TO; // 4: cmd index + path.cmds[5] = CMD_CLOSE; // 5: cmd index + + float magicX = rx * ARC_TO_BEZIER_90_DEG; + float magicY = ry * ARC_TO_BEZIER_90_DEG; + + // start point + path.data[0] = center.x; + path.data[1] = center.y - ry; + + // right top control point + path.data[2] = center.x + magicX; // 2: index + path.data[3] = center.y - ry; // 3: index + path.data[4] = center.x + rx; // 4: index + path.data[5] = center.y - magicY; // 5: index + path.data[6] = center.x + rx; // 6: index + path.data[7] = center.y; // 7: index + + // right bottom control point + path.data[8] = center.x + rx; // 8: index + path.data[9] = center.y + magicY; // 9: index + path.data[10] = center.x + magicX; // 10: index + path.data[11] = center.y + ry; // 11: index + path.data[12] = center.x; // 12: index + path.data[13] = center.y + ry; // 13: index + + // left bottom control point + path.data[14] = center.x - magicX; // 14: index + path.data[15] = center.y + ry; // 15: index + path.data[16] = center.x - rx; // 16: index + path.data[17] = center.y + magicY; // 17: index + path.data[18] = center.x - rx; // 18: index + path.data[19] = center.y; // 19: index + + // left top control point + path.data[20] = center.x - rx; // 20: index + path.data[21] = center.y - magicY; // 21: index + path.data[22] = center.x - magicX; // 22: index + path.data[23] = center.y - ry; // 23: index + path.data[24] = center.x; // 24: index + path.data[25] = center.y - ry; // 25: index +} + +bool HWDrawUtils::ObtainEllipsePath(const Point& center, uint16_t rx, uint16_t ry, Path& path) +{ + uint32_t cmdNum = 6; // 6: Ellipse path command number is 6 + if (path.cmdNum < cmdNum) { + if (path.cmds != nullptr) { + GrallocEngines::GetInstance()->FreeBuffer(path.cmds); + path.cmds = nullptr; + path.cmdNum = 0; + } + if (!AllocBufferForCmd(cmdNum, path.cmds)) { + return false; + } + } + path.cmdNum = cmdNum; + + uint32_t dataNum = 26; // 26: Ellipse path data number is 26 + if (path.dataNum < dataNum) { + if (path.data != nullptr) { + GrallocEngines::GetInstance()->FreeBuffer(reinterpret_cast(path.data)); + path.data = nullptr; + path.dataNum = 0; + } + if (!AllocBufferForData(dataNum, path.data)) { + GrallocEngines::GetInstance()->FreeBuffer(path.cmds); + path.cmds = nullptr; + path.cmdNum = 0; + return false; + } + } + path.dataNum = dataNum; + + GetEllipsePathData(center, rx, ry, path); + return true; +} + +void HWDrawUtils::Matrix3ToVguMatrix3(const Matrix3& matrix, VGUMatrix3& vguMat) +{ + const float* data = matrix.GetData(); + vguMat.m[0][0] = data[0]; // 0, 0: index + vguMat.m[0][1] = data[3]; // 0, 3: index + vguMat.m[0][2] = data[6]; // 0, 2, 6: index + vguMat.m[1][0] = data[1]; // 1, 0: index + vguMat.m[1][1] = data[4]; // 1, 4: index + vguMat.m[1][2] = data[7]; // 1, 2, 7: index + vguMat.m[2][0] = data[2]; // 2, 0: index + vguMat.m[2][1] = data[5]; // 2, 1, 5: index + vguMat.m[2][2] = data[8]; // 2, 8: index +} + +void HWDrawUtils::Matrix4ToVguMatrix3(const Matrix4& matrix, VGUMatrix3& vguMat) +{ + const float* data = matrix.GetData(); + vguMat.m[0][0] = data[0]; + vguMat.m[1][0] = data[1]; + vguMat.m[2][0] = data[3]; // 2, 3: index + vguMat.m[0][1] = data[4]; // 4: index + vguMat.m[1][1] = data[5]; // 5: index + vguMat.m[2][1] = data[7]; // 2, 7: index + vguMat.m[0][2] = data[12]; // 2, 12: index + vguMat.m[1][2] = data[13]; // 2, 13: index + vguMat.m[2][2] = data[15]; // 2, 15: index +} } #endif diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/draw/hw_draw_utils.h b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/draw/hw_draw_utils.h index 86d3b0403..2280c0dfa 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/draw/hw_draw_utils.h +++ b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/draw/hw_draw_utils.h @@ -17,9 +17,10 @@ #define GRAPHIC_LITE_HW_DRAW_H #include "graphic_config.h" -#if ENABLE_VGU_ENGINE && CAPABILITY_HWDRAW_PATH +#if ENABLE_VGU_ENGINE #include "engines/gfx/gfx_engine_manager.h" #include "common/graphic_hardware_types.h" +#include "display_vgu.h" namespace OHOS { class HWDrawUtils : public HeapBase { @@ -34,8 +35,14 @@ public: bool ObtainCirclePath(const ArcInfo& arc, uint32_t& cmdNum, uint8_t*& cmds, uint32_t& dataNum, float*& data); bool AllocBufferForCmd(uint16_t cmdNum, uint8_t*& addr); bool AllocBufferForData(uint16_t dataNum, float*& addr); + bool AllocBufferForPath(Path* path, uint16_t cmdNum, uint16_t dataNum); + void FreeBufferForPath(Path* path); void Obtain30DegSectorPath(const ArcInfo& arc, float x, float y, uint8_t* cmd, float* data); bool ObtainRectPathWithRadius(const Rect& rect, Path& path, int16_t radius); + bool ObtainEllipsePath(const Point& center, uint16_t rx, uint16_t ry, Path& path); + void Matrix3ToVguMatrix3(const Matrix3& matrix, VGUMatrix3& vguMat); + void Matrix4ToVguMatrix3(const Matrix4& matrix, VGUMatrix3& vguMat); + private: HWDrawUtils() {} virtual ~HWDrawUtils() {} diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/engines/gfx/lite_m_gfx_engine.h b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/engines/gfx/lite_m_gfx_engine.h index 4f42d2086..3d066c517 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/engines/gfx/lite_m_gfx_engine.h +++ b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/engines/gfx/lite_m_gfx_engine.h @@ -28,6 +28,7 @@ #include "gfx_utils/heap_base.h" #include "gfx_utils/style.h" #include "gfx_utils/transform.h" +#include "gfx_utils/vector.h" #include "common/ihardware_view.h" #include "common/graphic_hardware_types.h" @@ -44,6 +45,8 @@ struct AsyncSubmitInfo { bool needSwapToPendingFrame; }; +static constexpr uint16_t INIT_PATH_NUM = 20; + class LiteMGfxEngine : public BaseGfxEngine { public: using BaseGfxEngine::Flush; @@ -109,6 +112,15 @@ public: const ColorType color, const OpacityType opacity) override; + void DrawEllipse(BufferInfo& dst, + const Rect& mask, + const Point& center, + uint16_t rx, + uint16_t ry, + VGUStrokeAttr* strokeAttr, + VGUFillAttr* fillAttr, + VGUMatrix3* matrix); + #if CAPABILITY_HWDRAW_PATH uintptr_t InitPath(bool enAlias); void DeinitPath(uintptr_t path) const; @@ -170,15 +182,22 @@ private: ReleasePath(); } +#if defined(HW_ROTATE_ANGLE) + bool RotateBufferIfNecessary(); +#endif void DrawRectWithRound(BufferInfo& dst, const Rect& rect, const Style& style, const Rect& dirtyRect, OpacityType opacity); void DrawRectWithoutRound(BufferInfo& dst, const Rect& rect, const Style& style, const Rect& dirtyRect, OpacityType opacity); - List pathList_ = {}; + bool HandleImageSrc(const Image* imgSrc, VGUImage& image, const Style& style); void ReleasePath(); + void DrawArcInner(BufferInfo& dst, const ArcInfo& arcInfo, const Rect& mask, + const Style& style, OpacityType opacity, uint8_t cap, VGUImage& image); BufferInfo* bufferInfo_ = nullptr; BufferInfo* nextBufferInfo_ = nullptr; + Graphic::Vector pathSubmit_{INIT_PATH_NUM}; + Graphic::Vector pathRender_{INIT_PATH_NUM}; AsyncSubmitInfo lastAsyncInfo_ = {{0, 0, 1, 1}, false, false}; bool enableAsyncSubmit_ = true; @@ -194,10 +213,12 @@ private: IHardwareView* hardwareView_ {nullptr}; bool Convert2VGUBuffer(const BufferInfo& bufferInfo, VGUBuffer& buffer) const; - void BlitImages(); - void AddHwDraw(uint16_t cnt); + void BlitImages(bool calledBySync = false); + void CheckHwDrawLimit(uint16_t nodeCnt, uint16_t strokeCnt = 0); + void AddHwDraw(uint16_t nodeCnt, uint16_t strokeCnt = 0); void AsyncFlush(); + void RenderSubmitInner(bool isNeedWait = true); #endif }; } -#endif // GRAPHIC_LITE_LITE_M_GFX_ENGINE_H +#endif // GRAPHIC_LITE_LITE_M_GFX_ENGINE_H \ No newline at end of file diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/imgdecode/hw_jpeg_decoder.cpp b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/imgdecode/hw_jpeg_decoder.cpp index 3a2af9a06..108e4daa4 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/imgdecode/hw_jpeg_decoder.cpp +++ b/code/sdk/middleware/services/gui/uikit/proprietary/src/ui/frameworks/imgdecode/hw_jpeg_decoder.cpp @@ -43,17 +43,13 @@ RetCode HWJpegDecoder::Open(ImgResDsc& dsc) fseek(fp, 0, SEEK_END); g_fileLen = static_cast(ftell(fp)); - - AllocInfo dataInfo; - dataInfo.expectedSize = g_fileLen; - dataInfo.usage = HBM_USE_ASSIGN_SIZE | HBM_USE_MEM_JPEG_DATA; - GrallocBuffer dataBuffer; - if (!GrallocEngines::GetInstance()->AllocBuffer(dataInfo, dataBuffer)) { + filedata_ = GrallocEngines::GetInstance()->AllocBufferBySize(g_fileLen, + HBM_USE_ASSIGN_SIZE | HBM_USE_MEM_JPEG_DATA); + if (filedata_ == nullptr) { fclose(fp); GRAPHIC_LOGE("Alloc buffer for data failed."); return RetCode::FAIL; } - filedata_ = reinterpret_cast(dataBuffer.virAddr); fseek(fp, 0, SEEK_SET); if (fread(filedata_, 1, g_fileLen, fp) != g_fileLen) { diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/frameworks/hals/display_dev.cpp b/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/frameworks/hals/display_dev.cpp index c40188782..4f06c90f6 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/frameworks/hals/display_dev.cpp +++ b/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/frameworks/hals/display_dev.cpp @@ -22,6 +22,8 @@ #include "graphic_config.h" #include "hals/gralloc_engines.h" #include "dfx/dfx_frame_trace.h" +#include "imgdecode/image_load.h" +#include "engines/gfx/lite_m_gfx_engine.h" #ifndef _WIN32 #include "tcxo.h" @@ -43,6 +45,8 @@ DisplayDev::DisplayDev() : isDisplayDevInited_(false), devId_(0), layerFuncs_(nu (void)memset_s(&layer_[i].layerInfo, sizeof(LayerInfo), 0, sizeof(LayerInfo)); layer_[i].bufferCount = 0; layer_[i].buffer = nullptr; + (void)memset_s(&layer_[i].rotateInfo, sizeof(LayerInfo), 0, sizeof(LayerInfo)); + layer_[i].rotate = nullptr; layer_[i].rotateType = LayerRotateType::LAYER_ROTATE_NONE; } } @@ -63,7 +67,13 @@ void DisplayDev::LcdFlush(uint8_t layerId) return; } uint8_t currentBufferIndex = currentBufferId_[layerId]; - if (layerFuncs_->Flush(devId_, layer_[layerId].layerHdl, &layer_[layerId].buffer[currentBufferIndex]) != + LayerBuffer *buffer = nullptr; + if (layer_[layerId].rotate != nullptr) { + buffer = &layer_[layerId].rotate[currentBufferIndex]; + } else { + buffer = &layer_[layerId].buffer[currentBufferIndex]; + } + if (layerFuncs_->Flush(devId_, layer_[layerId].layerHdl, buffer) != DISPLAY_SUCCESS) { GRAPHIC_LOGE("flush failed."); return; @@ -123,6 +133,85 @@ LayerBuffer* DisplayDev::GetNextBuffer(uint8_t layerId) return &layer_[layerId].buffer[nextBufferId]; } +LayerBuffer* DisplayDev::GetCurrentRotateBuffer(uint8_t layerId) +{ + if (layerId < LAYER_0 || layerId >= LAYER_MAX) { + GRAPHIC_LOGE("Invalid layerId[%u].", layerId); + return nullptr; + } + if (layer_[layerId].bufferCount == 0) { + GRAPHIC_LOGE("layer[%u] is not opened.", layerId); + return nullptr; + } + if (layer_[layerId].rotate == nullptr) { + GRAPHIC_LOGE("rotateBuffer is nullptr!"); + return nullptr; + } + return &layer_[layerId].rotate[currentBufferId_[layerId]]; +} + +void DisplayDev::GetRotatePosition(int32_t width, int32_t height, int32_t &x, int32_t &y, LayerRotateType type) const +{ + int32_t outX = x; + int32_t outY = y; + switch (type) { + case LayerRotateType::LAYER_ROTATE_90: { + outX = height - y; + outY = x; + break; + } + case LayerRotateType::LAYER_ROTATE_180: { + outX = width - x; + outY = height - y; + break; + } + case LayerRotateType::LAYER_ROTATE_270: { + outX = y; + outY = width - x; + break; + } + default: + return; + } + x = outX; + y = outY; +} + +void DisplayDev::GetRotateRect(int32_t width, int32_t height, Rect &rect, LayerRotateType type) const +{ + Rect outRect = rect; + int32_t x = rect.GetLeft(); + int32_t y = rect.GetTop(); + switch (type) { + case LayerRotateType::LAYER_ROTATE_90: { + x = rect.GetLeft(); + y = rect.GetBottom(); + outRect.SetWidth(rect.GetHeight()); + outRect.SetHeight(rect.GetWidth()); + GetRotatePosition(width, height, x, y, type); + break; + } + case LayerRotateType::LAYER_ROTATE_180: { + x = rect.GetRight(); + y = rect.GetBottom(); + GetRotatePosition(width, height, x, y, type); + break; + } + case LayerRotateType::LAYER_ROTATE_270: { + x = rect.GetRight(); + y = rect.GetTop(); + outRect.SetWidth(rect.GetHeight()); + outRect.SetHeight(rect.GetWidth()); + GetRotatePosition(width, height, x, y, type); + break; + } + default: + return; + } + outRect.SetPosition(x, y); + rect = outRect; +} + bool DisplayDev::SwapBuffer(uint8_t layerId) { if (layerId < LAYER_0 || layerId >= LAYER_MAX) { @@ -142,29 +231,103 @@ bool DisplayDev::SwapBuffer(uint8_t layerId) return true; } -uint32_t DisplayDev::CalcStride(uint32_t width, PixelFormat fmt) +static uint32_t GetAlignedStride(uint32_t width, PixelFormat fmt, uint8_t cmpMode) { - uint32_t bytePerPixel; + uint32_t bpp; uint32_t stride; switch (fmt) { case PIXEL_FMT_RGBA_8888: - bytePerPixel = 4; // 4: byte per pixel + if (cmpMode == COMPRESS_MODE_HFBC) { + bpp = 12; /* 12 bits */ + } else if (cmpMode == COMPRESS_MODE_HFBC_ABYPASS) { + bpp = 16; /* 16 bits */ + } else { + bpp = 32; /* 32 bits */ + } + break; + case PIXEL_FMT_RGBA_5551: + case PIXEL_FMT_RGB_565: + bpp = 16; /* 16 bits */ + break; + case PIXEL_FMT_RGB_888: + bpp = (cmpMode != COMPRESS_MODE_NONE) ? 8 : 24; /* 8,24 bits */ + break; + case PIXEL_FMT_A1: + stride = width >> SHIFT_3; + if (width & 0x7) { + stride++; + } + stride = ALIGN_BYTE(stride, BYTE_ALIGNMENT); + return stride; + default: + bpp = 32; /* 32 bits */ + break; + } + stride = ALIGN_BYTE(width, BYTE_ALIGNMENT) * bpp / STRIDE_DIVIDER; + if (cmpMode != COMPRESS_MODE_NONE) { + stride = stride * 4; /* 4: compress coef */ + } + return stride; +} + +uint32_t DisplayDev::CalcStride(uint32_t width, PixelFormat fmt, uint8_t cmpMode) +{ + uint32_t bitPerPixel; + uint32_t stride; + switch (fmt) { + case PIXEL_FMT_RGBA_8888: + bitPerPixel = 32; // 32: bit per pixel break; case PIXEL_FMT_RGBA_5551: case PIXEL_FMT_RGB_565: - bytePerPixel = 2; // 2: byte per pixel + bitPerPixel = 16; // 16: bit per pixel break; case PIXEL_FMT_RGB_888: - bytePerPixel = 3; // 3: byte per pixel + bitPerPixel = 24; // 24: bit per pixel + break; + case PIXEL_FMT_A1: + case PIXEL_FMT_A2: + case PIXEL_FMT_A4: + case PIXEL_FMT_A8: + bitPerPixel = 8; /* 8 bits */ break; default: GRAPHIC_LOGE("unsupported PixelFormat: %d, just return 0.", fmt); return 0; } - stride = ALIGN_BYTE(width, BYTE_ALIGNMENT) * bytePerPixel; + + switch (cmpMode) { + case COMPRESS_MODE_NONE: + stride = ALIGN_BYTE(width, 16) * bitPerPixel / 8; /** 16-byte aligned 8 bits per byte */ + break; + case COMPRESS_MODE_HFBC: + case COMPRESS_MODE_HFBC_ABYPASS: + stride = GetAlignedStride(width, fmt, cmpMode); + break; + default: + GRAPHIC_LOGE("unsupported compress mode: %d, just return 0.", cmpMode); + return 0; + } + return stride; } +uint32_t DisplayDev::CalcSize(uint32_t stride, uint32_t height, uint8_t cmpMode) +{ + uint32_t size; + switch (cmpMode) { + case COMPRESS_MODE_NONE: + size = stride * height; + break; + default: + GRAPHIC_LOGE("unsupported compress mode: %d, just return 0.", cmpMode); + return 0; + break; + } + + return size; +} + bool DisplayDev::OpenLayer(uint8_t layerId, const LayerInfo& info, uint8_t bufferCount, LayerRotateType rotateType) { if (layerId < LAYER_0 || layerId >= LAYER_MAX || bufferCount == 0 || bufferCount > BUFFER_MAX) { @@ -190,18 +353,36 @@ bool DisplayDev::OpenLayer(uint8_t layerId, const LayerInfo& info, uint8_t buffe return false; } - layer_[layerId].layerInfo.width = info.width; - layer_[layerId].layerInfo.height = info.height; - layer_[layerId].layerInfo.type = info.type; - layer_[layerId].layerInfo.bpp = info.bpp; - layer_[layerId].layerInfo.pixFormat = info.pixFormat; + LayerInfo outInfo = info; + layer_[layerId].layerInfo = outInfo; layer_[layerId].bufferCount = bufferCount; layer_[layerId].rotateType = rotateType; layer_[layerId].pos.x = 0; layer_[layerId].pos.y = 0; - if (layerFuncs_->CreateLayer(devId_, &layer_[layerId].layerInfo, &layer_[layerId].layerHdl) != DISPLAY_SUCCESS) { + if (rotateType != LayerRotateType::LAYER_ROTATE_NONE) { + layer_[layerId].rotate = (LayerBuffer*)UIMalloc(size); + if (layer_[layerId].rotate == nullptr) { + UIFree(layer_[layerId].buffer); + GRAPHIC_LOGE("new rotate layerBuffer failed."); + layer_[layerId].buffer = nullptr; + return false; + } + if (rotateType == LayerRotateType::LAYER_ROTATE_90 || rotateType == LayerRotateType::LAYER_ROTATE_270) { + outInfo.height = info.width; + outInfo.width = info.height; + layer_[layerId].rotateInfo = outInfo; + } else { + layer_[layerId].rotateInfo = outInfo; + } + } + + if (layerFuncs_->CreateLayer(devId_, &outInfo, &layer_[layerId].layerHdl) != DISPLAY_SUCCESS) { UIFree(layer_[layerId].buffer); layer_[layerId].buffer = nullptr; + if (layer_[layerId].rotate != nullptr) { + UIFree(layer_[layerId].rotate); + layer_[layerId].rotate = nullptr; + } layer_[layerId].layerHdl = 0; layer_[layerId].bufferCount = 0; layer_[layerId].rotateType = LayerRotateType::LAYER_ROTATE_NONE; @@ -236,6 +417,10 @@ void DisplayDev::CloseLayer(uint8_t layerId) UIFree(layer_[layerId].buffer); layer_[layerId].buffer = nullptr; + if (layer_[layerId].rotate) { + UIFree(layer_[layerId].rotate); + layer_[layerId].rotate = nullptr; + } layer_[layerId].layerHdl = 0; layer_[layerId].bufferCount = 0; @@ -289,59 +474,97 @@ bool DisplayDev::IsDoubleBuffer(void) #endif } -bool DisplayDev::AllocLayerBuffer(uint8_t layerId) +bool DisplayDev::AllocBuffer(LayerBuffer *layerBuffer, const LayerInfo &layerInfo, uint8_t count, bool isFb) { - if (layerId < LAYER_0 || layerId >= LAYER_MAX || layer_[layerId].bufferCount == 0) { - GRAPHIC_LOGE("Invalid layerId[%u] or layer is not opened.", layerId); + if (layerBuffer == nullptr || count == 0) { return false; } - if (layer_[layerId].buffer[0].data.virAddr != nullptr) { - GRAPHIC_LOGE("layer[%u] : Memory of buffers is already allocated.", layerId); - return false; - } - -#if !ENABLE_GMMU - uint32_t stride = CalcStride(layer_[layerId].layerInfo.width, layer_[layerId].layerInfo.pixFormat); + uint32_t stride = CalcStride(layerInfo.width, layerInfo.pixFormat); if (stride == 0) { return false; } -#endif uint8_t index = 0; - while (index < layer_[layerId].bufferCount) { + while (index < count) { AllocInfo info; + if (isFb) { #if ENABLE_GMMU - info.usage = HBM_USE_MEM_FB; + info.usage = HBM_USE_MEM_FB; #else - info.expectedSize = stride * (uint16_t)layer_[layerId].layerInfo.height; - info.usage = HBM_USE_ASSIGN_SIZE | HBM_USE_MEM_FB; + info.expectedSize = stride * (uint16_t)layerInfo.height; + info.usage = HBM_USE_ASSIGN_SIZE | HBM_USE_MEM_FB; #endif + } else { + info.usage = HBM_USE_ASSIGN_SIZE; + info.expectedSize = stride * (uint16_t)layerInfo.height; + } + GrallocBuffer buffer; if (!GrallocEngines::GetInstance()->AllocBuffer(info, buffer)) { GRAPHIC_LOGE("AllocMem failed."); - goto ERROR; + FreeBuffer(layerBuffer, index); + return false; } - layer_[layerId].buffer[index].data.virAddr = buffer.virAddr; - layer_[layerId].buffer[index].data.phyAddr = reinterpret_cast(buffer.virAddr); - layer_[layerId].buffer[index].width = layer_[layerId].layerInfo.width; - layer_[layerId].buffer[index].height = layer_[layerId].layerInfo.height; + layerBuffer[index].data.virAddr = buffer.virAddr; + layerBuffer[index].data.phyAddr = reinterpret_cast(buffer.virAddr); + layerBuffer[index].width = layerInfo.width; + layerBuffer[index].height = layerInfo.height; + if (isFb) { #if ENABLE_GMMU - layer_[layerId].buffer[index].pitch = static_cast(buffer.stride); + layerBuffer[index].pitch = static_cast(buffer.stride); #else - layer_[layerId].buffer[index].pitch = (int32_t)stride; + layerBuffer[index].pitch = (int32_t)stride; #endif - layer_[layerId].buffer[index].pixFormat = layer_[layerId].layerInfo.pixFormat; + } else { + layerBuffer[index].pitch = (int32_t)stride; + } + layerBuffer[index].pixFormat = layerInfo.pixFormat; ++index; } + return true; -ERROR: - for (uint8_t i = 0; i < index; i++) { - GrallocEngines::GetInstance()->FreeBuffer((uint8_t*)layer_[layerId].buffer[i].data.virAddr); - ClearLayerBuffer(layer_[layerId].buffer[i]); +} + +void DisplayDev::FreeBuffer(LayerBuffer *buffer, uint8_t count) +{ + if (buffer == nullptr || count == 0) { + return; + } + + for (uint8_t i = 0; i < count; i++) { + GrallocEngines::GetInstance()->FreeBuffer(reinterpret_cast(buffer[i].data.virAddr)); + ClearLayerBuffer(buffer[i]); } - return false; +} + +bool DisplayDev::AllocLayerBuffer(uint8_t layerId) +{ + if (layerId < LAYER_0 || layerId >= LAYER_MAX || layer_[layerId].bufferCount == 0) { + GRAPHIC_LOGE("Invalid layerId[%u] or layer is not opened.", layerId); + return false; + } + + if (layer_[layerId].buffer[0].data.virAddr != nullptr) { + GRAPHIC_LOGE("layer[%u] : Memory of buffers is already allocated.", layerId); + return false; + } + + if (layer_[layerId].rotate != nullptr) { + if (!AllocBuffer(layer_[layerId].buffer, layer_[layerId].layerInfo, layer_[layerId].bufferCount)) { + return false; + } + if (!AllocBuffer(layer_[layerId].rotate, layer_[layerId].rotateInfo, layer_[layerId].bufferCount, false)) { + FreeBuffer(layer_[layerId].buffer, layer_[layerId].bufferCount); + return false; + } + } else { + if (!AllocBuffer(layer_[layerId].buffer, layer_[layerId].layerInfo, layer_[layerId].bufferCount)) { + return false; + } + } + return true; } void DisplayDev::FreeLayerBuffer(uint8_t layerId) @@ -356,9 +579,9 @@ void DisplayDev::FreeLayerBuffer(uint8_t layerId) return; } - for (uint8_t i = 0; i < layer_[layerId].bufferCount; i++) { - GrallocEngines::GetInstance()->FreeBuffer((uint8_t*)layer_[layerId].buffer[i].data.virAddr); - ClearLayerBuffer(layer_[layerId].buffer[i]); + FreeBuffer(layer_[layerId].buffer, layer_[layerId].bufferCount); + if (layer_[layerId].rotate != nullptr) { + FreeBuffer(layer_[layerId].rotate, layer_[layerId].bufferCount); } } @@ -386,7 +609,10 @@ void DisplayDev::SetLayerDirtyRegion(uint8_t layerId, const Rect& rect) if (layerFuncs_->SetLayerDirtyRegion != nullptr) { FRAME_TRACE_SET_RECT(rect); - IRect iRect = {rect.GetX(), rect.GetY(), rect.GetWidth(), rect.GetHeight()}; + Rect outRect = rect; + GetRotateRect( + layer_[layerId].layerInfo.width, layer_[layerId].layerInfo.height, outRect, layer_[layerId].rotateType); + IRect iRect = {outRect.GetX(), outRect.GetY(), outRect.GetWidth(), outRect.GetHeight()}; if (layerFuncs_->SetLayerDirtyRegion(devId_, layer_[layerId].layerHdl, &iRect) != DISPLAY_SUCCESS) { GRAPHIC_LOGE("SetLayerDirtyRegion failed. LayerId: %u.", layerId); @@ -478,6 +704,7 @@ void DisplayDev::DisplayDevInit() } LayerInfo layerInfo; + LayerRotateType type = static_cast(HW_ROTATE_ANGLE); layerInfo.width = HORIZONTAL_RESOLUTION; layerInfo.height = VERTICAL_RESOLUTION; layerInfo.pixFormat = layerPixFmt_; @@ -485,7 +712,7 @@ void DisplayDev::DisplayDevInit() layerInfo.type = LAYER_TYPE_GRAPHIC; uint8_t bufferCount = IsDoubleBuffer() ? 2 : 1; - if (!OpenLayer(LAYER_0, layerInfo, bufferCount)) { + if (!OpenLayer(LAYER_0, layerInfo, bufferCount, type)) { GRAPHIC_LOGE("OpenLayer failed."); return; } @@ -520,4 +747,93 @@ void DisplayDev::DisplayDevClose() } isDisplayDevInited_ = false; } + +#if defined(HW_ROTATE_ANGLE) +static void ConvertPixelFormat2ColorMode(ColorMode& mode, PixelFormat fmt) +{ + switch (fmt) { + case PIXEL_FMT_RGBA_8888: + mode = ARGB8888; + break; + case PIXEL_FMT_RGB_888: + mode = RGB888; + break; + default: + mode = UNKNOW; + break; + } +} + +bool LiteMGfxEngine::RotateBufferIfNecessary() +{ + LayerRotateType rotateType = DisplayDev::GetInstance()->GetLayerRotateType(LAYER_0); + if (rotateType == LayerRotateType::LAYER_ROTATE_NONE) { + return true; + } + LayerBuffer* rotateBuffer = DisplayDev::GetInstance()->GetCurrentBuffer(LAYER_0); + LayerBuffer* buffer = DisplayDev::GetInstance()->GetCurrentRotateBuffer(LAYER_0); + if (rotateBuffer == nullptr || rotateBuffer->data.virAddr == nullptr || + buffer == nullptr || buffer->data.virAddr == nullptr) { + return false; + } + + int32_t rotateBufferWidth = rotateBuffer->width; + int32_t rotateBufferHeight = rotateBuffer->height; + + BufferInfo src; + src.rect = {0, 0, static_cast(rotateBuffer->width - 1), static_cast(rotateBuffer->height - 1)}; + src.virAddr = rotateBuffer->data.virAddr; + src.phyAddr = src.virAddr; + src.stride = rotateBuffer->pitch; + ConvertPixelFormat2ColorMode(src.mode, rotateBuffer->pixFormat); + src.color = 0; + src.width = rotateBuffer->width; + src.height = rotateBuffer->height; + src.compressMode = COMPRESS_MODE_NONE; + + BufferInfo dst; + dst.rect = {0, 0, static_cast(buffer->width - 1), static_cast(buffer->height - 1)}; + dst.virAddr = buffer->data.virAddr; + dst.phyAddr = dst.virAddr; + dst.stride = buffer->pitch; + ConvertPixelFormat2ColorMode(dst.mode, buffer->pixFormat); + dst.color = 0; + dst.width = buffer->width; + dst.height = buffer->height; + dst.compressMode = COMPRESS_MODE_NONE; + + BlendOption blendOption; + + switch (rotateType) { + case LayerRotateType::LAYER_ROTATE_90: { + float rotAngle = 90; + blendOption.transMap.Rotate(rotAngle, Vector2{0, 0}); + blendOption.transMap.Translate(Vector2{static_cast(src.height), 0}); + break; + } + case LayerRotateType::LAYER_ROTATE_180: { + float rotAngle = 180; + blendOption.transMap.Rotate(rotAngle, Vector2{0, 0}); + blendOption.transMap.Translate( + Vector2{static_cast(src.width), static_cast(src.height)}); + break; + } + case LayerRotateType::LAYER_ROTATE_270: { + float rotAngle = 270; + blendOption.transMap.Rotate(rotAngle, Vector2{0, 0}); + blendOption.transMap.Translate(Vector2{0, static_cast(src.width)}); + break; + } + default: + GRAPHIC_LOGE("error rotate type %d", rotateType); + return false; + } + + blendOption.opacity = OPA_OPAQUE; + blendOption.mode = BLEND_SRC_OVER; + BaseGfxEngine::GetInstance()->Blit(dst, {0, 0}, src, dst.rect, blendOption); + + return true; +} +#endif } // namespace OHOS diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/frameworks/hals/gralloc_engines.cpp b/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/frameworks/hals/gralloc_engines.cpp index e07764dbd..645bfe95c 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/frameworks/hals/gralloc_engines.cpp +++ b/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/frameworks/hals/gralloc_engines.cpp @@ -126,6 +126,18 @@ void GrallocEngines::FreeBuffer(uint8_t* virAddr) } } +uint8_t* GrallocEngines::AllocBufferBySize(uint32_t size, uint64_t usage) +{ + AllocInfo info; + info.expectedSize = size; + info.usage = usage; + GrallocBuffer buffer; + if (!AllocBuffer(info, buffer)) { + return nullptr; + } + return reinterpret_cast(buffer.virAddr); +} + #if ENABLE_MEMORY_CHECK void GrallocEngines::DumpMem(bool dumpDetails) { diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/frameworks/hals/lite_input_distributer.cpp b/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/frameworks/hals/lite_input_distributer.cpp index 2ed0314dd..413505b48 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/frameworks/hals/lite_input_distributer.cpp +++ b/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/frameworks/hals/lite_input_distributer.cpp @@ -36,16 +36,22 @@ void LiteInputDistributer::SendRawEvent(const RawEvent& rawEvent) #if !defined(_WIN32) RawEvent event = rawEvent; DisplayDev* displayDev = DisplayDev::GetInstance(); - if ((event.type == InputDevType::INDEV_TYPE_TOUCH) && - (displayDev->GetLayerRotateType(LAYER_0) == LayerRotateType::LAYER_ROTATE_90)) { - LayerBuffer* buffer = displayDev->GetCurrentBuffer(LAYER_0); + if (event.type == InputDevType::INDEV_TYPE_TOUCH) { + LayerBuffer *buffer = displayDev->GetCurrentBuffer(LAYER_0); if (buffer == nullptr) { return; } - - int16_t tmp = buffer->height - event.x; - event.x = event.y; - event.y = tmp; + if (displayDev->GetLayerRotateType(LAYER_0) == LayerRotateType::LAYER_ROTATE_90) { + int16_t tmp = buffer->height - event.x; + event.x = event.y; + event.y = tmp; + } else if (displayDev->GetLayerRotateType(LAYER_0) == LayerRotateType::LAYER_ROTATE_180) { + event.x = buffer->width - event.x; + event.y = buffer->height - event.y; + } else if (displayDev->GetLayerRotateType(LAYER_0) == LayerRotateType::LAYER_ROTATE_270) { + event.x = buffer->width - rawEvent.y; + event.y = rawEvent.x; + } } #ifdef CONFIG_SUPPORTED_POWERMGR SendEventToPM(event); diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/frameworks/mem_custom.cpp b/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/frameworks/mem_custom.cpp index 664c3c9fd..7773497fe 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/frameworks/mem_custom.cpp +++ b/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/frameworks/mem_custom.cpp @@ -25,28 +25,27 @@ namespace OHOS { void* ImageCacheMalloc(ImageInfo& info) { - AllocInfo allocInfo; - allocInfo.expectedSize = info.dataSize; - allocInfo.usage = HBM_USE_ASSIGN_SIZE; - GrallocBuffer buffer; - if (!GrallocEngines::GetInstance()->AllocBuffer(allocInfo, buffer)) { + uint8_t* addr = GrallocEngines::GetInstance()->AllocBufferBySize(info.dataSize); + if (addr == nullptr) { GRAPHIC_LOGE("ImageCacheMalloc failed! size = %u", info.dataSize); return nullptr; } - info.phyAddr = reinterpret_cast(buffer.phyAddr); - info.data = reinterpret_cast(buffer.virAddr); + info.phyAddr = addr; + info.data = addr; info.fileLen = 0; info.resId = 0; - return buffer.virAddr; + return reinterpret_cast(addr); } -void ImageCacheFree(ImageInfo& info) +void ImageCacheFree(ImageInfo& info, bool syncHwDraw) { if (info.data == nullptr) { return; } - LiteMGfxEngine::GetInstance()->SyncHwDraw(); + if (syncHwDraw) { + LiteMGfxEngine::GetInstance()->SyncHwDraw(); + } GrallocEngines::GetInstance()->FreeBuffer(const_cast(info.data)); info.phyAddr = nullptr; info.data = nullptr; diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/innerkits/hals/display_dev.h b/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/innerkits/hals/display_dev.h index 24707c003..26518b3fd 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/innerkits/hals/display_dev.h +++ b/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/innerkits/hals/display_dev.h @@ -141,7 +141,13 @@ public: LayerBuffer* GetNextBuffer(uint8_t layerId); - uint32_t CalcStride(uint32_t width, PixelFormat fmt); + LayerBuffer* GetCurrentRotateBuffer(uint8_t layerId); + + void GetRotatePosition(int32_t width, int32_t height, int32_t &x, int32_t &y, LayerRotateType type) const; + void GetRotateRect(int32_t width, int32_t height, Rect &rect, LayerRotateType type) const; + + uint32_t CalcStride(uint32_t width, PixelFormat fmt, uint8_t cmpMode = 0); + uint32_t CalcSize(uint32_t stride, uint32_t height, uint8_t cmpMode); bool IsUlpsEnabled(void); bool TryExitUlps(bool isFlushing); bool IsDoubleBuffer(void); @@ -155,8 +161,10 @@ public: struct Layer { uint32_t layerHdl; LayerInfo layerInfo; + LayerInfo rotateInfo; uint8_t bufferCount; LayerBuffer* buffer; + LayerBuffer* rotate; LayerRotateType rotateType; Point pos; }; @@ -165,6 +173,8 @@ public: private: DisplayDev(); virtual ~DisplayDev() {} + bool AllocBuffer(LayerBuffer *layerBuffer, const LayerInfo &layerInfo, uint8_t count, bool isFb = true); + void FreeBuffer(LayerBuffer *buffer, uint8_t count); bool isDisplayDevInited_ : 1; uint32_t devId_; diff --git a/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/innerkits/hals/gralloc_engines.h b/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/innerkits/hals/gralloc_engines.h index e83c50691..38a5af8b4 100644 --- a/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/innerkits/hals/gralloc_engines.h +++ b/code/sdk/middleware/services/gui/uikit/proprietary/src/utils/innerkits/hals/gralloc_engines.h @@ -39,8 +39,8 @@ public: bool Init(); bool AllocBuffer(const AllocInfo& info, GrallocBuffer& buffer); - bool AllocBufferOnce(const AllocInfo& info, GrallocBuffer& buffer); void FreeBuffer(uint8_t* virAddr); + uint8_t* AllocBufferBySize(uint32_t size, uint64_t usage = HBM_USE_ASSIGN_SIZE); #if ENABLE_MEMORY_CHECK void DumpMem(bool dumpDetails = false); void SetMemMonitor(bool enable); diff --git a/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_cross/ui_test_cross.cpp b/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_cross/ui_test_cross.cpp index c95805f19..604bf640a 100644 --- a/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_cross/ui_test_cross.cpp +++ b/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_cross/ui_test_cross.cpp @@ -15,7 +15,7 @@ #include "engines/gfx/lite_m_gfx_engine.h" #include "ui_test_cross.h" #ifdef SUPPORT_OHOSFWK -#include "ui_screennotify.h" +#include "screennotify/ui_screennotify.h" #endif namespace OHOS { diff --git a/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_draw/ui_test_canvas_ext.cpp b/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_draw/ui_test_canvas_ext.cpp index 83db4663c..1249ec641 100644 --- a/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_draw/ui_test_canvas_ext.cpp +++ b/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_draw/ui_test_canvas_ext.cpp @@ -71,7 +71,7 @@ void UITestCanvasExt::SetUp() SetUpBtn(addSquareBtn_, "Add Square", X_300, 0); // 0: Y coordinate SetUpBtn(addSectorBtn_, "Add Sector", X_300, 60); // 60: Y coordinate SetUpBtn(clearBtn_, "Clear", X_300, 120); // 120: Y coordinate - SetUpBtn(transBtn_, "Y: +150", X_300, 180); // 180: Y coordinate + SetUpBtn(transBtn_, "Y: +100", X_300, 180); // 180: Y coordinate SetUpBtn(scaleBtn_, "Scale 0.5", X_300, 240); // 240: Y coordinate SetUpBtn(rotateBtn_, "Rotate 90", X_300, 300); // 300: Y coordinate SetUpBtn(matrixBtn_, "Matrix", X_300, 360); // 360: Y coordinate @@ -191,10 +191,13 @@ const UIView* UITestCanvasExt::GetTestView() { DrawArc(canvas_); DrawRect(canvas_); + DrawRoundRect(canvas_); DrawLine(canvas_); DrawCurve(canvas_); Draw123(canvas_); DrawPattern(canvas_); + DrawImage(canvas_); + DrawLabel(canvas_); return container_; } @@ -304,6 +307,22 @@ void UITestCanvasExt::DrawRect(UICanvasExt* canvas) } } +void UITestCanvasExt::DrawRoundRect(UICanvasExt* canvas) +{ + PaintExt paint; + paint.SetStyle(Paint::PaintStyle::STROKE_FILL_STYLE); + paint.SetStrokeWidth(10); // 10: stroke width + paint.SetStrokeColor(Color::Purple()); + paint.SetOpacity(125); // 125: opa + paint.SetFillColor(Color::Navy()); + paint.SetFillRule(FillRule::EVEN_ODD); + paint.SetAntialiased(true); + int16_t index = canvas->DrawRect({240, 220}, 50, 50, paint, 10); // 240, 220, 50, 10 : coordinate, radius + if (matrixIndex_ == -1) { + matrixIndex_ = index; + } +} + void UITestCanvasExt::DrawArc(UICanvasExt* canvas) { PaintExt paint; @@ -340,6 +359,15 @@ void UITestCanvasExt::DrawArc(UICanvasExt* canvas) canvas->DrawArc({cx, cy}, 30, 10, 390, paint); // 30, 10, 390: radius, startAngle, endAngle canvas->DrawArc({cx, cy}, 35, 380, 270, paint); // 35, 380, 270: radius, startAngle, endAngle canvas->DrawArc({cx, cy}, 40, 540, 630, paint); // 40, 540, 630: radius, startAngle, endAngle + + cx += 100; // 100: offset + paint.SetStyle(Paint::PaintStyle::FILL_STYLE); + paint.SetFillColor(Color::Red()); + paint.SetOpacity(OPA_OPAQUE); + canvas->DrawArc({cx, cy}, 40, 270, 360, paint); // 40, 270, 360: radius, startAngle, endAngle + canvas->DrawArc({cx, cy}, 40, 0, 90, paint); // 40, 0, 90: radius, startAngle, endAngle + canvas->DrawArc({cx, cy}, 40, 90, 180, paint); // 40, 90, 180: radius, startAngle, endAngle + canvas->DrawArc({cx, cy}, 40, 180, 270, paint); // 40, 180, 270: radius, startAngle, endAngle } void UITestCanvasExt::DrawSector(UICanvasExt* canvas) @@ -369,6 +397,44 @@ void UITestCanvasExt::DrawPattern(UICanvasExt* canvas) canvas->DrawRect({0, 0}, 160, 160, paint); // 160, 160: left, top, width, height Matrix3 mat2(1, 0, 0, 0, 1, 0, 250, 370, 1); // 250, 370: x/y axis translate canvas->SetMatrix(mat2); + + paint.SetStyle(Paint::PaintStyle::STROKE_STYLE); + paint.SetStrokeWidth(10); // 10: stroke width + Matrix3 patternMat3(1, 0, 0, 0, 1, 0, 0, 0, 1); + paint.SetWrapPattern(PatternType::PATTERN_FILL, Color::Yellow().full, patternMat3, *img_); + canvas->DrawArc({0, 0}, 40, 0, 360, paint); // 40, 0, 360: radius, startAngle, endAngle + Matrix3 mat3(1, 0, 0, 0, 1, 0, 100, 500, 1); // 100, 500: x/y axis translate + canvas->SetMatrix(mat3); +} + +void UITestCanvasExt::DrawImage(UICanvasExt* canvas) +{ + PaintExt paint; + canvas->DrawImage({200, 400}, RES_PATH"PROGRESS_BAR_TMAGE.bin", paint); // 200, 400: startPoint + Matrix3 mat(1, 0, 0, 0, 1, 0, 50, 0, 1); // 50: x axis translate + canvas->SetMatrix(mat); + + paint.Scale(0.5, 0.5); // 0.5: scale factor + paint.Rotate(30, 200, 400); // 30: rotate angle, 200, 400: coordinates + paint.Translate(0, 50); // 50: y axis translate + canvas->DrawImage({200, 400}, RES_PATH"haha.bin", paint); // 200, 400: startPoint +} + +void UITestCanvasExt::DrawLabel(UICanvasExt* canvas) +{ + PaintExt paint; + paint.SetFillColor(Color::Blue()); + UICanvasExt::FontStyle fontStyle; + fontStyle.align = TEXT_ALIGNMENT_LEFT; + fontStyle.direct = TEXT_DIRECT_LTR; + fontStyle.fontName = DEFAULT_VECTOR_FONT_FILENAME; + fontStyle.fontSize = 10; // 10: font size + fontStyle.letterSpace = 5; // 5 letter space + // {180, 30}: start point coordinates, 100: max width + canvas->DrawLabel({180, 30}, "canvasext label绘制", 100, fontStyle, paint); + Matrix3 rotate = Matrix3::Rotate(45, {180.0f, 30.0f}); // 180.0f, 30.0f: coordinates, 45: angle + canvas->SetMatrix(rotate); } + #endif } diff --git a/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_draw/ui_test_canvas_ext.h b/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_draw/ui_test_canvas_ext.h index ffe4ca44d..85cf83915 100644 --- a/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_draw/ui_test_canvas_ext.h +++ b/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_draw/ui_test_canvas_ext.h @@ -53,11 +53,14 @@ private: void Add3(UICanvasExt* canvas); void DrawCurve(UICanvasExt* canvas); void DrawRect(UICanvasExt* canvas); + void DrawRoundRect(UICanvasExt* canvas); void DrawLine(UICanvasExt* canvas); void DrawArc(UICanvasExt* canvas); void DrawSector(UICanvasExt* canvas); void SetUpBtn(UILabelButton*& btn, const char* text, int16_t x, int16_t y); void DrawPattern(UICanvasExt* canvas); + void DrawImage(UICanvasExt* canvas); + void DrawLabel(UICanvasExt* canvas); int16_t matrixIndex_ = -1; UICanvasExt* canvas_ = nullptr; UILabelButton* addSquareBtn_ = nullptr; diff --git a/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_lottie/ui_test_lottie.cpp b/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_lottie/ui_test_lottie.cpp new file mode 100644 index 000000000..6d0d7f194 --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_lottie/ui_test_lottie.cpp @@ -0,0 +1,92 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025. All rights reserved. + * Description: Lottie Test + * Author: Hisi Graphic Team + * Created: 2025-6 + */ + +#include "ui_test_lottie.h" +#include "common/image_cache_manager.h" + +namespace OHOS { +constexpr uint8_t FILE_MAX = 8; +static char* g_filePath[FILE_MAX] = { + RES_PATH"2016_lottie.bin", + RES_PATH"singing-contract.bin", + RES_PATH"girl-cycling-in-autumn.bin", + RES_PATH"loading.bin", + RES_PATH"ripple_loading_animation.bin", + RES_PATH"starts_transparent.bin", + RES_PATH"fingerprint_success.bin", + RES_PATH"intelia_logo_animation.bin", +}; + +void UITestLottie::SetUp() +{ + fileIndex_ = 0; + if (container_ == nullptr) { + container_ = new UIViewGroup(); + } + container_->SetPosition(0, 0, Screen::GetInstance().GetWidth(), Screen::GetInstance().GetHeight()); + container_->SetStyle(STYLE_BACKGROUND_OPA, OPA_OPAQUE); + container_->SetStyle(STYLE_BACKGROUND_COLOR, Color::Black().full); + + if (lottieView_ == nullptr) { + lottieView_ = new UILottView(); + lottieView_->SetPosition(0, 0, Screen::GetInstance().GetWidth(), Screen::GetInstance().GetHeight()); + lottieView_->SetStyle(STYLE_BACKGROUND_OPA, OPA_OPAQUE); + lottieView_->SetStyle(STYLE_BACKGROUND_COLOR, Color::White().full); + if (lottieView_->SetSrc(g_filePath[fileIndex_])) { + lottieView_->Start(); + } + fileIndex_++; + } + container_->Add(lottieView_); + + startBtn_ = new UILabelButton(); + startBtn_->SetPosition(167, 400, 60, 50); // 167, 400, 60, 50: coordinate + startBtn_->SetOnClickListener(this); + startBtn_->SetText("Start"); + container_->Add(startBtn_); + + switchBtn_ = new UILabelButton(); + switchBtn_->SetPosition(237, 400, 60, 50); // 237, 400, 60, 50: coordinate + switchBtn_->SetOnClickListener(this); + switchBtn_->SetText("Switch"); + container_->Add(switchBtn_); +} + +void UITestLottie::TearDown() +{ + DeleteChildren(container_); + lottieView_ = nullptr; + startBtn_ = nullptr; + switchBtn_ = nullptr; + container_ = nullptr; +} + +bool UITestLottie::OnClick(UIView& view, const ClickEvent& event) +{ + if (&view == startBtn_) { + if (lottieView_ != nullptr) { + lottieView_->Start(); + } + } + if (&view == switchBtn_) { + if (lottieView_ != nullptr) { + lottieView_->SetSrc(g_filePath[fileIndex_]); + fileIndex_++; + if (fileIndex_ == FILE_MAX) { + fileIndex_ = 0; + } + lottieView_->Start(); + } + } + return true; +} + +const UIView* UITestLottie::GetTestView() +{ + return container_; +} +} \ No newline at end of file diff --git a/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_lottie/ui_test_lottie.h b/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_lottie/ui_test_lottie.h new file mode 100644 index 000000000..97b1aa287 --- /dev/null +++ b/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_lottie/ui_test_lottie.h @@ -0,0 +1,33 @@ +/* + * Copyright (c) HiSilicon (Shanghai) Technologies Co., Ltd. 2025. All rights reserved. + * Description: Lottie Test + * Author: Hisi Graphic Team + * Created: 2025-6 + */ + +#ifndef UI_TEST_LOTTIE_H +#define UI_TEST_LOTTIE_H + +#include "ui_test.h" +#include "lottie/ui_lott_view.h" +#include "components/ui_label_button.h" + +namespace OHOS { +class UITestLottie : public UITest, public UIView::OnClickListener { +public: + UITestLottie() {} + ~UITestLottie() override {} + void SetUp() override; + void TearDown() override; + const UIView* GetTestView() override; + bool OnClick(UIView& view, const ClickEvent& event) override; + +private: + UIViewGroup* container_ = nullptr; + UILottView* lottieView_ = nullptr; + UILabelButton* startBtn_ = nullptr; + UILabelButton* switchBtn_ = nullptr; + uint8_t fileIndex_ = 0; +}; +} +#endif \ No newline at end of file diff --git a/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_video_play/ui_test_video_play.cpp b/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_video_play/ui_test_video_play.cpp index e7637d0d0..e8781a684 100644 --- a/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_video_play/ui_test_video_play.cpp +++ b/code/sdk/middleware/services/gui/uikit/sample/uitest/components/ui_test_video_play/ui_test_video_play.cpp @@ -18,7 +18,7 @@ #include "ui_test_video_play.h" #include "components/root_view.h" #ifdef SUPPORT_OHOSFWK -#include "ui_screennotify.h" +#include "screennotify/ui_screennotify.h" #endif namespace OHOS { diff --git a/code/sdk/middleware/services/gui/uikit/sample/uitest/framework/src/ui_test_group.cpp b/code/sdk/middleware/services/gui/uikit/sample/uitest/framework/src/ui_test_group.cpp index 291311531..bfd663836 100644 --- a/code/sdk/middleware/services/gui/uikit/sample/uitest/framework/src/ui_test_group.cpp +++ b/code/sdk/middleware/services/gui/uikit/sample/uitest/framework/src/ui_test_group.cpp @@ -87,6 +87,7 @@ #include "ui_test_transform_list/ui_test_scale_list.h" #include "ui_test_emoji/ui_test_emoji.h" #include "ui_test_particle/ui_test_particle.h" +#include "ui_test_lottie/ui_test_lottie.h" namespace OHOS { void UITestGroup::AddTestCase(TestCaseInfo testCaseInfo) @@ -104,6 +105,7 @@ void UITestGroup::SetUpTestCase() return; } testCaseList_->Clear(); + testCaseList_->PushBack(TestCaseInfo{"Lottie", new UITestLottie()}); testCaseList_->PushBack(TestCaseInfo{"粒子效果", new UITestParticle()}); testCaseList_->PushBack(TestCaseInfo{"瀑布列表", new UITestWaterfallList()}); testCaseList_->PushBack(TestCaseInfo{"老虎头", new UITestTiger()}); diff --git a/code/sdk/middleware/services/gui/uikit/ui/frameworks/common/text.cpp b/code/sdk/middleware/services/gui/uikit/ui/frameworks/common/text.cpp index 19d9375bd..24fb435a8 100644 --- a/code/sdk/middleware/services/gui/uikit/ui/frameworks/common/text.cpp +++ b/code/sdk/middleware/services/gui/uikit/ui/frameworks/common/text.cpp @@ -239,12 +239,16 @@ void Text::Draw(BufferInfo& gfxDstBuffer, pos.y = TextPositionY(coords, (lineCount * lineHeight - style.lineSpace_)); } OpacityType opa = DrawUtils::GetMixOpacity(opaScale, style.textOpa_); + bool isTransValid = false; + if (transMap_ != nullptr && !transMap_->IsInvalid()) { + isTransValid = true; + } for (int i = 0; i < lineCount; i++) { - if (pos.y > mask.GetBottom() || pos.y > coords.GetBottom()) { + if (!isTransValid && pos.y > mask.GetBottom()) { return; } int16_t nextLine = pos.y + lineHeight; - if (nextLine >= mask.GetTop() && nextLine >= coords.GetTop()) { + if (isTransValid || nextLine >= mask.GetTop()) { pos.x = LineStartPos(coords, textLine_[i].linePixelWidth); LabelLineInfo labelLine{pos, offset, mask, lineHeight, textLine_[i].lineBytes, 0, opa, style, &text_[lineBegin], textLine_[i].lineBytes, diff --git a/code/sdk/middleware/services/gui/uikit/ui/frameworks/components/text_adapter.cpp b/code/sdk/middleware/services/gui/uikit/ui/frameworks/components/text_adapter.cpp index 1f9c9ae67..cc01aa0a0 100644 --- a/code/sdk/middleware/services/gui/uikit/ui/frameworks/components/text_adapter.cpp +++ b/code/sdk/middleware/services/gui/uikit/ui/frameworks/components/text_adapter.cpp @@ -79,6 +79,12 @@ UIView* TextAdapter::GetView(UIView* inView, int16_t index) } if (label != nullptr) { + label->UIView::SetStyle(style_); + if (fontName_ == nullptr) { + label->SetFontId(fontId_); + } else { + label->SetFont(fontName_, fontSize_); + } if (dataMode_ == DYNAMIC_TEXT_MODE) { ListNode* node = dynamicText_.Begin(); for (int16_t i = 0; i < index; i++) { @@ -135,16 +141,10 @@ UILabel* TextAdapter::CreateUILabel() newView->SetHeight(height_); } - newView->UIView::SetStyle(style_); if (clickListener_) { newView->SetOnClickListener(clickListener_); newView->SetTouchable(true); } - if (fontName_ == nullptr) { - newView->SetFontId(fontId_); - } else { - newView->SetFont(fontName_, fontSize_); - } newView->SetDirect(direct_); return newView; } diff --git a/code/sdk/middleware/services/gui/uikit/ui/frameworks/components/ui_box_progress.cpp b/code/sdk/middleware/services/gui/uikit/ui/frameworks/components/ui_box_progress.cpp index 711cfe68c..8ba66742b 100644 --- a/code/sdk/middleware/services/gui/uikit/ui/frameworks/components/ui_box_progress.cpp +++ b/code/sdk/middleware/services/gui/uikit/ui/frameworks/components/ui_box_progress.cpp @@ -95,6 +95,12 @@ void UIBoxProgress::DrawRoundCap(BufferInfo& gfxDstBuffer, rightTop.y = leftTop.y; rightBottom.x = rightTop.x; rightBottom.y = leftBottom.y; +#if CAPABILITY_HWDRAW_ARC + leftTop.x += 1; + leftTop.y = leftBottom.y; + rightTop.y = leftTop.y; + leftBottom.x = leftTop.x; +#endif break; } @@ -108,6 +114,12 @@ void UIBoxProgress::DrawRoundCap(BufferInfo& gfxDstBuffer, leftBottom.y = rect.GetBottom() + 1; rightBottom.x = rightTop.x; rightBottom.y = leftBottom.y; +#if CAPABILITY_HWDRAW_ARC + leftTop.x = rightTop.x; + leftTop.y += 1; + rightTop.y = leftTop.y; + leftBottom.x = leftTop.x; +#endif break; } default: diff --git a/code/sdk/middleware/services/gui/uikit/ui/frameworks/components/ui_circle_progress.cpp b/code/sdk/middleware/services/gui/uikit/ui/frameworks/components/ui_circle_progress.cpp index eab2bb89c..6edd9b503 100644 --- a/code/sdk/middleware/services/gui/uikit/ui/frameworks/components/ui_circle_progress.cpp +++ b/code/sdk/middleware/services/gui/uikit/ui/frameworks/components/ui_circle_progress.cpp @@ -61,10 +61,29 @@ void UICircleProgress::GetStartEndAngle(int16_t& start, int16_t& end) const } } +#if ENABLE_VGU_ENGINE && CAPABILITY_HWDRAW_PATH +static void HwGetAngleRange(int16_t &start, int16_t &end) +{ + int16_t range = end - start; + int16_t absRange = (range < 0 ? -range : range); + if (absRange >= CIRCLE_IN_DEGREE) { + start = 0; + end = CIRCLE_IN_DEGREE; + return; + } + start = (start < 0 ? (start % CIRCLE_IN_DEGREE + CIRCLE_IN_DEGREE) : (start % CIRCLE_IN_DEGREE)); + end = start + range; +} +#endif + void UICircleProgress::GetAngleRange(int16_t& start, int16_t& end) const { GetStartEndAngle(start, end); +#if ENABLE_VGU_ENGINE && CAPABILITY_HWDRAW_PATH + HwGetAngleRange(start, end); +#else DrawArc::GetInstance()->GetDrawRange(start, end); +#endif } void UICircleProgress::GetRedrawAngle(int16_t& start, int16_t& end) const @@ -84,9 +103,13 @@ void UICircleProgress::GetRedrawAngle(int16_t& start, int16_t& end) const } else { end = angle + start; } +#if ENABLE_VGU_ENGINE && CAPABILITY_HWDRAW_PATH + HwGetAngleRange(start, end); +#else DrawArc::GetInstance()->GetDrawRange(start, end); +#endif } - +#if ENABLE_VGU_ENGINE && CAPABILITY_HWDRAW_PATH void UICircleProgress::DrawForegroundGradient(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea, const Point& point, const uint16_t& radius, const Vector2& angle) { @@ -112,7 +135,7 @@ void UICircleProgress::DrawForegroundGradient(BufferInfo& gfxDstBuffer, const Re int16_t strokeWidth = foregroundStyle_->lineWidth_; RenderGradientStroke(gfxDstBuffer, invalidatedArea, strokeWidth); } - +#endif void UICircleProgress::DrawCommonCircle(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea) { ArcInfo arcinfo = {{0}}; @@ -144,11 +167,13 @@ void UICircleProgress::DrawCommonCircle(BufferInfo& gfxDstBuffer, const Rect& in arcinfo.startAngle = startAngle; arcinfo.endAngle = endAngle; arcinfo.imgSrc = foregroundImage_; +#if ENABLE_VGU_ENGINE && CAPABILITY_HWDRAW_PATH if (foregroundStopCount_ != 0) { DrawForegroundGradient(gfxDstBuffer, invalidatedArea, arcinfo.center, arcinfo.radius, Vector2{arcinfo.startAngle, arcinfo.endAngle}); return; } +#endif BaseGfxEngine::GetInstance()->DrawArc(gfxDstBuffer, arcinfo, invalidatedArea, *foregroundStyle_, opaScale_, foregroundStyle_->lineCap_); } diff --git a/code/sdk/middleware/services/gui/uikit/ui/frameworks/components/ui_picker.cpp b/code/sdk/middleware/services/gui/uikit/ui/frameworks/components/ui_picker.cpp index 8e364e77c..0bd240e4b 100644 --- a/code/sdk/middleware/services/gui/uikit/ui/frameworks/components/ui_picker.cpp +++ b/code/sdk/middleware/services/gui/uikit/ui/frameworks/components/ui_picker.cpp @@ -297,7 +297,7 @@ void UIPicker::RefreshList() itemsWidth_ = GetWidth(); textAdapter_->SetWidth(itemsWidth_); textAdapter_->SetHeight(itemsHeight_); - textAdapter_->SetLineBreakMode(UILabel::LINE_BREAK_CLIP); + textAdapter_->SetLineBreakMode(lineBreakMode_); if (backgroundFontName_ == nullptr) { textAdapter_->SetFontId(backgroundFontId_); } else { @@ -459,6 +459,13 @@ void UIPicker::SetItemHeight(int16_t height) } } +void UIPicker::SetTextLineBreakMode(const uint8_t lineBreakMode) +{ + InitTextAdapter(); + lineBreakMode_ = lineBreakMode; + Refresh(); +} + void UIPicker::SetWidth(int16_t width) { if (width > 0) { diff --git a/code/sdk/middleware/services/gui/uikit/ui/frameworks/components/ui_view_group.cpp b/code/sdk/middleware/services/gui/uikit/ui/frameworks/components/ui_view_group.cpp index 43ed8fc4a..d14718d7d 100644 --- a/code/sdk/middleware/services/gui/uikit/ui/frameworks/components/ui_view_group.cpp +++ b/code/sdk/middleware/services/gui/uikit/ui/frameworks/components/ui_view_group.cpp @@ -170,7 +170,7 @@ void UIViewGroup::RemoveAndDeleteAllRecursively(UIViewGroup*& group) UIViewType type = group->GetViewType(); if ((type == UI_DIGITAL_CLOCK) || (type == UI_PICKER) || (type == UI_TIME_PICKER) || (type == UI_MENU_ITEM) || - (type == UI_IMAGE_PICKER) || (type == UI_ROLLER_VIEW) || (type == UI_COVER_FLOW)) { + (type == UI_IMAGE_PICKER) || (type == UI_ROLLER_VIEW) || (type == UI_COVER_FLOW) || (type == UI_LIST)) { delete group; group = nullptr; return; @@ -195,6 +195,8 @@ void UIViewGroup::RemoveAndDeleteAllRecursively(UIViewGroup*& group) UIViewGroup* tmpGroup = dynamic_cast(tmp); RemoveAndDeleteAllRecursively(tmpGroup); } else { + tmp->SetParent(nullptr); + tmp->SetNextSibling(nullptr); delete tmp; } } diff --git a/code/sdk/middleware/services/gui/uikit/ui/frameworks/font/ui_font_vector.cpp b/code/sdk/middleware/services/gui/uikit/ui/frameworks/font/ui_font_vector.cpp index 4c36db7ae..ecf5bbd97 100644 --- a/code/sdk/middleware/services/gui/uikit/ui/frameworks/font/ui_font_vector.cpp +++ b/code/sdk/middleware/services/gui/uikit/ui/frameworks/font/ui_font_vector.cpp @@ -200,7 +200,7 @@ int16_t UIFontVector::GetEmojiHeight() return GetHeight(); } -uint16_t UIFontVector::GetEmojiWidth(uint32_t unicode, uint8_t fontId) +int16_t UIFontVector::GetEmojiWidth(uint32_t unicode, uint8_t fontId) { ImageInfo info; if (!GetEmoji(unicode, info)) { diff --git a/code/sdk/middleware/services/gui/uikit/ui/interfaces/innerkits/font/ui_font_vector.h b/code/sdk/middleware/services/gui/uikit/ui/interfaces/innerkits/font/ui_font_vector.h index e777127a7..c920bbc03 100644 --- a/code/sdk/middleware/services/gui/uikit/ui/interfaces/innerkits/font/ui_font_vector.h +++ b/code/sdk/middleware/services/gui/uikit/ui/interfaces/innerkits/font/ui_font_vector.h @@ -50,7 +50,7 @@ public: int32_t OpenVectorFont(uint8_t ttfId) override; bool GetEmoji(uint32_t unicode, ImageInfo &unicodeInfo); int16_t GetEmojiHeight(); - uint16_t GetEmojiWidth(uint32_t unicode, uint8_t fontId); + int16_t GetEmojiWidth(uint32_t unicode, uint8_t fontId); protected: bool freeTypeInited_; diff --git a/code/sdk/middleware/services/gui/uikit/ui/interfaces/kits/components/ui_circle_progress.h b/code/sdk/middleware/services/gui/uikit/ui/interfaces/kits/components/ui_circle_progress.h index e07b63683..7fc5f84b3 100644 --- a/code/sdk/middleware/services/gui/uikit/ui/interfaces/kits/components/ui_circle_progress.h +++ b/code/sdk/middleware/services/gui/uikit/ui/interfaces/kits/components/ui_circle_progress.h @@ -249,9 +249,10 @@ private: void GetAngleRange(int16_t& start, int16_t& end) const; void GetRedrawAngle(int16_t& start, int16_t& end) const; void DrawCommonCircle(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea); +#if ENABLE_VGU_ENGINE && CAPABILITY_HWDRAW_PATH void DrawForegroundGradient(BufferInfo& gfxDstBuffer, const Rect& invalidatedArea, const Point& point, const uint16_t& radius, const Vector2& angle); - +#endif Point center_; Point backgroundImagePos_; Point progressImagePos_; diff --git a/code/sdk/middleware/services/gui/uikit/ui/interfaces/kits/components/ui_picker.h b/code/sdk/middleware/services/gui/uikit/ui/interfaces/kits/components/ui_picker.h index ee74f2922..8a4521068 100644 --- a/code/sdk/middleware/services/gui/uikit/ui/interfaces/kits/components/ui_picker.h +++ b/code/sdk/middleware/services/gui/uikit/ui/interfaces/kits/components/ui_picker.h @@ -134,6 +134,15 @@ public: */ void SetBackgroundFont(const char* name, uint8_t size); + /** + * @brief Sets the line break mode for text. + * + * @param lineBreakMode Indicates the line break mode numebr to set. + * @since 1.0 + * @version 1.0 + */ + void SetTextLineBreakMode(const uint8_t lineBreakMode); + /** * @brief Sets the font name and size for the highlighted text. * diff --git a/code/sdk/middleware/services/gui/uikit/ui/interfaces/kits/components/ui_view_group.h b/code/sdk/middleware/services/gui/uikit/ui/interfaces/kits/components/ui_view_group.h index c05695b89..10412f955 100644 --- a/code/sdk/middleware/services/gui/uikit/ui/interfaces/kits/components/ui_view_group.h +++ b/code/sdk/middleware/services/gui/uikit/ui/interfaces/kits/components/ui_view_group.h @@ -115,12 +115,15 @@ public: virtual void RemoveAll(); /** - * @brief Removes and delete all child views recursively. this method have some limitation: - * 1. Some UI group views delete children in their destructor function, don't delete them repeatly in this - * function in this situation. some special treatment has already been done for below basic UI group views: - * UIPicker UITimePicker UIImagePicker UIDigitalClock UIRollerView UICoverFlow UIMenuItem - * However, the custom UI group views was ignored in this function, so be carefully when using this method. - * 2. Not all children in UICrossView are deleted in this method, you should remove UICardPages in addtion. + * @brief Removes and delete all children views recursively. The following points should be noted: + * 1. If the group and its child views don't delete their child views in their destructior function, + * you can use this mehod safely. + * 2. If the group or its child views delete (all/some of) their child views in their destructor function, + * don't delete it using this method unless it have been specially handled. for example: + * 2.1 if delete all, You can delete it using this method: + * - UIPicker UITimePicker UIImagePicker UIDigitalClock UIRollerView UICoverFlow UIMenuItem UIList + * 2.2 if delete some, You can delete it using this method, and need to delete other children mannually: + * - UICrossView * @since 1.0 * @version 1.0 */ diff --git a/code/sdk/middleware/services/gui/uikit/utils/frameworks/mem_api.cpp b/code/sdk/middleware/services/gui/uikit/utils/frameworks/mem_api.cpp index ebb78c271..d9464bcb3 100644 --- a/code/sdk/middleware/services/gui/uikit/utils/frameworks/mem_api.cpp +++ b/code/sdk/middleware/services/gui/uikit/utils/frameworks/mem_api.cpp @@ -33,7 +33,7 @@ void* ImageCacheMalloc(ImageInfo& info) #endif } -void ImageCacheFree(ImageInfo& info) +void ImageCacheFree(ImageInfo& info, bool syncHwDraw) { uint8_t* buf = const_cast(info.data); #if ENABLE_MEMORY_CHECK diff --git a/code/sdk/middleware/services/gui/uikit/utils/interfaces/innerkits/graphic_config.h b/code/sdk/middleware/services/gui/uikit/utils/interfaces/innerkits/graphic_config.h index 18e4bb240..606fd9031 100644 --- a/code/sdk/middleware/services/gui/uikit/utils/interfaces/innerkits/graphic_config.h +++ b/code/sdk/middleware/services/gui/uikit/utils/interfaces/innerkits/graphic_config.h @@ -573,10 +573,17 @@ static constexpr uint8_t DEFAULT_VECTOR_FONT_SIZE = 18; #define DEFAULT_LINE_BREAK_RULE_FILENAME "line_cj.brk" /* Defines some configurations and their default values on LiteOS and other system platforms. */ #ifdef VERSION_IOT +#if HW_ROTATE_ANGLE == 0 || HW_ROTATE_ANGLE == 2 /* Resolution width of a graphics display screen. The default value is 454. */ static constexpr int16_t HORIZONTAL_RESOLUTION = RESOLUTION_WIDTH; /* Resolution height of a graphics display screen. The default value is 454. */ static constexpr int16_t VERTICAL_RESOLUTION = RESOLUTION_HEIGHT; +#else +/* Resolution width of a graphics display screen. The default value is 454. */ +static constexpr int16_t HORIZONTAL_RESOLUTION = RESOLUTION_HEIGHT; +/* Resolution height of a graphics display screen. The default value is 454. */ +static constexpr int16_t VERTICAL_RESOLUTION = RESOLUTION_WIDTH; +#endif #elif defined _LITEOS /* Resolution width of a graphics display screen. The default value is 454. */ static constexpr int16_t HORIZONTAL_RESOLUTION = RESOLUTION_WIDTH; diff --git a/code/sdk/middleware/services/gui/uikit/utils/interfaces/innerkits/graphic_mutex.h b/code/sdk/middleware/services/gui/uikit/utils/interfaces/innerkits/graphic_mutex.h index a16c1c352..f85e4be74 100644 --- a/code/sdk/middleware/services/gui/uikit/utils/interfaces/innerkits/graphic_mutex.h +++ b/code/sdk/middleware/services/gui/uikit/utils/interfaces/innerkits/graphic_mutex.h @@ -184,5 +184,40 @@ private: pthread_cond_t cond_; #endif }; + +// do not support multi-thread +class GraphicLockGuard { +public: + explicit GraphicLockGuard(GraphicMutex& mutex) : mutex_(mutex) + { + Lock(); + } + ~GraphicLockGuard() + { + Unlock(); + } + void Lock() + { + mutex_.Lock(); + lockCnt_++; + } + void Unlock() + { + if (lockCnt_ > 0) { + mutex_.Unlock(); + lockCnt_--; + } + } + + GraphicLockGuard() = delete; + GraphicLockGuard(const GraphicLockGuard&) = delete; + GraphicLockGuard(const GraphicLockGuard&&) = delete; + GraphicLockGuard& operator=(const GraphicLockGuard&) = delete; + GraphicLockGuard& operator=(const GraphicLockGuard&&) = delete; + +private: + GraphicMutex& mutex_; + int8_t lockCnt_ = 0; +}; } // namespace OHOS #endif // GRAPHIC_LITE_GRAPHIC_MUTEX_H \ No newline at end of file diff --git a/code/sdk/middleware/services/gui/uikit/utils/interfaces/kits/gfx_utils/mem_api.h b/code/sdk/middleware/services/gui/uikit/utils/interfaces/kits/gfx_utils/mem_api.h index 0b53989f6..1040f0e50 100644 --- a/code/sdk/middleware/services/gui/uikit/utils/interfaces/kits/gfx_utils/mem_api.h +++ b/code/sdk/middleware/services/gui/uikit/utils/interfaces/kits/gfx_utils/mem_api.h @@ -58,7 +58,7 @@ void* ImageCacheMalloc(ImageInfo& info); * @since 1.0 * @version 1.0 */ -void ImageCacheFree(ImageInfo& info); +void ImageCacheFree(ImageInfo& info, bool syncHwDraw = true); /** * @brief Applies for memory for the graphics module. You can implement this function to override the malloc and