diff --git a/docs/src/details/integration/embedded_linux/drivers/drm.rst b/docs/src/details/integration/embedded_linux/drivers/drm.rst index 33ea82bbb7..95cda33161 100644 --- a/docs/src/details/integration/embedded_linux/drivers/drm.rst +++ b/docs/src/details/integration/embedded_linux/drivers/drm.rst @@ -96,6 +96,19 @@ Notes - DRM requires proper modesetting. By default, LVGL will select a preferred display mode. +In order to avoid hard codding the device card path, you can ask LVGL to find a connected one for you using :cpp:func:`lv_linux_drm_find_device_path`. +It will return the first connected card it can find. + +.. code-block:: c + + lv_display_t * disp = lv_linux_drm_create(); + + /* Find the first connected card in /sys/class/drm */ + char * device = lv_linux_drm_find_device_path(); + lv_linux_drm_set_file(disp, device, -1); + /* Free the path pointer */ + lv_free(device); + Using DRM with GBM ------------------ diff --git a/docs/src/details/integration/embedded_linux/drivers/egl.rst b/docs/src/details/integration/embedded_linux/drivers/egl.rst index 04081cf618..0a6c148014 100644 --- a/docs/src/details/integration/embedded_linux/drivers/egl.rst +++ b/docs/src/details/integration/embedded_linux/drivers/egl.rst @@ -43,19 +43,6 @@ This API is currently private and experimental, and people should expect breakin This allows you to use EGL with your own context management or other platforms, but the API may change without notice in future versions. -Render Direct to Window ------------------------ - -.. warning:: - - This feature is incomplete and has bugs. - -Performance can be improved if the LVGL OpenGL driver renders its cached textures directly to the window -(and :c:macro:`LV_USE_DRAW_OPENGLES` is enabled). This can be done by creating the display with -:cpp:func:`lv_opengles_window_display_create` instead of :cpp:func:`lv_opengles_texture_create` + -:cpp:func:`lv_opengles_texture_get_texture_id` + :cpp:func:`lv_opengles_window_add_texture`. -Performance should be better with GLFW than EGL. EGL currently has issues when used this way. - Improving Performance --------------------- diff --git a/scripts/code-format.cfg b/scripts/code-format.cfg index c69b5e5260..e7a4de9ca4 100644 --- a/scripts/code-format.cfg +++ b/scripts/code-format.cfg @@ -50,6 +50,7 @@ --exclude=../src/libs/expat --exclude=../src/libs/lz4 --exclude=../src/libs/FT800-FT813 +--exclude=../src/drivers/opengles/glad --exclude=../src/others/vg_lite_tvg/vg_lite.h --exclude=../demos/high_res/fonts --exclude=../tests/unity/unity.c diff --git a/src/draw/opengles/lv_draw_opengles.c b/src/draw/opengles/lv_draw_opengles.c index 875b8f6bb5..72ded26d0f 100644 --- a/src/draw/opengles/lv_draw_opengles.c +++ b/src/draw/opengles/lv_draw_opengles.c @@ -552,7 +552,6 @@ static void execute_drawing(lv_draw_opengles_unit_t * u) t->draw_unit = (lv_draw_unit_t *)u; /* the shader-based fill is not working reliably with EGL. */ -#if !LV_USE_EGL if(t->type == LV_DRAW_TASK_TYPE_FILL) { lv_draw_fill_dsc_t * fill_dsc = t->draw_dsc; if(fill_dsc->radius == 0 && fill_dsc->grad.dir == LV_GRAD_DIR_NONE) { @@ -581,7 +580,6 @@ static void execute_drawing(lv_draw_opengles_unit_t * u) return; } } -#endif /*!LV_USE_EGL*/ if(t->type == LV_DRAW_TASK_TYPE_LAYER) { blend_texture_layer(t); @@ -621,13 +619,17 @@ static unsigned int create_texture(int32_t w, int32_t h, const void * data) GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)); GL_CALL(glPixelStorei(GL_UNPACK_ALIGNMENT, 1)); - /* LV_COLOR_DEPTH 32, 24, 16 are supported but the cached textures will always + /* LV_COLOR_DEPTH 32, 16 are supported but the cached textures will always * have full ARGB pixels since the alpha channel is required for blending. */ GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_BGRA, GL_UNSIGNED_BYTE, data)); +#if 0 GL_CALL(glGenerateMipmap(GL_TEXTURE_2D)); GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 20)); GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST)); +#endif + + GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)); GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)); GL_CALL(glBindTexture(GL_TEXTURE_2D, 0)); diff --git a/src/drivers/display/drm/lv_linux_drm.c b/src/drivers/display/drm/lv_linux_drm.c index 047b0418fa..640fe7cf3e 100644 --- a/src/drivers/display/drm/lv_linux_drm.c +++ b/src/drivers/display/drm/lv_linux_drm.c @@ -7,7 +7,7 @@ * INCLUDES *********************/ #include "lv_linux_drm.h" -#if LV_USE_LINUX_DRM +#if LV_USE_LINUX_DRM && !LV_LINUX_DRM_USE_EGL #include #include @@ -25,10 +25,6 @@ #include "../../../stdlib/lv_sprintf.h" #include "../../../draw/lv_draw_buf.h" -#if LV_LINUX_DRM_USE_EGL && !LV_USE_LINUX_DRM_GBM_BUFFERS - #error LV_USE_LINUX_DRM_GBM_BUFFERS is required to use LV_LINUX_DRM_USE_EGL -#endif - #if LV_USE_LINUX_DRM_GBM_BUFFERS #include @@ -37,17 +33,6 @@ #endif -#if LV_LINUX_DRM_USE_EGL - - #include "../../opengles/lv_opengles_egl.h" - #include "../../opengles/lv_opengles_texture.h" - #include "../../opengles/lv_opengles_window.h" - #include "../../opengles/lv_opengles_private.h" - #include - #include - -#endif - /********************* * DEFINES *********************/ @@ -61,8 +46,6 @@ #define BUFFER_CNT 2 -#define USE_EGL_EXPERIMENTAL_DIRECT_WINDOW_RENDER 0 - /********************** * TYPEDEFS **********************/ @@ -73,19 +56,8 @@ typedef struct { unsigned long int size; uint8_t * map; uint32_t fb_handle; -#if LV_LINUX_DRM_USE_EGL - uint32_t fb_id; -#endif } drm_buffer_t; -#if LV_LINUX_DRM_USE_EGL - typedef EGLint(*egl_wait_sync_khr_t)(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags); - typedef EGLint(*egl_dup_native_fence_fd_android_t)(EGLDisplay dpy, EGLSyncKHR sync); - typedef EGLSyncKHR(*egl_create_sync_khr_t)(EGLDisplay dpy, EGLenum type, const EGLint * attrib_list); - typedef EGLBoolean(*egl_destroy_sync_khr_t)(EGLDisplay dpy, EGLSyncKHR sync); - typedef EGLint(*egl_client_wait_sync_khr_t)(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout); -#endif - typedef struct { int fd; uint32_t conn_id, enc_id, crtc_id, plane_id, crtc_idx; @@ -111,20 +83,6 @@ typedef struct { #if LV_USE_LINUX_DRM_GBM_BUFFERS struct gbm_device * gbm_device; #endif -#if LV_LINUX_DRM_USE_EGL - struct gbm_surface * surface; - int kms_in_fence_fd; - int kms_out_fence_fd; - EGLSyncKHR kms_fence; - EGLSyncKHR gpu_fence; - struct gbm_bo * bo; - - egl_wait_sync_khr_t egl_wait_sync_khr; - egl_dup_native_fence_fd_android_t egl_dup_native_fence_fd_android; - egl_create_sync_khr_t egl_create_sync_khr; - egl_destroy_sync_khr_t egl_destroy_sync_khr; - egl_client_wait_sync_khr_t egl_client_wait_sync_khr; -#endif } drm_dev_t; /********************** @@ -151,26 +109,15 @@ static uint32_t tick_get_cb(void); #if !LV_USE_LINUX_DRM_GBM_BUFFERS static int drm_allocate_dumb(drm_dev_t * drm_dev, drm_buffer_t * buf); -#elif LV_USE_LINUX_DRM_GBM_BUFFERS && !LV_LINUX_DRM_USE_EGL +#elif LV_USE_LINUX_DRM_GBM_BUFFERS static int create_gbm_buffer(drm_dev_t * drm_dev, drm_buffer_t * buf); #endif -#if LV_LINUX_DRM_USE_EGL - static drm_buffer_t * drm_fb_get_from_bo(struct gbm_bo * bo); - static void drm_fb_destroy_callback(struct gbm_bo * bo, void * data); - static void drm_gbm_egl_pre(lv_opengles_window_t * window); - static void drm_gbm_egl_post1(lv_opengles_window_t * window); - static void drm_gbm_egl_post2(lv_opengles_window_t * window); - static int drm_atomic_commit(drm_dev_t * drm_dev, uint32_t fb_id, uint32_t flags); - static EGLSyncKHR create_fence(drm_dev_t * drm_dev, EGLDisplay display, int fd); -#else - static int drm_setup_buffers(drm_dev_t * drm_dev); - static int drm_dmabuf_set_plane(drm_dev_t * drm_dev, drm_buffer_t * buf); - static void drm_flush_wait(lv_display_t * drm_dev); - static void drm_flush(lv_display_t * disp, const lv_area_t * area, uint8_t * px_map); - static void drm_dmabuf_set_active_buf(lv_event_t * event); -#endif - +static int drm_setup_buffers(drm_dev_t * drm_dev); +static int drm_dmabuf_set_plane(drm_dev_t * drm_dev, drm_buffer_t * buf); +static void drm_flush_wait(lv_display_t * drm_dev); +static void drm_flush(lv_display_t * disp, const lv_area_t * area, uint8_t * px_map); +static void drm_dmabuf_set_active_buf(lv_event_t * event); /********************** * STATIC VARIABLES @@ -198,7 +145,7 @@ lv_display_t * lv_linux_drm_create(void) if(drm_dev == NULL) return NULL; drm_dev->fd = -1; -#if !LV_LINUX_DRM_USE_EGL + disp = lv_display_create(800, 480); if(disp == NULL) { lv_free(drm_dev); @@ -208,18 +155,9 @@ lv_display_t * lv_linux_drm_create(void) lv_display_set_flush_wait_cb(disp, drm_flush_wait); lv_display_set_flush_cb(disp, drm_flush); -#else /*LV_LINUX_DRM_USE_EGL*/ - disp = (lv_display_t *) drm_dev; - - drm_dev->kms_in_fence_fd = -1; - drm_dev->kms_out_fence_fd = -1; - -#endif - return disp; } -#if !LV_LINUX_DRM_USE_EGL /* Called by LVGL when there is something that needs redrawing * it sets the active buffer. if GBM buffers are used, it issues a DMA_BUF_SYNC * ioctl call to lock the buffer for CPU access, the buffer is unlocked just @@ -265,17 +203,12 @@ static void drm_dmabuf_set_active_buf(lv_event_t * event) } } -#endif /*!LV_LINUX_DRM_USE_EGL*/ void lv_linux_drm_set_file(lv_display_t * disp, const char * file, int64_t connector_id) { int ret; -#if !LV_LINUX_DRM_USE_EGL drm_dev_t * drm_dev = lv_display_get_driver_data(disp); -#else - drm_dev_t * drm_dev = (drm_dev_t *) disp; -#endif ret = drm_setup(drm_dev, file, connector_id, DRM_FOURCC); if(ret) { @@ -285,7 +218,6 @@ void lv_linux_drm_set_file(lv_display_t * disp, const char * file, int64_t conne int32_t hor_res = drm_dev->width; int32_t ver_res = drm_dev->height; -#if !LV_LINUX_DRM_USE_EGL ret = drm_setup_buffers(drm_dev); if(ret) { LV_LOG_ERROR("DRM buffer allocation failed"); @@ -317,34 +249,6 @@ void lv_linux_drm_set_file(lv_display_t * disp, const char * file, int64_t conne LV_LOG_INFO("Resolution is set to %" LV_PRId32 "x%" LV_PRId32 " at %" LV_PRId32 "dpi", hor_res, ver_res, lv_display_get_dpi(disp)); - -#else /*LV_LINUX_DRM_USE_EGL*/ - lv_opengles_window_t * window = lv_opengles_egl_window_create(hor_res, ver_res, drm_dev->surface, drm_dev->gbm_device, - drm_gbm_egl_pre, drm_gbm_egl_post1, drm_gbm_egl_post2); - lv_opengles_egl_window_set_user_data(window, drm_dev); - -#if !USE_EGL_EXPERIMENTAL_DIRECT_WINDOW_RENDER - /* create a display that flushes to a texture */ - lv_display_t * texture = lv_opengles_texture_create(hor_res, ver_res); - lv_display_set_default(texture); -#if LV_USE_DRAW_OPENGLES - lv_display_delete_refr_timer(texture); -#endif - /* add the texture to the window */ - unsigned int texture_id = lv_opengles_texture_get_texture_id(texture); - lv_opengles_window_add_texture(window, texture_id, hor_res, ver_res); -#else - /* render directly to the window */ - lv_opengles_window_display_create(window, hor_res, ver_res); -#endif - - drm_dev->egl_wait_sync_khr = (egl_wait_sync_khr_t) eglGetProcAddress("eglWaitSyncKHR"); - drm_dev->egl_dup_native_fence_fd_android = (egl_dup_native_fence_fd_android_t) - eglGetProcAddress("eglDupNativeFenceFDANDROID"); - drm_dev->egl_create_sync_khr = (egl_create_sync_khr_t) eglGetProcAddress("eglCreateSyncKHR"); - drm_dev->egl_destroy_sync_khr = (egl_destroy_sync_khr_t) eglGetProcAddress("eglDestroySyncKHR"); - drm_dev->egl_client_wait_sync_khr = (egl_client_wait_sync_khr_t) eglGetProcAddress("eglClientWaitSyncKHR"); -#endif } /********************** @@ -531,14 +435,13 @@ static int drm_add_conn_property(drm_dev_t * drm_dev, const char * name, uint64_ return 0; } -#if !LV_LINUX_DRM_USE_EGL static int drm_dmabuf_set_plane(drm_dev_t * drm_dev, drm_buffer_t * buf) { int ret; static int first = 1; uint32_t flags = DRM_MODE_PAGE_FLIP_EVENT | DRM_MODE_ATOMIC_NONBLOCK; -#if LV_USE_LINUX_DRM_GBM_BUFFERS && !LV_LINUX_DRM_USE_EGL +#if LV_USE_LINUX_DRM_GBM_BUFFERS struct dma_buf_sync sync_req; @@ -583,7 +486,6 @@ static int drm_dmabuf_set_plane(drm_dev_t * drm_dev, drm_buffer_t * buf) return 0; } -#endif /*!LV_LINUX_DRM_USE_EGL*/ static int find_plane(drm_dev_t * drm_dev, unsigned int fourcc, uint32_t * plane_id, uint32_t crtc_id, uint32_t crtc_idx) @@ -917,20 +819,6 @@ static int drm_setup(drm_dev_t * drm_dev, const char * device_path, int64_t conn LV_LOG_INFO("GBM device backend: %s", gbm_device_get_backend_name(drm_dev->gbm_device)); #endif -#if LV_LINUX_DRM_USE_EGL - - /* Add support to create a surface with modifiers */ - drm_dev->surface = gbm_surface_create(drm_dev->gbm_device, - drm_dev->width, drm_dev->height, GBM_BO_FORMAT_ARGB8888, - GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING); - if(!drm_dev->surface) { - LV_LOG_ERROR("failed to create gbm surface"); - gbm_device_destroy(drm_dev->gbm_device); - goto err; - } - -#endif - return 0; err: @@ -998,7 +886,7 @@ static int drm_allocate_dumb(drm_dev_t * drm_dev, drm_buffer_t * buf) } #endif /*!LV_USE_LINUX_DRM_GBM_BUFFERS*/ -#if LV_USE_LINUX_DRM_GBM_BUFFERS && !LV_LINUX_DRM_USE_EGL +#if LV_USE_LINUX_DRM_GBM_BUFFERS static int create_gbm_buffer(drm_dev_t * drm_dev, drm_buffer_t * buf) { @@ -1082,9 +970,8 @@ static int create_gbm_buffer(drm_dev_t * drm_dev, drm_buffer_t * buf) } -#endif /* LV_USE_LINUX_DRM_GBM_BUFFERS && !LV_LINUX_DRM_USE_EGL*/ +#endif /* LV_USE_LINUX_DRM_GBM_BUFFERS */ -#if !LV_LINUX_DRM_USE_EGL static int drm_setup_buffers(drm_dev_t * drm_dev) { int ret; @@ -1159,204 +1046,6 @@ static void drm_flush(lv_display_t * disp, const lv_area_t * area, uint8_t * px_ drm_dev->act_buf = NULL; } -#endif /*!LV_LINUX_DRM_USE_EGL*/ - -#if LV_LINUX_DRM_USE_EGL - -static void drm_gbm_egl_pre(lv_opengles_window_t * window) -{ - drm_dev_t * drm_dev = lv_opengles_egl_window_get_user_data(window); - if(drm_dev->kms_out_fence_fd != -1) { - EGLDisplay display = lv_opengles_egl_window_get_display(window); - drm_dev->kms_fence = create_fence(drm_dev, display, drm_dev->kms_out_fence_fd); - LV_ASSERT_NULL(drm_dev->kms_fence); - - drm_dev->kms_out_fence_fd = -1; - - int result = drm_dev->egl_wait_sync_khr(display, drm_dev->kms_fence, 0); - LV_ASSERT(result == 1); - } -} - -static void drm_gbm_egl_post1(lv_opengles_window_t * window) -{ - drm_dev_t * drm_dev = lv_opengles_egl_window_get_user_data(window); - EGLDisplay display = lv_opengles_egl_window_get_display(window); - drm_dev->gpu_fence = create_fence(drm_dev, display, EGL_NO_NATIVE_FENCE_FD_ANDROID); - LV_ASSERT_NULL(drm_dev->gpu_fence); -} - -static void drm_gbm_egl_post2(lv_opengles_window_t * window) -{ - drm_dev_t * drm_dev = lv_opengles_egl_window_get_user_data(window); - EGLDisplay display = lv_opengles_egl_window_get_display(window); - - drm_dev->kms_in_fence_fd = drm_dev->egl_dup_native_fence_fd_android(display, drm_dev->gpu_fence); - bool res = drm_dev->egl_destroy_sync_khr(display, drm_dev->gpu_fence); - LV_ASSERT(res); - drm_dev->gpu_fence = NULL; - LV_ASSERT(drm_dev->kms_in_fence_fd != -1); - - drm_buffer_t * fb; - uint32_t flags = DRM_MODE_ATOMIC_NONBLOCK; - int ret; - - /* Get the next bo to display */ - struct gbm_bo * next_bo = gbm_surface_lock_front_buffer(drm_dev->surface); - if(!next_bo) { - LV_LOG_ERROR("Failed to lock frontbuffer"); - } - - fb = drm_fb_get_from_bo(next_bo); - if(!fb) { - LV_LOG_ERROR("Failed to get a new framebuffer BO"); - } - - if(drm_dev->kms_fence) { - EGLint status; - - do { - status = drm_dev->egl_client_wait_sync_khr(display, - drm_dev->kms_fence, - 0, - EGL_FOREVER_KHR); - } while(status != EGL_CONDITION_SATISFIED_KHR); - - bool res = drm_dev->egl_destroy_sync_khr(display, drm_dev->kms_fence); - LV_ASSERT(res); - drm_dev->kms_fence = NULL; - } - - ret = drm_atomic_commit(drm_dev, fb->fb_id, flags); - if(ret) { - LV_LOG_ERROR("failed to commit: %s", strerror(errno)); - } - - /* release last buffer to render on again: */ - if(drm_dev->bo) - gbm_surface_release_buffer(drm_dev->surface, drm_dev->bo); - drm_dev->bo = next_bo; - -} - - -static drm_buffer_t * drm_fb_get_from_bo(struct gbm_bo * bo) -{ - int drm_fd = gbm_device_get_fd(gbm_bo_get_device(bo)); - drm_buffer_t * fb = gbm_bo_get_user_data(bo); - uint32_t width, height, format, strides[4] = {0}, handles[4] = {0}, offsets[4] = {0}; - int ret = -1; - - if(fb) - return fb; - - fb = lv_malloc_zeroed(sizeof(drm_buffer_t)); - - width = gbm_bo_get_width(bo); - height = gbm_bo_get_height(bo); - format = gbm_bo_get_format(bo); - const int num_planes = gbm_bo_get_plane_count(bo); - for(int i = 0; i < num_planes; i++) { - handles[i] = gbm_bo_get_handle_for_plane(bo, i).u32; - strides[i] = gbm_bo_get_stride_for_plane(bo, i); - offsets[i] = gbm_bo_get_offset(bo, i); - } - - memcpy(handles, (uint32_t [4]) { - gbm_bo_get_handle(bo).u32, 0, 0, 0 - }, 16); - memcpy(strides, (uint32_t [4]) { - gbm_bo_get_stride(bo), 0, 0, 0 - }, 16); - memset(offsets, 0, 16); - ret = drmModeAddFB2(drm_fd, width, height, format, - handles, strides, offsets, &fb->fb_id, 0); - fb->fb_handle = fb->fb_id; - - if(ret) { - LV_LOG_ERROR("failed to create fb: %s", strerror(errno)); - lv_free(fb); - return NULL; - } - - gbm_bo_set_user_data(bo, fb, drm_fb_destroy_callback); - - return fb; -} - -static void drm_fb_destroy_callback(struct gbm_bo * bo, void * data) -{ - int drm_fd = gbm_device_get_fd(gbm_bo_get_device(bo)); - drm_buffer_t * fb = data; - - if(fb->fb_id) - drmModeRmFB(drm_fd, fb->fb_id); - - lv_free(fb); -} - -static int drm_atomic_commit(drm_dev_t * drm_dev, uint32_t fb_id, uint32_t flags) -{ - int ret; - static int first = 1; - - drm_dev->req = drmModeAtomicAlloc(); - - /* On first Atomic commit, do a modeset */ - if(first) { - drm_add_conn_property(drm_dev, "CRTC_ID", drm_dev->crtc_id); - - drm_add_crtc_property(drm_dev, "MODE_ID", drm_dev->blob_id); - drm_add_crtc_property(drm_dev, "ACTIVE", 1); - - flags |= DRM_MODE_ATOMIC_ALLOW_MODESET; - - first = 0; - } - - drm_add_plane_property(drm_dev, "FB_ID", fb_id); - drm_add_plane_property(drm_dev, "CRTC_ID", drm_dev->crtc_id); - drm_add_plane_property(drm_dev, "SRC_X", 0); - drm_add_plane_property(drm_dev, "SRC_Y", 0); - drm_add_plane_property(drm_dev, "SRC_W", drm_dev->width << 16); - drm_add_plane_property(drm_dev, "SRC_H", drm_dev->height << 16); - drm_add_plane_property(drm_dev, "CRTC_X", 0); - drm_add_plane_property(drm_dev, "CRTC_Y", 0); - drm_add_plane_property(drm_dev, "CRTC_W", drm_dev->width); - drm_add_plane_property(drm_dev, "CRTC_H", drm_dev->height); - - if(drm_dev->kms_in_fence_fd != -1) { - drm_add_crtc_property(drm_dev, "OUT_FENCE_PTR", (uintptr_t) &drm_dev->kms_out_fence_fd); - drm_add_plane_property(drm_dev, "IN_FENCE_FD", drm_dev->kms_in_fence_fd); - } - - ret = drmModeAtomicCommit(drm_dev->fd, drm_dev->req, flags, NULL); - if(ret) { - LV_LOG_ERROR("drmModeAtomicCommit failed: %s (%d)", strerror(errno), errno); - drmModeAtomicFree(drm_dev->req); - return ret; - } - - if(drm_dev->kms_in_fence_fd != -1) { - close(drm_dev->kms_in_fence_fd); - drm_dev->kms_in_fence_fd = -1; - } - - return 0; -} - -static EGLSyncKHR create_fence(drm_dev_t * drm_dev, EGLDisplay display, int fd) -{ - EGLint attrib_list[] = { - EGL_SYNC_NATIVE_FENCE_FD_ANDROID, fd, - EGL_NONE, - }; - EGLSyncKHR fence = drm_dev->egl_create_sync_khr(display, EGL_SYNC_NATIVE_FENCE_ANDROID, attrib_list); - LV_ASSERT_NULL(fence); - return fence; -} - -#endif /*LV_LINUX_DRM_USE_EGL*/ static uint32_t tick_get_cb(void) { @@ -1366,4 +1055,4 @@ static uint32_t tick_get_cb(void) return time_ms; } -#endif /*LV_USE_LINUX_DRM*/ +#endif /*LV_USE_LINUX_DRM && !LV_LINUX_DRM_USE_EGL*/ diff --git a/src/drivers/display/drm/lv_linux_drm.h b/src/drivers/display/drm/lv_linux_drm.h index ee32466caa..71f622a2ab 100644 --- a/src/drivers/display/drm/lv_linux_drm.h +++ b/src/drivers/display/drm/lv_linux_drm.h @@ -29,10 +29,41 @@ extern "C" { /********************** * GLOBAL PROTOTYPES **********************/ + +/** + * @brief Create a new Linux DRM display + * + * Creates and initializes a new LVGL display using the Linux DRM (Direct Rendering Manager) + * subsystem for hardware-accelerated graphics output. + * + * @return Pointer to the created display object, or NULL on failure + */ lv_display_t * lv_linux_drm_create(void); +/** + * @brief Configure the DRM device file and connector for a display + * + * Sets the DRM device file path and connector ID to use for the specified display. + * The DRM device file is typically located at /dev/dri/cardN where N is the card number. + * The connector ID specifies which physical output (HDMI, VGA, etc.) to use. + * + * @param disp Pointer to the display object created with lv_linux_drm_create() + * @param file Path to the DRM device file (e.g., "/dev/dri/card0") + * @param connector_id ID of the DRM connector to use, or -1 to auto-select the first available + */ void lv_linux_drm_set_file(lv_display_t * disp, const char * file, int64_t connector_id); +/** + * @brief Automatically find a suitable DRM device path + * + * Scans the system for available DRM devices and returns the path to a suitable + * device file that can be used with lv_linux_drm_set_file(). + * + * @return Dynamically allocated string containing the device path (must be freed with lv_free()), + * or NULL if no suitable device is found + */ +char * lv_linux_drm_find_device_path(void); + /********************** * MACROS **********************/ diff --git a/src/drivers/display/drm/lv_linux_drm_common.c b/src/drivers/display/drm/lv_linux_drm_common.c new file mode 100644 index 0000000000..317a235032 --- /dev/null +++ b/src/drivers/display/drm/lv_linux_drm_common.c @@ -0,0 +1,95 @@ +/** + * @file lv_linux_drm_common.c + * + */ + +/********************* + * INCLUDES + *********************/ + +#include "lv_linux_drm.h" + +#if LV_USE_LINUX_DRM + +#include + +#include "lv_linux_drm.h" +#include "../../../stdlib/lv_sprintf.h" + +/********************* + * DEFINES + *********************/ + +#define LV_DRM_CLASS_DIR "/sys/class/drm" +#define LV_DRM_CARD_PATH "/dev/dri/card" + +/********************** + * TYPEDEFS + **********************/ + +/********************** + * STATIC PROTOTYPES + **********************/ + +static char * find_by_class(void); + +/********************** + * STATIC VARIABLES + **********************/ + +/********************** + * MACROS + **********************/ + +/********************** + * GLOBAL FUNCTIONS + **********************/ + +char * lv_linux_drm_find_device_path(void) +{ + return find_by_class(); +} + +/********************** + * STATIC FUNCTIONS + **********************/ + +static char * find_by_class(void) +{ + DIR * d = opendir(LV_DRM_CLASS_DIR); + if(!d) { + return NULL; + } + + struct dirent * ent; + while((ent = readdir(d)) != NULL) { + if(lv_strcmp(ent->d_name, ".") == 0 || lv_strcmp(ent->d_name, "..") == 0) { + continue; + } + /* connector dirs look like card0-HDMI-A-1, card0-eDP-1, etc. */ + bool is_card = lv_strncmp(ent->d_name, "card", 4) == 0; + bool is_connected = lv_strchr(ent->d_name, '-') != NULL; + + if(!is_card || !is_connected) { + continue; + } + + const size_t buf_size = lv_strlen(LV_DRM_CARD_PATH) + 3; + char * card_path = lv_zalloc(buf_size); + if(ent->d_name[5] != '-') { + /* Double digit card*/ + lv_snprintf(card_path, buf_size, LV_DRM_CARD_PATH "%c%c", ent->d_name[4], ent->d_name[5]); + } + else { + lv_snprintf(card_path, buf_size, LV_DRM_CARD_PATH "%c", ent->d_name[4]); + } + closedir(d); + return card_path; + } + + closedir(d); + return NULL; + +} + +#endif /*LV_USE_LINUX_DRM*/ diff --git a/src/drivers/display/drm/lv_linux_drm_egl.c b/src/drivers/display/drm/lv_linux_drm_egl.c new file mode 100644 index 0000000000..842edd1f1c --- /dev/null +++ b/src/drivers/display/drm/lv_linux_drm_egl.c @@ -0,0 +1,715 @@ +/** + * @file lv_linux_drm_egl.c + * + */ + +/********************* + * INCLUDES + *********************/ +#include "lv_linux_drm.h" + +#if LV_USE_LINUX_DRM && LV_LINUX_DRM_USE_EGL + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "lv_linux_drm_egl_private.h" +#include "../../../draw/lv_draw_buf.h" +#include "../../opengles/lv_opengles_debug.h" + +#include "../../opengles/lv_opengles_driver.h" +#include "../../opengles/lv_opengles_texture.h" +#include "../../opengles/lv_opengles_private.h" + +#include "../../../stdlib/lv_string.h" +#include "../../../display/lv_display.h" + +/********************** + * TYPEDEFS + **********************/ + +typedef struct { + int fd; + struct gbm_bo * bo; + uint32_t fb_id; +} drm_fb_state_t; + +/********************** + * STATIC PROTOTYPES + **********************/ + +static uint32_t tick_cb(void); +static void flush_cb(lv_display_t * disp, const lv_area_t * area, uint8_t * px_map); +static void event_cb(lv_event_t * e); + +static lv_result_t drm_device_init(lv_drm_ctx_t * ctx, const char * path); +static void drm_device_deinit(lv_drm_ctx_t * ctx); + +static lv_egl_interface_t drm_get_egl_interface(lv_drm_ctx_t * ctx); +static drmModeConnector * drm_get_connector(lv_drm_ctx_t * ctx); +static drmModeModeInfo * drm_get_mode(lv_drm_ctx_t * ctx); +static drmModeEncoder * drm_get_encoder(lv_drm_ctx_t * ctx); +static drmModeCrtc * drm_get_crtc(lv_drm_ctx_t * ctx); +static void drm_on_page_flip(int fd, unsigned int frame, unsigned int sec, unsigned int usec, void * data); +static drm_fb_state_t * drm_fb_state_create(lv_drm_ctx_t * ctx, struct gbm_bo * bo); +static void drm_fb_state_destroy_cb(struct gbm_bo * bo, void * data); +static void drm_flip_cb(void * driver_data, bool vsync); + +static void * drm_create_window(void * driver_data, const lv_egl_native_window_properties_t * properties); +static void drm_destroy_window(void * driver_data, void * native_window); +static size_t drm_egl_select_config_cb(void * driver_data, const lv_egl_config_t * configs, size_t config_count); +static inline void set_viewport(lv_display_t * display); + +/********************** + * STATIC VARIABLES + **********************/ + +/********************** + * MACROS + **********************/ + +/********************** + * GLOBAL FUNCTIONS + **********************/ + +lv_display_t * lv_linux_drm_create(void) +{ + lv_tick_set_cb(tick_cb); + lv_drm_ctx_t * ctx = lv_zalloc(sizeof(*ctx)); + LV_ASSERT_MALLOC(ctx); + if(!ctx) { + LV_LOG_ERROR("Failed to create drm context"); + return NULL; + } + + ctx->display = lv_display_create(1, 1); + + if(!ctx->display) { + LV_LOG_ERROR("Failed to create display"); + lv_free(ctx); + return NULL; + } + + lv_display_set_driver_data(ctx->display, ctx); + lv_display_add_event_cb(ctx->display, event_cb, LV_EVENT_DELETE, NULL); + return ctx->display; +} + +void lv_linux_drm_set_file(lv_display_t * display, const char * file, int64_t connector_id) +{ + LV_UNUSED(connector_id); + lv_drm_ctx_t * ctx = lv_display_get_driver_data(display); + + lv_result_t err = drm_device_init(ctx, file); + if(err != LV_RESULT_OK) { + LV_LOG_ERROR("Failed to initialize DRM device"); + return; + } + + lv_display_set_resolution(display, ctx->drm_mode->hdisplay, ctx->drm_mode->vdisplay); + + ctx->egl_interface = drm_get_egl_interface(ctx); + ctx->egl_ctx = lv_opengles_egl_context_create(&ctx->egl_interface); + if(!ctx->egl_ctx) { + LV_LOG_ERROR("Failed to create egl context"); + return; + } + + /* Let the opengles texture driver handle the texture lifetime */ + ctx->texture.is_texture_owner = true; + lv_result_t res = lv_opengles_texture_create_draw_buffers(&ctx->texture, display); + if(res != LV_RESULT_OK) { + LV_LOG_ERROR("Failed to create draw buffers"); + lv_opengles_egl_context_destroy(ctx->egl_ctx); + ctx->egl_ctx = NULL; + return; + } + /* This creates the texture for the first time*/ + lv_opengles_texture_reshape(display, ctx->drm_mode->hdisplay, ctx->drm_mode->vdisplay); + + lv_display_set_flush_cb(display, flush_cb); + lv_display_set_render_mode(display, LV_DISPLAY_RENDER_MODE_DIRECT); + + lv_display_add_event_cb(ctx->display, event_cb, LV_EVENT_RESOLUTION_CHANGED, NULL); + lv_display_add_event_cb(ctx->display, event_cb, LV_EVENT_DELETE, NULL); +} + + +/********************** + * STATIC FUNCTIONS + **********************/ + +static void event_cb(lv_event_t * e) +{ + lv_event_code_t code = lv_event_get_code(e); + lv_display_t * display = (lv_display_t *) lv_event_get_target(e); + lv_drm_ctx_t * ctx = lv_display_get_driver_data(display); + switch(code) { + case LV_EVENT_DELETE: + if(ctx) { + lv_opengles_egl_context_destroy(ctx->egl_ctx); + ctx->egl_ctx = NULL; + lv_opengles_texture_deinit(&ctx->texture); + drm_device_deinit(ctx); + lv_display_set_driver_data(display, NULL); + } + break; + case LV_EVENT_RESOLUTION_CHANGED: + lv_opengles_texture_reshape(display, lv_display_get_horizontal_resolution(display), + lv_display_get_vertical_resolution(display)); + break; + default: + return; + } +} + +static uint32_t tick_cb(void) +{ + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + return ts.tv_sec * 1000 + (ts.tv_nsec / 1000000);; +} + +static inline void set_viewport(lv_display_t * display) +{ + const lv_display_rotation_t rotation = lv_display_get_rotation(display); + int32_t disp_width, disp_height; + if(rotation == LV_DISPLAY_ROTATION_0 || rotation == LV_DISPLAY_ROTATION_180) { + disp_width = lv_display_get_horizontal_resolution(display); + disp_height = lv_display_get_vertical_resolution(display); + } + else { + disp_width = lv_display_get_vertical_resolution(display) ; + disp_height = lv_display_get_horizontal_resolution(display) ; + } + lv_opengles_viewport(0, 0, disp_width, disp_height); +} + +#if LV_USE_DRAW_OPENGLES + +static void flush_cb(lv_display_t * disp, const lv_area_t * area, uint8_t * px_map) +{ + LV_UNUSED(area); + LV_UNUSED(px_map); + if(lv_display_flush_is_last(disp)) { + set_viewport(disp); + lv_drm_ctx_t * ctx = lv_display_get_driver_data(disp); + lv_opengles_render_display_texture(disp, false, true); + lv_opengles_egl_update(ctx->egl_ctx); + } + lv_display_flush_ready(disp); +} + +#else + +static void flush_cb(lv_display_t * disp, const lv_area_t * area, uint8_t * px_map) +{ + LV_UNUSED(px_map); + LV_UNUSED(area); + if(lv_display_flush_is_last(disp)) { + lv_drm_ctx_t * ctx = lv_display_get_driver_data(disp); + int32_t disp_width = lv_display_get_horizontal_resolution(disp); + int32_t disp_height = lv_display_get_vertical_resolution(disp); + + set_viewport(disp); + + lv_color_format_t cf = lv_display_get_color_format(disp); + uint32_t stride = lv_draw_buf_width_to_stride(lv_display_get_horizontal_resolution(disp), cf); + GL_CALL(glBindTexture(GL_TEXTURE_2D, ctx->texture.texture_id)); + + GL_CALL(glPixelStorei(GL_UNPACK_ALIGNMENT, 1)); + GL_CALL(glPixelStorei(GL_UNPACK_ROW_LENGTH, stride / lv_color_format_get_size(cf))); + /*Color depth: 16 (RGB565), 32 (ARGB8888)*/ +#if LV_COLOR_DEPTH == 16 + GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB565, disp_width, disp_height, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, + ctx->texture.fb1)); +#elif LV_COLOR_DEPTH == 32 + GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, disp_width, disp_height, 0, GL_BGRA, GL_UNSIGNED_BYTE, + ctx->texture.fb1)); +#else +#error("Unsupported color format") +#endif + + lv_opengles_render_display_texture(disp, false, false); + lv_opengles_egl_update(ctx->egl_ctx); + } + lv_display_flush_ready(disp); +} +#endif + +void drm_device_deinit(lv_drm_ctx_t * ctx) +{ + if(ctx->drm_crtc) { + drmModeSetCrtc(ctx->fd, + ctx->drm_crtc->crtc_id, + ctx->drm_crtc->buffer_id, + ctx->drm_crtc->x, + ctx->drm_crtc->y, + &ctx->drm_connector->connector_id, + 1, + &ctx->drm_crtc->mode); + drmModeFreeCrtc(ctx->drm_crtc); + ctx->drm_crtc = 0; + } + drm_destroy_window(ctx, ctx->gbm_surface); + + if(ctx->gbm_dev) { + gbm_device_destroy(ctx->gbm_dev); + ctx->gbm_dev = NULL; + } + if(ctx->drm_connector) { + drmModeFreeConnector(ctx->drm_connector); + ctx->drm_connector = NULL; + } + if(ctx->drm_encoder) { + drmModeFreeEncoder(ctx->drm_encoder); + ctx->drm_encoder = NULL; + } + if(ctx->drm_resources) { + drmModeFreeResources(ctx->drm_resources); + ctx->drm_resources = NULL; + } + if(ctx->fd > 0) { + drmClose(ctx->fd); + } + ctx->fd = 0; + ctx->drm_mode = NULL; + lv_free(ctx); +} + +static void drm_fb_state_destroy_cb(struct gbm_bo * bo, void * data) +{ + LV_UNUSED(bo); + drm_fb_state_t * fb = (drm_fb_state_t *) data; + if(fb && fb->fb_id) { + drmModeRmFB(fb->fd, fb->fb_id); + } + lv_free(fb); +} + +static int drm_do_page_flip(lv_drm_ctx_t * ctx, int timeout_ms) +{ + fd_set fds; + FD_ZERO(&fds); + FD_SET(ctx->fd, &fds); + + drmEventContext event_ctx; + lv_memset(&event_ctx, 0, sizeof(event_ctx)); + event_ctx.version = 2; + event_ctx.page_flip_handler = drm_on_page_flip; + + struct timeval timeout; + int status; + if(timeout_ms >= 0) { + timeout.tv_sec = timeout_ms / 1000; + timeout.tv_usec = (timeout_ms % 1000) * 1000; + status = select(ctx->fd + 1, &fds, NULL, NULL, &timeout); + } + else { + status = select(ctx->fd + 1, &fds, NULL, NULL, NULL); + } + + if(status == 1) { + drmHandleEvent(ctx->fd, &event_ctx); + } + return status; +} + +static void drm_on_page_flip(int fd, unsigned int frame, unsigned int sec, unsigned int usec, void * data) +{ + LV_UNUSED(fd); + LV_UNUSED(frame); + LV_UNUSED(sec); + LV_UNUSED(usec); + lv_drm_ctx_t * ctx = (lv_drm_ctx_t *) data; + + if(ctx->gbm_bo_presented) { + gbm_surface_release_buffer(ctx->gbm_surface, ctx->gbm_bo_presented); + } + ctx->gbm_bo_presented = ctx->gbm_bo_flipped; + ctx->gbm_bo_flipped = NULL; +} + +static drm_fb_state_t * drm_fb_state_create(lv_drm_ctx_t * ctx, struct gbm_bo * bo) +{ + LV_ASSERT_NULL(bo); + drm_fb_state_t * fb = (drm_fb_state_t *)gbm_bo_get_user_data(bo); + + if(fb) { + return fb; + } + + uint32_t width = gbm_bo_get_width(bo); + uint32_t height = gbm_bo_get_height(bo); + uint32_t handles[4] = {0}; + uint32_t strides[4] = {0}; + uint32_t offsets[4] = {0}; + uint64_t modifiers[4] = {0}; + uint32_t format = gbm_bo_get_format(bo); + uint64_t modifier = gbm_bo_get_modifier(bo); + uint32_t fb_id = 0; + uint64_t addfb2_mods = 0; + int32_t status; + + drmGetCap(ctx->fd, DRM_CAP_ADDFB2_MODIFIERS, &addfb2_mods); + + for(int i = 0; i < gbm_bo_get_plane_count(bo); i++) { + handles[i] = gbm_bo_get_handle_for_plane(bo, i).u32; + strides[i] = gbm_bo_get_stride_for_plane(bo, i); + offsets[i] = gbm_bo_get_offset(bo, i); + modifiers[i] = modifier; + } + + if(addfb2_mods && modifier != DRM_FORMAT_MOD_INVALID) { + status = drmModeAddFB2WithModifiers(ctx->fd, width, height, format, + handles, strides, offsets, modifiers, + &fb_id, DRM_MODE_FB_MODIFIERS); + } + else { + status = drmModeAddFB2(ctx->fd, width, height, format, + handles, strides, offsets, &fb_id, 0); + } + + if(status < 0) { + LV_LOG_ERROR("Failed to create drm_fb_state: %d", status); + return NULL; + } + + fb = (drm_fb_state_t *)lv_malloc(sizeof(*fb)); + if(!fb) { + LV_LOG_ERROR("Failed to allocate drmfb_state"); + return NULL; + } + + fb->fd = ctx->fd; + fb->bo = bo; + fb->fb_id = fb_id; + + gbm_bo_set_user_data(bo, fb, drm_fb_state_destroy_cb); + return fb; +} + +static void drm_flip_cb(void * driver_data, bool vsync) +{ + lv_drm_ctx_t * ctx = (lv_drm_ctx_t *) driver_data; + + if(ctx->gbm_bo_pending) { + gbm_surface_release_buffer(ctx->gbm_surface, ctx->gbm_bo_pending); + } + ctx->gbm_bo_pending = gbm_surface_lock_front_buffer(ctx->gbm_surface); + + if(!ctx->gbm_bo_pending) { + LV_LOG_ERROR("Failed to lock front buffer"); + return; + } + + drm_fb_state_t * pending_fb = drm_fb_state_create(ctx, ctx->gbm_bo_pending); + + if(!ctx->gbm_bo_pending || !pending_fb) { + LV_LOG_ERROR("Failed to get gbm front buffer"); + return; + } + + if(vsync) { + while(ctx->gbm_bo_flipped && drm_do_page_flip(ctx, -1) >= 0) + continue; + } + else { + drm_do_page_flip(ctx, 0); + } + + if(!ctx->gbm_bo_flipped) { + if(!ctx->crtc_isset) { + int status = drmModeSetCrtc(ctx->fd, ctx->drm_encoder->crtc_id, pending_fb->fb_id, 0, 0, + &(ctx->drm_connector->connector_id), 1, ctx->drm_mode); + if(status < 0) { + LV_LOG_ERROR("Failed to set crtc: %d", status); + return; + } + ctx->crtc_isset = true; + if(ctx->gbm_bo_presented) + gbm_surface_release_buffer(ctx->gbm_surface, ctx->gbm_bo_presented); + ctx->gbm_bo_presented = ctx->gbm_bo_pending; + ctx->gbm_bo_flipped = NULL; + ctx->gbm_bo_pending = NULL; + return; + } + + + uint32_t flip_flags = DRM_MODE_PAGE_FLIP_EVENT; + int status = drmModePageFlip(ctx->fd, ctx->drm_encoder->crtc_id, pending_fb->fb_id, flip_flags, ctx); + if(status < 0) { + LV_LOG_ERROR("Failed to enqueue page flip: %d", status); + return; + } + ctx->gbm_bo_flipped = ctx->gbm_bo_pending; + ctx->gbm_bo_pending = NULL; + } + + /* We need to ensure our surface has a free buffer, otherwise GL will + * have no buffer to render on. */ + while(!gbm_surface_has_free_buffers(ctx->gbm_surface) && + drm_do_page_flip(ctx, -1) >= 0) { + continue; + } +} + +static lv_result_t drm_device_init(lv_drm_ctx_t * ctx, const char * path) +{ + if(!path) { + LV_LOG_ERROR("Device path must not be NULL"); + return LV_RESULT_INVALID; + } + int ret = open(path, O_RDWR); + if(ret < 0) { + LV_LOG_ERROR("Failed to open device path '%s'", path); + goto open_err; + } + ctx->fd = ret; + + ret = drmSetClientCap(ctx->fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1); + if(ret < 0) { + LV_LOG_ERROR("Failed to set universal planes capability"); + goto set_client_cap_err; + } + + ctx->drm_resources = drmModeGetResources(ctx->fd); + if(!ctx->drm_resources) { + LV_LOG_ERROR("Failed to get card resources"); + goto get_resources_err; + } + + ctx->drm_connector = drm_get_connector(ctx); + if(!ctx->drm_connector) { + LV_LOG_ERROR("Failed to find a suitable connector"); + goto get_connector_err; + } + + ctx->drm_mode = drm_get_mode(ctx); + if(!ctx->drm_mode) { + LV_LOG_ERROR("Failed to find a suitable drm mode"); + goto get_mode_err; + } + + ctx->drm_encoder = drm_get_encoder(ctx); + if(!ctx->drm_encoder) { + LV_LOG_ERROR("Failed to find a suitable encoder"); + goto get_encoder_err; + } + + ctx->gbm_dev = gbm_create_device(ctx->fd); + if(!ctx->gbm_dev) { + LV_LOG_ERROR("Failed to create gbm device"); + goto gbm_create_device_err; + } + + if(drmSetMaster(ctx->fd) < 0) { + LV_LOG_ERROR("Failed to become DRM master"); + goto set_master_err; + } + + ctx->drm_crtc = drm_get_crtc(ctx); + if(!ctx->drm_crtc) { + LV_LOG_ERROR("Failed to get crtc"); + goto get_crtc_err; + } + + return LV_RESULT_OK; + +get_crtc_err: + gbm_device_destroy(ctx->gbm_dev); + ctx->gbm_dev = NULL; +set_master_err: + /* Nothing special to do */ +gbm_create_device_err: + drmModeFreeEncoder(ctx->drm_encoder); + ctx->drm_encoder = NULL; +get_encoder_err: + drmModeFreeConnector(ctx->drm_connector); + ctx->drm_connector = NULL; +get_mode_err: + /* Nothing special to do */ +get_connector_err: + drmModeFreeResources(ctx->drm_resources); + ctx->drm_resources = NULL; +get_resources_err: + /* Nothing special to do */ +set_client_cap_err: + close(ctx->fd); + ctx->fd = 0; +open_err: + return LV_RESULT_INVALID; +} + +static size_t drm_egl_select_config_cb(void * driver_data, const lv_egl_config_t * configs, size_t config_count) +{ + lv_drm_ctx_t * ctx = (lv_drm_ctx_t *)driver_data; + int32_t target_w = lv_display_get_horizontal_resolution(ctx->display); + int32_t target_h = lv_display_get_vertical_resolution(ctx->display); + lv_color_format_t target_cf = lv_display_get_color_format(ctx->display); + + for(size_t i = 0; i < config_count; ++i) { + LV_LOG_TRACE("Got config %zu %#x %dx%d %d %d %d %d buffer size %d depth %d samples %d stencil %d surface type %d", + i, configs[i].id, + configs[i].max_width, configs[i].max_height, configs[i].r_bits, configs[i].g_bits, configs[i].b_bits, configs[i].a_bits, + configs[i].buffer_size, configs[i].depth, configs[i].samples, configs[i].stencil, configs[i].surface_type); + } + + for(size_t i = 0; i < config_count; ++i) { + lv_color_format_t config_cf = lv_display_get_color_format(ctx->display); + if(configs[i].max_width >= target_w && + configs[i].max_height >= target_h && + config_cf == target_cf && + configs[i].surface_type & EGL_WINDOW_BIT + ) { + LV_LOG_TRACE("Choosing config %zu", i); + return i; + } + } + return config_count; +} + + +/********************** + * STATIC FUNCTIONS + **********************/ + +static lv_egl_interface_t drm_get_egl_interface(lv_drm_ctx_t * ctx) +{ + return (lv_egl_interface_t) { + .driver_data = ctx, + .native_display = ctx->gbm_dev, + .egl_platform = EGL_PLATFORM_GBM_KHR, + .select_config = drm_egl_select_config_cb, + .flip_cb = drm_flip_cb, + .create_window_cb = drm_create_window, + .destroy_window_cb = drm_destroy_window, + }; +} + +static drmModeConnector * drm_get_connector(lv_drm_ctx_t * ctx) +{ + drmModeConnector * connector = NULL; + + LV_ASSERT_NULL(ctx->drm_resources); + for(int i = 0; i < ctx->drm_resources->count_connectors; i++) { + connector = drmModeGetConnector(ctx->fd, ctx->drm_resources->connectors[i]); + if(connector->connection == DRM_MODE_CONNECTED && connector->count_modes > 0) { + return connector; + } + drmModeFreeConnector(connector); + connector = NULL; + } + return connector; +} + +static drmModeModeInfo * drm_get_mode(lv_drm_ctx_t * ctx) +{ + LV_ASSERT_NULL(ctx->drm_connector); + drmModeModeInfo * best_mode = NULL; + uint32_t best_area = 0; + + for(int i = 0 ; i < ctx->drm_connector->count_modes; ++i) { + drmModeModeInfo * mode = &ctx->drm_connector->modes[i]; + if(mode->type & DRM_MODE_TYPE_PREFERRED) { + return mode; + } + uint32_t area = mode->hdisplay * mode->vdisplay; + if(area > best_area) { + best_area = area; + best_mode = mode; + } + } + LV_LOG_WARN("Failed to find a drm mode with the TYPE_PREFERRED flag. Using the one with the biggest area"); + return best_mode; +} + +static drmModeCrtc * drm_get_crtc(lv_drm_ctx_t * ctx) +{ + drmModeCrtc * crtc = drmModeGetCrtc(ctx->fd, ctx->drm_encoder->crtc_id); + if(crtc) { + return crtc; + } + + /* if there is no current CRTC, attach a suitable one */ + for(int i = 0; i < ctx->drm_resources->count_crtcs; i++) { + if(ctx->drm_encoder->possible_crtcs & (1 << i)) { + ctx->drm_encoder->crtc_id = ctx->drm_resources->crtcs[i]; + crtc = drmModeGetCrtc(ctx->fd, ctx->drm_encoder->crtc_id); + break; + } + } + return crtc; +} + +static drmModeEncoder * drm_get_encoder(lv_drm_ctx_t * ctx) +{ + LV_ASSERT_NULL(ctx->drm_connector); + drmModeEncoder * encoder = NULL; + for(int i = 0; i < ctx->drm_resources->count_encoders; i++) { + encoder = drmModeGetEncoder(ctx->fd, ctx->drm_resources->encoders[i]); + if(!encoder) { + continue; + } + for(int j = 0; j < ctx->drm_connector->count_encoders; j++) { + if(encoder->encoder_id == ctx->drm_connector->encoders[j]) { + return encoder; + } + } + drmModeFreeEncoder(encoder); + encoder = NULL; + } + return encoder; +} + +static void * drm_create_window(void * driver_data, const lv_egl_native_window_properties_t * properties) +{ + lv_drm_ctx_t * ctx = (lv_drm_ctx_t *)driver_data; + LV_ASSERT_NULL(ctx->gbm_dev); + + uint32_t format = properties->visual_id; + + ctx->gbm_surface = gbm_surface_create(ctx->gbm_dev, ctx->drm_mode->hdisplay, ctx->drm_mode->vdisplay, format, + GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING); + if(!ctx->gbm_surface) { + LV_LOG_ERROR("Failed to create GBM surface"); + return NULL; + } + return (void *)ctx->gbm_surface; + +} + +static void drm_destroy_window(void * driver_data, void * native_window) +{ + lv_drm_ctx_t * ctx = (lv_drm_ctx_t *)driver_data; + LV_ASSERT(native_window == ctx->gbm_surface); + + if(!ctx->gbm_surface) { + return; + } + + if(ctx->gbm_bo_pending) { + gbm_surface_release_buffer(ctx->gbm_surface, ctx->gbm_bo_pending); + ctx->gbm_bo_pending = NULL; + } + if(ctx->gbm_bo_flipped) { + gbm_surface_release_buffer(ctx->gbm_surface, ctx->gbm_bo_flipped); + ctx->gbm_bo_flipped = NULL; + } + if(ctx->gbm_bo_presented) { + gbm_surface_release_buffer(ctx->gbm_surface, ctx->gbm_bo_presented); + ctx->gbm_bo_presented = NULL; + } + gbm_surface_destroy(ctx->gbm_surface); + ctx->gbm_surface = NULL; +} + + +#endif /*LV_USE_LINUX_DRM && LV_LINUX_DRM_USE_EGL*/ diff --git a/src/drivers/display/drm/lv_linux_drm_egl_private.h b/src/drivers/display/drm/lv_linux_drm_egl_private.h new file mode 100644 index 0000000000..30968d33cf --- /dev/null +++ b/src/drivers/display/drm/lv_linux_drm_egl_private.h @@ -0,0 +1,74 @@ +/** + * @file lv_linux_drm_egl_private.h + * + */ + +#ifndef LV_LINUX_DRM_EGL_PRIVATE_H +#define LV_LINUX_DRM_EGL_PRIVATE_H + + +#ifdef __cplusplus +extern "C" { +#endif + +/********************* + * INCLUDES + *********************/ + +#include "../../../lv_conf_internal.h" + +#if LV_USE_LINUX_DRM && LV_LINUX_DRM_USE_EGL + +#include +#include "../../opengles/lv_opengles_texture_private.h" +#include "../../opengles/lv_opengles_egl.h" +#include "../../opengles/lv_opengles_egl_private.h" + +/********************* + * DEFINES + *********************/ + +/********************** + * TYPEDEFS + **********************/ + +typedef struct { + lv_opengles_texture_t texture; + lv_display_t * display; + lv_opengles_egl_t * egl_ctx; + lv_egl_interface_t egl_interface; + + drmModeRes * drm_resources; + drmModeConnector * drm_connector; + drmModeEncoder * drm_encoder; + drmModeCrtc * drm_crtc; + drmModeModeInfo * drm_mode; + + struct gbm_device * gbm_dev; + struct gbm_surface * gbm_surface; + struct gbm_bo * gbm_bo_pending; + struct gbm_bo * gbm_bo_flipped; + struct gbm_bo * gbm_bo_presented; + + int fd; + bool crtc_isset; +} lv_drm_ctx_t; + + + +/********************** + * GLOBAL PROTOTYPES + **********************/ + +/********************** + * MACROS + **********************/ + +#endif /*LV_USE_LINUX_DRM && LV_LINUX_DRM_USE_EGL*/ + +#ifdef __cplusplus +} /*extern "C"*/ +#endif + + +#endif /*LV_LINUX_DRM_EGL_PRIVATE_H*/ diff --git a/src/drivers/opengles/assets/lv_opengles_standard_shader.c b/src/drivers/opengles/assets/lv_opengles_standard_shader.c index f40667523c..a6dfcb828b 100644 --- a/src/drivers/opengles/assets/lv_opengles_standard_shader.c +++ b/src/drivers/opengles/assets/lv_opengles_standard_shader.c @@ -6,40 +6,28 @@ #include static const lv_opengl_shader_t src_includes[] = { - { "hsv_adjust.glsl", R"( + { + "hsv_adjust.glsl", R"( uniform float u_Hue; uniform float u_Saturation; uniform float u_Value; - vec3 rgb2hsv(vec3 c){ - float M = max(max(c.r,c.g),c.b); - float m = min(min(c.r,c.g),c.b); - float d = M - m; - float h = 0.0; - if(d > 0.00001){ - if(M == c.r) h = mod((c.g - c.b)/d, 6.0); - else if(M == c.g) h = (c.b - c.r)/d + 2.0; - else h = (c.r - c.g)/d + 4.0; - h /= 6.0; - } - float s = (M <= 0.00001) ? 0.0 : d / M; - return vec3(h, s, M); + // Convert RGB to HSV + vec3 rgb2hsv(vec3 c) { + vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0); + vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g)); + vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r)); + float d = q.x - min(q.w, q.y); + float e = 1.0e-10; + return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x); } - vec3 hsv2rgb(vec3 c){ - float h = c.x * 6.0; - float i = floor(h); - float f = h - i; - float p = c.z * (1.0 - c.y); - float q = c.z * (1.0 - c.y * f); - float t = c.z * (1.0 - c.y * (1.0 - f)); - if(i == 0.0) return vec3(c.z, t, p); - if(i == 1.0) return vec3(q, c.z, p); - if(i == 2.0) return vec3(p, c.z, t); - if(i == 3.0) return vec3(p, q, c.z); - if(i == 4.0) return vec3(t, p, c.z); - return vec3(c.z, p, q); + // Convert HSV to RGB + vec3 hsv2rgb(vec3 c) { + vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); + vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); + return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); } vec3 adjustHSV(vec3 color){ @@ -49,23 +37,28 @@ static const lv_opengl_shader_t src_includes[] = { hsv.z = clamp(hsv.z * u_Value, 0.0, 1.0); return hsv2rgb(hsv); } - )" }, - { "brightness_adjust.glsl", R"( + )" + }, + { + "brightness_adjust.glsl", R"( uniform float u_Brightness; // add/subtract in [ -1.0 .. +1.0 ], 0.0 = no change vec3 adjustBrightness(vec3 color){ return clamp(color + vec3(u_Brightness), 0.0, 1.0); } - )" }, - { "contrast_adjust.glsl", R"( + )" + }, + { + "contrast_adjust.glsl", R"( uniform float u_Contrast; // 0.0 = mid-gray, 1.0 = no change, >1.0 increases contrast vec3 adjustContrast(vec3 color){ // shift to [-0.5..0.5], scale, shift back return clamp(((color - 0.5) * u_Contrast) + 0.5, 0.0, 1.0); } - )" }, + )" + }, }; static const char * src_vertex_shader = R"( @@ -98,13 +91,18 @@ static const char *src_fragment_shader = R"( uniform bool u_IsFill; uniform vec3 u_FillColor; + #ifdef HSV_ADJUST +#include + #endif + void main() { vec4 texColor; if (u_IsFill) { texColor = vec4(u_FillColor, 1.0); } else { - texColor = texture(u_Texture, v_TexCoord); + //texColor = texture(u_Texture, v_TexCoord); + texColor = textureLod(u_Texture, v_TexCoord, 0.0); // If the vertices have been transformed, and mipmaps have not been generated, some rotation angles (notably 90 and 270) require using textureLod() to mitigate derivative calculation errors from increments flipping direction } if (abs(u_ColorDepth - 8.0) < 0.1) { float gray = texColor.r; @@ -113,6 +111,9 @@ static const char *src_fragment_shader = R"( float combinedAlpha = texColor.a * u_Opa; color = vec4(texColor.rgb * combinedAlpha, combinedAlpha); } + #ifdef HSV_ADJUST + color.rgb = adjustHSV(color.rgb); + #endif } )"; @@ -132,8 +133,8 @@ char* lv_opengles_standard_shader_get_fragment(void) { void lv_opengles_standard_shader_get_src(lv_opengl_shader_portions_t *portions) { - portions->all = src_includes; - portions->count = sizeof(src_includes) / sizeof(src_includes[0]); + portions->all = src_includes; + portions->count = sizeof(src_includes) / sizeof(src_includes[0]); } #endif /*LV_USE_OPENGLES*/ diff --git a/src/drivers/opengles/glad/README.md b/src/drivers/opengles/glad/README.md new file mode 100644 index 0000000000..67e1cd44cc --- /dev/null +++ b/src/drivers/opengles/glad/README.md @@ -0,0 +1,5 @@ + +# glad + +GLAD source files are generated using GLAD's online generator. +[Permalink](https://gen.glad.sh/#generator=c&api=egl%3D1.5%2Cgles2%3D2.0&profile=gl%3Dcompatibility%2Cgles1%3Dcommon&extensions=EGL_EXT_image_dma_buf_import%2CEGL_EXT_image_dma_buf_import_modifiers%2CEGL_EXT_platform_base%2CEGL_EXT_platform_wayland%2CEGL_KHR_fence_sync%2CEGL_KHR_image_base%2CEGL_KHR_platform_gbm%2CEGL_KHR_platform_wayland%2CGL_APPLE_texture_max_level%2CGL_EXT_texture_format_BGRA8888%2CGL_EXT_unpack_subimage%2CGL_OES_mapbuffer%2CGL_OES_vertex_array_object) diff --git a/src/drivers/opengles/glad/include/EGL/eglplatform.h b/src/drivers/opengles/glad/include/EGL/eglplatform.h new file mode 100644 index 0000000000..d556b74f55 --- /dev/null +++ b/src/drivers/opengles/glad/include/EGL/eglplatform.h @@ -0,0 +1,181 @@ +#ifndef __eglplatform_h_ +#define __eglplatform_h_ + +#include "../../../lv_opengles_egl.h" + +#if LV_USE_EGL + +/* +** Copyright 2007-2020 The Khronos Group Inc. +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* Platform-specific types and definitions for egl.h + * + * Adopters may modify khrplatform.h and this file to suit their platform. + * You are encouraged to submit all modifications to the Khronos group so that + * they can be included in future versions of this file. Please submit changes + * by filing an issue or pull request on the public Khronos EGL Registry, at + * https://www.github.com/KhronosGroup/EGL-Registry/ + */ + +#include + +/* Macros used in EGL function prototype declarations. + * + * EGL functions should be prototyped as: + * + * EGLAPI return-type EGLAPIENTRY eglFunction(arguments); + * typedef return-type (EXPAPIENTRYP PFNEGLFUNCTIONPROC) (arguments); + * + * KHRONOS_APICALL and KHRONOS_APIENTRY are defined in KHR/khrplatform.h + */ + +#ifndef EGLAPI +#define EGLAPI KHRONOS_APICALL +#endif + +#ifndef EGLAPIENTRY +#define EGLAPIENTRY KHRONOS_APIENTRY +#endif +#define EGLAPIENTRYP EGLAPIENTRY* + +/* The types NativeDisplayType, NativeWindowType, and NativePixmapType + * are aliases of window-system-dependent types, such as X Display * or + * Windows Device Context. They must be defined in platform-specific + * code below. The EGL-prefixed versions of Native*Type are the same + * types, renamed in EGL 1.3 so all types in the API start with "EGL". + * + * Khronos STRONGLY RECOMMENDS that you use the default definitions + * provided below, since these changes affect both binary and source + * portability of applications using EGL running on different EGL + * implementations. + */ + +#if defined(EGL_NO_PLATFORM_SPECIFIC_TYPES) + +typedef void *EGLNativeDisplayType; +typedef void *EGLNativePixmapType; +typedef void *EGLNativeWindowType; + +#elif defined(_WIN32) || defined(__VC32__) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) /* Win32 and WinCE */ +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN 1 +#endif +#include + +typedef HDC EGLNativeDisplayType; +typedef HBITMAP EGLNativePixmapType; +typedef HWND EGLNativeWindowType; + +#elif defined(__QNX__) + +typedef khronos_uintptr_t EGLNativeDisplayType; +typedef struct _screen_pixmap* EGLNativePixmapType; /* screen_pixmap_t */ +typedef struct _screen_window* EGLNativeWindowType; /* screen_window_t */ + +#elif defined(__EMSCRIPTEN__) + +typedef int EGLNativeDisplayType; +typedef int EGLNativePixmapType; +typedef int EGLNativeWindowType; + +#elif defined(__WINSCW__) || defined(__SYMBIAN32__) /* Symbian */ + +typedef int EGLNativeDisplayType; +typedef void *EGLNativePixmapType; +typedef void *EGLNativeWindowType; + +#elif defined(WL_EGL_PLATFORM) + +typedef struct wl_display *EGLNativeDisplayType; +typedef struct wl_egl_pixmap *EGLNativePixmapType; +typedef struct wl_egl_window *EGLNativeWindowType; + +#elif defined(__GBM__) + +typedef struct gbm_device *EGLNativeDisplayType; +typedef struct gbm_bo *EGLNativePixmapType; +typedef void *EGLNativeWindowType; + +#elif defined(__ANDROID__) || defined(ANDROID) + +struct ANativeWindow; +struct egl_native_pixmap_t; + +typedef void* EGLNativeDisplayType; +typedef struct egl_native_pixmap_t* EGLNativePixmapType; +typedef struct ANativeWindow* EGLNativeWindowType; + +#elif defined(USE_OZONE) + +typedef intptr_t EGLNativeDisplayType; +typedef intptr_t EGLNativePixmapType; +typedef intptr_t EGLNativeWindowType; + +#elif defined(USE_X11) + +/* X11 (tentative) */ +#include +#include + +typedef Display *EGLNativeDisplayType; +typedef Pixmap EGLNativePixmapType; +typedef Window EGLNativeWindowType; + +#elif defined(__unix__) + +typedef void *EGLNativeDisplayType; +typedef khronos_uintptr_t EGLNativePixmapType; +typedef khronos_uintptr_t EGLNativeWindowType; + +#elif defined(__APPLE__) + +typedef int EGLNativeDisplayType; +typedef void *EGLNativePixmapType; +typedef void *EGLNativeWindowType; + +#elif defined(__HAIKU__) + +#include + +typedef void *EGLNativeDisplayType; +typedef khronos_uintptr_t EGLNativePixmapType; +typedef khronos_uintptr_t EGLNativeWindowType; + +#elif defined(__Fuchsia__) + +typedef void *EGLNativeDisplayType; +typedef khronos_uintptr_t EGLNativePixmapType; +typedef khronos_uintptr_t EGLNativeWindowType; + +#else +#error "Platform not recognized" +#endif + +/* EGL 1.2 types, renamed for consistency in EGL 1.3 */ +typedef EGLNativeDisplayType NativeDisplayType; +typedef EGLNativePixmapType NativePixmapType; +typedef EGLNativeWindowType NativeWindowType; + + +/* Define EGLint. This must be a signed integral type large enough to contain + * all legal attribute names and values passed into and out of EGL, whether + * their type is boolean, bitmask, enumerant (symbolic constant), integer, + * handle, or other. While in general a 32-bit integer will suffice, if + * handles are 64 bit types, then EGLint should be defined as a signed 64-bit + * integer type. + */ +typedef khronos_int32_t EGLint; + + +/* C++ / C typecast macros for special EGL handle values */ +#if defined(__cplusplus) +#define EGL_CAST(type, value) (static_cast(value)) +#else +#define EGL_CAST(type, value) ((type) (value)) +#endif + +#endif /*LV_USE_EGL*/ + +#endif /* __eglplatform_h */ diff --git a/src/drivers/opengles/glad/include/KHR/khrplatform.h b/src/drivers/opengles/glad/include/KHR/khrplatform.h new file mode 100644 index 0000000000..11a22b3e7d --- /dev/null +++ b/src/drivers/opengles/glad/include/KHR/khrplatform.h @@ -0,0 +1,317 @@ +#ifndef __khrplatform_h_ +#define __khrplatform_h_ + +#include "../../../lv_opengles_egl.h" + +#if LV_USE_EGL + +/* +** Copyright (c) 2008-2018 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +/* Khronos platform-specific types and definitions. + * + * The master copy of khrplatform.h is maintained in the Khronos EGL + * Registry repository at https://github.com/KhronosGroup/EGL-Registry + * The last semantic modification to khrplatform.h was at commit ID: + * 67a3e0864c2d75ea5287b9f3d2eb74a745936692 + * + * Adopters may modify this file to suit their platform. Adopters are + * encouraged to submit platform specific modifications to the Khronos + * group so that they can be included in future versions of this file. + * Please submit changes by filing pull requests or issues on + * the EGL Registry repository linked above. + * + * + * See the Implementer's Guidelines for information about where this file + * should be located on your system and for more details of its use: + * http://www.khronos.org/registry/implementers_guide.pdf + * + * This file should be included as + * #include + * by Khronos client API header files that use its types and defines. + * + * The types in khrplatform.h should only be used to define API-specific types. + * + * Types defined in khrplatform.h: + * khronos_int8_t signed 8 bit + * khronos_uint8_t unsigned 8 bit + * khronos_int16_t signed 16 bit + * khronos_uint16_t unsigned 16 bit + * khronos_int32_t signed 32 bit + * khronos_uint32_t unsigned 32 bit + * khronos_int64_t signed 64 bit + * khronos_uint64_t unsigned 64 bit + * khronos_intptr_t signed same number of bits as a pointer + * khronos_uintptr_t unsigned same number of bits as a pointer + * khronos_ssize_t signed size + * khronos_usize_t unsigned size + * khronos_float_t signed 32 bit floating point + * khronos_time_ns_t unsigned 64 bit time in nanoseconds + * khronos_utime_nanoseconds_t unsigned time interval or absolute time in + * nanoseconds + * khronos_stime_nanoseconds_t signed time interval in nanoseconds + * khronos_boolean_enum_t enumerated boolean type. This should + * only be used as a base type when a client API's boolean type is + * an enum. Client APIs which use an integer or other type for + * booleans cannot use this as the base type for their boolean. + * + * Tokens defined in khrplatform.h: + * + * KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values. + * + * KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0. + * KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0. + * + * Calling convention macros defined in this file: + * KHRONOS_APICALL + * KHRONOS_APIENTRY + * KHRONOS_APIATTRIBUTES + * + * These may be used in function prototypes as: + * + * KHRONOS_APICALL void KHRONOS_APIENTRY funcname( + * int arg1, + * int arg2) KHRONOS_APIATTRIBUTES; + */ + +#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC) +# define KHRONOS_STATIC 1 +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APICALL + *------------------------------------------------------------------------- + * This precedes the return type of the function in the function prototype. + */ +#if defined(KHRONOS_STATIC) + /* If the preprocessor constant KHRONOS_STATIC is defined, make the + * header compatible with static linking. */ +# define KHRONOS_APICALL +#elif defined(_WIN32) +# define KHRONOS_APICALL __declspec(dllimport) +#elif defined (__SYMBIAN32__) +# define KHRONOS_APICALL IMPORT_C +#elif defined(__ANDROID__) +# define KHRONOS_APICALL __attribute__((visibility("default"))) +#else +# define KHRONOS_APICALL +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APIENTRY + *------------------------------------------------------------------------- + * This follows the return type of the function and precedes the function + * name in the function prototype. + */ +#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__) + /* Win32 but not WinCE */ +# define KHRONOS_APIENTRY __stdcall +#else +# define KHRONOS_APIENTRY +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APIATTRIBUTES + *------------------------------------------------------------------------- + * This follows the closing parenthesis of the function prototype arguments. + */ +#if defined (__ARMCC_2__) +#define KHRONOS_APIATTRIBUTES __softfp +#else +#define KHRONOS_APIATTRIBUTES +#endif + +/*------------------------------------------------------------------------- + * basic type definitions + *-----------------------------------------------------------------------*/ +#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__) + + +/* + * Using + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 +/* + * To support platform where unsigned long cannot be used interchangeably with + * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t. + * Ideally, we could just use (u)intptr_t everywhere, but this could result in + * ABI breakage if khronos_uintptr_t is changed from unsigned long to + * unsigned long long or similar (this results in different C++ name mangling). + * To avoid changes for existing platforms, we restrict usage of intptr_t to + * platforms where the size of a pointer is larger than the size of long. + */ +#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__) +#if __SIZEOF_POINTER__ > __SIZEOF_LONG__ +#define KHRONOS_USE_INTPTR_T +#endif +#endif + +#elif defined(__VMS ) || defined(__sgi) + +/* + * Using + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif defined(_WIN32) && !defined(__SCITECH_SNAP__) + +/* + * Win32 + */ +typedef __int32 khronos_int32_t; +typedef unsigned __int32 khronos_uint32_t; +typedef __int64 khronos_int64_t; +typedef unsigned __int64 khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif defined(__sun__) || defined(__digital__) + +/* + * Sun or Digital + */ +typedef int khronos_int32_t; +typedef unsigned int khronos_uint32_t; +#if defined(__arch64__) || defined(_LP64) +typedef long int khronos_int64_t; +typedef unsigned long int khronos_uint64_t; +#else +typedef long long int khronos_int64_t; +typedef unsigned long long int khronos_uint64_t; +#endif /* __arch64__ */ +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif 0 + +/* + * Hypothetical platform with no float or int64 support + */ +typedef int khronos_int32_t; +typedef unsigned int khronos_uint32_t; +#define KHRONOS_SUPPORT_INT64 0 +#define KHRONOS_SUPPORT_FLOAT 0 + +#else + +/* + * Generic fallback + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#endif + + +/* + * Types that are (so far) the same on all platforms + */ +typedef signed char khronos_int8_t; +typedef unsigned char khronos_uint8_t; +typedef signed short int khronos_int16_t; +typedef unsigned short int khronos_uint16_t; + +/* + * Types that differ between LLP64 and LP64 architectures - in LLP64, + * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears + * to be the only LLP64 architecture in current use. + */ +#ifdef KHRONOS_USE_INTPTR_T +typedef intptr_t khronos_intptr_t; +typedef uintptr_t khronos_uintptr_t; +#elif defined(_WIN64) +typedef signed long long int khronos_intptr_t; +typedef unsigned long long int khronos_uintptr_t; +#else +typedef signed long int khronos_intptr_t; +typedef unsigned long int khronos_uintptr_t; +#endif + +#if defined(_WIN64) +typedef signed long long int khronos_ssize_t; +typedef unsigned long long int khronos_usize_t; +#else +typedef signed long int khronos_ssize_t; +typedef unsigned long int khronos_usize_t; +#endif + +#if KHRONOS_SUPPORT_FLOAT +/* + * Float type + */ +typedef float khronos_float_t; +#endif + +#if KHRONOS_SUPPORT_INT64 +/* Time types + * + * These types can be used to represent a time interval in nanoseconds or + * an absolute Unadjusted System Time. Unadjusted System Time is the number + * of nanoseconds since some arbitrary system event (e.g. since the last + * time the system booted). The Unadjusted System Time is an unsigned + * 64 bit value that wraps back to 0 every 584 years. Time intervals + * may be either signed or unsigned. + */ +typedef khronos_uint64_t khronos_utime_nanoseconds_t; +typedef khronos_int64_t khronos_stime_nanoseconds_t; +#endif + +/* + * Dummy value used to pad enum types to 32 bits. + */ +#ifndef KHRONOS_MAX_ENUM +#define KHRONOS_MAX_ENUM 0x7FFFFFFF +#endif + +/* + * Enumerated boolean type + * + * Values other than zero should be considered to be true. Therefore + * comparisons should not be made against KHRONOS_TRUE. + */ +typedef enum { + KHRONOS_FALSE = 0, + KHRONOS_TRUE = 1, + KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM +} khronos_boolean_enum_t; + +#endif /* __khrplatform_h_ */ + +#endif /*LV_USE_EGL*/ diff --git a/src/drivers/opengles/glad/include/glad/egl.h b/src/drivers/opengles/glad/include/glad/egl.h new file mode 100644 index 0000000000..e294f96f69 --- /dev/null +++ b/src/drivers/opengles/glad/include/glad/egl.h @@ -0,0 +1,638 @@ +/** + * Loader generated by glad 2.0.8 on Sun Sep 28 20:09:30 2025 + * + * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0 + * + * Generator: C/C++ + * Specification: egl + * Extensions: 8 + * + * APIs: + * - egl=1.5 + * + * Options: + * - ALIAS = False + * - DEBUG = False + * - HEADER_ONLY = False + * - LOADER = False + * - MX = False + * - ON_DEMAND = False + * + * Commandline: + * --api='egl=1.5' --extensions='EGL_EXT_image_dma_buf_import,EGL_EXT_image_dma_buf_import_modifiers,EGL_EXT_platform_base,EGL_EXT_platform_wayland,EGL_KHR_fence_sync,EGL_KHR_image_base,EGL_KHR_platform_gbm,EGL_KHR_platform_wayland' c + * + * Online: + * http://glad.sh/#api=egl%3D1.5&extensions=EGL_EXT_image_dma_buf_import%2CEGL_EXT_image_dma_buf_import_modifiers%2CEGL_EXT_platform_base%2CEGL_EXT_platform_wayland%2CEGL_KHR_fence_sync%2CEGL_KHR_image_base%2CEGL_KHR_platform_gbm%2CEGL_KHR_platform_wayland&generator=c&options= + * + */ + +#ifndef GLAD_EGL_H_ +#define GLAD_EGL_H_ + +#include "../../../lv_opengles_egl.h" + +#if LV_USE_EGL + +#define GLAD_EGL + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef GLAD_PLATFORM_H_ +#define GLAD_PLATFORM_H_ + +#ifndef GLAD_PLATFORM_WIN32 + #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__MINGW32__) + #define GLAD_PLATFORM_WIN32 1 + #else + #define GLAD_PLATFORM_WIN32 0 + #endif +#endif + +#ifndef GLAD_PLATFORM_APPLE + #ifdef __APPLE__ + #define GLAD_PLATFORM_APPLE 1 + #else + #define GLAD_PLATFORM_APPLE 0 + #endif +#endif + +#ifndef GLAD_PLATFORM_EMSCRIPTEN + #ifdef __EMSCRIPTEN__ + #define GLAD_PLATFORM_EMSCRIPTEN 1 + #else + #define GLAD_PLATFORM_EMSCRIPTEN 0 + #endif +#endif + +#ifndef GLAD_PLATFORM_UWP + #if defined(_MSC_VER) && !defined(GLAD_INTERNAL_HAVE_WINAPIFAMILY) + #ifdef __has_include + #if __has_include() + #define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1 + #endif + #elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ + #define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1 + #endif + #endif + + #ifdef GLAD_INTERNAL_HAVE_WINAPIFAMILY + #include + #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + #define GLAD_PLATFORM_UWP 1 + #endif + #endif + + #ifndef GLAD_PLATFORM_UWP + #define GLAD_PLATFORM_UWP 0 + #endif +#endif + +#ifdef __GNUC__ + #define GLAD_GNUC_EXTENSION __extension__ +#else + #define GLAD_GNUC_EXTENSION +#endif + +#define GLAD_UNUSED(x) (void)(x) + +#ifndef GLAD_API_CALL + #if defined(GLAD_API_CALL_EXPORT) + #if GLAD_PLATFORM_WIN32 || defined(__CYGWIN__) + #if defined(GLAD_API_CALL_EXPORT_BUILD) + #if defined(__GNUC__) + #define GLAD_API_CALL __attribute__ ((dllexport)) extern + #else + #define GLAD_API_CALL __declspec(dllexport) extern + #endif + #else + #if defined(__GNUC__) + #define GLAD_API_CALL __attribute__ ((dllimport)) extern + #else + #define GLAD_API_CALL __declspec(dllimport) extern + #endif + #endif + #elif defined(__GNUC__) && defined(GLAD_API_CALL_EXPORT_BUILD) + #define GLAD_API_CALL __attribute__ ((visibility ("default"))) extern + #else + #define GLAD_API_CALL extern + #endif + #else + #define GLAD_API_CALL extern + #endif +#endif + +#ifdef APIENTRY + #define GLAD_API_PTR APIENTRY +#elif GLAD_PLATFORM_WIN32 + #define GLAD_API_PTR __stdcall +#else + #define GLAD_API_PTR +#endif + +#ifndef GLAPI +#define GLAPI GLAD_API_CALL +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY GLAD_API_PTR +#endif + +#define GLAD_MAKE_VERSION(major, minor) (major * 10000 + minor) +#define GLAD_VERSION_MAJOR(version) (version / 10000) +#define GLAD_VERSION_MINOR(version) (version % 10000) + +#define GLAD_GENERATOR_VERSION "2.0.8" + +typedef void (*GLADapiproc)(void); + +typedef GLADapiproc (*GLADloadfunc)(const char *name); +typedef GLADapiproc (*GLADuserptrloadfunc)(void *userptr, const char *name); + +typedef void (*GLADprecallback)(const char *name, GLADapiproc apiproc, int len_args, ...); +typedef void (*GLADpostcallback)(void *ret, const char *name, GLADapiproc apiproc, int len_args, ...); + +#endif /* GLAD_PLATFORM_H_ */ + +#define EGL_ALPHA_FORMAT 0x3088 +#define EGL_ALPHA_FORMAT_NONPRE 0x308B +#define EGL_ALPHA_FORMAT_PRE 0x308C +#define EGL_ALPHA_MASK_SIZE 0x303E +#define EGL_ALPHA_SIZE 0x3021 +#define EGL_BACK_BUFFER 0x3084 +#define EGL_BAD_ACCESS 0x3002 +#define EGL_BAD_ALLOC 0x3003 +#define EGL_BAD_ATTRIBUTE 0x3004 +#define EGL_BAD_CONFIG 0x3005 +#define EGL_BAD_CONTEXT 0x3006 +#define EGL_BAD_CURRENT_SURFACE 0x3007 +#define EGL_BAD_DISPLAY 0x3008 +#define EGL_BAD_MATCH 0x3009 +#define EGL_BAD_NATIVE_PIXMAP 0x300A +#define EGL_BAD_NATIVE_WINDOW 0x300B +#define EGL_BAD_PARAMETER 0x300C +#define EGL_BAD_SURFACE 0x300D +#define EGL_BIND_TO_TEXTURE_RGB 0x3039 +#define EGL_BIND_TO_TEXTURE_RGBA 0x303A +#define EGL_BLUE_SIZE 0x3022 +#define EGL_BUFFER_DESTROYED 0x3095 +#define EGL_BUFFER_PRESERVED 0x3094 +#define EGL_BUFFER_SIZE 0x3020 +#define EGL_CLIENT_APIS 0x308D +#define EGL_CL_EVENT_HANDLE 0x309C +#define EGL_COLORSPACE 0x3087 +#define EGL_COLORSPACE_LINEAR 0x308A +#define EGL_COLORSPACE_sRGB 0x3089 +#define EGL_COLOR_BUFFER_TYPE 0x303F +#define EGL_CONDITION_SATISFIED 0x30F6 +#define EGL_CONFIG_CAVEAT 0x3027 +#define EGL_CONFIG_ID 0x3028 +#define EGL_CONFORMANT 0x3042 +#define EGL_CONTEXT_CLIENT_TYPE 0x3097 +#define EGL_CONTEXT_CLIENT_VERSION 0x3098 +#define EGL_CONTEXT_LOST 0x300E +#define EGL_CONTEXT_MAJOR_VERSION 0x3098 +#define EGL_CONTEXT_MINOR_VERSION 0x30FB +#define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT 0x00000002 +#define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT 0x00000001 +#define EGL_CONTEXT_OPENGL_DEBUG 0x31B0 +#define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE 0x31B1 +#define EGL_CONTEXT_OPENGL_PROFILE_MASK 0x30FD +#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY 0x31BD +#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS 0x31B2 +#define EGL_CORE_NATIVE_ENGINE 0x305B +#define EGL_DEFAULT_DISPLAY EGL_CAST(EGLNativeDisplayType,0) +#define EGL_DEPTH_SIZE 0x3025 +#define EGL_DISPLAY_SCALING 10000 +#define EGL_DMA_BUF_PLANE0_FD_EXT 0x3272 +#define EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT 0x3444 +#define EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT 0x3443 +#define EGL_DMA_BUF_PLANE0_OFFSET_EXT 0x3273 +#define EGL_DMA_BUF_PLANE0_PITCH_EXT 0x3274 +#define EGL_DMA_BUF_PLANE1_FD_EXT 0x3275 +#define EGL_DMA_BUF_PLANE1_MODIFIER_HI_EXT 0x3446 +#define EGL_DMA_BUF_PLANE1_MODIFIER_LO_EXT 0x3445 +#define EGL_DMA_BUF_PLANE1_OFFSET_EXT 0x3276 +#define EGL_DMA_BUF_PLANE1_PITCH_EXT 0x3277 +#define EGL_DMA_BUF_PLANE2_FD_EXT 0x3278 +#define EGL_DMA_BUF_PLANE2_MODIFIER_HI_EXT 0x3448 +#define EGL_DMA_BUF_PLANE2_MODIFIER_LO_EXT 0x3447 +#define EGL_DMA_BUF_PLANE2_OFFSET_EXT 0x3279 +#define EGL_DMA_BUF_PLANE2_PITCH_EXT 0x327A +#define EGL_DMA_BUF_PLANE3_FD_EXT 0x3440 +#define EGL_DMA_BUF_PLANE3_MODIFIER_HI_EXT 0x344A +#define EGL_DMA_BUF_PLANE3_MODIFIER_LO_EXT 0x3449 +#define EGL_DMA_BUF_PLANE3_OFFSET_EXT 0x3441 +#define EGL_DMA_BUF_PLANE3_PITCH_EXT 0x3442 +#define EGL_DONT_CARE EGL_CAST(EGLint,-1) +#define EGL_DRAW 0x3059 +#define EGL_EXTENSIONS 0x3055 +#define EGL_FALSE 0 +#define EGL_FOREVER 0xFFFFFFFFFFFFFFFF +#define EGL_GL_COLORSPACE 0x309D +#define EGL_GL_COLORSPACE_LINEAR 0x308A +#define EGL_GL_COLORSPACE_SRGB 0x3089 +#define EGL_GL_RENDERBUFFER 0x30B9 +#define EGL_GL_TEXTURE_2D 0x30B1 +#define EGL_GL_TEXTURE_3D 0x30B2 +#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x30B4 +#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x30B6 +#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x30B8 +#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x30B3 +#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x30B5 +#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x30B7 +#define EGL_GL_TEXTURE_LEVEL 0x30BC +#define EGL_GL_TEXTURE_ZOFFSET 0x30BD +#define EGL_GREEN_SIZE 0x3023 +#define EGL_HEIGHT 0x3056 +#define EGL_HORIZONTAL_RESOLUTION 0x3090 +#define EGL_IMAGE_PRESERVED 0x30D2 +#define EGL_IMAGE_PRESERVED_KHR 0x30D2 +#define EGL_ITU_REC2020_EXT 0x3281 +#define EGL_ITU_REC601_EXT 0x327F +#define EGL_ITU_REC709_EXT 0x3280 +#define EGL_LARGEST_PBUFFER 0x3058 +#define EGL_LEVEL 0x3029 +#define EGL_LINUX_DMA_BUF_EXT 0x3270 +#define EGL_LINUX_DRM_FOURCC_EXT 0x3271 +#define EGL_LOSE_CONTEXT_ON_RESET 0x31BF +#define EGL_LUMINANCE_BUFFER 0x308F +#define EGL_LUMINANCE_SIZE 0x303D +#define EGL_MATCH_NATIVE_PIXMAP 0x3041 +#define EGL_MAX_PBUFFER_HEIGHT 0x302A +#define EGL_MAX_PBUFFER_PIXELS 0x302B +#define EGL_MAX_PBUFFER_WIDTH 0x302C +#define EGL_MAX_SWAP_INTERVAL 0x303C +#define EGL_MIN_SWAP_INTERVAL 0x303B +#define EGL_MIPMAP_LEVEL 0x3083 +#define EGL_MIPMAP_TEXTURE 0x3082 +#define EGL_MULTISAMPLE_RESOLVE 0x3099 +#define EGL_MULTISAMPLE_RESOLVE_BOX 0x309B +#define EGL_MULTISAMPLE_RESOLVE_BOX_BIT 0x0200 +#define EGL_MULTISAMPLE_RESOLVE_DEFAULT 0x309A +#define EGL_NATIVE_RENDERABLE 0x302D +#define EGL_NATIVE_VISUAL_ID 0x302E +#define EGL_NATIVE_VISUAL_TYPE 0x302F +#define EGL_NONE 0x3038 +#define EGL_NON_CONFORMANT_CONFIG 0x3051 +#define EGL_NOT_INITIALIZED 0x3001 +#define EGL_NO_CONTEXT EGL_CAST(EGLContext,0) +#define EGL_NO_DISPLAY EGL_CAST(EGLDisplay,0) +#define EGL_NO_IMAGE EGL_CAST(EGLImage,0) +#define EGL_NO_IMAGE_KHR EGL_CAST(EGLImageKHR,0) +#define EGL_NO_RESET_NOTIFICATION 0x31BE +#define EGL_NO_SURFACE EGL_CAST(EGLSurface,0) +#define EGL_NO_SYNC EGL_CAST(EGLSync,0) +#define EGL_NO_TEXTURE 0x305C +#define EGL_OPENGL_API 0x30A2 +#define EGL_OPENGL_BIT 0x0008 +#define EGL_OPENGL_ES2_BIT 0x0004 +#define EGL_OPENGL_ES3_BIT 0x00000040 +#define EGL_OPENGL_ES_API 0x30A0 +#define EGL_OPENGL_ES_BIT 0x0001 +#define EGL_OPENVG_API 0x30A1 +#define EGL_OPENVG_BIT 0x0002 +#define EGL_OPENVG_IMAGE 0x3096 +#define EGL_PBUFFER_BIT 0x0001 +#define EGL_PIXEL_ASPECT_RATIO 0x3092 +#define EGL_PIXMAP_BIT 0x0002 +#define EGL_PLATFORM_GBM_KHR 0x31D7 +#define EGL_PLATFORM_WAYLAND_EXT 0x31D8 +#define EGL_PLATFORM_WAYLAND_KHR 0x31D8 +#define EGL_READ 0x305A +#define EGL_RED_SIZE 0x3024 +#define EGL_RENDERABLE_TYPE 0x3040 +#define EGL_RENDER_BUFFER 0x3086 +#define EGL_RGB_BUFFER 0x308E +#define EGL_SAMPLES 0x3031 +#define EGL_SAMPLE_BUFFERS 0x3032 +#define EGL_SAMPLE_RANGE_HINT_EXT 0x327C +#define EGL_SIGNALED 0x30F2 +#define EGL_SINGLE_BUFFER 0x3085 +#define EGL_SLOW_CONFIG 0x3050 +#define EGL_STENCIL_SIZE 0x3026 +#define EGL_SUCCESS 0x3000 +#define EGL_SURFACE_TYPE 0x3033 +#define EGL_SWAP_BEHAVIOR 0x3093 +#define EGL_SWAP_BEHAVIOR_PRESERVED_BIT 0x0400 +#define EGL_SYNC_CL_EVENT 0x30FE +#define EGL_SYNC_CL_EVENT_COMPLETE 0x30FF +#define EGL_SYNC_CONDITION 0x30F8 +#define EGL_SYNC_CONDITION_KHR 0x30F8 +#define EGL_SYNC_FENCE 0x30F9 +#define EGL_SYNC_FENCE_KHR 0x30F9 +#define EGL_SYNC_FLUSH_COMMANDS_BIT 0x0001 +#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE 0x30F0 +#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR 0x30F0 +#define EGL_SYNC_STATUS 0x30F1 +#define EGL_SYNC_TYPE 0x30F7 +#define EGL_TEXTURE_2D 0x305F +#define EGL_TEXTURE_FORMAT 0x3080 +#define EGL_TEXTURE_RGB 0x305D +#define EGL_TEXTURE_RGBA 0x305E +#define EGL_TEXTURE_TARGET 0x3081 +#define EGL_TIMEOUT_EXPIRED 0x30F5 +#define EGL_TRANSPARENT_BLUE_VALUE 0x3035 +#define EGL_TRANSPARENT_GREEN_VALUE 0x3036 +#define EGL_TRANSPARENT_RED_VALUE 0x3037 +#define EGL_TRANSPARENT_RGB 0x3052 +#define EGL_TRANSPARENT_TYPE 0x3034 +#define EGL_TRUE 1 +#define EGL_UNKNOWN EGL_CAST(EGLint,-1) +#define EGL_UNSIGNALED 0x30F3 +#define EGL_VENDOR 0x3053 +#define EGL_VERSION 0x3054 +#define EGL_VERTICAL_RESOLUTION 0x3091 +#define EGL_VG_ALPHA_FORMAT 0x3088 +#define EGL_VG_ALPHA_FORMAT_NONPRE 0x308B +#define EGL_VG_ALPHA_FORMAT_PRE 0x308C +#define EGL_VG_ALPHA_FORMAT_PRE_BIT 0x0040 +#define EGL_VG_COLORSPACE 0x3087 +#define EGL_VG_COLORSPACE_LINEAR 0x308A +#define EGL_VG_COLORSPACE_LINEAR_BIT 0x0020 +#define EGL_VG_COLORSPACE_sRGB 0x3089 +#define EGL_WIDTH 0x3057 +#define EGL_WINDOW_BIT 0x0004 +#define EGL_YUV_CHROMA_HORIZONTAL_SITING_HINT_EXT 0x327D +#define EGL_YUV_CHROMA_SITING_0_5_EXT 0x3285 +#define EGL_YUV_CHROMA_SITING_0_EXT 0x3284 +#define EGL_YUV_CHROMA_VERTICAL_SITING_HINT_EXT 0x327E +#define EGL_YUV_COLOR_SPACE_HINT_EXT 0x327B +#define EGL_YUV_FULL_RANGE_EXT 0x3282 +#define EGL_YUV_NARROW_RANGE_EXT 0x3283 + + +#include +#include + + + + + + + + + + + +struct AHardwareBuffer; +struct wl_buffer; +struct wl_display; +struct wl_resource; + +typedef unsigned int EGLBoolean; +typedef unsigned int EGLenum; +typedef intptr_t EGLAttribKHR; +typedef intptr_t EGLAttrib; +typedef void *EGLClientBuffer; +typedef void *EGLConfig; +typedef void *EGLContext; +typedef void *EGLDeviceEXT; +typedef void *EGLDisplay; +typedef void *EGLImage; +typedef void *EGLImageKHR; +typedef void *EGLLabelKHR; +typedef void *EGLObjectKHR; +typedef void *EGLOutputLayerEXT; +typedef void *EGLOutputPortEXT; +typedef void *EGLStreamKHR; +typedef void *EGLSurface; +typedef void *EGLSync; +typedef void *EGLSyncKHR; +typedef void *EGLSyncNV; +typedef void (*__eglMustCastToProperFunctionPointerType)(void); +typedef khronos_utime_nanoseconds_t EGLTimeKHR; +typedef khronos_utime_nanoseconds_t EGLTime; +typedef khronos_utime_nanoseconds_t EGLTimeNV; +typedef khronos_utime_nanoseconds_t EGLuint64NV; +typedef khronos_uint64_t EGLuint64KHR; +typedef khronos_stime_nanoseconds_t EGLnsecsANDROID; +typedef int EGLNativeFileDescriptorKHR; +typedef khronos_ssize_t EGLsizeiANDROID; +typedef void (*EGLSetBlobFuncANDROID) (const void *key, EGLsizeiANDROID keySize, const void *value, EGLsizeiANDROID valueSize); +typedef EGLsizeiANDROID (*EGLGetBlobFuncANDROID) (const void *key, EGLsizeiANDROID keySize, void *value, EGLsizeiANDROID valueSize); +struct EGLClientPixmapHI { + void *pData; + EGLint iWidth; + EGLint iHeight; + EGLint iStride; +}; +typedef void (GLAD_API_PTR *EGLDEBUGPROCKHR)(EGLenum error,const char *command,EGLint messageType,EGLLabelKHR threadLabel,EGLLabelKHR objectLabel,const char* message); +#define PFNEGLBINDWAYLANDDISPLAYWL PFNEGLBINDWAYLANDDISPLAYWLPROC +#define PFNEGLUNBINDWAYLANDDISPLAYWL PFNEGLUNBINDWAYLANDDISPLAYWLPROC +#define PFNEGLQUERYWAYLANDBUFFERWL PFNEGLQUERYWAYLANDBUFFERWLPROC +#define PFNEGLCREATEWAYLANDBUFFERFROMIMAGEWL PFNEGLCREATEWAYLANDBUFFERFROMIMAGEWLPROC + + +#define EGL_VERSION_1_0 1 +GLAD_API_CALL int GLAD_EGL_VERSION_1_0; +#define EGL_VERSION_1_1 1 +GLAD_API_CALL int GLAD_EGL_VERSION_1_1; +#define EGL_VERSION_1_2 1 +GLAD_API_CALL int GLAD_EGL_VERSION_1_2; +#define EGL_VERSION_1_3 1 +GLAD_API_CALL int GLAD_EGL_VERSION_1_3; +#define EGL_VERSION_1_4 1 +GLAD_API_CALL int GLAD_EGL_VERSION_1_4; +#define EGL_VERSION_1_5 1 +GLAD_API_CALL int GLAD_EGL_VERSION_1_5; +#define EGL_EXT_image_dma_buf_import 1 +GLAD_API_CALL int GLAD_EGL_EXT_image_dma_buf_import; +#define EGL_EXT_image_dma_buf_import_modifiers 1 +GLAD_API_CALL int GLAD_EGL_EXT_image_dma_buf_import_modifiers; +#define EGL_EXT_platform_base 1 +GLAD_API_CALL int GLAD_EGL_EXT_platform_base; +#define EGL_EXT_platform_wayland 1 +GLAD_API_CALL int GLAD_EGL_EXT_platform_wayland; +#define EGL_KHR_fence_sync 1 +GLAD_API_CALL int GLAD_EGL_KHR_fence_sync; +#define EGL_KHR_image_base 1 +GLAD_API_CALL int GLAD_EGL_KHR_image_base; +#define EGL_KHR_platform_gbm 1 +GLAD_API_CALL int GLAD_EGL_KHR_platform_gbm; +#define EGL_KHR_platform_wayland 1 +GLAD_API_CALL int GLAD_EGL_KHR_platform_wayland; + + +typedef EGLBoolean (GLAD_API_PTR *PFNEGLBINDAPIPROC)(EGLenum api); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLBINDTEXIMAGEPROC)(EGLDisplay dpy, EGLSurface surface, EGLint buffer); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLCHOOSECONFIGPROC)(EGLDisplay dpy, const EGLint * attrib_list, EGLConfig * configs, EGLint config_size, EGLint * num_config); +typedef EGLint (GLAD_API_PTR *PFNEGLCLIENTWAITSYNCPROC)(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout); +typedef EGLint (GLAD_API_PTR *PFNEGLCLIENTWAITSYNCKHRPROC)(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLCOPYBUFFERSPROC)(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target); +typedef EGLContext (GLAD_API_PTR *PFNEGLCREATECONTEXTPROC)(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint * attrib_list); +typedef EGLImage (GLAD_API_PTR *PFNEGLCREATEIMAGEPROC)(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLAttrib * attrib_list); +typedef EGLImageKHR (GLAD_API_PTR *PFNEGLCREATEIMAGEKHRPROC)(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint * attrib_list); +typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC)(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint * attrib_list); +typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEPBUFFERSURFACEPROC)(EGLDisplay dpy, EGLConfig config, const EGLint * attrib_list); +typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEPIXMAPSURFACEPROC)(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint * attrib_list); +typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC)(EGLDisplay dpy, EGLConfig config, void * native_pixmap, const EGLAttrib * attrib_list); +typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC)(EGLDisplay dpy, EGLConfig config, void * native_pixmap, const EGLint * attrib_list); +typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEPLATFORMWINDOWSURFACEPROC)(EGLDisplay dpy, EGLConfig config, void * native_window, const EGLAttrib * attrib_list); +typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC)(EGLDisplay dpy, EGLConfig config, void * native_window, const EGLint * attrib_list); +typedef EGLSync (GLAD_API_PTR *PFNEGLCREATESYNCPROC)(EGLDisplay dpy, EGLenum type, const EGLAttrib * attrib_list); +typedef EGLSyncKHR (GLAD_API_PTR *PFNEGLCREATESYNCKHRPROC)(EGLDisplay dpy, EGLenum type, const EGLint * attrib_list); +typedef EGLSurface (GLAD_API_PTR *PFNEGLCREATEWINDOWSURFACEPROC)(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint * attrib_list); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLDESTROYCONTEXTPROC)(EGLDisplay dpy, EGLContext ctx); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLDESTROYIMAGEPROC)(EGLDisplay dpy, EGLImage image); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLDESTROYIMAGEKHRPROC)(EGLDisplay dpy, EGLImageKHR image); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLDESTROYSURFACEPROC)(EGLDisplay dpy, EGLSurface surface); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLDESTROYSYNCPROC)(EGLDisplay dpy, EGLSync sync); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLDESTROYSYNCKHRPROC)(EGLDisplay dpy, EGLSyncKHR sync); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLGETCONFIGATTRIBPROC)(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint * value); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLGETCONFIGSPROC)(EGLDisplay dpy, EGLConfig * configs, EGLint config_size, EGLint * num_config); +typedef EGLContext (GLAD_API_PTR *PFNEGLGETCURRENTCONTEXTPROC)(void); +typedef EGLDisplay (GLAD_API_PTR *PFNEGLGETCURRENTDISPLAYPROC)(void); +typedef EGLSurface (GLAD_API_PTR *PFNEGLGETCURRENTSURFACEPROC)(EGLint readdraw); +typedef EGLDisplay (GLAD_API_PTR *PFNEGLGETDISPLAYPROC)(EGLNativeDisplayType display_id); +typedef EGLint (GLAD_API_PTR *PFNEGLGETERRORPROC)(void); +typedef EGLDisplay (GLAD_API_PTR *PFNEGLGETPLATFORMDISPLAYPROC)(EGLenum platform, void * native_display, const EGLAttrib * attrib_list); +typedef EGLDisplay (GLAD_API_PTR *PFNEGLGETPLATFORMDISPLAYEXTPROC)(EGLenum platform, void * native_display, const EGLint * attrib_list); +typedef __eglMustCastToProperFunctionPointerType (GLAD_API_PTR *PFNEGLGETPROCADDRESSPROC)(const char * procname); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLGETSYNCATTRIBPROC)(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib * value); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLGETSYNCATTRIBKHRPROC)(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint * value); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLINITIALIZEPROC)(EGLDisplay dpy, EGLint * major, EGLint * minor); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLMAKECURRENTPROC)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx); +typedef EGLenum (GLAD_API_PTR *PFNEGLQUERYAPIPROC)(void); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLQUERYCONTEXTPROC)(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint * value); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLQUERYDMABUFFORMATSEXTPROC)(EGLDisplay dpy, EGLint max_formats, EGLint * formats, EGLint * num_formats); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLQUERYDMABUFMODIFIERSEXTPROC)(EGLDisplay dpy, EGLint format, EGLint max_modifiers, EGLuint64KHR * modifiers, EGLBoolean * external_only, EGLint * num_modifiers); +typedef const char * (GLAD_API_PTR *PFNEGLQUERYSTRINGPROC)(EGLDisplay dpy, EGLint name); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLQUERYSURFACEPROC)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint * value); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLRELEASETEXIMAGEPROC)(EGLDisplay dpy, EGLSurface surface, EGLint buffer); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLRELEASETHREADPROC)(void); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLSURFACEATTRIBPROC)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLSWAPBUFFERSPROC)(EGLDisplay dpy, EGLSurface surface); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLSWAPINTERVALPROC)(EGLDisplay dpy, EGLint interval); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLTERMINATEPROC)(EGLDisplay dpy); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLWAITCLIENTPROC)(void); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLWAITGLPROC)(void); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLWAITNATIVEPROC)(EGLint engine); +typedef EGLBoolean (GLAD_API_PTR *PFNEGLWAITSYNCPROC)(EGLDisplay dpy, EGLSync sync, EGLint flags); + +GLAD_API_CALL PFNEGLBINDAPIPROC glad_eglBindAPI; +#define eglBindAPI glad_eglBindAPI +GLAD_API_CALL PFNEGLBINDTEXIMAGEPROC glad_eglBindTexImage; +#define eglBindTexImage glad_eglBindTexImage +GLAD_API_CALL PFNEGLCHOOSECONFIGPROC glad_eglChooseConfig; +#define eglChooseConfig glad_eglChooseConfig +GLAD_API_CALL PFNEGLCLIENTWAITSYNCPROC glad_eglClientWaitSync; +#define eglClientWaitSync glad_eglClientWaitSync +GLAD_API_CALL PFNEGLCLIENTWAITSYNCKHRPROC glad_eglClientWaitSyncKHR; +#define eglClientWaitSyncKHR glad_eglClientWaitSyncKHR +GLAD_API_CALL PFNEGLCOPYBUFFERSPROC glad_eglCopyBuffers; +#define eglCopyBuffers glad_eglCopyBuffers +GLAD_API_CALL PFNEGLCREATECONTEXTPROC glad_eglCreateContext; +#define eglCreateContext glad_eglCreateContext +GLAD_API_CALL PFNEGLCREATEIMAGEPROC glad_eglCreateImage; +#define eglCreateImage glad_eglCreateImage +GLAD_API_CALL PFNEGLCREATEIMAGEKHRPROC glad_eglCreateImageKHR; +#define eglCreateImageKHR glad_eglCreateImageKHR +GLAD_API_CALL PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC glad_eglCreatePbufferFromClientBuffer; +#define eglCreatePbufferFromClientBuffer glad_eglCreatePbufferFromClientBuffer +GLAD_API_CALL PFNEGLCREATEPBUFFERSURFACEPROC glad_eglCreatePbufferSurface; +#define eglCreatePbufferSurface glad_eglCreatePbufferSurface +GLAD_API_CALL PFNEGLCREATEPIXMAPSURFACEPROC glad_eglCreatePixmapSurface; +#define eglCreatePixmapSurface glad_eglCreatePixmapSurface +GLAD_API_CALL PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC glad_eglCreatePlatformPixmapSurface; +#define eglCreatePlatformPixmapSurface glad_eglCreatePlatformPixmapSurface +GLAD_API_CALL PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC glad_eglCreatePlatformPixmapSurfaceEXT; +#define eglCreatePlatformPixmapSurfaceEXT glad_eglCreatePlatformPixmapSurfaceEXT +GLAD_API_CALL PFNEGLCREATEPLATFORMWINDOWSURFACEPROC glad_eglCreatePlatformWindowSurface; +#define eglCreatePlatformWindowSurface glad_eglCreatePlatformWindowSurface +GLAD_API_CALL PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC glad_eglCreatePlatformWindowSurfaceEXT; +#define eglCreatePlatformWindowSurfaceEXT glad_eglCreatePlatformWindowSurfaceEXT +GLAD_API_CALL PFNEGLCREATESYNCPROC glad_eglCreateSync; +#define eglCreateSync glad_eglCreateSync +GLAD_API_CALL PFNEGLCREATESYNCKHRPROC glad_eglCreateSyncKHR; +#define eglCreateSyncKHR glad_eglCreateSyncKHR +GLAD_API_CALL PFNEGLCREATEWINDOWSURFACEPROC glad_eglCreateWindowSurface; +#define eglCreateWindowSurface glad_eglCreateWindowSurface +GLAD_API_CALL PFNEGLDESTROYCONTEXTPROC glad_eglDestroyContext; +#define eglDestroyContext glad_eglDestroyContext +GLAD_API_CALL PFNEGLDESTROYIMAGEPROC glad_eglDestroyImage; +#define eglDestroyImage glad_eglDestroyImage +GLAD_API_CALL PFNEGLDESTROYIMAGEKHRPROC glad_eglDestroyImageKHR; +#define eglDestroyImageKHR glad_eglDestroyImageKHR +GLAD_API_CALL PFNEGLDESTROYSURFACEPROC glad_eglDestroySurface; +#define eglDestroySurface glad_eglDestroySurface +GLAD_API_CALL PFNEGLDESTROYSYNCPROC glad_eglDestroySync; +#define eglDestroySync glad_eglDestroySync +GLAD_API_CALL PFNEGLDESTROYSYNCKHRPROC glad_eglDestroySyncKHR; +#define eglDestroySyncKHR glad_eglDestroySyncKHR +GLAD_API_CALL PFNEGLGETCONFIGATTRIBPROC glad_eglGetConfigAttrib; +#define eglGetConfigAttrib glad_eglGetConfigAttrib +GLAD_API_CALL PFNEGLGETCONFIGSPROC glad_eglGetConfigs; +#define eglGetConfigs glad_eglGetConfigs +GLAD_API_CALL PFNEGLGETCURRENTCONTEXTPROC glad_eglGetCurrentContext; +#define eglGetCurrentContext glad_eglGetCurrentContext +GLAD_API_CALL PFNEGLGETCURRENTDISPLAYPROC glad_eglGetCurrentDisplay; +#define eglGetCurrentDisplay glad_eglGetCurrentDisplay +GLAD_API_CALL PFNEGLGETCURRENTSURFACEPROC glad_eglGetCurrentSurface; +#define eglGetCurrentSurface glad_eglGetCurrentSurface +GLAD_API_CALL PFNEGLGETDISPLAYPROC glad_eglGetDisplay; +#define eglGetDisplay glad_eglGetDisplay +GLAD_API_CALL PFNEGLGETERRORPROC glad_eglGetError; +#define eglGetError glad_eglGetError +GLAD_API_CALL PFNEGLGETPLATFORMDISPLAYPROC glad_eglGetPlatformDisplay; +#define eglGetPlatformDisplay glad_eglGetPlatformDisplay +GLAD_API_CALL PFNEGLGETPLATFORMDISPLAYEXTPROC glad_eglGetPlatformDisplayEXT; +#define eglGetPlatformDisplayEXT glad_eglGetPlatformDisplayEXT +GLAD_API_CALL PFNEGLGETPROCADDRESSPROC glad_eglGetProcAddress; +#define eglGetProcAddress glad_eglGetProcAddress +GLAD_API_CALL PFNEGLGETSYNCATTRIBPROC glad_eglGetSyncAttrib; +#define eglGetSyncAttrib glad_eglGetSyncAttrib +GLAD_API_CALL PFNEGLGETSYNCATTRIBKHRPROC glad_eglGetSyncAttribKHR; +#define eglGetSyncAttribKHR glad_eglGetSyncAttribKHR +GLAD_API_CALL PFNEGLINITIALIZEPROC glad_eglInitialize; +#define eglInitialize glad_eglInitialize +GLAD_API_CALL PFNEGLMAKECURRENTPROC glad_eglMakeCurrent; +#define eglMakeCurrent glad_eglMakeCurrent +GLAD_API_CALL PFNEGLQUERYAPIPROC glad_eglQueryAPI; +#define eglQueryAPI glad_eglQueryAPI +GLAD_API_CALL PFNEGLQUERYCONTEXTPROC glad_eglQueryContext; +#define eglQueryContext glad_eglQueryContext +GLAD_API_CALL PFNEGLQUERYDMABUFFORMATSEXTPROC glad_eglQueryDmaBufFormatsEXT; +#define eglQueryDmaBufFormatsEXT glad_eglQueryDmaBufFormatsEXT +GLAD_API_CALL PFNEGLQUERYDMABUFMODIFIERSEXTPROC glad_eglQueryDmaBufModifiersEXT; +#define eglQueryDmaBufModifiersEXT glad_eglQueryDmaBufModifiersEXT +GLAD_API_CALL PFNEGLQUERYSTRINGPROC glad_eglQueryString; +#define eglQueryString glad_eglQueryString +GLAD_API_CALL PFNEGLQUERYSURFACEPROC glad_eglQuerySurface; +#define eglQuerySurface glad_eglQuerySurface +GLAD_API_CALL PFNEGLRELEASETEXIMAGEPROC glad_eglReleaseTexImage; +#define eglReleaseTexImage glad_eglReleaseTexImage +GLAD_API_CALL PFNEGLRELEASETHREADPROC glad_eglReleaseThread; +#define eglReleaseThread glad_eglReleaseThread +GLAD_API_CALL PFNEGLSURFACEATTRIBPROC glad_eglSurfaceAttrib; +#define eglSurfaceAttrib glad_eglSurfaceAttrib +GLAD_API_CALL PFNEGLSWAPBUFFERSPROC glad_eglSwapBuffers; +#define eglSwapBuffers glad_eglSwapBuffers +GLAD_API_CALL PFNEGLSWAPINTERVALPROC glad_eglSwapInterval; +#define eglSwapInterval glad_eglSwapInterval +GLAD_API_CALL PFNEGLTERMINATEPROC glad_eglTerminate; +#define eglTerminate glad_eglTerminate +GLAD_API_CALL PFNEGLWAITCLIENTPROC glad_eglWaitClient; +#define eglWaitClient glad_eglWaitClient +GLAD_API_CALL PFNEGLWAITGLPROC glad_eglWaitGL; +#define eglWaitGL glad_eglWaitGL +GLAD_API_CALL PFNEGLWAITNATIVEPROC glad_eglWaitNative; +#define eglWaitNative glad_eglWaitNative +GLAD_API_CALL PFNEGLWAITSYNCPROC glad_eglWaitSync; +#define eglWaitSync glad_eglWaitSync + + + + + +GLAD_API_CALL int gladLoadEGLUserPtr(EGLDisplay display, GLADuserptrloadfunc load, void *userptr); +GLAD_API_CALL int gladLoadEGL(EGLDisplay display, GLADloadfunc load); + + +#ifdef __cplusplus +} +#endif +#endif /*LV_USE_EGL*/ + +#endif diff --git a/src/drivers/opengles/glad/include/glad/gles2.h b/src/drivers/opengles/glad/include/glad/gles2.h new file mode 100644 index 0000000000..18e90b17d6 --- /dev/null +++ b/src/drivers/opengles/glad/include/glad/gles2.h @@ -0,0 +1,1067 @@ +/** + * Loader generated by glad 2.0.8 on Sun Sep 28 20:09:31 2025 + * + * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0 + * + * Generator: C/C++ + * Specification: gl + * Extensions: 5 + * + * APIs: + * - gles2=2.0 + * + * Options: + * - ALIAS = False + * - DEBUG = False + * - HEADER_ONLY = False + * - LOADER = False + * - MX = False + * - ON_DEMAND = False + * + * Commandline: + * --api='gles2=2.0' --extensions='GL_APPLE_texture_max_level,GL_EXT_texture_format_BGRA8888,GL_EXT_unpack_subimage,GL_OES_mapbuffer,GL_OES_vertex_array_object' c + * + * Online: + * http://glad.sh/#api=gles2%3D2.0&extensions=GL_APPLE_texture_max_level%2CGL_EXT_texture_format_BGRA8888%2CGL_EXT_unpack_subimage%2CGL_OES_mapbuffer%2CGL_OES_vertex_array_object&generator=c&options= + * + */ + +#ifndef GLAD_GLES2_H_ +#define GLAD_GLES2_H_ + +#include "../../../lv_opengles_egl.h" + +#if LV_USE_EGL + +#ifdef __clang__ + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wreserved-id-macro" +#endif +#ifdef __gl2_h_ + #error OpenGL ES 2 header already included (API: gles2), remove previous include! +#endif +#define __gl2_h_ 1 +#ifdef __gles2_gl2_h_ + #error OpenGL ES 2 header already included (API: gles2), remove previous include! +#endif +#define __gles2_gl2_h_ 1 +#ifdef __gl3_h_ + #error OpenGL ES 3 header already included (API: gles2), remove previous include! +#endif +#define __gl3_h_ 1 +#ifdef __gles2_gl3_h_ + #error OpenGL ES 3 header already included (API: gles2), remove previous include! +#endif +#define __gles2_gl3_h_ 1 +#ifdef __clang__ + #pragma clang diagnostic pop +#endif + +#define GLAD_GLES2 + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef GLAD_PLATFORM_H_ +#define GLAD_PLATFORM_H_ + +#ifndef GLAD_PLATFORM_WIN32 +#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__MINGW32__) +#define GLAD_PLATFORM_WIN32 1 +#else +#define GLAD_PLATFORM_WIN32 0 +#endif +#endif + +#ifndef GLAD_PLATFORM_APPLE +#ifdef __APPLE__ +#define GLAD_PLATFORM_APPLE 1 +#else +#define GLAD_PLATFORM_APPLE 0 +#endif +#endif + +#ifndef GLAD_PLATFORM_EMSCRIPTEN +#ifdef __EMSCRIPTEN__ +#define GLAD_PLATFORM_EMSCRIPTEN 1 +#else +#define GLAD_PLATFORM_EMSCRIPTEN 0 +#endif +#endif + +#ifndef GLAD_PLATFORM_UWP +#if defined(_MSC_VER) && !defined(GLAD_INTERNAL_HAVE_WINAPIFAMILY) +#ifdef __has_include +#if __has_include() +#define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1 +#endif +#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ +#define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1 +#endif +#endif + +#ifdef GLAD_INTERNAL_HAVE_WINAPIFAMILY +#include +#if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +#define GLAD_PLATFORM_UWP 1 +#endif +#endif + +#ifndef GLAD_PLATFORM_UWP +#define GLAD_PLATFORM_UWP 0 +#endif +#endif + +#ifdef __GNUC__ +#define GLAD_GNUC_EXTENSION __extension__ +#else +#define GLAD_GNUC_EXTENSION +#endif + +#define GLAD_UNUSED(x) (void)(x) + +#ifndef GLAD_API_CALL +#if defined(GLAD_API_CALL_EXPORT) +#if GLAD_PLATFORM_WIN32 || defined(__CYGWIN__) +#if defined(GLAD_API_CALL_EXPORT_BUILD) +#if defined(__GNUC__) +#define GLAD_API_CALL __attribute__ ((dllexport)) extern +#else +#define GLAD_API_CALL __declspec(dllexport) extern +#endif +#else +#if defined(__GNUC__) +#define GLAD_API_CALL __attribute__ ((dllimport)) extern +#else +#define GLAD_API_CALL __declspec(dllimport) extern +#endif +#endif +#elif defined(__GNUC__) && defined(GLAD_API_CALL_EXPORT_BUILD) +#define GLAD_API_CALL __attribute__ ((visibility ("default"))) extern +#else +#define GLAD_API_CALL extern +#endif +#else +#define GLAD_API_CALL extern +#endif +#endif + +#ifdef APIENTRY +#define GLAD_API_PTR APIENTRY +#elif GLAD_PLATFORM_WIN32 +#define GLAD_API_PTR __stdcall +#else +#define GLAD_API_PTR +#endif + +#ifndef GLAPI +#define GLAPI GLAD_API_CALL +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY GLAD_API_PTR +#endif + +#define GLAD_MAKE_VERSION(major, minor) (major * 10000 + minor) +#define GLAD_VERSION_MAJOR(version) (version / 10000) +#define GLAD_VERSION_MINOR(version) (version % 10000) + +#define GLAD_GENERATOR_VERSION "2.0.8" + +typedef void (*GLADapiproc)(void); + +typedef GLADapiproc(*GLADloadfunc)(const char * name); +typedef GLADapiproc(*GLADuserptrloadfunc)(void * userptr, const char * name); + +typedef void (*GLADprecallback)(const char * name, GLADapiproc apiproc, int len_args, ...); +typedef void (*GLADpostcallback)(void * ret, const char * name, GLADapiproc apiproc, int len_args, ...); + +#endif /* GLAD_PLATFORM_H_ */ + +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E +#define GL_ALIASED_POINT_SIZE_RANGE 0x846D +#define GL_ALPHA 0x1906 +#define GL_ALPHA_BITS 0x0D55 +#define GL_ALWAYS 0x0207 +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ARRAY_BUFFER_BINDING 0x8894 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_BACK 0x0405 +#define GL_BGRA_EXT 0x80E1 +#define GL_BLEND 0x0BE2 +#define GL_BLEND_COLOR 0x8005 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_EQUATION 0x8009 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_BLEND_EQUATION_RGB 0x8009 +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLUE_BITS 0x0D54 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_BUFFER_ACCESS_OES 0x88BB +#define GL_BUFFER_MAPPED_OES 0x88BC +#define GL_BUFFER_MAP_POINTER_OES 0x88BD +#define GL_BUFFER_SIZE 0x8764 +#define GL_BUFFER_USAGE 0x8765 +#define GL_BYTE 0x1400 +#define GL_CCW 0x0901 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_COLOR_BUFFER_BIT 0x00004000 +#define GL_COLOR_CLEAR_VALUE 0x0C22 +#define GL_COLOR_WRITEMASK 0x0C23 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_CONSTANT_COLOR 0x8001 +#define GL_CULL_FACE 0x0B44 +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_CURRENT_PROGRAM 0x8B8D +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 +#define GL_CW 0x0900 +#define GL_DECR 0x1E03 +#define GL_DECR_WRAP 0x8508 +#define GL_DELETE_STATUS 0x8B80 +#define GL_DEPTH_ATTACHMENT 0x8D00 +#define GL_DEPTH_BITS 0x0D56 +#define GL_DEPTH_BUFFER_BIT 0x00000100 +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_FUNC 0x0B74 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_TEST 0x0B71 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DITHER 0x0BD0 +#define GL_DONT_CARE 0x1100 +#define GL_DST_ALPHA 0x0304 +#define GL_DST_COLOR 0x0306 +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 +#define GL_EQUAL 0x0202 +#define GL_EXTENSIONS 0x1F03 +#define GL_FALSE 0 +#define GL_FASTEST 0x1101 +#define GL_FIXED 0x140C +#define GL_FLOAT 0x1406 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_FRAMEBUFFER 0x8D40 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 +#define GL_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS 0x8CD9 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD +#define GL_FRONT 0x0404 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_FRONT_FACE 0x0B46 +#define GL_FUNC_ADD 0x8006 +#define GL_FUNC_REVERSE_SUBTRACT 0x800B +#define GL_FUNC_SUBTRACT 0x800A +#define GL_GENERATE_MIPMAP_HINT 0x8192 +#define GL_GEQUAL 0x0206 +#define GL_GREATER 0x0204 +#define GL_GREEN_BITS 0x0D53 +#define GL_HIGH_FLOAT 0x8DF2 +#define GL_HIGH_INT 0x8DF5 +#define GL_IMPLEMENTATION_COLOR_READ_FORMAT 0x8B9B +#define GL_IMPLEMENTATION_COLOR_READ_TYPE 0x8B9A +#define GL_INCR 0x1E02 +#define GL_INCR_WRAP 0x8507 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_INT 0x1404 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 +#define GL_INVALID_OPERATION 0x0502 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVERT 0x150A +#define GL_KEEP 0x1E00 +#define GL_LEQUAL 0x0203 +#define GL_LESS 0x0201 +#define GL_LINEAR 0x2601 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_LINES 0x0001 +#define GL_LINE_LOOP 0x0002 +#define GL_LINE_STRIP 0x0003 +#define GL_LINE_WIDTH 0x0B21 +#define GL_LINK_STATUS 0x8B82 +#define GL_LOW_FLOAT 0x8DF0 +#define GL_LOW_INT 0x8DF3 +#define GL_LUMINANCE 0x1909 +#define GL_LUMINANCE_ALPHA 0x190A +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_MAX_FRAGMENT_UNIFORM_VECTORS 0x8DFD +#define GL_MAX_RENDERBUFFER_SIZE 0x84E8 +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_MAX_TEXTURE_SIZE 0x0D33 +#define GL_MAX_VARYING_VECTORS 0x8DFC +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_VERTEX_UNIFORM_VECTORS 0x8DFB +#define GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GL_MEDIUM_FLOAT 0x8DF1 +#define GL_MEDIUM_INT 0x8DF4 +#define GL_MIRRORED_REPEAT 0x8370 +#define GL_NEAREST 0x2600 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_NEVER 0x0200 +#define GL_NICEST 0x1102 +#define GL_NONE 0 +#define GL_NOTEQUAL 0x0205 +#define GL_NO_ERROR 0 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_NUM_SHADER_BINARY_FORMATS 0x8DF9 +#define GL_ONE 1 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_OUT_OF_MEMORY 0x0505 +#define GL_PACK_ALIGNMENT 0x0D05 +#define GL_POINTS 0x0000 +#define GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GL_POLYGON_OFFSET_FILL 0x8037 +#define GL_POLYGON_OFFSET_UNITS 0x2A00 +#define GL_RED_BITS 0x0D52 +#define GL_RENDERBUFFER 0x8D41 +#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 +#define GL_RENDERBUFFER_BINDING 0x8CA7 +#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 +#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 +#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 +#define GL_RENDERBUFFER_HEIGHT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 +#define GL_RENDERBUFFER_RED_SIZE 0x8D50 +#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 +#define GL_RENDERBUFFER_WIDTH 0x8D42 +#define GL_RENDERER 0x1F01 +#define GL_REPEAT 0x2901 +#define GL_REPLACE 0x1E01 +#define GL_RGB 0x1907 +#define GL_RGB565 0x8D62 +#define GL_RGB5_A1 0x8057 +#define GL_RGBA 0x1908 +#define GL_RGBA4 0x8056 +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SCISSOR_BOX 0x0C10 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_SHADER_BINARY_FORMATS 0x8DF8 +#define GL_SHADER_COMPILER 0x8DFA +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_SHADER_TYPE 0x8B4F +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_SHORT 0x1402 +#define GL_SRC_ALPHA 0x0302 +#define GL_SRC_ALPHA_SATURATE 0x0308 +#define GL_SRC_COLOR 0x0300 +#define GL_STATIC_DRAW 0x88E4 +#define GL_STENCIL_ATTACHMENT 0x8D20 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 +#define GL_STENCIL_BITS 0x0D57 +#define GL_STENCIL_BUFFER_BIT 0x00000400 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_INDEX8 0x8D48 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_TEST 0x0B90 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_STREAM_DRAW 0x88E0 +#define GL_SUBPIXEL_BITS 0x0D50 +#define GL_TEXTURE 0x1702 +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_TEXTURE_BINDING_2D 0x8069 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MAX_LEVEL_APPLE 0x813D +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 +#define GL_TRIANGLES 0x0004 +#define GL_TRIANGLE_FAN 0x0006 +#define GL_TRIANGLE_STRIP 0x0005 +#define GL_TRUE 1 +#define GL_UNPACK_ALIGNMENT 0x0CF5 +#define GL_UNPACK_ROW_LENGTH_EXT 0x0CF2 +#define GL_UNPACK_SKIP_PIXELS_EXT 0x0CF4 +#define GL_UNPACK_SKIP_ROWS_EXT 0x0CF3 +#define GL_UNSIGNED_BYTE 0x1401 +#define GL_UNSIGNED_INT 0x1405 +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_VENDOR 0x1F00 +#define GL_VERSION 0x1F02 +#define GL_VERTEX_ARRAY_BINDING_OES 0x85B5 +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_VIEWPORT 0x0BA2 +#define GL_WRITE_ONLY_OES 0x88B9 +#define GL_ZERO 0 + + +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef khronos_int8_t GLbyte; +typedef khronos_uint8_t GLubyte; +typedef khronos_int16_t GLshort; +typedef khronos_uint16_t GLushort; +typedef int GLint; +typedef unsigned int GLuint; +typedef khronos_int32_t GLclampx; +typedef int GLsizei; +typedef khronos_float_t GLfloat; +typedef khronos_float_t GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void * GLeglClientBufferEXT; +typedef void * GLeglImageOES; +typedef char GLchar; +typedef char GLcharARB; +#ifdef __APPLE__ +typedef void * GLhandleARB; +#else +typedef unsigned int GLhandleARB; +#endif +typedef khronos_uint16_t GLhalf; +typedef khronos_uint16_t GLhalfARB; +typedef khronos_int32_t GLfixed; +#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060) +typedef khronos_intptr_t GLintptr; +#else +typedef khronos_intptr_t GLintptr; +#endif +#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060) +typedef khronos_intptr_t GLintptrARB; +#else +typedef khronos_intptr_t GLintptrARB; +#endif +#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060) +typedef khronos_ssize_t GLsizeiptr; +#else +typedef khronos_ssize_t GLsizeiptr; +#endif +#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060) +typedef khronos_ssize_t GLsizeiptrARB; +#else +typedef khronos_ssize_t GLsizeiptrARB; +#endif +typedef khronos_int64_t GLint64; +typedef khronos_int64_t GLint64EXT; +typedef khronos_uint64_t GLuint64; +typedef khronos_uint64_t GLuint64EXT; +typedef struct __GLsync * GLsync; +struct _cl_context; +struct _cl_event; +typedef void (GLAD_API_PTR * GLDEBUGPROC)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, + const GLchar * message, const void * userParam); +typedef void (GLAD_API_PTR * GLDEBUGPROCARB)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, + const GLchar * message, const void * userParam); +typedef void (GLAD_API_PTR * GLDEBUGPROCKHR)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, + const GLchar * message, const void * userParam); +typedef void (GLAD_API_PTR * GLDEBUGPROCAMD)(GLuint id, GLenum category, GLenum severity, GLsizei length, + const GLchar * message, void * userParam); +typedef unsigned short GLhalfNV; +typedef GLintptr GLvdpauSurfaceNV; +typedef void (GLAD_API_PTR * GLVULKANPROCNV)(void); + + +#define GL_ES_VERSION_2_0 1 +GLAD_API_CALL int GLAD_GL_ES_VERSION_2_0; +#define GL_APPLE_texture_max_level 1 +GLAD_API_CALL int GLAD_GL_APPLE_texture_max_level; +#define GL_EXT_texture_format_BGRA8888 1 +GLAD_API_CALL int GLAD_GL_EXT_texture_format_BGRA8888; +#define GL_EXT_unpack_subimage 1 +GLAD_API_CALL int GLAD_GL_EXT_unpack_subimage; +#define GL_OES_mapbuffer 1 +GLAD_API_CALL int GLAD_GL_OES_mapbuffer; +#define GL_OES_vertex_array_object 1 +GLAD_API_CALL int GLAD_GL_OES_vertex_array_object; + + +typedef void (GLAD_API_PTR * PFNGLACTIVETEXTUREPROC)(GLenum texture); +typedef void (GLAD_API_PTR * PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader); +typedef void (GLAD_API_PTR * PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar * name); +typedef void (GLAD_API_PTR * PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer); +typedef void (GLAD_API_PTR * PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer); +typedef void (GLAD_API_PTR * PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer); +typedef void (GLAD_API_PTR * PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture); +typedef void (GLAD_API_PTR * PFNGLBINDVERTEXARRAYOESPROC)(GLuint array); +typedef void (GLAD_API_PTR * PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +typedef void (GLAD_API_PTR * PFNGLBLENDEQUATIONPROC)(GLenum mode); +typedef void (GLAD_API_PTR * PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha); +typedef void (GLAD_API_PTR * PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor); +typedef void (GLAD_API_PTR * PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, + GLenum dfactorAlpha); +typedef void (GLAD_API_PTR * PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void * data, GLenum usage); +typedef void (GLAD_API_PTR * PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, + const void * data); +typedef GLenum(GLAD_API_PTR * PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target); +typedef void (GLAD_API_PTR * PFNGLCLEARPROC)(GLbitfield mask); +typedef void (GLAD_API_PTR * PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +typedef void (GLAD_API_PTR * PFNGLCLEARDEPTHFPROC)(GLfloat d); +typedef void (GLAD_API_PTR * PFNGLCLEARSTENCILPROC)(GLint s); +typedef void (GLAD_API_PTR * PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +typedef void (GLAD_API_PTR * PFNGLCOMPILESHADERPROC)(GLuint shader); +typedef void (GLAD_API_PTR * PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, + GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data); +typedef void (GLAD_API_PTR * PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, + GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data); +typedef void (GLAD_API_PTR * PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, + GLint y, GLsizei width, GLsizei height, GLint border); +typedef void (GLAD_API_PTR * PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, + GLint x, GLint y, GLsizei width, GLsizei height); +typedef GLuint(GLAD_API_PTR * PFNGLCREATEPROGRAMPROC)(void); +typedef GLuint(GLAD_API_PTR * PFNGLCREATESHADERPROC)(GLenum type); +typedef void (GLAD_API_PTR * PFNGLCULLFACEPROC)(GLenum mode); +typedef void (GLAD_API_PTR * PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint * buffers); +typedef void (GLAD_API_PTR * PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint * framebuffers); +typedef void (GLAD_API_PTR * PFNGLDELETEPROGRAMPROC)(GLuint program); +typedef void (GLAD_API_PTR * PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint * renderbuffers); +typedef void (GLAD_API_PTR * PFNGLDELETESHADERPROC)(GLuint shader); +typedef void (GLAD_API_PTR * PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint * textures); +typedef void (GLAD_API_PTR * PFNGLDELETEVERTEXARRAYSOESPROC)(GLsizei n, const GLuint * arrays); +typedef void (GLAD_API_PTR * PFNGLDEPTHFUNCPROC)(GLenum func); +typedef void (GLAD_API_PTR * PFNGLDEPTHMASKPROC)(GLboolean flag); +typedef void (GLAD_API_PTR * PFNGLDEPTHRANGEFPROC)(GLfloat n, GLfloat f); +typedef void (GLAD_API_PTR * PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader); +typedef void (GLAD_API_PTR * PFNGLDISABLEPROC)(GLenum cap); +typedef void (GLAD_API_PTR * PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index); +typedef void (GLAD_API_PTR * PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count); +typedef void (GLAD_API_PTR * PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void * indices); +typedef void (GLAD_API_PTR * PFNGLENABLEPROC)(GLenum cap); +typedef void (GLAD_API_PTR * PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index); +typedef void (GLAD_API_PTR * PFNGLFINISHPROC)(void); +typedef void (GLAD_API_PTR * PFNGLFLUSHPROC)(void); +typedef void (GLAD_API_PTR * PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, + GLenum renderbuffertarget, GLuint renderbuffer); +typedef void (GLAD_API_PTR * PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, + GLuint texture, GLint level); +typedef void (GLAD_API_PTR * PFNGLFRONTFACEPROC)(GLenum mode); +typedef void (GLAD_API_PTR * PFNGLGENBUFFERSPROC)(GLsizei n, GLuint * buffers); +typedef void (GLAD_API_PTR * PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint * framebuffers); +typedef void (GLAD_API_PTR * PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint * renderbuffers); +typedef void (GLAD_API_PTR * PFNGLGENTEXTURESPROC)(GLsizei n, GLuint * textures); +typedef void (GLAD_API_PTR * PFNGLGENVERTEXARRAYSOESPROC)(GLsizei n, GLuint * arrays); +typedef void (GLAD_API_PTR * PFNGLGENERATEMIPMAPPROC)(GLenum target); +typedef void (GLAD_API_PTR * PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, + GLint * size, GLenum * type, GLchar * name); +typedef void (GLAD_API_PTR * PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, + GLint * size, GLenum * type, GLchar * name); +typedef void (GLAD_API_PTR * PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei * count, + GLuint * shaders); +typedef GLint(GLAD_API_PTR * PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar * name); +typedef void (GLAD_API_PTR * PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean * data); +typedef void (GLAD_API_PTR * PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint * params); +typedef void (GLAD_API_PTR * PFNGLGETBUFFERPOINTERVOESPROC)(GLenum target, GLenum pname, void ** params); +typedef GLenum(GLAD_API_PTR * PFNGLGETERRORPROC)(void); +typedef void (GLAD_API_PTR * PFNGLGETFLOATVPROC)(GLenum pname, GLfloat * data); +typedef void (GLAD_API_PTR * PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, + GLenum pname, GLint * params); +typedef void (GLAD_API_PTR * PFNGLGETINTEGERVPROC)(GLenum pname, GLint * data); +typedef void (GLAD_API_PTR * PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei * length, + GLchar * infoLog); +typedef void (GLAD_API_PTR * PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint * params); +typedef void (GLAD_API_PTR * PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint * params); +typedef void (GLAD_API_PTR * PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei * length, + GLchar * infoLog); +typedef void (GLAD_API_PTR * PFNGLGETSHADERPRECISIONFORMATPROC)(GLenum shadertype, GLenum precisiontype, GLint * range, + GLint * precision); +typedef void (GLAD_API_PTR * PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei * length, + GLchar * source); +typedef void (GLAD_API_PTR * PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint * params); +typedef const GLubyte * (GLAD_API_PTR * PFNGLGETSTRINGPROC)(GLenum name); +typedef void (GLAD_API_PTR * PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat * params); +typedef void (GLAD_API_PTR * PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint * params); +typedef GLint(GLAD_API_PTR * PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar * name); +typedef void (GLAD_API_PTR * PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat * params); +typedef void (GLAD_API_PTR * PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint * params); +typedef void (GLAD_API_PTR * PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void ** pointer); +typedef void (GLAD_API_PTR * PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat * params); +typedef void (GLAD_API_PTR * PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint * params); +typedef void (GLAD_API_PTR * PFNGLHINTPROC)(GLenum target, GLenum mode); +typedef GLboolean(GLAD_API_PTR * PFNGLISBUFFERPROC)(GLuint buffer); +typedef GLboolean(GLAD_API_PTR * PFNGLISENABLEDPROC)(GLenum cap); +typedef GLboolean(GLAD_API_PTR * PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer); +typedef GLboolean(GLAD_API_PTR * PFNGLISPROGRAMPROC)(GLuint program); +typedef GLboolean(GLAD_API_PTR * PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer); +typedef GLboolean(GLAD_API_PTR * PFNGLISSHADERPROC)(GLuint shader); +typedef GLboolean(GLAD_API_PTR * PFNGLISTEXTUREPROC)(GLuint texture); +typedef GLboolean(GLAD_API_PTR * PFNGLISVERTEXARRAYOESPROC)(GLuint array); +typedef void (GLAD_API_PTR * PFNGLLINEWIDTHPROC)(GLfloat width); +typedef void (GLAD_API_PTR * PFNGLLINKPROGRAMPROC)(GLuint program); +typedef void * (GLAD_API_PTR * PFNGLMAPBUFFEROESPROC)(GLenum target, GLenum access); +typedef void (GLAD_API_PTR * PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param); +typedef void (GLAD_API_PTR * PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units); +typedef void (GLAD_API_PTR * PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, + GLenum type, void * pixels); +typedef void (GLAD_API_PTR * PFNGLRELEASESHADERCOMPILERPROC)(void); +typedef void (GLAD_API_PTR * PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, + GLsizei height); +typedef void (GLAD_API_PTR * PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert); +typedef void (GLAD_API_PTR * PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAD_API_PTR * PFNGLSHADERBINARYPROC)(GLsizei count, const GLuint * shaders, GLenum binaryFormat, + const void * binary, GLsizei length); +typedef void (GLAD_API_PTR * PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar * const * string, + const GLint * length); +typedef void (GLAD_API_PTR * PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask); +typedef void (GLAD_API_PTR * PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask); +typedef void (GLAD_API_PTR * PFNGLSTENCILMASKPROC)(GLuint mask); +typedef void (GLAD_API_PTR * PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask); +typedef void (GLAD_API_PTR * PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass); +typedef void (GLAD_API_PTR * PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +typedef void (GLAD_API_PTR * PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, + GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels); +typedef void (GLAD_API_PTR * PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param); +typedef void (GLAD_API_PTR * PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat * params); +typedef void (GLAD_API_PTR * PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param); +typedef void (GLAD_API_PTR * PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint * params); +typedef void (GLAD_API_PTR * PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, + GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels); +typedef void (GLAD_API_PTR * PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0); +typedef void (GLAD_API_PTR * PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat * value); +typedef void (GLAD_API_PTR * PFNGLUNIFORM1IPROC)(GLint location, GLint v0); +typedef void (GLAD_API_PTR * PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint * value); +typedef void (GLAD_API_PTR * PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1); +typedef void (GLAD_API_PTR * PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat * value); +typedef void (GLAD_API_PTR * PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1); +typedef void (GLAD_API_PTR * PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint * value); +typedef void (GLAD_API_PTR * PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +typedef void (GLAD_API_PTR * PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat * value); +typedef void (GLAD_API_PTR * PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2); +typedef void (GLAD_API_PTR * PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint * value); +typedef void (GLAD_API_PTR * PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +typedef void (GLAD_API_PTR * PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat * value); +typedef void (GLAD_API_PTR * PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +typedef void (GLAD_API_PTR * PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint * value); +typedef void (GLAD_API_PTR * PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, + const GLfloat * value); +typedef void (GLAD_API_PTR * PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, + const GLfloat * value); +typedef void (GLAD_API_PTR * PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, + const GLfloat * value); +typedef GLboolean(GLAD_API_PTR * PFNGLUNMAPBUFFEROESPROC)(GLenum target); +typedef void (GLAD_API_PTR * PFNGLUSEPROGRAMPROC)(GLuint program); +typedef void (GLAD_API_PTR * PFNGLVALIDATEPROGRAMPROC)(GLuint program); +typedef void (GLAD_API_PTR * PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x); +typedef void (GLAD_API_PTR * PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat * v); +typedef void (GLAD_API_PTR * PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y); +typedef void (GLAD_API_PTR * PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat * v); +typedef void (GLAD_API_PTR * PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAD_API_PTR * PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat * v); +typedef void (GLAD_API_PTR * PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAD_API_PTR * PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat * v); +typedef void (GLAD_API_PTR * PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, + GLsizei stride, const void * pointer); +typedef void (GLAD_API_PTR * PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height); + +GLAD_API_CALL PFNGLACTIVETEXTUREPROC glad_glActiveTexture; +#define glActiveTexture glad_glActiveTexture +GLAD_API_CALL PFNGLATTACHSHADERPROC glad_glAttachShader; +#define glAttachShader glad_glAttachShader +GLAD_API_CALL PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation; +#define glBindAttribLocation glad_glBindAttribLocation +GLAD_API_CALL PFNGLBINDBUFFERPROC glad_glBindBuffer; +#define glBindBuffer glad_glBindBuffer +GLAD_API_CALL PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer; +#define glBindFramebuffer glad_glBindFramebuffer +GLAD_API_CALL PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer; +#define glBindRenderbuffer glad_glBindRenderbuffer +GLAD_API_CALL PFNGLBINDTEXTUREPROC glad_glBindTexture; +#define glBindTexture glad_glBindTexture +GLAD_API_CALL PFNGLBINDVERTEXARRAYOESPROC glad_glBindVertexArrayOES; +#define glBindVertexArrayOES glad_glBindVertexArrayOES +GLAD_API_CALL PFNGLBLENDCOLORPROC glad_glBlendColor; +#define glBlendColor glad_glBlendColor +GLAD_API_CALL PFNGLBLENDEQUATIONPROC glad_glBlendEquation; +#define glBlendEquation glad_glBlendEquation +GLAD_API_CALL PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate; +#define glBlendEquationSeparate glad_glBlendEquationSeparate +GLAD_API_CALL PFNGLBLENDFUNCPROC glad_glBlendFunc; +#define glBlendFunc glad_glBlendFunc +GLAD_API_CALL PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate; +#define glBlendFuncSeparate glad_glBlendFuncSeparate +GLAD_API_CALL PFNGLBUFFERDATAPROC glad_glBufferData; +#define glBufferData glad_glBufferData +GLAD_API_CALL PFNGLBUFFERSUBDATAPROC glad_glBufferSubData; +#define glBufferSubData glad_glBufferSubData +GLAD_API_CALL PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus; +#define glCheckFramebufferStatus glad_glCheckFramebufferStatus +GLAD_API_CALL PFNGLCLEARPROC glad_glClear; +#define glClear glad_glClear +GLAD_API_CALL PFNGLCLEARCOLORPROC glad_glClearColor; +#define glClearColor glad_glClearColor +GLAD_API_CALL PFNGLCLEARDEPTHFPROC glad_glClearDepthf; +#define glClearDepthf glad_glClearDepthf +GLAD_API_CALL PFNGLCLEARSTENCILPROC glad_glClearStencil; +#define glClearStencil glad_glClearStencil +GLAD_API_CALL PFNGLCOLORMASKPROC glad_glColorMask; +#define glColorMask glad_glColorMask +GLAD_API_CALL PFNGLCOMPILESHADERPROC glad_glCompileShader; +#define glCompileShader glad_glCompileShader +GLAD_API_CALL PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D; +#define glCompressedTexImage2D glad_glCompressedTexImage2D +GLAD_API_CALL PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D; +#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D +GLAD_API_CALL PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D; +#define glCopyTexImage2D glad_glCopyTexImage2D +GLAD_API_CALL PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D; +#define glCopyTexSubImage2D glad_glCopyTexSubImage2D +GLAD_API_CALL PFNGLCREATEPROGRAMPROC glad_glCreateProgram; +#define glCreateProgram glad_glCreateProgram +GLAD_API_CALL PFNGLCREATESHADERPROC glad_glCreateShader; +#define glCreateShader glad_glCreateShader +GLAD_API_CALL PFNGLCULLFACEPROC glad_glCullFace; +#define glCullFace glad_glCullFace +GLAD_API_CALL PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers; +#define glDeleteBuffers glad_glDeleteBuffers +GLAD_API_CALL PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers; +#define glDeleteFramebuffers glad_glDeleteFramebuffers +GLAD_API_CALL PFNGLDELETEPROGRAMPROC glad_glDeleteProgram; +#define glDeleteProgram glad_glDeleteProgram +GLAD_API_CALL PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers; +#define glDeleteRenderbuffers glad_glDeleteRenderbuffers +GLAD_API_CALL PFNGLDELETESHADERPROC glad_glDeleteShader; +#define glDeleteShader glad_glDeleteShader +GLAD_API_CALL PFNGLDELETETEXTURESPROC glad_glDeleteTextures; +#define glDeleteTextures glad_glDeleteTextures +GLAD_API_CALL PFNGLDELETEVERTEXARRAYSOESPROC glad_glDeleteVertexArraysOES; +#define glDeleteVertexArraysOES glad_glDeleteVertexArraysOES +GLAD_API_CALL PFNGLDEPTHFUNCPROC glad_glDepthFunc; +#define glDepthFunc glad_glDepthFunc +GLAD_API_CALL PFNGLDEPTHMASKPROC glad_glDepthMask; +#define glDepthMask glad_glDepthMask +GLAD_API_CALL PFNGLDEPTHRANGEFPROC glad_glDepthRangef; +#define glDepthRangef glad_glDepthRangef +GLAD_API_CALL PFNGLDETACHSHADERPROC glad_glDetachShader; +#define glDetachShader glad_glDetachShader +GLAD_API_CALL PFNGLDISABLEPROC glad_glDisable; +#define glDisable glad_glDisable +GLAD_API_CALL PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray; +#define glDisableVertexAttribArray glad_glDisableVertexAttribArray +GLAD_API_CALL PFNGLDRAWARRAYSPROC glad_glDrawArrays; +#define glDrawArrays glad_glDrawArrays +GLAD_API_CALL PFNGLDRAWELEMENTSPROC glad_glDrawElements; +#define glDrawElements glad_glDrawElements +GLAD_API_CALL PFNGLENABLEPROC glad_glEnable; +#define glEnable glad_glEnable +GLAD_API_CALL PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray; +#define glEnableVertexAttribArray glad_glEnableVertexAttribArray +GLAD_API_CALL PFNGLFINISHPROC glad_glFinish; +#define glFinish glad_glFinish +GLAD_API_CALL PFNGLFLUSHPROC glad_glFlush; +#define glFlush glad_glFlush +GLAD_API_CALL PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer; +#define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer +GLAD_API_CALL PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D; +#define glFramebufferTexture2D glad_glFramebufferTexture2D +GLAD_API_CALL PFNGLFRONTFACEPROC glad_glFrontFace; +#define glFrontFace glad_glFrontFace +GLAD_API_CALL PFNGLGENBUFFERSPROC glad_glGenBuffers; +#define glGenBuffers glad_glGenBuffers +GLAD_API_CALL PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers; +#define glGenFramebuffers glad_glGenFramebuffers +GLAD_API_CALL PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers; +#define glGenRenderbuffers glad_glGenRenderbuffers +GLAD_API_CALL PFNGLGENTEXTURESPROC glad_glGenTextures; +#define glGenTextures glad_glGenTextures +GLAD_API_CALL PFNGLGENVERTEXARRAYSOESPROC glad_glGenVertexArraysOES; +#define glGenVertexArraysOES glad_glGenVertexArraysOES +GLAD_API_CALL PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap; +#define glGenerateMipmap glad_glGenerateMipmap +GLAD_API_CALL PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib; +#define glGetActiveAttrib glad_glGetActiveAttrib +GLAD_API_CALL PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform; +#define glGetActiveUniform glad_glGetActiveUniform +GLAD_API_CALL PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders; +#define glGetAttachedShaders glad_glGetAttachedShaders +GLAD_API_CALL PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation; +#define glGetAttribLocation glad_glGetAttribLocation +GLAD_API_CALL PFNGLGETBOOLEANVPROC glad_glGetBooleanv; +#define glGetBooleanv glad_glGetBooleanv +GLAD_API_CALL PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv; +#define glGetBufferParameteriv glad_glGetBufferParameteriv +GLAD_API_CALL PFNGLGETBUFFERPOINTERVOESPROC glad_glGetBufferPointervOES; +#define glGetBufferPointervOES glad_glGetBufferPointervOES +GLAD_API_CALL PFNGLGETERRORPROC glad_glGetError; +#define glGetError glad_glGetError +GLAD_API_CALL PFNGLGETFLOATVPROC glad_glGetFloatv; +#define glGetFloatv glad_glGetFloatv +GLAD_API_CALL PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv; +#define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv +GLAD_API_CALL PFNGLGETINTEGERVPROC glad_glGetIntegerv; +#define glGetIntegerv glad_glGetIntegerv +GLAD_API_CALL PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog; +#define glGetProgramInfoLog glad_glGetProgramInfoLog +GLAD_API_CALL PFNGLGETPROGRAMIVPROC glad_glGetProgramiv; +#define glGetProgramiv glad_glGetProgramiv +GLAD_API_CALL PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv; +#define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv +GLAD_API_CALL PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog; +#define glGetShaderInfoLog glad_glGetShaderInfoLog +GLAD_API_CALL PFNGLGETSHADERPRECISIONFORMATPROC glad_glGetShaderPrecisionFormat; +#define glGetShaderPrecisionFormat glad_glGetShaderPrecisionFormat +GLAD_API_CALL PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource; +#define glGetShaderSource glad_glGetShaderSource +GLAD_API_CALL PFNGLGETSHADERIVPROC glad_glGetShaderiv; +#define glGetShaderiv glad_glGetShaderiv +GLAD_API_CALL PFNGLGETSTRINGPROC glad_glGetString; +#define glGetString glad_glGetString +GLAD_API_CALL PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv; +#define glGetTexParameterfv glad_glGetTexParameterfv +GLAD_API_CALL PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv; +#define glGetTexParameteriv glad_glGetTexParameteriv +GLAD_API_CALL PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation; +#define glGetUniformLocation glad_glGetUniformLocation +GLAD_API_CALL PFNGLGETUNIFORMFVPROC glad_glGetUniformfv; +#define glGetUniformfv glad_glGetUniformfv +GLAD_API_CALL PFNGLGETUNIFORMIVPROC glad_glGetUniformiv; +#define glGetUniformiv glad_glGetUniformiv +GLAD_API_CALL PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv; +#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv +GLAD_API_CALL PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv; +#define glGetVertexAttribfv glad_glGetVertexAttribfv +GLAD_API_CALL PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv; +#define glGetVertexAttribiv glad_glGetVertexAttribiv +GLAD_API_CALL PFNGLHINTPROC glad_glHint; +#define glHint glad_glHint +GLAD_API_CALL PFNGLISBUFFERPROC glad_glIsBuffer; +#define glIsBuffer glad_glIsBuffer +GLAD_API_CALL PFNGLISENABLEDPROC glad_glIsEnabled; +#define glIsEnabled glad_glIsEnabled +GLAD_API_CALL PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer; +#define glIsFramebuffer glad_glIsFramebuffer +GLAD_API_CALL PFNGLISPROGRAMPROC glad_glIsProgram; +#define glIsProgram glad_glIsProgram +GLAD_API_CALL PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer; +#define glIsRenderbuffer glad_glIsRenderbuffer +GLAD_API_CALL PFNGLISSHADERPROC glad_glIsShader; +#define glIsShader glad_glIsShader +GLAD_API_CALL PFNGLISTEXTUREPROC glad_glIsTexture; +#define glIsTexture glad_glIsTexture +GLAD_API_CALL PFNGLISVERTEXARRAYOESPROC glad_glIsVertexArrayOES; +#define glIsVertexArrayOES glad_glIsVertexArrayOES +GLAD_API_CALL PFNGLLINEWIDTHPROC glad_glLineWidth; +#define glLineWidth glad_glLineWidth +GLAD_API_CALL PFNGLLINKPROGRAMPROC glad_glLinkProgram; +#define glLinkProgram glad_glLinkProgram +GLAD_API_CALL PFNGLMAPBUFFEROESPROC glad_glMapBufferOES; +#define glMapBufferOES glad_glMapBufferOES +GLAD_API_CALL PFNGLPIXELSTOREIPROC glad_glPixelStorei; +#define glPixelStorei glad_glPixelStorei +GLAD_API_CALL PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset; +#define glPolygonOffset glad_glPolygonOffset +GLAD_API_CALL PFNGLREADPIXELSPROC glad_glReadPixels; +#define glReadPixels glad_glReadPixels +GLAD_API_CALL PFNGLRELEASESHADERCOMPILERPROC glad_glReleaseShaderCompiler; +#define glReleaseShaderCompiler glad_glReleaseShaderCompiler +GLAD_API_CALL PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage; +#define glRenderbufferStorage glad_glRenderbufferStorage +GLAD_API_CALL PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage; +#define glSampleCoverage glad_glSampleCoverage +GLAD_API_CALL PFNGLSCISSORPROC glad_glScissor; +#define glScissor glad_glScissor +GLAD_API_CALL PFNGLSHADERBINARYPROC glad_glShaderBinary; +#define glShaderBinary glad_glShaderBinary +GLAD_API_CALL PFNGLSHADERSOURCEPROC glad_glShaderSource; +#define glShaderSource glad_glShaderSource +GLAD_API_CALL PFNGLSTENCILFUNCPROC glad_glStencilFunc; +#define glStencilFunc glad_glStencilFunc +GLAD_API_CALL PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate; +#define glStencilFuncSeparate glad_glStencilFuncSeparate +GLAD_API_CALL PFNGLSTENCILMASKPROC glad_glStencilMask; +#define glStencilMask glad_glStencilMask +GLAD_API_CALL PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate; +#define glStencilMaskSeparate glad_glStencilMaskSeparate +GLAD_API_CALL PFNGLSTENCILOPPROC glad_glStencilOp; +#define glStencilOp glad_glStencilOp +GLAD_API_CALL PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate; +#define glStencilOpSeparate glad_glStencilOpSeparate +GLAD_API_CALL PFNGLTEXIMAGE2DPROC glad_glTexImage2D; +#define glTexImage2D glad_glTexImage2D +GLAD_API_CALL PFNGLTEXPARAMETERFPROC glad_glTexParameterf; +#define glTexParameterf glad_glTexParameterf +GLAD_API_CALL PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv; +#define glTexParameterfv glad_glTexParameterfv +GLAD_API_CALL PFNGLTEXPARAMETERIPROC glad_glTexParameteri; +#define glTexParameteri glad_glTexParameteri +GLAD_API_CALL PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv; +#define glTexParameteriv glad_glTexParameteriv +GLAD_API_CALL PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D; +#define glTexSubImage2D glad_glTexSubImage2D +GLAD_API_CALL PFNGLUNIFORM1FPROC glad_glUniform1f; +#define glUniform1f glad_glUniform1f +GLAD_API_CALL PFNGLUNIFORM1FVPROC glad_glUniform1fv; +#define glUniform1fv glad_glUniform1fv +GLAD_API_CALL PFNGLUNIFORM1IPROC glad_glUniform1i; +#define glUniform1i glad_glUniform1i +GLAD_API_CALL PFNGLUNIFORM1IVPROC glad_glUniform1iv; +#define glUniform1iv glad_glUniform1iv +GLAD_API_CALL PFNGLUNIFORM2FPROC glad_glUniform2f; +#define glUniform2f glad_glUniform2f +GLAD_API_CALL PFNGLUNIFORM2FVPROC glad_glUniform2fv; +#define glUniform2fv glad_glUniform2fv +GLAD_API_CALL PFNGLUNIFORM2IPROC glad_glUniform2i; +#define glUniform2i glad_glUniform2i +GLAD_API_CALL PFNGLUNIFORM2IVPROC glad_glUniform2iv; +#define glUniform2iv glad_glUniform2iv +GLAD_API_CALL PFNGLUNIFORM3FPROC glad_glUniform3f; +#define glUniform3f glad_glUniform3f +GLAD_API_CALL PFNGLUNIFORM3FVPROC glad_glUniform3fv; +#define glUniform3fv glad_glUniform3fv +GLAD_API_CALL PFNGLUNIFORM3IPROC glad_glUniform3i; +#define glUniform3i glad_glUniform3i +GLAD_API_CALL PFNGLUNIFORM3IVPROC glad_glUniform3iv; +#define glUniform3iv glad_glUniform3iv +GLAD_API_CALL PFNGLUNIFORM4FPROC glad_glUniform4f; +#define glUniform4f glad_glUniform4f +GLAD_API_CALL PFNGLUNIFORM4FVPROC glad_glUniform4fv; +#define glUniform4fv glad_glUniform4fv +GLAD_API_CALL PFNGLUNIFORM4IPROC glad_glUniform4i; +#define glUniform4i glad_glUniform4i +GLAD_API_CALL PFNGLUNIFORM4IVPROC glad_glUniform4iv; +#define glUniform4iv glad_glUniform4iv +GLAD_API_CALL PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv; +#define glUniformMatrix2fv glad_glUniformMatrix2fv +GLAD_API_CALL PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv; +#define glUniformMatrix3fv glad_glUniformMatrix3fv +GLAD_API_CALL PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv; +#define glUniformMatrix4fv glad_glUniformMatrix4fv +GLAD_API_CALL PFNGLUNMAPBUFFEROESPROC glad_glUnmapBufferOES; +#define glUnmapBufferOES glad_glUnmapBufferOES +GLAD_API_CALL PFNGLUSEPROGRAMPROC glad_glUseProgram; +#define glUseProgram glad_glUseProgram +GLAD_API_CALL PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram; +#define glValidateProgram glad_glValidateProgram +GLAD_API_CALL PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f; +#define glVertexAttrib1f glad_glVertexAttrib1f +GLAD_API_CALL PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv; +#define glVertexAttrib1fv glad_glVertexAttrib1fv +GLAD_API_CALL PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f; +#define glVertexAttrib2f glad_glVertexAttrib2f +GLAD_API_CALL PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv; +#define glVertexAttrib2fv glad_glVertexAttrib2fv +GLAD_API_CALL PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f; +#define glVertexAttrib3f glad_glVertexAttrib3f +GLAD_API_CALL PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv; +#define glVertexAttrib3fv glad_glVertexAttrib3fv +GLAD_API_CALL PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f; +#define glVertexAttrib4f glad_glVertexAttrib4f +GLAD_API_CALL PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv; +#define glVertexAttrib4fv glad_glVertexAttrib4fv +GLAD_API_CALL PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer; +#define glVertexAttribPointer glad_glVertexAttribPointer +GLAD_API_CALL PFNGLVIEWPORTPROC glad_glViewport; +#define glViewport glad_glViewport + + + + + +GLAD_API_CALL int gladLoadGLES2UserPtr(GLADuserptrloadfunc load, void * userptr); +GLAD_API_CALL int gladLoadGLES2(GLADloadfunc load); + + + +#ifdef __cplusplus +} +#endif +#endif /*LV_USE_EGL*/ + +#endif diff --git a/src/drivers/opengles/glad/src/egl.c b/src/drivers/opengles/glad/src/egl.c new file mode 100644 index 0000000000..13ec667b7a --- /dev/null +++ b/src/drivers/opengles/glad/src/egl.c @@ -0,0 +1,333 @@ +/** + * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0 + */ +#include "../../lv_opengles_egl.h" + +#if LV_USE_EGL + +#include +#include +#include +#include "../include/glad/egl.h" + +#ifndef GLAD_IMPL_UTIL_C_ + #define GLAD_IMPL_UTIL_C_ + + #ifdef _MSC_VER + #define GLAD_IMPL_UTIL_SSCANF sscanf_s + #else + #define GLAD_IMPL_UTIL_SSCANF sscanf + #endif + +#endif /* GLAD_IMPL_UTIL_C_ */ + +#ifdef __cplusplus +extern "C" { +#endif + + + +int GLAD_EGL_VERSION_1_0 = 0; +int GLAD_EGL_VERSION_1_1 = 0; +int GLAD_EGL_VERSION_1_2 = 0; +int GLAD_EGL_VERSION_1_3 = 0; +int GLAD_EGL_VERSION_1_4 = 0; +int GLAD_EGL_VERSION_1_5 = 0; +int GLAD_EGL_EXT_image_dma_buf_import = 0; +int GLAD_EGL_EXT_image_dma_buf_import_modifiers = 0; +int GLAD_EGL_EXT_platform_base = 0; +int GLAD_EGL_EXT_platform_wayland = 0; +int GLAD_EGL_KHR_fence_sync = 0; +int GLAD_EGL_KHR_image_base = 0; +int GLAD_EGL_KHR_platform_gbm = 0; +int GLAD_EGL_KHR_platform_wayland = 0; + + + +PFNEGLBINDAPIPROC glad_eglBindAPI = NULL; +PFNEGLBINDTEXIMAGEPROC glad_eglBindTexImage = NULL; +PFNEGLCHOOSECONFIGPROC glad_eglChooseConfig = NULL; +PFNEGLCLIENTWAITSYNCPROC glad_eglClientWaitSync = NULL; +PFNEGLCLIENTWAITSYNCKHRPROC glad_eglClientWaitSyncKHR = NULL; +PFNEGLCOPYBUFFERSPROC glad_eglCopyBuffers = NULL; +PFNEGLCREATECONTEXTPROC glad_eglCreateContext = NULL; +PFNEGLCREATEIMAGEPROC glad_eglCreateImage = NULL; +PFNEGLCREATEIMAGEKHRPROC glad_eglCreateImageKHR = NULL; +PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC glad_eglCreatePbufferFromClientBuffer = NULL; +PFNEGLCREATEPBUFFERSURFACEPROC glad_eglCreatePbufferSurface = NULL; +PFNEGLCREATEPIXMAPSURFACEPROC glad_eglCreatePixmapSurface = NULL; +PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC glad_eglCreatePlatformPixmapSurface = NULL; +PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC glad_eglCreatePlatformPixmapSurfaceEXT = NULL; +PFNEGLCREATEPLATFORMWINDOWSURFACEPROC glad_eglCreatePlatformWindowSurface = NULL; +PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC glad_eglCreatePlatformWindowSurfaceEXT = NULL; +PFNEGLCREATESYNCPROC glad_eglCreateSync = NULL; +PFNEGLCREATESYNCKHRPROC glad_eglCreateSyncKHR = NULL; +PFNEGLCREATEWINDOWSURFACEPROC glad_eglCreateWindowSurface = NULL; +PFNEGLDESTROYCONTEXTPROC glad_eglDestroyContext = NULL; +PFNEGLDESTROYIMAGEPROC glad_eglDestroyImage = NULL; +PFNEGLDESTROYIMAGEKHRPROC glad_eglDestroyImageKHR = NULL; +PFNEGLDESTROYSURFACEPROC glad_eglDestroySurface = NULL; +PFNEGLDESTROYSYNCPROC glad_eglDestroySync = NULL; +PFNEGLDESTROYSYNCKHRPROC glad_eglDestroySyncKHR = NULL; +PFNEGLGETCONFIGATTRIBPROC glad_eglGetConfigAttrib = NULL; +PFNEGLGETCONFIGSPROC glad_eglGetConfigs = NULL; +PFNEGLGETCURRENTCONTEXTPROC glad_eglGetCurrentContext = NULL; +PFNEGLGETCURRENTDISPLAYPROC glad_eglGetCurrentDisplay = NULL; +PFNEGLGETCURRENTSURFACEPROC glad_eglGetCurrentSurface = NULL; +PFNEGLGETDISPLAYPROC glad_eglGetDisplay = NULL; +PFNEGLGETERRORPROC glad_eglGetError = NULL; +PFNEGLGETPLATFORMDISPLAYPROC glad_eglGetPlatformDisplay = NULL; +PFNEGLGETPLATFORMDISPLAYEXTPROC glad_eglGetPlatformDisplayEXT = NULL; +PFNEGLGETPROCADDRESSPROC glad_eglGetProcAddress = NULL; +PFNEGLGETSYNCATTRIBPROC glad_eglGetSyncAttrib = NULL; +PFNEGLGETSYNCATTRIBKHRPROC glad_eglGetSyncAttribKHR = NULL; +PFNEGLINITIALIZEPROC glad_eglInitialize = NULL; +PFNEGLMAKECURRENTPROC glad_eglMakeCurrent = NULL; +PFNEGLQUERYAPIPROC glad_eglQueryAPI = NULL; +PFNEGLQUERYCONTEXTPROC glad_eglQueryContext = NULL; +PFNEGLQUERYDMABUFFORMATSEXTPROC glad_eglQueryDmaBufFormatsEXT = NULL; +PFNEGLQUERYDMABUFMODIFIERSEXTPROC glad_eglQueryDmaBufModifiersEXT = NULL; +PFNEGLQUERYSTRINGPROC glad_eglQueryString = NULL; +PFNEGLQUERYSURFACEPROC glad_eglQuerySurface = NULL; +PFNEGLRELEASETEXIMAGEPROC glad_eglReleaseTexImage = NULL; +PFNEGLRELEASETHREADPROC glad_eglReleaseThread = NULL; +PFNEGLSURFACEATTRIBPROC glad_eglSurfaceAttrib = NULL; +PFNEGLSWAPBUFFERSPROC glad_eglSwapBuffers = NULL; +PFNEGLSWAPINTERVALPROC glad_eglSwapInterval = NULL; +PFNEGLTERMINATEPROC glad_eglTerminate = NULL; +PFNEGLWAITCLIENTPROC glad_eglWaitClient = NULL; +PFNEGLWAITGLPROC glad_eglWaitGL = NULL; +PFNEGLWAITNATIVEPROC glad_eglWaitNative = NULL; +PFNEGLWAITSYNCPROC glad_eglWaitSync = NULL; + + +static void glad_egl_load_EGL_VERSION_1_0(GLADuserptrloadfunc load, void * userptr) +{ + if(!GLAD_EGL_VERSION_1_0) return; + glad_eglChooseConfig = (PFNEGLCHOOSECONFIGPROC) load(userptr, "eglChooseConfig"); + glad_eglCopyBuffers = (PFNEGLCOPYBUFFERSPROC) load(userptr, "eglCopyBuffers"); + glad_eglCreateContext = (PFNEGLCREATECONTEXTPROC) load(userptr, "eglCreateContext"); + glad_eglCreatePbufferSurface = (PFNEGLCREATEPBUFFERSURFACEPROC) load(userptr, "eglCreatePbufferSurface"); + glad_eglCreatePixmapSurface = (PFNEGLCREATEPIXMAPSURFACEPROC) load(userptr, "eglCreatePixmapSurface"); + glad_eglCreateWindowSurface = (PFNEGLCREATEWINDOWSURFACEPROC) load(userptr, "eglCreateWindowSurface"); + glad_eglDestroyContext = (PFNEGLDESTROYCONTEXTPROC) load(userptr, "eglDestroyContext"); + glad_eglDestroySurface = (PFNEGLDESTROYSURFACEPROC) load(userptr, "eglDestroySurface"); + glad_eglGetConfigAttrib = (PFNEGLGETCONFIGATTRIBPROC) load(userptr, "eglGetConfigAttrib"); + glad_eglGetConfigs = (PFNEGLGETCONFIGSPROC) load(userptr, "eglGetConfigs"); + glad_eglGetCurrentDisplay = (PFNEGLGETCURRENTDISPLAYPROC) load(userptr, "eglGetCurrentDisplay"); + glad_eglGetCurrentSurface = (PFNEGLGETCURRENTSURFACEPROC) load(userptr, "eglGetCurrentSurface"); + glad_eglGetDisplay = (PFNEGLGETDISPLAYPROC) load(userptr, "eglGetDisplay"); + glad_eglGetError = (PFNEGLGETERRORPROC) load(userptr, "eglGetError"); + glad_eglGetProcAddress = (PFNEGLGETPROCADDRESSPROC) load(userptr, "eglGetProcAddress"); + glad_eglInitialize = (PFNEGLINITIALIZEPROC) load(userptr, "eglInitialize"); + glad_eglMakeCurrent = (PFNEGLMAKECURRENTPROC) load(userptr, "eglMakeCurrent"); + glad_eglQueryContext = (PFNEGLQUERYCONTEXTPROC) load(userptr, "eglQueryContext"); + glad_eglQueryString = (PFNEGLQUERYSTRINGPROC) load(userptr, "eglQueryString"); + glad_eglQuerySurface = (PFNEGLQUERYSURFACEPROC) load(userptr, "eglQuerySurface"); + glad_eglSwapBuffers = (PFNEGLSWAPBUFFERSPROC) load(userptr, "eglSwapBuffers"); + glad_eglTerminate = (PFNEGLTERMINATEPROC) load(userptr, "eglTerminate"); + glad_eglWaitGL = (PFNEGLWAITGLPROC) load(userptr, "eglWaitGL"); + glad_eglWaitNative = (PFNEGLWAITNATIVEPROC) load(userptr, "eglWaitNative"); +} +static void glad_egl_load_EGL_VERSION_1_1(GLADuserptrloadfunc load, void * userptr) +{ + if(!GLAD_EGL_VERSION_1_1) return; + glad_eglBindTexImage = (PFNEGLBINDTEXIMAGEPROC) load(userptr, "eglBindTexImage"); + glad_eglReleaseTexImage = (PFNEGLRELEASETEXIMAGEPROC) load(userptr, "eglReleaseTexImage"); + glad_eglSurfaceAttrib = (PFNEGLSURFACEATTRIBPROC) load(userptr, "eglSurfaceAttrib"); + glad_eglSwapInterval = (PFNEGLSWAPINTERVALPROC) load(userptr, "eglSwapInterval"); +} +static void glad_egl_load_EGL_VERSION_1_2(GLADuserptrloadfunc load, void * userptr) +{ + if(!GLAD_EGL_VERSION_1_2) return; + glad_eglBindAPI = (PFNEGLBINDAPIPROC) load(userptr, "eglBindAPI"); + glad_eglCreatePbufferFromClientBuffer = (PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC) load(userptr, + "eglCreatePbufferFromClientBuffer"); + glad_eglQueryAPI = (PFNEGLQUERYAPIPROC) load(userptr, "eglQueryAPI"); + glad_eglReleaseThread = (PFNEGLRELEASETHREADPROC) load(userptr, "eglReleaseThread"); + glad_eglWaitClient = (PFNEGLWAITCLIENTPROC) load(userptr, "eglWaitClient"); +} +static void glad_egl_load_EGL_VERSION_1_4(GLADuserptrloadfunc load, void * userptr) +{ + if(!GLAD_EGL_VERSION_1_4) return; + glad_eglGetCurrentContext = (PFNEGLGETCURRENTCONTEXTPROC) load(userptr, "eglGetCurrentContext"); +} +static void glad_egl_load_EGL_VERSION_1_5(GLADuserptrloadfunc load, void * userptr) +{ + if(!GLAD_EGL_VERSION_1_5) return; + glad_eglClientWaitSync = (PFNEGLCLIENTWAITSYNCPROC) load(userptr, "eglClientWaitSync"); + glad_eglCreateImage = (PFNEGLCREATEIMAGEPROC) load(userptr, "eglCreateImage"); + glad_eglCreatePlatformPixmapSurface = (PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC) load(userptr, + "eglCreatePlatformPixmapSurface"); + glad_eglCreatePlatformWindowSurface = (PFNEGLCREATEPLATFORMWINDOWSURFACEPROC) load(userptr, + "eglCreatePlatformWindowSurface"); + glad_eglCreateSync = (PFNEGLCREATESYNCPROC) load(userptr, "eglCreateSync"); + glad_eglDestroyImage = (PFNEGLDESTROYIMAGEPROC) load(userptr, "eglDestroyImage"); + glad_eglDestroySync = (PFNEGLDESTROYSYNCPROC) load(userptr, "eglDestroySync"); + glad_eglGetPlatformDisplay = (PFNEGLGETPLATFORMDISPLAYPROC) load(userptr, "eglGetPlatformDisplay"); + glad_eglGetSyncAttrib = (PFNEGLGETSYNCATTRIBPROC) load(userptr, "eglGetSyncAttrib"); + glad_eglWaitSync = (PFNEGLWAITSYNCPROC) load(userptr, "eglWaitSync"); +} +static void glad_egl_load_EGL_EXT_image_dma_buf_import_modifiers(GLADuserptrloadfunc load, void * userptr) +{ + if(!GLAD_EGL_EXT_image_dma_buf_import_modifiers) return; + glad_eglQueryDmaBufFormatsEXT = (PFNEGLQUERYDMABUFFORMATSEXTPROC) load(userptr, "eglQueryDmaBufFormatsEXT"); + glad_eglQueryDmaBufModifiersEXT = (PFNEGLQUERYDMABUFMODIFIERSEXTPROC) load(userptr, "eglQueryDmaBufModifiersEXT"); +} +static void glad_egl_load_EGL_EXT_platform_base(GLADuserptrloadfunc load, void * userptr) +{ + if(!GLAD_EGL_EXT_platform_base) return; + glad_eglCreatePlatformPixmapSurfaceEXT = (PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC) load(userptr, + "eglCreatePlatformPixmapSurfaceEXT"); + glad_eglCreatePlatformWindowSurfaceEXT = (PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC) load(userptr, + "eglCreatePlatformWindowSurfaceEXT"); + glad_eglGetPlatformDisplayEXT = (PFNEGLGETPLATFORMDISPLAYEXTPROC) load(userptr, "eglGetPlatformDisplayEXT"); +} +static void glad_egl_load_EGL_KHR_fence_sync(GLADuserptrloadfunc load, void * userptr) +{ + if(!GLAD_EGL_KHR_fence_sync) return; + glad_eglClientWaitSyncKHR = (PFNEGLCLIENTWAITSYNCKHRPROC) load(userptr, "eglClientWaitSyncKHR"); + glad_eglCreateSyncKHR = (PFNEGLCREATESYNCKHRPROC) load(userptr, "eglCreateSyncKHR"); + glad_eglDestroySyncKHR = (PFNEGLDESTROYSYNCKHRPROC) load(userptr, "eglDestroySyncKHR"); + glad_eglGetSyncAttribKHR = (PFNEGLGETSYNCATTRIBKHRPROC) load(userptr, "eglGetSyncAttribKHR"); +} +static void glad_egl_load_EGL_KHR_image_base(GLADuserptrloadfunc load, void * userptr) +{ + if(!GLAD_EGL_KHR_image_base) return; + glad_eglCreateImageKHR = (PFNEGLCREATEIMAGEKHRPROC) load(userptr, "eglCreateImageKHR"); + glad_eglDestroyImageKHR = (PFNEGLDESTROYIMAGEKHRPROC) load(userptr, "eglDestroyImageKHR"); +} + + + +static int glad_egl_get_extensions(EGLDisplay display, const char ** extensions) +{ + *extensions = eglQueryString(display, EGL_EXTENSIONS); + + return extensions != NULL; +} + +static int glad_egl_has_extension(const char * extensions, const char * ext) +{ + const char * loc; + const char * terminator; + if(extensions == NULL) { + return 0; + } + while(1) { + loc = strstr(extensions, ext); + if(loc == NULL) { + return 0; + } + terminator = loc + strlen(ext); + if((loc == extensions || *(loc - 1) == ' ') && + (*terminator == ' ' || *terminator == '\0')) { + return 1; + } + extensions = terminator; + } +} + +static GLADapiproc glad_egl_get_proc_from_userptr(void * userptr, const char * name) +{ + return (GLAD_GNUC_EXTENSION(GLADapiproc(*)(const char * name)) userptr)(name); +} + +static int glad_egl_find_extensions_egl(EGLDisplay display) +{ + const char * extensions; + if(!glad_egl_get_extensions(display, &extensions)) return 0; + + GLAD_EGL_EXT_image_dma_buf_import = glad_egl_has_extension(extensions, "EGL_EXT_image_dma_buf_import"); + GLAD_EGL_EXT_image_dma_buf_import_modifiers = glad_egl_has_extension(extensions, + "EGL_EXT_image_dma_buf_import_modifiers"); + GLAD_EGL_EXT_platform_base = glad_egl_has_extension(extensions, "EGL_EXT_platform_base"); + GLAD_EGL_EXT_platform_wayland = glad_egl_has_extension(extensions, "EGL_EXT_platform_wayland"); + GLAD_EGL_KHR_fence_sync = glad_egl_has_extension(extensions, "EGL_KHR_fence_sync"); + GLAD_EGL_KHR_image_base = glad_egl_has_extension(extensions, "EGL_KHR_image_base"); + GLAD_EGL_KHR_platform_gbm = glad_egl_has_extension(extensions, "EGL_KHR_platform_gbm"); + GLAD_EGL_KHR_platform_wayland = glad_egl_has_extension(extensions, "EGL_KHR_platform_wayland"); + + return 1; +} + +static int glad_egl_find_core_egl(EGLDisplay display) +{ + int major, minor; + const char * version; + + if(display == NULL) { + display = EGL_NO_DISPLAY; /* this is usually NULL, better safe than sorry */ + } + if(display == EGL_NO_DISPLAY) { + display = eglGetCurrentDisplay(); + } +#ifdef EGL_VERSION_1_4 + if(display == EGL_NO_DISPLAY) { + display = eglGetDisplay(EGL_DEFAULT_DISPLAY); + } +#endif +#ifndef EGL_VERSION_1_5 + if(display == EGL_NO_DISPLAY) { + return 0; + } +#endif + + version = eglQueryString(display, EGL_VERSION); + (void) eglGetError(); + + if(version == NULL) { + major = 1; + minor = 0; + } + else { + GLAD_IMPL_UTIL_SSCANF(version, "%d.%d", &major, &minor); + } + + GLAD_EGL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; + GLAD_EGL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; + GLAD_EGL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; + GLAD_EGL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; + GLAD_EGL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; + GLAD_EGL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; + + return GLAD_MAKE_VERSION(major, minor); +} + +int gladLoadEGLUserPtr(EGLDisplay display, GLADuserptrloadfunc load, void * userptr) +{ + int version; + eglGetDisplay = (PFNEGLGETDISPLAYPROC) load(userptr, "eglGetDisplay"); + eglGetCurrentDisplay = (PFNEGLGETCURRENTDISPLAYPROC) load(userptr, "eglGetCurrentDisplay"); + eglQueryString = (PFNEGLQUERYSTRINGPROC) load(userptr, "eglQueryString"); + eglGetError = (PFNEGLGETERRORPROC) load(userptr, "eglGetError"); + if(eglGetDisplay == NULL || eglGetCurrentDisplay == NULL || eglQueryString == NULL || eglGetError == NULL) return 0; + + version = glad_egl_find_core_egl(display); + if(!version) return 0; + glad_egl_load_EGL_VERSION_1_0(load, userptr); + glad_egl_load_EGL_VERSION_1_1(load, userptr); + glad_egl_load_EGL_VERSION_1_2(load, userptr); + glad_egl_load_EGL_VERSION_1_4(load, userptr); + glad_egl_load_EGL_VERSION_1_5(load, userptr); + + if(!glad_egl_find_extensions_egl(display)) return 0; + glad_egl_load_EGL_EXT_image_dma_buf_import_modifiers(load, userptr); + glad_egl_load_EGL_EXT_platform_base(load, userptr); + glad_egl_load_EGL_KHR_fence_sync(load, userptr); + glad_egl_load_EGL_KHR_image_base(load, userptr); + + + return version; +} + +int gladLoadEGL(EGLDisplay display, GLADloadfunc load) +{ + return gladLoadEGLUserPtr(display, glad_egl_get_proc_from_userptr, GLAD_GNUC_EXTENSION(void *) load); +} + +#ifdef __cplusplus +} +#endif + +#endif /*LV_USE_EGL*/ diff --git a/src/drivers/opengles/glad/src/gles2.c b/src/drivers/opengles/glad/src/gles2.c new file mode 100644 index 0000000000..10809582b9 --- /dev/null +++ b/src/drivers/opengles/glad/src/gles2.c @@ -0,0 +1,529 @@ +/** + * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0 + */ + +#include "../../lv_opengles_egl.h" + +#if LV_USE_EGL + +#include +#include +#include +#include "../include/glad/gles2.h" + +#ifndef GLAD_IMPL_UTIL_C_ + #define GLAD_IMPL_UTIL_C_ + + #ifdef _MSC_VER + #define GLAD_IMPL_UTIL_SSCANF sscanf_s + #else + #define GLAD_IMPL_UTIL_SSCANF sscanf + #endif + +#endif /* GLAD_IMPL_UTIL_C_ */ + +#ifdef __cplusplus +extern "C" { +#endif + + + +int GLAD_GL_ES_VERSION_2_0 = 0; +int GLAD_GL_APPLE_texture_max_level = 0; +int GLAD_GL_EXT_texture_format_BGRA8888 = 0; +int GLAD_GL_EXT_unpack_subimage = 0; +int GLAD_GL_OES_mapbuffer = 0; +int GLAD_GL_OES_vertex_array_object = 0; + + + +PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; +PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; +PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; +PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; +PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL; +PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL; +PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; +PFNGLBINDVERTEXARRAYOESPROC glad_glBindVertexArrayOES = NULL; +PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; +PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; +PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; +PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; +PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; +PFNGLBUFFERDATAPROC glad_glBufferData = NULL; +PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL; +PFNGLCLEARPROC glad_glClear = NULL; +PFNGLCLEARCOLORPROC glad_glClearColor = NULL; +PFNGLCLEARDEPTHFPROC glad_glClearDepthf = NULL; +PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; +PFNGLCOLORMASKPROC glad_glColorMask = NULL; +PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; +PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; +PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; +PFNGLCREATESHADERPROC glad_glCreateShader = NULL; +PFNGLCULLFACEPROC glad_glCullFace = NULL; +PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; +PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL; +PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; +PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL; +PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; +PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; +PFNGLDELETEVERTEXARRAYSOESPROC glad_glDeleteVertexArraysOES = NULL; +PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; +PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; +PFNGLDEPTHRANGEFPROC glad_glDepthRangef = NULL; +PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; +PFNGLDISABLEPROC glad_glDisable = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; +PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; +PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; +PFNGLENABLEPROC glad_glEnable = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; +PFNGLFINISHPROC glad_glFinish = NULL; +PFNGLFLUSHPROC glad_glFlush = NULL; +PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL; +PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL; +PFNGLFRONTFACEPROC glad_glFrontFace = NULL; +PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; +PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL; +PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL; +PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; +PFNGLGENVERTEXARRAYSOESPROC glad_glGenVertexArraysOES = NULL; +PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL; +PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; +PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; +PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; +PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; +PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; +PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; +PFNGLGETBUFFERPOINTERVOESPROC glad_glGetBufferPointervOES = NULL; +PFNGLGETERRORPROC glad_glGetError = NULL; +PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL; +PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; +PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; +PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL; +PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; +PFNGLGETSHADERPRECISIONFORMATPROC glad_glGetShaderPrecisionFormat = NULL; +PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; +PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; +PFNGLGETSTRINGPROC glad_glGetString = NULL; +PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; +PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; +PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; +PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; +PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; +PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; +PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; +PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; +PFNGLHINTPROC glad_glHint = NULL; +PFNGLISBUFFERPROC glad_glIsBuffer = NULL; +PFNGLISENABLEDPROC glad_glIsEnabled = NULL; +PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL; +PFNGLISPROGRAMPROC glad_glIsProgram = NULL; +PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL; +PFNGLISSHADERPROC glad_glIsShader = NULL; +PFNGLISTEXTUREPROC glad_glIsTexture = NULL; +PFNGLISVERTEXARRAYOESPROC glad_glIsVertexArrayOES = NULL; +PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; +PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; +PFNGLMAPBUFFEROESPROC glad_glMapBufferOES = NULL; +PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; +PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; +PFNGLREADPIXELSPROC glad_glReadPixels = NULL; +PFNGLRELEASESHADERCOMPILERPROC glad_glReleaseShaderCompiler = NULL; +PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL; +PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; +PFNGLSCISSORPROC glad_glScissor = NULL; +PFNGLSHADERBINARYPROC glad_glShaderBinary = NULL; +PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; +PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; +PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; +PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; +PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; +PFNGLSTENCILOPPROC glad_glStencilOp = NULL; +PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; +PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; +PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; +PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; +PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; +PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; +PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; +PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; +PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; +PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; +PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; +PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; +PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; +PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; +PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; +PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; +PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; +PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; +PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; +PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; +PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; +PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; +PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; +PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; +PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; +PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; +PFNGLUNMAPBUFFEROESPROC glad_glUnmapBufferOES = NULL; +PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; +PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; +PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; +PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; +PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; +PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; +PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; +PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; +PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; +PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; +PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; +PFNGLVIEWPORTPROC glad_glViewport = NULL; + + +static void glad_gl_load_GL_ES_VERSION_2_0(GLADuserptrloadfunc load, void * userptr) +{ + if(!GLAD_GL_ES_VERSION_2_0) return; + glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC) load(userptr, "glActiveTexture"); + glad_glAttachShader = (PFNGLATTACHSHADERPROC) load(userptr, "glAttachShader"); + glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC) load(userptr, "glBindAttribLocation"); + glad_glBindBuffer = (PFNGLBINDBUFFERPROC) load(userptr, "glBindBuffer"); + glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC) load(userptr, "glBindFramebuffer"); + glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC) load(userptr, "glBindRenderbuffer"); + glad_glBindTexture = (PFNGLBINDTEXTUREPROC) load(userptr, "glBindTexture"); + glad_glBlendColor = (PFNGLBLENDCOLORPROC) load(userptr, "glBlendColor"); + glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC) load(userptr, "glBlendEquation"); + glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC) load(userptr, "glBlendEquationSeparate"); + glad_glBlendFunc = (PFNGLBLENDFUNCPROC) load(userptr, "glBlendFunc"); + glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC) load(userptr, "glBlendFuncSeparate"); + glad_glBufferData = (PFNGLBUFFERDATAPROC) load(userptr, "glBufferData"); + glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC) load(userptr, "glBufferSubData"); + glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC) load(userptr, "glCheckFramebufferStatus"); + glad_glClear = (PFNGLCLEARPROC) load(userptr, "glClear"); + glad_glClearColor = (PFNGLCLEARCOLORPROC) load(userptr, "glClearColor"); + glad_glClearDepthf = (PFNGLCLEARDEPTHFPROC) load(userptr, "glClearDepthf"); + glad_glClearStencil = (PFNGLCLEARSTENCILPROC) load(userptr, "glClearStencil"); + glad_glColorMask = (PFNGLCOLORMASKPROC) load(userptr, "glColorMask"); + glad_glCompileShader = (PFNGLCOMPILESHADERPROC) load(userptr, "glCompileShader"); + glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC) load(userptr, "glCompressedTexImage2D"); + glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) load(userptr, "glCompressedTexSubImage2D"); + glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC) load(userptr, "glCopyTexImage2D"); + glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC) load(userptr, "glCopyTexSubImage2D"); + glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC) load(userptr, "glCreateProgram"); + glad_glCreateShader = (PFNGLCREATESHADERPROC) load(userptr, "glCreateShader"); + glad_glCullFace = (PFNGLCULLFACEPROC) load(userptr, "glCullFace"); + glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC) load(userptr, "glDeleteBuffers"); + glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC) load(userptr, "glDeleteFramebuffers"); + glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC) load(userptr, "glDeleteProgram"); + glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC) load(userptr, "glDeleteRenderbuffers"); + glad_glDeleteShader = (PFNGLDELETESHADERPROC) load(userptr, "glDeleteShader"); + glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC) load(userptr, "glDeleteTextures"); + glad_glDepthFunc = (PFNGLDEPTHFUNCPROC) load(userptr, "glDepthFunc"); + glad_glDepthMask = (PFNGLDEPTHMASKPROC) load(userptr, "glDepthMask"); + glad_glDepthRangef = (PFNGLDEPTHRANGEFPROC) load(userptr, "glDepthRangef"); + glad_glDetachShader = (PFNGLDETACHSHADERPROC) load(userptr, "glDetachShader"); + glad_glDisable = (PFNGLDISABLEPROC) load(userptr, "glDisable"); + glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC) load(userptr, "glDisableVertexAttribArray"); + glad_glDrawArrays = (PFNGLDRAWARRAYSPROC) load(userptr, "glDrawArrays"); + glad_glDrawElements = (PFNGLDRAWELEMENTSPROC) load(userptr, "glDrawElements"); + glad_glEnable = (PFNGLENABLEPROC) load(userptr, "glEnable"); + glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC) load(userptr, "glEnableVertexAttribArray"); + glad_glFinish = (PFNGLFINISHPROC) load(userptr, "glFinish"); + glad_glFlush = (PFNGLFLUSHPROC) load(userptr, "glFlush"); + glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC) load(userptr, "glFramebufferRenderbuffer"); + glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC) load(userptr, "glFramebufferTexture2D"); + glad_glFrontFace = (PFNGLFRONTFACEPROC) load(userptr, "glFrontFace"); + glad_glGenBuffers = (PFNGLGENBUFFERSPROC) load(userptr, "glGenBuffers"); + glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC) load(userptr, "glGenFramebuffers"); + glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC) load(userptr, "glGenRenderbuffers"); + glad_glGenTextures = (PFNGLGENTEXTURESPROC) load(userptr, "glGenTextures"); + glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC) load(userptr, "glGenerateMipmap"); + glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC) load(userptr, "glGetActiveAttrib"); + glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC) load(userptr, "glGetActiveUniform"); + glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC) load(userptr, "glGetAttachedShaders"); + glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC) load(userptr, "glGetAttribLocation"); + glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC) load(userptr, "glGetBooleanv"); + glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC) load(userptr, "glGetBufferParameteriv"); + glad_glGetError = (PFNGLGETERRORPROC) load(userptr, "glGetError"); + glad_glGetFloatv = (PFNGLGETFLOATVPROC) load(userptr, "glGetFloatv"); + glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC) load(userptr, + "glGetFramebufferAttachmentParameteriv"); + glad_glGetIntegerv = (PFNGLGETINTEGERVPROC) load(userptr, "glGetIntegerv"); + glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC) load(userptr, "glGetProgramInfoLog"); + glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC) load(userptr, "glGetProgramiv"); + glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC) load(userptr, "glGetRenderbufferParameteriv"); + glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC) load(userptr, "glGetShaderInfoLog"); + glad_glGetShaderPrecisionFormat = (PFNGLGETSHADERPRECISIONFORMATPROC) load(userptr, "glGetShaderPrecisionFormat"); + glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC) load(userptr, "glGetShaderSource"); + glad_glGetShaderiv = (PFNGLGETSHADERIVPROC) load(userptr, "glGetShaderiv"); + glad_glGetString = (PFNGLGETSTRINGPROC) load(userptr, "glGetString"); + glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC) load(userptr, "glGetTexParameterfv"); + glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC) load(userptr, "glGetTexParameteriv"); + glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC) load(userptr, "glGetUniformLocation"); + glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC) load(userptr, "glGetUniformfv"); + glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC) load(userptr, "glGetUniformiv"); + glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC) load(userptr, "glGetVertexAttribPointerv"); + glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC) load(userptr, "glGetVertexAttribfv"); + glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC) load(userptr, "glGetVertexAttribiv"); + glad_glHint = (PFNGLHINTPROC) load(userptr, "glHint"); + glad_glIsBuffer = (PFNGLISBUFFERPROC) load(userptr, "glIsBuffer"); + glad_glIsEnabled = (PFNGLISENABLEDPROC) load(userptr, "glIsEnabled"); + glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC) load(userptr, "glIsFramebuffer"); + glad_glIsProgram = (PFNGLISPROGRAMPROC) load(userptr, "glIsProgram"); + glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC) load(userptr, "glIsRenderbuffer"); + glad_glIsShader = (PFNGLISSHADERPROC) load(userptr, "glIsShader"); + glad_glIsTexture = (PFNGLISTEXTUREPROC) load(userptr, "glIsTexture"); + glad_glLineWidth = (PFNGLLINEWIDTHPROC) load(userptr, "glLineWidth"); + glad_glLinkProgram = (PFNGLLINKPROGRAMPROC) load(userptr, "glLinkProgram"); + glad_glPixelStorei = (PFNGLPIXELSTOREIPROC) load(userptr, "glPixelStorei"); + glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC) load(userptr, "glPolygonOffset"); + glad_glReadPixels = (PFNGLREADPIXELSPROC) load(userptr, "glReadPixels"); + glad_glReleaseShaderCompiler = (PFNGLRELEASESHADERCOMPILERPROC) load(userptr, "glReleaseShaderCompiler"); + glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC) load(userptr, "glRenderbufferStorage"); + glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC) load(userptr, "glSampleCoverage"); + glad_glScissor = (PFNGLSCISSORPROC) load(userptr, "glScissor"); + glad_glShaderBinary = (PFNGLSHADERBINARYPROC) load(userptr, "glShaderBinary"); + glad_glShaderSource = (PFNGLSHADERSOURCEPROC) load(userptr, "glShaderSource"); + glad_glStencilFunc = (PFNGLSTENCILFUNCPROC) load(userptr, "glStencilFunc"); + glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC) load(userptr, "glStencilFuncSeparate"); + glad_glStencilMask = (PFNGLSTENCILMASKPROC) load(userptr, "glStencilMask"); + glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC) load(userptr, "glStencilMaskSeparate"); + glad_glStencilOp = (PFNGLSTENCILOPPROC) load(userptr, "glStencilOp"); + glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC) load(userptr, "glStencilOpSeparate"); + glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC) load(userptr, "glTexImage2D"); + glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC) load(userptr, "glTexParameterf"); + glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC) load(userptr, "glTexParameterfv"); + glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC) load(userptr, "glTexParameteri"); + glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC) load(userptr, "glTexParameteriv"); + glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC) load(userptr, "glTexSubImage2D"); + glad_glUniform1f = (PFNGLUNIFORM1FPROC) load(userptr, "glUniform1f"); + glad_glUniform1fv = (PFNGLUNIFORM1FVPROC) load(userptr, "glUniform1fv"); + glad_glUniform1i = (PFNGLUNIFORM1IPROC) load(userptr, "glUniform1i"); + glad_glUniform1iv = (PFNGLUNIFORM1IVPROC) load(userptr, "glUniform1iv"); + glad_glUniform2f = (PFNGLUNIFORM2FPROC) load(userptr, "glUniform2f"); + glad_glUniform2fv = (PFNGLUNIFORM2FVPROC) load(userptr, "glUniform2fv"); + glad_glUniform2i = (PFNGLUNIFORM2IPROC) load(userptr, "glUniform2i"); + glad_glUniform2iv = (PFNGLUNIFORM2IVPROC) load(userptr, "glUniform2iv"); + glad_glUniform3f = (PFNGLUNIFORM3FPROC) load(userptr, "glUniform3f"); + glad_glUniform3fv = (PFNGLUNIFORM3FVPROC) load(userptr, "glUniform3fv"); + glad_glUniform3i = (PFNGLUNIFORM3IPROC) load(userptr, "glUniform3i"); + glad_glUniform3iv = (PFNGLUNIFORM3IVPROC) load(userptr, "glUniform3iv"); + glad_glUniform4f = (PFNGLUNIFORM4FPROC) load(userptr, "glUniform4f"); + glad_glUniform4fv = (PFNGLUNIFORM4FVPROC) load(userptr, "glUniform4fv"); + glad_glUniform4i = (PFNGLUNIFORM4IPROC) load(userptr, "glUniform4i"); + glad_glUniform4iv = (PFNGLUNIFORM4IVPROC) load(userptr, "glUniform4iv"); + glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC) load(userptr, "glUniformMatrix2fv"); + glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC) load(userptr, "glUniformMatrix3fv"); + glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC) load(userptr, "glUniformMatrix4fv"); + glad_glUseProgram = (PFNGLUSEPROGRAMPROC) load(userptr, "glUseProgram"); + glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC) load(userptr, "glValidateProgram"); + glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC) load(userptr, "glVertexAttrib1f"); + glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC) load(userptr, "glVertexAttrib1fv"); + glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC) load(userptr, "glVertexAttrib2f"); + glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC) load(userptr, "glVertexAttrib2fv"); + glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC) load(userptr, "glVertexAttrib3f"); + glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC) load(userptr, "glVertexAttrib3fv"); + glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC) load(userptr, "glVertexAttrib4f"); + glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC) load(userptr, "glVertexAttrib4fv"); + glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC) load(userptr, "glVertexAttribPointer"); + glad_glViewport = (PFNGLVIEWPORTPROC) load(userptr, "glViewport"); +} +static void glad_gl_load_GL_OES_mapbuffer(GLADuserptrloadfunc load, void * userptr) +{ + if(!GLAD_GL_OES_mapbuffer) return; + glad_glGetBufferPointervOES = (PFNGLGETBUFFERPOINTERVOESPROC) load(userptr, "glGetBufferPointervOES"); + glad_glMapBufferOES = (PFNGLMAPBUFFEROESPROC) load(userptr, "glMapBufferOES"); + glad_glUnmapBufferOES = (PFNGLUNMAPBUFFEROESPROC) load(userptr, "glUnmapBufferOES"); +} +static void glad_gl_load_GL_OES_vertex_array_object(GLADuserptrloadfunc load, void * userptr) +{ + if(!GLAD_GL_OES_vertex_array_object) return; + glad_glBindVertexArrayOES = (PFNGLBINDVERTEXARRAYOESPROC) load(userptr, "glBindVertexArrayOES"); + glad_glDeleteVertexArraysOES = (PFNGLDELETEVERTEXARRAYSOESPROC) load(userptr, "glDeleteVertexArraysOES"); + glad_glGenVertexArraysOES = (PFNGLGENVERTEXARRAYSOESPROC) load(userptr, "glGenVertexArraysOES"); + glad_glIsVertexArrayOES = (PFNGLISVERTEXARRAYOESPROC) load(userptr, "glIsVertexArrayOES"); +} + + + +static void glad_gl_free_extensions(char ** exts_i) +{ + if(exts_i != NULL) { + unsigned int index; + for(index = 0; exts_i[index]; index++) { + free((void *)(exts_i[index])); + } + free((void *)exts_i); + exts_i = NULL; + } +} +static int glad_gl_get_extensions(const char ** out_exts, char *** out_exts_i) +{ +#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) + if(glad_glGetStringi != NULL && glad_glGetIntegerv != NULL) { + unsigned int index = 0; + unsigned int num_exts_i = 0; + char ** exts_i = NULL; + glad_glGetIntegerv(GL_NUM_EXTENSIONS, (int *) &num_exts_i); + exts_i = (char **) malloc((num_exts_i + 1) * (sizeof * exts_i)); + if(exts_i == NULL) { + return 0; + } + for(index = 0; index < num_exts_i; index++) { + const char * gl_str_tmp = (const char *) glad_glGetStringi(GL_EXTENSIONS, index); + size_t len = strlen(gl_str_tmp) + 1; + + char * local_str = (char *) malloc(len * sizeof(char)); + if(local_str == NULL) { + exts_i[index] = NULL; + glad_gl_free_extensions(exts_i); + return 0; + } + + memcpy(local_str, gl_str_tmp, len * sizeof(char)); + exts_i[index] = local_str; + } + exts_i[index] = NULL; + + *out_exts_i = exts_i; + + return 1; + } +#else + GLAD_UNUSED(out_exts_i); +#endif + if(glad_glGetString == NULL) { + return 0; + } + *out_exts = (const char *)glad_glGetString(GL_EXTENSIONS); + return 1; +} +static int glad_gl_has_extension(const char * exts, char ** exts_i, const char * ext) +{ + if(exts_i) { + unsigned int index; + for(index = 0; exts_i[index]; index++) { + const char * e = exts_i[index]; + if(strcmp(e, ext) == 0) { + return 1; + } + } + } + else { + const char * extensions; + const char * loc; + const char * terminator; + extensions = exts; + if(extensions == NULL || ext == NULL) { + return 0; + } + while(1) { + loc = strstr(extensions, ext); + if(loc == NULL) { + return 0; + } + terminator = loc + strlen(ext); + if((loc == extensions || *(loc - 1) == ' ') && + (*terminator == ' ' || *terminator == '\0')) { + return 1; + } + extensions = terminator; + } + } + return 0; +} + +static GLADapiproc glad_gl_get_proc_from_userptr(void * userptr, const char * name) +{ + return (GLAD_GNUC_EXTENSION(GLADapiproc(*)(const char * name)) userptr)(name); +} + +static int glad_gl_find_extensions_gles2(void) +{ + const char * exts = NULL; + char ** exts_i = NULL; + if(!glad_gl_get_extensions(&exts, &exts_i)) return 0; + + GLAD_GL_APPLE_texture_max_level = glad_gl_has_extension(exts, exts_i, "GL_APPLE_texture_max_level"); + GLAD_GL_EXT_texture_format_BGRA8888 = glad_gl_has_extension(exts, exts_i, "GL_EXT_texture_format_BGRA8888"); + GLAD_GL_EXT_unpack_subimage = glad_gl_has_extension(exts, exts_i, "GL_EXT_unpack_subimage"); + GLAD_GL_OES_mapbuffer = glad_gl_has_extension(exts, exts_i, "GL_OES_mapbuffer"); + GLAD_GL_OES_vertex_array_object = glad_gl_has_extension(exts, exts_i, "GL_OES_vertex_array_object"); + + glad_gl_free_extensions(exts_i); + + return 1; +} + +static int glad_gl_find_core_gles2(void) +{ + int i; + const char * version; + const char * prefixes[] = { + "OpenGL ES-CM ", + "OpenGL ES-CL ", + "OpenGL ES ", + "OpenGL SC ", + NULL + }; + int major = 0; + int minor = 0; + version = (const char *) glad_glGetString(GL_VERSION); + if(!version) return 0; + for(i = 0; prefixes[i]; i++) { + const size_t length = strlen(prefixes[i]); + if(strncmp(version, prefixes[i], length) == 0) { + version += length; + break; + } + } + + GLAD_IMPL_UTIL_SSCANF(version, "%d.%d", &major, &minor); + + GLAD_GL_ES_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; + + return GLAD_MAKE_VERSION(major, minor); +} + +int gladLoadGLES2UserPtr(GLADuserptrloadfunc load, void * userptr) +{ + int version; + + glad_glGetString = (PFNGLGETSTRINGPROC) load(userptr, "glGetString"); + if(glad_glGetString == NULL) return 0; + version = glad_gl_find_core_gles2(); + + glad_gl_load_GL_ES_VERSION_2_0(load, userptr); + + if(!glad_gl_find_extensions_gles2()) return 0; + glad_gl_load_GL_OES_mapbuffer(load, userptr); + glad_gl_load_GL_OES_vertex_array_object(load, userptr); + + + + return version; +} + + +int gladLoadGLES2(GLADloadfunc load) +{ + return gladLoadGLES2UserPtr(glad_gl_get_proc_from_userptr, GLAD_GNUC_EXTENSION(void *) load); +} + + + + + + +#ifdef __cplusplus +} +#endif + +#endif /*LV_USE_EGL*/ diff --git a/src/drivers/opengles/lv_opengles_driver.c b/src/drivers/opengles/lv_opengles_driver.c index 6bec431824..65368bdd52 100644 --- a/src/drivers/opengles/lv_opengles_driver.c +++ b/src/drivers/opengles/lv_opengles_driver.c @@ -64,6 +64,9 @@ static void lv_opengles_shader_set_uniform1f(const char * name, float value); static void lv_opengles_shader_set_uniform3f(const char * name, float value_0, float value_1, float value_2); static void lv_opengles_render_draw(void); static float lv_opengles_map_float(float x, float min_in, float max_in, float min_out, float max_out); +static void populate_vertex_buffer(float vertex_buffer[LV_OPENGLES_VERTEX_BUFFER_LEN], + lv_display_rotation_t rotation, bool * h_flip, bool * v_flip, + float clip_x1, float clip_y1, float clip_x2, float clip_y2); /*********************** * GLOBAL PROTOTYPES @@ -85,8 +88,8 @@ static unsigned int index_buffer_count = 0; static unsigned int shader_id; -static const char * shader_names[] = { "u_Texture", "u_ColorDepth", "u_VertexTransform", "u_Opa", "u_IsFill", "u_FillColor" }; -static int shader_location[] = { 0, 0, 0, 0, 0, 0 }; +static const char * shader_names[] = { "u_Texture", "u_ColorDepth", "u_VertexTransform", "u_Opa", "u_IsFill", "u_FillColor", "u_Hue", "u_Saturation", "u_Value" }; +static int shader_location[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }; /********************** * MACROS @@ -154,6 +157,44 @@ void lv_opengles_render_fill(lv_color_t color, const lv_area_t * area, lv_opa_t LV_PROFILER_DRAW_END; } +void lv_opengles_render_display_texture(lv_display_t * display, bool h_flip, bool v_flip) +{ + LV_PROFILER_DRAW_BEGIN; + unsigned int texture = *(unsigned int *)lv_display_get_driver_data(display); + GL_CALL(glActiveTexture(GL_TEXTURE0)); + GL_CALL(glBindTexture(GL_TEXTURE_2D, texture)); + + lv_display_rotation_t rotation = lv_display_get_rotation(display); + + float vert_buffer[LV_OPENGLES_VERTEX_BUFFER_LEN]; + populate_vertex_buffer(vert_buffer, rotation, &h_flip, &v_flip, 0.f, 0.f, 1.f, 1.f); + lv_opengles_vertex_buffer_init(vert_buffer, sizeof(vert_buffer)); + + float hor_scale = 1.0f; + float ver_scale = 1.0f; + float hor_translate = 0.0f; + float ver_translate = 0.0f; + hor_scale = h_flip ? -hor_scale : hor_scale; + ver_scale = v_flip ? ver_scale : -ver_scale; + + float matrix[9] = { + hor_scale, 0.0f, hor_translate, + 0.0f, ver_scale, ver_translate, + 0.0f, 0.0f, 1.0f + }; + + lv_opengles_shader_bind(); + lv_opengles_shader_set_uniform1f("u_ColorDepth", LV_COLOR_DEPTH); + lv_opengles_shader_set_uniform1i("u_Texture", 0); + lv_opengles_shader_set_uniformmatrix3fv("u_VertexTransform", 1, true, matrix); + lv_opengles_shader_set_uniform1f("u_Opa", 1); + lv_opengles_shader_set_uniform1i("u_IsFill", 0); + lv_opengles_shader_set_uniform3f("u_FillColor", 1.0f, 1.0f, 1.0f); + + lv_opengles_render_draw(); + LV_PROFILER_DRAW_END; +} + void lv_opengles_render_clear(void) { LV_PROFILER_DRAW_BEGIN; @@ -341,14 +382,10 @@ static void lv_opengles_shader_manager_init(void) static unsigned int lv_opengles_shader_program_init(void) { - /* To add defines: lv_opengl_shader_define_t frag_defs[1] = { { "PLACEHOLDER", NULL, false} }; */ - uint32_t frag_shader_hash = lv_opengl_shader_manager_select_shader(&shader_manager, "__MAIN__.frag", NULL, 0); uint32_t vert_shader_hash = lv_opengl_shader_manager_select_shader(&shader_manager, "__MAIN__.vert", NULL, 0); - lv_opengl_shader_program_t * program = lv_opengl_shader_manager_get_program(&shader_manager, frag_shader_hash, vert_shader_hash); - return lv_opengl_shader_program_get_id(program); } @@ -466,4 +503,97 @@ static float lv_opengles_map_float(float x, float min_in, float max_in, float mi return ((x - min_in) * delta_out) / delta_in + min_out; } +static void populate_vertex_buffer(float vertex_buffer[LV_OPENGLES_VERTEX_BUFFER_LEN], + lv_display_rotation_t rotation, bool * h_flip, bool * v_flip, float clip_x1, float clip_y1, float clip_x2, + float clip_y2) +{ +#if !LV_USE_DRAW_OPENGLES + LV_UNUSED(h_flip); + LV_UNUSED(v_flip); +#endif + switch(rotation) { + case LV_DISPLAY_ROTATION_0: + vertex_buffer[0] = -1.f; + vertex_buffer[1] = 1.0f; + vertex_buffer[2] = clip_x1; + vertex_buffer[3] = clip_y2; + vertex_buffer[4] = 1.0f; + vertex_buffer[5] = 1.0f; + vertex_buffer[6] = clip_x2; + vertex_buffer[7] = clip_y2; + vertex_buffer[8] = 1.0f; + vertex_buffer[9] = -1.0f; + vertex_buffer[10] = clip_x2; + vertex_buffer[11] = clip_y1; + vertex_buffer[12] = -1.f; + vertex_buffer[13] = -1.0f; + vertex_buffer[14] = clip_x1; + vertex_buffer[15] = clip_y1; + break; + + case LV_DISPLAY_ROTATION_270: +#if LV_USE_DRAW_OPENGLES + *h_flip = !*h_flip; + *v_flip = !*v_flip; +#endif + vertex_buffer[0] = 1.0f; + vertex_buffer[1] = 1.0f; + vertex_buffer[2] = clip_x1; + vertex_buffer[3] = clip_y2; + vertex_buffer[4] = 1.0f; + vertex_buffer[5] = -1.0f; + vertex_buffer[6] = clip_x2; + vertex_buffer[7] = clip_y2; + vertex_buffer[8] = -1.f; + vertex_buffer[9] = -1.0f; + vertex_buffer[10] = clip_x2; + vertex_buffer[11] = clip_y1; + vertex_buffer[12] = -1.f; + vertex_buffer[13] = 1.0f; + vertex_buffer[14] = clip_x1; + vertex_buffer[15] = clip_y1; + break; + + case LV_DISPLAY_ROTATION_180: + vertex_buffer[0] = 1.0f; + vertex_buffer[1] = -1.0f; + vertex_buffer[2] = clip_x1; + vertex_buffer[3] = clip_y2; + vertex_buffer[4] = -1.f; + vertex_buffer[5] = -1.0f; + vertex_buffer[6] = clip_x2; + vertex_buffer[7] = clip_y2; + vertex_buffer[8] = -1.f; + vertex_buffer[9] = 1.0f; + vertex_buffer[10] = clip_x2; + vertex_buffer[11] = clip_y1; + vertex_buffer[12] = 1.0f; + vertex_buffer[13] = 1.0f; + vertex_buffer[14] = clip_x1; + vertex_buffer[15] = clip_y1; + break; + case LV_DISPLAY_ROTATION_90: +#if LV_USE_DRAW_OPENGLES + *h_flip = !*h_flip; + *v_flip = !*v_flip; +#endif + vertex_buffer[0] = -1.f; + vertex_buffer[1] = -1.0f; + vertex_buffer[2] = clip_x1; + vertex_buffer[3] = clip_y2; + vertex_buffer[4] = -1.f; + vertex_buffer[5] = 1.0f; + vertex_buffer[6] = clip_x2; + vertex_buffer[7] = clip_y2; + vertex_buffer[8] = 1.0f; + vertex_buffer[9] = 1.0f; + vertex_buffer[10] = clip_x2; + vertex_buffer[11] = clip_y1; + vertex_buffer[12] = 1.0f; + vertex_buffer[13] = -1.0f; + vertex_buffer[14] = clip_x1; + vertex_buffer[15] = clip_y1; + break; + } +} #endif /* LV_USE_OPENGLES */ diff --git a/src/drivers/opengles/lv_opengles_driver.h b/src/drivers/opengles/lv_opengles_driver.h index 8769ccda64..67dcf5d270 100644 --- a/src/drivers/opengles/lv_opengles_driver.h +++ b/src/drivers/opengles/lv_opengles_driver.h @@ -57,6 +57,14 @@ void lv_opengles_deinit(void); void lv_opengles_render_texture(unsigned int texture, const lv_area_t * texture_area, lv_opa_t opa, int32_t disp_w, int32_t disp_h, const lv_area_t * texture_clip_area, bool h_flip, bool v_flip); +/** + * Render a display texture - Supports rotation + * @param display LVGL Texture display. Created with the `lv_opengles_texture` module + * @param h_flip horizontal flip + * @param v_flip vertical flip + */ +void lv_opengles_render_display_texture(lv_display_t * display, bool h_flip, bool v_flip); + /** * Render a fill * @param color the color of the fill diff --git a/src/drivers/opengles/lv_opengles_egl.c b/src/drivers/opengles/lv_opengles_egl.c index bef392d452..0a5e3c1316 100644 --- a/src/drivers/opengles/lv_opengles_egl.c +++ b/src/drivers/opengles/lv_opengles_egl.c @@ -6,552 +6,552 @@ /********************* * INCLUDES *********************/ - #include "lv_opengles_egl.h" +#include + #if LV_USE_EGL -#include "lv_opengles_window.h" -#include "lv_opengles_driver.h" -#include "lv_opengles_texture.h" -#include "lv_opengles_private.h" +#include + +#include #include "lv_opengles_debug.h" -#include "../../core/lv_refr_private.h" -#include "../../stdlib/lv_string.h" -#include "../../core/lv_global.h" -#include "../../display/lv_display_private.h" -#include "../../indev/lv_indev.h" -#include "../../lv_init.h" -#include "../../misc/lv_area_private.h" - -#include +#include "glad/include/glad/egl.h" +#include "../../misc/lv_assert.h" +#include "../../misc/lv_log.h" +#include "../../misc/lv_types.h" +#include "../../misc/lv_types.h" +#include "../../stdlib/lv_mem.h" +#include "lv_opengles_private.h" +#include "lv_opengles_egl_private.h" +#include "lv_opengles_driver.h" /********************* - * DEFINES - *********************/ +* DEFINES +*********************/ /********************** - * TYPEDEFS - **********************/ - -struct _lv_opengles_window_t { - EGLSurface surface; - int32_t hor_res; - int32_t ver_res; - lv_ll_t textures; - lv_opengles_egl_window_cb_t pre; - lv_opengles_egl_window_cb_t post1; - lv_opengles_egl_window_cb_t post2; - void * user_data; -#if LV_USE_DRAW_OPENGLES - uint8_t direct_render_invalidated: 1; -#endif -}; - -struct _lv_opengles_window_texture_t { - lv_opengles_window_t * window; - unsigned int texture_id; /* 0 if it's a window display */ - lv_display_t * disp; /* non-NULL if it's a display texture or a window display */ - uint8_t * fb; /* non-NULL if it's a window display and !DRAW_OPENGLES */ - lv_area_t area; - lv_opa_t opa; -}; +* TYPEDEFS +**********************/ /********************** - * STATIC PROTOTYPES - **********************/ +* STATIC PROTOTYPES +**********************/ -static lv_result_t lv_egl_init(void); -static void lv_egl_timer_init(void); -static void window_update_handler(lv_timer_t * t); -static void window_display_delete_cb(lv_event_t * e); -static void window_display_flush_cb(lv_display_t * disp, const lv_area_t * area, uint8_t * px_map); -#if !LV_USE_DRAW_OPENGLES - static void ensure_init_window_display_texture(void); -#endif +static lv_result_t load_egl(lv_opengles_egl_t * ctx); +static EGLDisplay create_egl_display(lv_opengles_egl_t * ctx); +static EGLSurface create_egl_surface(lv_opengles_egl_t * ctx); +static EGLContext create_egl_context(lv_opengles_egl_t * ctx); +static EGLConfig create_egl_config(lv_opengles_egl_t * ctx); +static lv_result_t lv_egl_config_from_egl_config(lv_opengles_egl_t * ctx, lv_egl_config_t * lv_egl_config, + EGLConfig egl_config); +static void * create_native_window(lv_opengles_egl_t * ctx); +static lv_result_t get_native_config(lv_opengles_egl_t * ctx, EGLint * native_id, uint64_t ** mods, size_t * count); +static GLADapiproc glad_egl_load_cb(void * userdata, const char * name); /********************** - * STATIC VARIABLES - **********************/ - -static bool egl_inited; -static lv_timer_t * update_handler_timer; -static lv_ll_t egl_window_ll; -static EGLDisplay egl_display; -static EGLContext egl_config; -static EGLContext egl_context; -static void * backend_device; -#if !LV_USE_DRAW_OPENGLES - static unsigned int window_display_texture; -#endif - -static EGLint const attribute_list[] = { - EGL_RED_SIZE, 8, - EGL_GREEN_SIZE, 8, - EGL_BLUE_SIZE, 8, - EGL_ALPHA_SIZE, 8, - EGL_NONE -}; - -static EGLint const context_attribute_list[] = { - EGL_CONTEXT_CLIENT_VERSION, 2, - EGL_NONE -}; +* STATIC VARIABLES +**********************/ /********************** - * MACROS - **********************/ +* MACROS +**********************/ /********************** - * GLOBAL FUNCTIONS - **********************/ +* GLOBAL FUNCTIONS +**********************/ -lv_opengles_window_t * lv_opengles_egl_window_create(int32_t hor_res, int32_t ver_res, void * native_window_handle, - void * device, - lv_opengles_egl_window_cb_t pre, - lv_opengles_egl_window_cb_t post1, - lv_opengles_egl_window_cb_t post2) +lv_opengles_egl_t * lv_opengles_egl_context_create(const lv_egl_interface_t * interface) { - backend_device = device; - if(lv_egl_init() == LV_RESULT_INVALID) { + lv_opengles_egl_t * ctx = lv_zalloc(sizeof(*ctx)); + LV_ASSERT_MALLOC(ctx); + if(!ctx) { + LV_LOG_ERROR("Failed to create egl context"); return NULL; } + ctx->interface = *interface; + ctx->vsync = false; - lv_opengles_window_t * window = lv_ll_ins_tail(&egl_window_ll); - LV_ASSERT_MALLOC(window); - if(window == NULL) return NULL; - lv_memzero(window, sizeof(*window)); - - /* Create window with graphics context */ - window->surface = eglCreateWindowSurface(egl_display, egl_config, (EGLNativeWindowType)(uintptr_t)native_window_handle, - NULL); - if(window->surface == EGL_NO_SURFACE) { - LV_LOG_ERROR("eglCreateWindowSurface failed."); - lv_ll_remove(&egl_window_ll, window); - lv_free(window); + lv_result_t res = load_egl(ctx); + if(res != LV_RESULT_OK) { + LV_LOG_ERROR("Failed to load egl "); + lv_free(ctx); return NULL; } - - window->hor_res = hor_res; - window->ver_res = ver_res; - lv_ll_init(&window->textures, sizeof(lv_opengles_window_texture_t)); - - window->pre = pre; - window->post1 = post1; - window->post2 = post2; - -#if LV_USE_DRAW_OPENGLES - window->direct_render_invalidated = 1; -#endif - - lv_egl_timer_init(); - - EGLBoolean res = eglMakeCurrent(egl_display, window->surface, window->surface, egl_context); - if(res == EGL_FALSE) { - LV_LOG_ERROR("eglMakeCurrent failed."); - return NULL; - } - - res = eglSwapInterval(egl_display, 0); - if(res == EGL_FALSE) { - LV_LOG_ERROR("eglSwapInterval failed."); - return NULL; - } - lv_opengles_init(); - - return window; + return ctx; } -void * lv_opengles_egl_window_get_surface(lv_opengles_window_t * window) +void lv_opengles_egl_context_destroy(lv_opengles_egl_t * ctx) { - return (void *)(uintptr_t)window->surface; -} - -void * lv_opengles_egl_window_get_display(lv_opengles_window_t * window) -{ - LV_UNUSED(window); - return (void *)(uintptr_t)egl_display; -} - -void lv_opengles_egl_window_set_user_data(lv_opengles_window_t * window, void * user_data) -{ - window->user_data = user_data; -} - -void * lv_opengles_egl_window_get_user_data(lv_opengles_window_t * window) -{ - return window->user_data; -} - -void lv_opengles_window_delete(lv_opengles_window_t * window) -{ - EGLBoolean res = eglDestroySurface(egl_display, window->surface); - if(res == EGL_FALSE) { - LV_LOG_ERROR("eglDestroySurface failed."); - return; + if(ctx->egl_display) { + eglMakeCurrent(ctx->egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); + if(ctx->egl_context) { + eglDestroyContext(ctx->egl_display, ctx->egl_context); + } + ctx->egl_context = EGL_NO_CONTEXT; + } + if(ctx->egl_surface && ctx->egl_display) { + eglDestroySurface(ctx->egl_display, ctx->egl_surface); + ctx->egl_surface = EGL_NO_SURFACE; } - lv_opengles_window_texture_t * texture; - while((texture = lv_ll_get_head(&window->textures))) { - if(texture->texture_id) { - lv_opengles_window_texture_remove(texture); - } - else { - lv_display_delete(texture->disp); + if(ctx->egl_lib_handle) { + dlclose(ctx->egl_lib_handle); + } + if(ctx->opengl_lib_handle) { + dlclose(ctx->opengl_lib_handle); + } + + if(ctx->native_window && ctx->interface.destroy_window_cb) { + ctx->interface.destroy_window_cb(ctx->interface.driver_data, (void *)ctx->native_window); + ctx->native_window = 0; + } + if(ctx->egl_display) { + eglTerminate(ctx->egl_display); + ctx->egl_display = EGL_NO_DISPLAY; + } + ctx->egl_config = NULL; + lv_free(ctx); +} + +void lv_opengles_egl_clear(lv_opengles_egl_t * ctx) +{ + LV_UNUSED(ctx); + GL_CALL(glClearColor(0.f, 0.f, 0.f, 1.0f)); + GL_CALL(glDepthRangef(-1.0, 1.0)); + GL_CALL(glDepthFunc(GL_ALWAYS)); + GL_CALL(glClearDepthf(1.0f)); + GL_CALL(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)); +} + +void lv_opengles_egl_update(lv_opengles_egl_t * ctx) +{ + eglSwapBuffers(ctx->egl_display, ctx->egl_surface); + ctx->interface.flip_cb(ctx->interface.driver_data, ctx->vsync); +} + + +/********************** +* STATIC FUNCTIONS +**********************/ + +static void * load_lib(const char ** libs, size_t count) +{ + const int mode = RTLD_NOW | RTLD_NODELETE; + for(size_t i = 0; i < count; ++i) { + + void * handle = dlopen(libs[i], mode); + if(handle) { + return handle; } } - - lv_ll_remove(&egl_window_ll, window); - lv_free(window); - -#if !LV_USE_DRAW_OPENGLES - if(lv_ll_is_empty(&egl_window_ll)) { - GL_CALL(glDeleteTextures(1, &window_display_texture)); - window_display_texture = 0; - } -#endif -} - -lv_opengles_window_texture_t * lv_opengles_window_add_texture(lv_opengles_window_t * window, unsigned int texture_id, - int32_t w, int32_t h) -{ - lv_opengles_window_texture_t * texture = lv_ll_ins_tail(&window->textures); - LV_ASSERT_MALLOC(texture); - if(texture == NULL) return NULL; - lv_memzero(texture, sizeof(*texture)); - texture->window = window; - texture->texture_id = texture_id; - texture->disp = lv_opengles_texture_get_from_texture_id(texture_id); - lv_area_set(&texture->area, 0, 0, w - 1, h - 1); - texture->opa = LV_OPA_COVER; - -#if LV_USE_DRAW_OPENGLES - window->direct_render_invalidated = 1; -#endif - - return texture; -} - -void lv_opengles_window_texture_remove(lv_opengles_window_texture_t * texture) -{ - if(texture->texture_id == 0) { - LV_LOG_WARN("window displays should be deleted with `lv_display_delete`"); - return; - } - -#if LV_USE_DRAW_OPENGLES - texture->window->direct_render_invalidated = 1; -#endif - - lv_ll_remove(&texture->window->textures, texture); - lv_free(texture); -} - -lv_display_t * lv_opengles_window_display_create(lv_opengles_window_t * window, int32_t w, int32_t h) -{ - lv_display_t * disp = lv_display_create(w, h); - if(disp == NULL) { - return NULL; - } - - lv_opengles_window_texture_t * dsc = lv_ll_ins_tail(&window->textures); - LV_ASSERT_MALLOC(dsc); - if(dsc == NULL) { - lv_display_delete(disp); - return NULL; - } - lv_memzero(dsc, sizeof(*dsc)); - dsc->window = window; - dsc->disp = disp; - lv_area_set(&dsc->area, 0, 0, w - 1, h - 1); - dsc->opa = LV_OPA_COVER; - -#if LV_USE_DRAW_OPENGLES - static size_t LV_ATTRIBUTE_MEM_ALIGN dummy_buf; - lv_display_set_buffers(disp, &dummy_buf, NULL, h * lv_draw_buf_width_to_stride(w, LV_COLOR_FORMAT_ARGB8888), - LV_DISPLAY_RENDER_MODE_FULL); -#else - uint32_t stride = lv_draw_buf_width_to_stride(w, lv_display_get_color_format(disp)); - uint32_t buf_size = stride * h; - dsc->fb = malloc(buf_size); - LV_ASSERT_MALLOC(dsc->fb); - if(dsc->fb == NULL) { - lv_display_delete(disp); - lv_ll_remove(&window->textures, dsc); - lv_free(dsc); - return NULL; - } - lv_display_set_buffers(disp, dsc->fb, NULL, buf_size, LV_DISPLAY_RENDER_MODE_DIRECT); -#endif - - lv_display_set_driver_data(disp, dsc); - lv_display_delete_refr_timer(disp); - lv_display_set_flush_cb(disp, window_display_flush_cb); - lv_display_add_event_cb(disp, window_display_delete_cb, LV_EVENT_DELETE, disp); - -#if LV_USE_DRAW_OPENGLES - window->direct_render_invalidated = 1; -#endif - - return disp; -} - -lv_opengles_window_texture_t * lv_opengles_window_display_get_window_texture(lv_display_t * window_display) -{ - return lv_display_get_driver_data(window_display); -} - -void lv_opengles_window_texture_set_x(lv_opengles_window_texture_t * texture, int32_t x) -{ - lv_area_set_pos(&texture->area, x, texture->area.y1); - -#if LV_USE_DRAW_OPENGLES - texture->window->direct_render_invalidated = 1; -#endif -} - -void lv_opengles_window_texture_set_y(lv_opengles_window_texture_t * texture, int32_t y) -{ - lv_area_set_pos(&texture->area, texture->area.x1, y); - -#if LV_USE_DRAW_OPENGLES - texture->window->direct_render_invalidated = 1; -#endif -} - -void lv_opengles_window_texture_set_opa(lv_opengles_window_texture_t * texture, lv_opa_t opa) -{ - texture->opa = opa; - -#if LV_USE_DRAW_OPENGLES - texture->window->direct_render_invalidated = 1; -#endif -} - -lv_indev_t * lv_opengles_window_texture_get_mouse_indev(lv_opengles_window_texture_t * texture) -{ - LV_UNUSED(texture); - LV_LOG_WARN("EGL does not create indevs. Returning NULL."); return NULL; } - -/********************** - * STATIC FUNCTIONS - **********************/ - -static lv_result_t lv_egl_init(void) +static void * load_egl_lib(void) { - if(egl_inited) { - return LV_RESULT_OK; + const char * egl_libs[] = {"libEGL.so", "libEGL.so.1"}; + return load_lib(egl_libs, sizeof(egl_libs) / sizeof(egl_libs[0])); +} +static void * load_gl_lib(void) +{ + const char * gl_libs[] = {"libGLESv2.so", "libGLESv2.so.2"}; + return load_lib(gl_libs, sizeof(gl_libs) / sizeof(gl_libs[0])); +} + +static lv_result_t load_egl(lv_opengles_egl_t * ctx) +{ + ctx->egl_lib_handle = load_egl_lib(); + if(!ctx->egl_lib_handle) { + LV_LOG_ERROR("Failed to load egl shared lib: %s", dlerror()); + goto err; } - /* get an EGL display connection */ - if(backend_device) { - egl_display = eglGetDisplay(backend_device); - } - else { - egl_display = eglGetDisplay(EGL_DEFAULT_DISPLAY); + ctx->egl_display = create_egl_display(ctx); + if(!ctx->egl_display) { + LV_LOG_ERROR("Failed to create egl display"); + goto egl_display_err; } - if(egl_display == EGL_NO_DISPLAY) { - LV_LOG_ERROR("eglGetDisplay failed."); + if(!gladLoadEGLUserPtr(ctx->egl_display, glad_egl_load_cb, ctx->egl_lib_handle)) { + LV_LOG_ERROR("Failed to load EGL entry points"); + goto load_egl_functions_err; + } + + if(eglBindAPI && !eglBindAPI(EGL_OPENGL_ES_API)) { + LV_LOG_ERROR("Failed to bind api"); + goto err; + } + + ctx->opengl_lib_handle = load_gl_lib(); + if(!ctx->opengl_lib_handle) { + LV_LOG_ERROR("Failed to load OpenGL library. %s", dlerror()); + goto opengl_lib_err; + } + + ctx->egl_config = create_egl_config(ctx); + if(!ctx->egl_config) { + LV_LOG_ERROR("Failed to create EGL config. Error code: %#x", eglGetError()); + goto egl_config_err; + } + + ctx->native_window = (EGLNativeWindowType)create_native_window(ctx); + if(!ctx->native_window) { + LV_LOG_ERROR("Failed to create native window"); + goto create_window_err; + + } + ctx->egl_surface = create_egl_surface(ctx); + if(!ctx->egl_surface) { + LV_LOG_ERROR("Failed to create EGL surface. Error code: %#x", eglGetError()); + goto egl_surface_err; + } + + ctx->egl_context = create_egl_context(ctx); + if(!ctx->egl_context) { + LV_LOG_ERROR("Failed to create EGL context. Error code: %#x", eglGetError()); + goto egl_context_err; + } + + if(!eglMakeCurrent(ctx->egl_display, ctx->egl_surface, ctx->egl_surface, ctx->egl_context)) { + LV_LOG_ERROR("Failed to set current egl context. Error code: %#x", eglGetError()); + goto egl_make_current_context_err; + } + + if(!eglSwapInterval || !eglSwapInterval(ctx->egl_display, 0)) { + LV_LOG_WARN("Can't set egl swap interval"); + } + + if(!gladLoadGLES2UserPtr(glad_egl_load_cb, ctx->opengl_lib_handle)) { + LV_LOG_ERROR("Failed to load load OpenGL entry points"); + goto load_opengl_functions_err; + } + + return LV_RESULT_OK; + +load_opengl_functions_err: + eglMakeCurrent(ctx->egl_display, NULL, NULL, NULL); + eglDestroyContext(ctx->egl_display, ctx->egl_context); +egl_make_current_context_err: + ctx->egl_context = NULL; +egl_context_err: + ctx->egl_surface = NULL; +egl_surface_err: + ctx->interface.destroy_window_cb(ctx->interface.driver_data, (void *)ctx->native_window); + ctx->native_window = 0; +create_window_err: + ctx->egl_config = NULL; +egl_config_err: + dlclose(ctx->opengl_lib_handle); + ctx->opengl_lib_handle = NULL; +opengl_lib_err: + ctx->egl_display = NULL; +load_egl_functions_err: +egl_display_err: + dlclose(ctx->egl_lib_handle); + ctx->egl_lib_handle = NULL; +err: + return LV_RESULT_INVALID; +} + +static EGLDisplay create_egl_display(lv_opengles_egl_t * ctx) +{ + union { + PFNEGLQUERYSTRINGPROC fn; + void * ptr; + } egl_query_string; + + union { + PFNEGLGETPROCADDRESSPROC fn; + void * ptr; + } egl_get_proc_address; + + union { + PFNEGLGETERRORPROC fn; + void * ptr; + } egl_get_error; + + union { + PFNEGLGETDISPLAYPROC fn; + void * ptr; + } egl_get_display; + + union { + PFNEGLINITIALIZEPROC fn; + void * ptr; + } egl_initialize; + + EGLDisplay display = NULL; + + egl_get_proc_address.ptr = dlsym(ctx->egl_lib_handle, "eglGetProcAddress"); + if(!egl_get_proc_address.ptr) { + LV_LOG_ERROR("Failed to load eglGetProcAddress"); + return NULL; + } + + egl_query_string.ptr = dlsym(ctx->egl_lib_handle, "eglQueryString"); + if(!egl_query_string.ptr) { + LV_LOG_ERROR("Failed to load eglQueryString"); + return NULL; + } + + egl_get_display.ptr = dlsym(ctx->egl_lib_handle, "eglGetDisplay"); + if(!egl_get_display.ptr) { + LV_LOG_ERROR("Failed to load eglGetDisplay"); + return NULL; + } + + egl_get_error.ptr = dlsym(ctx->egl_lib_handle, "eglGetError"); + if(!egl_get_error.ptr) { + LV_LOG_ERROR("Failed to load eglGetError"); + return NULL; + } + + egl_initialize.ptr = dlsym(ctx->egl_lib_handle, "eglInitialize"); + if(!egl_initialize.ptr) { + LV_LOG_ERROR("Failed to load eglInitialize"); + return NULL; + } + + char const * supported_extensions = egl_query_string.fn(EGL_NO_DISPLAY, EGL_EXTENSIONS); + + bool has_platform_display_ext_support = ctx->interface.egl_platform != 0 && supported_extensions && + strstr(supported_extensions, "EGL_EXT_platform_base"); + if(has_platform_display_ext_support) { + PFNEGLGETPLATFORMDISPLAYEXTPROC egl_get_platform_display = (PFNEGLGETPLATFORMDISPLAYEXTPROC) + egl_get_proc_address.fn("eglGetPlatformDisplayEXT"); + if(egl_get_platform_display) { + display = egl_get_platform_display(ctx->interface.egl_platform, (void *)ctx->interface.native_display, NULL); + } + if(!display) { + LV_LOG_WARN("Failed to get egl display from eglGetPlatformDisplay. Error code: %#x", egl_get_error.fn()); + } + } + + if(!display) { + LV_LOG_INFO("Falling back to eglGetDisplay()"); + display = egl_get_display.fn(ctx->interface.native_display); + } + + if(!display) { + LV_LOG_ERROR("Failed to get egl display from eglGetDisplay. Error code: %#x", egl_get_error.fn()); + return NULL; + } + + EGLint egl_major; + EGLint egl_minor; + if(!egl_initialize.fn(display, &egl_major, &egl_minor)) { + LV_LOG_ERROR("Failed to initialize egl. Error code: %#x", egl_get_error.fn()); + return NULL; + } + LV_LOG_INFO("Egl version %d.%d", egl_major, egl_minor); + + return display; +} + +static GLADapiproc glad_egl_load_cb(void * userdata, const char * name) +{ + union { + GLADapiproc fn; + void * ptr; + } result; + + if(eglGetProcAddress) { + GLADapiproc sym = (GLADapiproc)eglGetProcAddress(name); + if(sym) { + return sym; + } + } + result.ptr = dlsym(userdata, name); + return result.fn; +} + +static EGLConfig create_egl_config(lv_opengles_egl_t * ctx) +{ + const EGLint config_attribs[] = { + EGL_RENDERABLE_TYPE, + EGL_OPENGL_ES2_BIT, + EGL_NONE + }; + + EGLint num_configs = 0; + if(!eglChooseConfig(ctx->egl_display, config_attribs, 0, 0, &num_configs)) { + LV_LOG_ERROR("Failed to get number of configs: %d", eglGetError()); + return NULL; + } + + if(num_configs == 0) { + LV_LOG_ERROR("No valid configs"); + return NULL; + } + + EGLConfig * egl_configs = lv_malloc(num_configs * sizeof(*egl_configs)); + LV_ASSERT_MALLOC(egl_configs); + if(!egl_configs) { + LV_LOG_ERROR("Failed to allocate memory for possible configs"); + return NULL; + } + + if(!eglChooseConfig(ctx->egl_display, config_attribs, egl_configs, num_configs, &num_configs)) { + LV_LOG_ERROR("Failed to get configs: %d", eglGetError()); + return NULL; + } + + lv_egl_config_t * configs = lv_malloc(num_configs * sizeof(*configs)); + LV_ASSERT_MALLOC(configs); + if(!configs) { + LV_LOG_ERROR("Failed to allocate memory for configs"); + lv_free(egl_configs); + return NULL; + } + + size_t valid_config_count = 0; + for(size_t i = 0; i < (size_t)num_configs; ++i) { + lv_result_t err = lv_egl_config_from_egl_config(ctx, configs + i, egl_configs[i]); + if(err == LV_RESULT_OK) { + valid_config_count ++; + } + } + + if(valid_config_count == 0) { + LV_LOG_ERROR("Failed to parse available EGL configs"); + lv_free(egl_configs); + lv_free(configs); + return NULL; + } + + size_t config_id = ctx->interface.select_config(ctx->interface.driver_data, configs, valid_config_count); + + if(config_id >= (size_t)num_configs) { + LV_LOG_ERROR("Failed to find suitable EGL config"); + lv_free(egl_configs); + lv_free(configs); + return NULL; + } + EGLConfig config = egl_configs[config_id]; + lv_free(configs); + lv_free(egl_configs); + return config; +} + +static EGLSurface create_egl_surface(lv_opengles_egl_t * ctx) +{ + LV_ASSERT_NULL(ctx->egl_display); + LV_ASSERT_NULL(ctx->egl_config); + LV_ASSERT(ctx->native_window != 0); + return eglCreateWindowSurface(ctx->egl_display, ctx->egl_config, ctx->native_window, NULL); +} + +static EGLContext create_egl_context(lv_opengles_egl_t * ctx) +{ + static const EGLint context_attribs[] = { + EGL_CONTEXT_CLIENT_VERSION, 2, + EGL_NONE + }; + return eglCreateContext(ctx->egl_display, ctx->egl_config, + EGL_NO_CONTEXT, context_attribs); +} + +lv_color_format_t lv_opengles_egl_color_format_from_egl_config(const lv_egl_config_t * config) +{ + if(config->r_bits == 5 && config->g_bits == 6 && config->b_bits == 5) { + if(config->a_bits == 8) { + return LV_COLOR_FORMAT_RGB565A8; + } + else { + return LV_COLOR_FORMAT_RGB565; + } + } + if(config->r_bits == 8 && config->g_bits == 8 && config->b_bits == 8) { + if(config->a_bits == 8) { + return LV_COLOR_FORMAT_ARGB8888; + } + else { + + return LV_COLOR_FORMAT_RGB888; + } + } + LV_LOG_INFO("Unhandled color format (RGBA) (%d %d %d %d)", r_bits, g_bits, b_bits, a_bits); + return LV_COLOR_FORMAT_UNKNOWN; +} + +static lv_result_t lv_egl_config_from_egl_config(lv_opengles_egl_t * ctx, lv_egl_config_t * lv_egl_config, + EGLConfig egl_config) +{ + int res = 1; + res &= eglGetConfigAttrib(ctx->egl_display, egl_config, EGL_CONFIG_ID, &lv_egl_config->id); + res &= eglGetConfigAttrib(ctx->egl_display, egl_config, EGL_RED_SIZE, &lv_egl_config->r_bits); + res &= eglGetConfigAttrib(ctx->egl_display, egl_config, EGL_GREEN_SIZE, &lv_egl_config->g_bits); + res &= eglGetConfigAttrib(ctx->egl_display, egl_config, EGL_BLUE_SIZE, &lv_egl_config->b_bits); + res &= eglGetConfigAttrib(ctx->egl_display, egl_config, EGL_ALPHA_SIZE, &lv_egl_config->a_bits); + res &= eglGetConfigAttrib(ctx->egl_display, egl_config, EGL_MAX_PBUFFER_WIDTH, &lv_egl_config->max_width); + res &= eglGetConfigAttrib(ctx->egl_display, egl_config, EGL_MAX_PBUFFER_HEIGHT, &lv_egl_config->max_height); + res &= eglGetConfigAttrib(ctx->egl_display, egl_config, EGL_BUFFER_SIZE, &lv_egl_config->buffer_size); + res &= eglGetConfigAttrib(ctx->egl_display, egl_config, EGL_DEPTH_SIZE, &lv_egl_config->depth); + res &= eglGetConfigAttrib(ctx->egl_display, egl_config, EGL_STENCIL_SIZE, &lv_egl_config->stencil); + res &= eglGetConfigAttrib(ctx->egl_display, egl_config, EGL_SAMPLES, &lv_egl_config->samples); + res &= eglGetConfigAttrib(ctx->egl_display, egl_config, EGL_SURFACE_TYPE, &lv_egl_config->surface_type); + + if(!res) { + LV_LOG_WARN("Failed to fetch egl config properties"); return LV_RESULT_INVALID; } - - /* initialize the EGL display connection */ - EGLBoolean res = eglInitialize(egl_display, NULL, NULL); - if(res == EGL_FALSE) { - LV_LOG_ERROR("eglInitialize failed."); - return LV_RESULT_INVALID; - } - - /* get an appropriate EGL frame buffer configuration */ - EGLint num_config; - res = eglChooseConfig(egl_display, attribute_list, &egl_config, 1, &num_config); - if(res == EGL_FALSE) { - LV_LOG_ERROR("eglChooseConfig failed."); - eglTerminate(egl_display); - return LV_RESULT_INVALID; - } - - /* create an EGL rendering context */ - egl_context = eglCreateContext(egl_display, egl_config, EGL_NO_CONTEXT, context_attribute_list); - if(egl_context == EGL_NO_CONTEXT) { - LV_LOG_ERROR("eglCreateContext failed."); - eglTerminate(egl_display); - return LV_RESULT_INVALID; - } - - lv_ll_init(&egl_window_ll, sizeof(lv_opengles_window_t)); - - egl_inited = true; return LV_RESULT_OK; } -static void lv_egl_timer_init(void) +static void * create_native_window(lv_opengles_egl_t * ctx) { - if(update_handler_timer == NULL) { - update_handler_timer = lv_timer_create(window_update_handler, LV_DEF_REFR_PERIOD, NULL); - } -} + EGLint native_config_id; + uint64_t * mods = NULL; + size_t mod_count = 0; + lv_result_t res = get_native_config(ctx, &native_config_id, &mods, &mod_count); -static void window_update_handler(lv_timer_t * t) -{ - LV_UNUSED(t); - lv_opengles_window_t * window; - - /* render each window */ - LV_LL_READ(&egl_window_ll, window) { - if(window->pre) window->pre(window); - - EGLBoolean res = eglMakeCurrent(egl_display, window->surface, window->surface, egl_context); - if(res == EGL_FALSE) { - LV_LOG_ERROR("eglMakeCurrent failed."); - return; - } - - lv_opengles_viewport(0, 0, window->hor_res, window->ver_res); - -#if LV_USE_DRAW_OPENGLES - lv_opengles_window_texture_t * textures_head; - bool window_display_direct_render = - !window->direct_render_invalidated - && (textures_head = lv_ll_get_head(&window->textures)) - && textures_head->texture_id == 0 /* it's a window display */ - && lv_ll_get_next(&window->textures, textures_head) == NULL /* it's the only one */ - && textures_head->opa == LV_OPA_COVER - && textures_head->area.x1 == 0 - && textures_head->area.y1 == 0 - && textures_head->area.x2 == window->hor_res - 1 - && textures_head->area.y2 == window->ver_res - 1 - ; - window->direct_render_invalidated = 0; - if(!window_display_direct_render) { - lv_opengles_render_clear(); - } -#else - lv_opengles_render_clear(); -#endif - - /* render each texture in the window */ - lv_opengles_window_texture_t * texture; - LV_LL_READ(&window->textures, texture) { - if(texture->texture_id == 0) { /* it's a window display */ -#if LV_USE_DRAW_OPENGLES - lv_display_set_render_mode(texture->disp, - window_display_direct_render ? LV_DISPLAY_RENDER_MODE_DIRECT : LV_DISPLAY_RENDER_MODE_FULL); -#endif - - lv_display_t * default_save = lv_display_get_default(); - lv_display_set_default(texture->disp); - lv_display_refr_timer(NULL); - lv_display_set_default(default_save); - -#if !LV_USE_DRAW_OPENGLES - ensure_init_window_display_texture(); - - GL_CALL(glBindTexture(GL_TEXTURE_2D, window_display_texture)); - - /* set the dimensions and format to complete the texture */ - /* Color depth: 8 (L8), 16 (RGB565), 24 (RGB888), 32 (XRGB8888) */ -#if LV_COLOR_DEPTH == 8 - GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, lv_area_get_width(&texture->area), lv_area_get_height(&texture->area), 0, - GL_RED, GL_UNSIGNED_BYTE, texture->fb)); -#elif LV_COLOR_DEPTH == 16 - GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB565, lv_area_get_width(&texture->area), lv_area_get_height(&texture->area), - 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, - texture->fb)); -#elif LV_COLOR_DEPTH == 24 - GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, lv_area_get_width(&texture->area), lv_area_get_height(&texture->area), 0, - GL_BGR, GL_UNSIGNED_BYTE, texture->fb)); -#elif LV_COLOR_DEPTH == 32 - GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, lv_area_get_width(&texture->area), lv_area_get_height(&texture->area), - 0, GL_BGRA, GL_UNSIGNED_BYTE, texture->fb)); -#else -#error("Unsupported color format") -#endif - - GL_CALL(glGenerateMipmap(GL_TEXTURE_2D)); - - GL_CALL(glBindTexture(GL_TEXTURE_2D, 0)); - - lv_opengles_render_texture(window_display_texture, &texture->area, texture->opa, window->hor_res, window->ver_res, - &texture->area, false, false); -#endif - } - else { - /* if the added texture is an LVGL opengles texture display, refresh it before rendering it */ - if(texture->disp != NULL) { -#if LV_USE_DRAW_OPENGLES - lv_display_t * default_save = lv_display_get_default(); - lv_display_set_default(texture->disp); - lv_display_refr_timer(NULL); - lv_display_set_default(default_save); -#else - lv_refr_now(texture->disp); -#endif - } - -#if LV_USE_DRAW_OPENGLES - lv_opengles_render_texture(texture->texture_id, &texture->area, texture->opa, window->hor_res, window->ver_res, - &texture->area, false, texture->disp != NULL); -#else - lv_opengles_render_texture(texture->texture_id, &texture->area, texture->opa, window->hor_res, window->ver_res, - &texture->area, false, false); -#endif - } - } - - if(window->post1) window->post1(window); - - /* Swap front and back buffers */ - res = eglSwapBuffers(egl_display, window->surface); - if(res == EGL_FALSE) { - LV_LOG_ERROR("eglSwapBuffers failed."); - return; - } - - if(window->post2) window->post2(window); - } -} - -static void window_display_delete_cb(lv_event_t * e) -{ - lv_display_t * disp = lv_event_get_target(e); - lv_opengles_window_texture_t * dsc = lv_display_get_driver_data(disp); - free(dsc->fb); - lv_opengles_window_texture_remove(dsc); -} - -static void window_display_flush_cb(lv_display_t * disp, const lv_area_t * area, uint8_t * px_map) -{ - LV_UNUSED(area); - LV_UNUSED(px_map); - lv_display_flush_ready(disp); -} - -#if !LV_USE_DRAW_OPENGLES -static void ensure_init_window_display_texture(void) -{ - if(window_display_texture) { - return; + if(res == LV_RESULT_INVALID) { + LV_LOG_ERROR("Failed to get native config"); + return NULL; } - GL_CALL(glGenTextures(1, &window_display_texture)); - GL_CALL(glBindTexture(GL_TEXTURE_2D, window_display_texture)); - GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)); - GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)); - GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)); - GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)); - GL_CALL(glPixelStorei(GL_UNPACK_ALIGNMENT, 1)); + lv_egl_native_window_properties_t properties = { .visual_id = native_config_id }; - GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 20)); - GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST)); - GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)); - - GL_CALL(glBindTexture(GL_TEXTURE_2D, 0)); + void * native_window = ctx->interface.create_window_cb(ctx->interface.driver_data, &properties); + if(!native_window) { + LV_LOG_ERROR("Faield to create window"); + lv_free(mods); + return NULL; + } + lv_free(mods); + return native_window; +} + +static lv_result_t get_native_config(lv_opengles_egl_t * ctx, EGLint * native_id, uint64_t ** mods, size_t * count) +{ + EGLint num_mods; + + if(!eglGetConfigAttrib(ctx->egl_display, ctx->egl_config, EGL_NATIVE_VISUAL_ID, native_id)) { + LV_LOG_ERROR("Failed to get native visual id for egl config"); + return LV_RESULT_INVALID; + } + return LV_RESULT_OK; + + if(!eglQueryDmaBufModifiersEXT || !eglQueryDmaBufModifiersEXT(ctx->egl_display, *native_id, 0, NULL, NULL, &num_mods)) { + LV_LOG_WARN("Failed to get native modifiers"); + return LV_RESULT_OK; + } + + if(num_mods <= 0) { + LV_LOG_INFO("No native modifiers"); + return LV_RESULT_OK; + } + + *mods = lv_malloc(num_mods * sizeof(*mods)); + LV_ASSERT_MALLOC(mods); + eglQueryDmaBufModifiersEXT(ctx->egl_display, *native_id, num_mods, *mods, NULL, &num_mods); + if(*mods[0] == 0) { + lv_free(mods); + return LV_RESULT_OK; + } + *count = (size_t) num_mods; + return LV_RESULT_OK; } -#endif #endif /*LV_USE_EGL*/ diff --git a/src/drivers/opengles/lv_opengles_egl.h b/src/drivers/opengles/lv_opengles_egl.h index 5d4055ff86..b32ade9152 100644 --- a/src/drivers/opengles/lv_opengles_egl.h +++ b/src/drivers/opengles/lv_opengles_egl.h @@ -10,16 +10,16 @@ extern "C" { #endif +/********************* + * INCLUDES + *********************/ #include "../../lv_conf_internal.h" - #if LV_USE_EGL #include "../../misc/lv_types.h" +#include "../../misc/lv_color.h" -/********************* - * INCLUDES - *********************/ /********************* * DEFINES @@ -29,40 +29,26 @@ extern "C" { * TYPEDEFS **********************/ -typedef void (*lv_opengles_egl_window_cb_t)(lv_opengles_window_t * window); +typedef struct _lv_opengles_egl lv_opengles_egl_t; +typedef struct _lv_egl_interface lv_egl_interface_t; +typedef struct _lv_egl_config lv_egl_config_t; /********************** * GLOBAL PROTOTYPES **********************/ -/** - * Create an EGL OpenGL window with no textures. OpenGL should be initialized beforehand. - * @param hor_res width in pixels of the window - * @param ver_res height in pixels of the window - * @param native_window_handle a handle to a native window for the platform - * @param device a `EGLNativeDisplayType` - * @param pre called before rendering - * @param post1 called after rendering, before swapping - * @param post2 called after swapping - * @return the new EGL OpenGL window handle - */ -lv_opengles_window_t * lv_opengles_egl_window_create(int32_t hor_res, int32_t ver_res, void * native_window_handle, - void * device, - lv_opengles_egl_window_cb_t pre, - lv_opengles_egl_window_cb_t post1, - lv_opengles_egl_window_cb_t post2); +lv_opengles_egl_t * lv_opengles_egl_context_create(const lv_egl_interface_t * interface); +lv_color_format_t lv_opengles_egl_color_format_from_egl_config(const lv_egl_config_t * config); -void * lv_opengles_egl_window_get_surface(lv_opengles_window_t * window); -void * lv_opengles_egl_window_get_display(lv_opengles_window_t * window); -void lv_opengles_egl_window_set_user_data(lv_opengles_window_t * window, void * user_data); -void * lv_opengles_egl_window_get_user_data(lv_opengles_window_t * window); +void lv_opengles_egl_update(lv_opengles_egl_t * ctx); +void lv_opengles_egl_clear(lv_opengles_egl_t * ctx); +void lv_opengles_egl_context_destroy(lv_opengles_egl_t * ctx); /********************** * MACROS **********************/ #endif /*LV_USE_EGL*/ - #ifdef __cplusplus } /*extern "C"*/ #endif diff --git a/src/drivers/opengles/lv_opengles_egl_private.h b/src/drivers/opengles/lv_opengles_egl_private.h new file mode 100644 index 0000000000..78969e399f --- /dev/null +++ b/src/drivers/opengles/lv_opengles_egl_private.h @@ -0,0 +1,102 @@ +/** + * @file lv_opengles_egl_private.h + * + */ + +#ifndef LV_OPENGLES_EGL_PRIVATE_H +#define LV_OPENGLES_EGL_PRIVATE_H + +#ifdef __cplusplus +extern "C" { +#endif + +/********************* + * INCLUDES + *********************/ +#include "../../lv_conf_internal.h" + +#if LV_USE_EGL + +#include "../../misc/lv_types.h" +#include "../../misc/lv_color.h" +#include "lv_opengles_private.h" +#include "lv_opengles_egl.h" + + +/********************* + * DEFINES + *********************/ + +/********************** + * TYPEDEFS + **********************/ + +struct _lv_egl_config { + EGLint id; + EGLint max_width; + EGLint max_height; + EGLint buffer_size; + EGLint depth; + EGLint stencil; + EGLint samples; + EGLint surface_type; + EGLint r_bits; + EGLint g_bits; + EGLint b_bits; + EGLint a_bits; +}; + +typedef struct { + EGLint visual_id; +} lv_egl_native_window_properties_t; + +typedef void * (*lv_egl_init_display_t)(void * driver_data, int32_t width, int32_t height); +typedef void * (*lv_egl_get_display_t)(void * driver_data); +typedef void * (*lv_create_window_t)(void * driver_data, const lv_egl_native_window_properties_t * props); +typedef void (*lv_destroy_window_t)(void * driver_data, void * native_window); + +typedef void (*lv_egl_set_visible_t)(void * driver_data, bool v); +typedef void (*lv_egl_flip_t)(void * driver_data, bool vsync); +typedef void (*lv_egl_native_state_deinit_t)(void ** driver_data); +typedef size_t (*lv_egl_select_config_t)(void * driver_data, const lv_egl_config_t * configs, + size_t config_count); + +struct _lv_egl_interface { + lv_egl_select_config_t select_config; + void * driver_data; + void * native_display; + uint16_t egl_platform; + lv_create_window_t create_window_cb; + lv_destroy_window_t destroy_window_cb; + lv_egl_flip_t flip_cb; +}; + + +struct _lv_opengles_egl { + EGLNativeWindowType native_window; + EGLDisplay egl_display; + EGLConfig egl_config; + EGLContext egl_context; + EGLSurface egl_surface; + void * egl_lib_handle; + void * opengl_lib_handle; + lv_egl_interface_t interface; + int32_t width; + int32_t height; + bool vsync; +}; + +/********************** + * GLOBAL PROTOTYPES + **********************/ + +/********************** + * MACROS + **********************/ + +#endif /*LV_USE_EGL*/ +#ifdef __cplusplus +} /*extern "C"*/ +#endif + +#endif /*LV_OPENGLES_EGL_PRIVATE_H*/ diff --git a/src/drivers/opengles/lv_opengles_private.h b/src/drivers/opengles/lv_opengles_private.h index 7638557249..fc7c53cd6d 100644 --- a/src/drivers/opengles/lv_opengles_private.h +++ b/src/drivers/opengles/lv_opengles_private.h @@ -18,11 +18,8 @@ extern "C" { #if LV_USE_OPENGLES #if LV_USE_EGL -#include -#include -#include -#include -#include +#include "glad/include/glad/gles2.h" +#include "glad/include/glad/egl.h" #else /* For now, by default we add glew and glfw. In the future we need to consider adding a config for setting these includes*/ @@ -40,9 +37,25 @@ extern "C" { #define GL_BGRA GL_BGRA_EXT #endif /*GL_BGRA*/ -#ifndef GL_BGR -#define GL_BGR GL_BGR_EXT -#endif /*GL_BGR*/ +#ifndef GL_TEXTURE_MAX_LEVEL +#define GL_TEXTURE_MAX_LEVEL GL_TEXTURE_MAX_LEVEL_APPLE +#endif /*GL_TEXTURE_MAX_LEVEL*/ + +#ifndef GL_UNPACK_ROW_LENGTH +#define GL_UNPACK_ROW_LENGTH GL_UNPACK_ROW_LENGTH_EXT +#endif /*GL_UNPACK_ROW_LENGTH*/ + +#ifndef glGenVertexArrays +#define glGenVertexArrays glGenVertexArraysOES +#endif + +#ifndef glBindVertexArray +#define glBindVertexArray glBindVertexArrayOES +#endif + +#ifndef glDeleteVertexArrays +#define glDeleteVertexArrays glDeleteVertexArraysOES +#endif /********************** * TYPEDEFS diff --git a/src/drivers/opengles/lv_opengles_texture.c b/src/drivers/opengles/lv_opengles_texture.c index c55bcffa69..c5b460db52 100644 --- a/src/drivers/opengles/lv_opengles_texture.c +++ b/src/drivers/opengles/lv_opengles_texture.c @@ -11,9 +11,12 @@ #if LV_USE_OPENGLES #include "lv_opengles_debug.h" -#include "lv_opengles_private.h" - #include "lv_opengles_driver.h" + +#include "../../misc/lv_types.h" +#include "../../stdlib/lv_mem.h" +#include "lv_opengles_private.h" +#include "lv_opengles_texture_private.h" #include "../../display/lv_display_private.h" #include @@ -26,14 +29,6 @@ * TYPEDEFS **********************/ -typedef struct { - unsigned int texture_id; -#if !LV_USE_DRAW_OPENGLES - uint8_t * fb1; -#endif /*!LV_USE_DRAW_OPENGLES*/ - bool is_texture_owner; -} lv_opengles_texture_t; - /********************** * STATIC PROTOTYPES **********************/ @@ -55,11 +50,11 @@ static void release_disp_cb(lv_event_t * e); * GLOBAL FUNCTIONS **********************/ - lv_display_t * lv_opengles_texture_create(int32_t w, int32_t h) { lv_display_t * disp = lv_opengles_texture_create_common(w, h); if(!disp) { + LV_LOG_ERROR("Failed to create display"); return NULL; } lv_opengles_texture_t * dsc = lv_display_get_driver_data(disp); @@ -73,6 +68,7 @@ lv_display_t * lv_opengles_texture_create_from_texture_id(int32_t w, int32_t h, { lv_display_t * disp = lv_opengles_texture_create_common(w, h); if(!disp) { + LV_LOG_ERROR("Failed to create display"); return NULL; } lv_opengles_texture_t * dsc = lv_display_get_driver_data(disp); @@ -81,6 +77,66 @@ lv_display_t * lv_opengles_texture_create_from_texture_id(int32_t w, int32_t h, return disp; } +void lv_opengles_texture_reshape(lv_display_t * disp, int32_t width, int32_t height) +{ + lv_opengles_texture_t * dsc = lv_display_get_driver_data(disp); + unsigned int new_texture = create_texture(width, height); + if(new_texture == GL_NONE) { + LV_LOG_ERROR("Failed to reshape texture. Couldn't acquire new texture from GPU"); + return; + } +#if !LV_USE_DRAW_OPENGLES + uint32_t stride = lv_draw_buf_width_to_stride(width, lv_display_get_color_format(disp)); + uint32_t buf_size = stride * height; + uint8_t * buffer = lv_realloc(dsc->fb1, buf_size); + LV_ASSERT_MALLOC(buffer); + if(!buffer) { + GL_CALL(glDeleteTextures(1, &new_texture)); + LV_LOG_ERROR("Failed to reshape texture. Couldn't resize buffer"); + return; + } + dsc->fb1 = buffer; +#endif /*!LV_USE_DRAW_OPENGLES*/ + + if(dsc->is_texture_owner && dsc->texture_id != 0) { + GL_CALL(glDeleteTextures(1, &dsc->texture_id)); + } + dsc->texture_id = new_texture; +} + +lv_result_t lv_opengles_texture_create_draw_buffers(lv_opengles_texture_t * texture, lv_display_t * display) +{ + int32_t w = lv_display_get_horizontal_resolution(display); + int32_t h = lv_display_get_vertical_resolution(display); + +#if LV_USE_DRAW_OPENGLES + LV_UNUSED(texture); + static size_t LV_ATTRIBUTE_MEM_ALIGN dummy_buf; + lv_display_set_buffers(display, &dummy_buf, NULL, w * h * 4, LV_DISPLAY_RENDER_MODE_DIRECT); +#else + uint32_t stride = lv_draw_buf_width_to_stride(w, lv_display_get_color_format(display)); + uint32_t buf_size = stride * h; + texture->fb1 = lv_malloc(buf_size); + LV_ASSERT_MALLOC(texture->fb1); + if(!texture->fb1) { + return LV_RESULT_INVALID; + } + lv_display_set_buffers(display, texture->fb1, NULL, buf_size, LV_DISPLAY_RENDER_MODE_DIRECT); +#endif + return LV_RESULT_OK; +} + +void lv_opengles_texture_deinit(lv_opengles_texture_t * texture) +{ +#if !LV_USE_DRAW_OPENGLES + lv_free(texture->fb1); +#endif /*!LV_USE_DRAW_OPENGLES*/ + + if(texture->is_texture_owner && texture->texture_id != 0) { + GL_CALL(glDeleteTextures(1, &texture->texture_id)); + } +} + unsigned int lv_opengles_texture_get_texture_id(lv_display_t * disp) { lv_opengles_texture_t * dsc = lv_display_get_driver_data(disp); @@ -106,34 +162,29 @@ lv_display_t * lv_opengles_texture_get_from_texture_id(unsigned int texture_id) static lv_display_t * lv_opengles_texture_create_common(int32_t w, int32_t h) { lv_display_t * disp = lv_display_create(w, h); - if(disp == NULL) { + if(!disp) { + LV_LOG_ERROR("Failed to create display"); return NULL; } - lv_opengles_texture_t * dsc = lv_malloc_zeroed(sizeof(lv_opengles_texture_t)); - LV_ASSERT_MALLOC(dsc); - if(dsc == NULL) { + lv_opengles_texture_t * texture = lv_malloc_zeroed(sizeof(lv_opengles_texture_t)); + LV_ASSERT_MALLOC(texture); + if(!texture) { + LV_LOG_ERROR("Failed to create texture"); lv_display_delete(disp); return NULL; } - -#if LV_USE_DRAW_OPENGLES - static size_t LV_ATTRIBUTE_MEM_ALIGN dummy_buf; - lv_display_set_buffers(disp, &dummy_buf, NULL, w * h * 4, LV_DISPLAY_RENDER_MODE_DIRECT); -#else - uint32_t stride = lv_draw_buf_width_to_stride(w, lv_display_get_color_format(disp)); - uint32_t buf_size = stride * h; - dsc->fb1 = malloc(buf_size); - LV_ASSERT_MALLOC(dsc->fb1); - if(dsc->fb1 == NULL) { - lv_free(dsc); + lv_result_t res = lv_opengles_texture_create_draw_buffers(texture, disp); + if(res != LV_RESULT_OK) { + LV_LOG_ERROR("Failed to create draw buffers"); + lv_free(texture); lv_display_delete(disp); return NULL; } - lv_display_set_buffers(disp, dsc->fb1, NULL, buf_size, LV_DISPLAY_RENDER_MODE_DIRECT); -#endif + lv_display_set_resolution(disp, w, h); lv_display_set_flush_cb(disp, flush_cb); - lv_display_set_driver_data(disp, dsc); + lv_display_set_driver_data(disp, texture); lv_display_add_event_cb(disp, release_disp_cb, LV_EVENT_DELETE, disp); + lv_opengles_init(); return disp; } @@ -150,27 +201,32 @@ static unsigned int create_texture(int32_t w, int32_t h) GL_CALL(glPixelStorei(GL_UNPACK_ALIGNMENT, 1)); /* set the dimensions and format to complete the texture */ - /* Color depth: 8 (L8), 16 (RGB565), 24 (RGB888), 32 (XRGB8888) */ -#if LV_COLOR_DEPTH == 8 - GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, w, h, 0, GL_RED, GL_UNSIGNED_BYTE, NULL)); -#elif LV_COLOR_DEPTH == 16 + /* Color depth: 16 (RGB565), 32 (XRGB8888) */ +#if LV_COLOR_DEPTH == 16 GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB565, w, h, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, NULL)); -#elif LV_COLOR_DEPTH == 24 - GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_BGR, GL_UNSIGNED_BYTE, NULL)); #elif LV_COLOR_DEPTH == 32 GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL)); #else #error("Unsupported color format") #endif +#if 0 GL_CALL(glGenerateMipmap(GL_TEXTURE_2D)); GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 20)); GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST)); - GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)); - return texture; +#endif + GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)); + GL_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)); + GL_CALL(glBindTexture(GL_TEXTURE_2D, GL_NONE)); + return texture; } + +/********************** + * STATIC FUNCTIONS + **********************/ + static void flush_cb(lv_display_t * disp, const lv_area_t * area, uint8_t * px_map) { LV_UNUSED(area); @@ -187,14 +243,10 @@ static void flush_cb(lv_display_t * disp, const lv_area_t * area, uint8_t * px_m GL_CALL(glPixelStorei(GL_UNPACK_ALIGNMENT, 1)); GL_CALL(glPixelStorei(GL_UNPACK_ROW_LENGTH, stride / lv_color_format_get_size(cf))); - /*Color depth: 8 (L8), 16 (RGB565), 24 (RGB888), 32 (XRGB8888)*/ -#if LV_COLOR_DEPTH == 8 - GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, disp->hor_res, disp->ver_res, 0, GL_RED, GL_UNSIGNED_BYTE, dsc->fb1)); -#elif LV_COLOR_DEPTH == 16 + /*Color depth: 16 (RGB565), 32 (XRGB8888)*/ +#if LV_COLOR_DEPTH == 16 GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB565, disp->hor_res, disp->ver_res, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, dsc->fb1)); -#elif LV_COLOR_DEPTH == 24 - GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, disp->hor_res, disp->ver_res, 0, GL_BGR, GL_UNSIGNED_BYTE, dsc->fb1)); #elif LV_COLOR_DEPTH == 32 GL_CALL(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, disp->hor_res, disp->ver_res, 0, GL_BGRA, GL_UNSIGNED_BYTE, dsc->fb1)); #else @@ -209,14 +261,9 @@ static void flush_cb(lv_display_t * disp, const lv_area_t * area, uint8_t * px_m static void release_disp_cb(lv_event_t * e) { lv_display_t * disp = lv_event_get_user_data(e); - lv_opengles_texture_t * dsc = lv_display_get_driver_data(disp); -#if !LV_USE_DRAW_OPENGLES - free(dsc->fb1); -#endif /*!LV_USE_DRAW_OPENGLES*/ - if(dsc->is_texture_owner) { - GL_CALL(glDeleteTextures(1, &dsc->texture_id)); - } - lv_free(dsc); + lv_opengles_texture_t * texture = lv_display_get_driver_data(disp); + lv_opengles_texture_deinit(texture); + lv_free(texture); } #endif /*LV_USE_OPENGLES*/ diff --git a/src/drivers/opengles/lv_opengles_texture_private.h b/src/drivers/opengles/lv_opengles_texture_private.h new file mode 100644 index 0000000000..47c7a74b56 --- /dev/null +++ b/src/drivers/opengles/lv_opengles_texture_private.h @@ -0,0 +1,57 @@ +/** + * @file lv_opengles_texture_private.h + * + */ + + +#ifndef LV_OPENGLES_TEXTURE_PRIVATE_H +#define LV_OPENGLES_TEXTURE_PRIVATE_H + +#ifdef __cplusplus +extern "C" { +#endif + +/********************* + * INCLUDES + *********************/ +#include "../../lv_conf_internal.h" + +#if LV_USE_OPENGLES + +#include "lv_opengles_texture.h" + +/********************* + * DEFINES + *********************/ + +/********************** + * TYPEDEFS + **********************/ + +typedef struct { + unsigned int texture_id; +#if !LV_USE_DRAW_OPENGLES + uint8_t * fb1; +#endif /*!LV_USE_DRAW_OPENGLES*/ + bool is_texture_owner; +} lv_opengles_texture_t; + +/********************** + * GLOBAL PROTOTYPES + **********************/ + +lv_result_t lv_opengles_texture_create_draw_buffers(lv_opengles_texture_t * texture, lv_display_t * display); +void lv_opengles_texture_reshape(lv_display_t * disp, int32_t width, int32_t height); +void lv_opengles_texture_deinit(lv_opengles_texture_t * texture); + +/********************** + * MACROS + **********************/ + +#endif /*LV_USE_OPENGLES*/ + +#ifdef __cplusplus +} /*extern "C"*/ +#endif + +#endif /* LV_OPENGLES_TEXTURE_PRIVATE_H */ diff --git a/src/drivers/opengles/opengl_shader/lv_opengl_shader_program.c b/src/drivers/opengles/opengl_shader/lv_opengl_shader_program.c index 0dfd9385f7..5d94bd79fc 100644 --- a/src/drivers/opengles/opengl_shader/lv_opengl_shader_program.c +++ b/src/drivers/opengles/opengl_shader/lv_opengl_shader_program.c @@ -19,6 +19,8 @@ * DEFINES *********************/ +#define INVALID_LOCATION 0xFFFFFFFFu + /********************** * TYPEDEFS **********************/ @@ -87,14 +89,15 @@ GLuint lv_opengl_shader_program_get_id(lv_opengl_shader_program_t * program) * STATIC FUNCTIONS **********************/ + static void update_uniform_1i(lv_opengl_shader_program_t * program, const char * prop, int value) { GLuint location = glGetUniformLocation(program->id, prop); - LV_ASSERT_FORMAT_MSG(location != GL_INVALID_INDEX, + LV_ASSERT_FORMAT_MSG(location != INVALID_LOCATION, "Uniform '%s' not found in program %d", prop, program->id); - if(location == GL_INVALID_INDEX) { + if(location == INVALID_LOCATION) { LV_LOG_ERROR("Uniform '%s' not found in program %d", prop, program->id); return; @@ -107,10 +110,10 @@ static void update_uniform_1f(lv_opengl_shader_program_t * program, const char * { GLuint location = glGetUniformLocation(program->id, prop); - LV_ASSERT_FORMAT_MSG(location != GL_INVALID_INDEX, + LV_ASSERT_FORMAT_MSG(location != INVALID_LOCATION, "Uniform '%s' not found in program %d", prop, program->id); - if(location == GL_INVALID_INDEX) { + if(location == INVALID_LOCATION) { LV_LOG_ERROR("Uniform '%s' not found in program %d", prop, program->id); return; diff --git a/src/libs/gltf/gltf_view/assets/lv_gltf_view_shader.c b/src/libs/gltf/gltf_view/assets/lv_gltf_view_shader.c index 2c8187edde..9e1df4e7e6 100644 --- a/src/libs/gltf/gltf_view/assets/lv_gltf_view_shader.c +++ b/src/libs/gltf/gltf_view/assets/lv_gltf_view_shader.c @@ -6,7 +6,8 @@ #include static const lv_opengl_shader_t src_includes[] = { - { "tonemapping.glsl", R"( + { + "tonemapping.glsl", R"( uniform float u_Exposure; @@ -145,8 +146,10 @@ static const lv_opengl_shader_t src_includes[] = { return linearTosRGB(color); } - )" }, - { "textures1.glsl", R"( + )" + }, + { + "textures1.glsl", R"( // IBL @@ -272,8 +275,10 @@ static const lv_opengl_shader_t src_includes[] = { #endif #endif - )" }, - { "textures2.glsl", R"( + )" + }, + { + "textures2.glsl", R"( // Specular Glossiness Material @@ -374,8 +379,10 @@ static const lv_opengl_shader_t src_includes[] = { uniform int u_SheenRoughnessUVSet; uniform mat3 u_SheenRoughnessUVTransform; - )" }, - { "textures3.glsl", R"( + )" + }, + { + "textures3.glsl", R"( vec2 getSheenColorUV() { vec3 uv = vec3(u_SheenColorUVSet < 1 ? v_texcoord_0 : v_texcoord_1, 1.0); @@ -465,8 +472,10 @@ static const lv_opengl_shader_t src_includes[] = { uniform mat3 u_ThicknessUVTransform; - )" }, - { "textures4.glsl", R"( + )" + }, + { + "textures4.glsl", R"( vec2 getThicknessUV() { vec3 uv = vec3(u_ThicknessUVSet < 1 ? v_texcoord_0 : v_texcoord_1, 1.0); @@ -566,8 +575,10 @@ static const lv_opengl_shader_t src_includes[] = { #endif - )" }, - { "functions.glsl", R"( + )" + }, + { + "functions.glsl", R"( const float M_PI = 3.141592653589793; @@ -663,8 +674,10 @@ static const lv_opengl_shader_t src_includes[] = { } - )" }, - { "brdf1.glsl", R"( + )" + }, + { + "brdf1.glsl", R"( // // Fresnel // @@ -732,8 +745,10 @@ static const lv_opengl_shader_t src_includes[] = { return Schlick_to_F0(f, 1.0, VdotH); } - )" }, - { "brdf2.glsl", R"( + )" + }, + { + "brdf2.glsl", R"( // Smith Joint GGX // Note: Vis = G / (4 * NdotL * NdotV) // see Eric Heitz. 2014. Understanding the Masking-Shadowing Function in Microfacet-Based BRDFs. Journal of Computer Graphics Techniques, 3 @@ -814,8 +829,10 @@ static const lv_opengl_shader_t src_includes[] = { float sin2h = 1.0 - cos2h; return (2.0 + invR) * pow(sin2h, invR * 0.5) / (2.0 * M_PI); } - )" }, - { "brdf3.glsl", R"( + )" + }, + { + "brdf3.glsl", R"( //https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#acknowledgments AppendixB vec3 BRDF_lambertian(vec3 diffuseColor) @@ -880,8 +897,10 @@ static const lv_opengl_shader_t src_includes[] = { float sheenVisibility = V_Sheen(NdotL, NdotV, sheenRoughness); return sheenColor * sheenDistribution * sheenVisibility; } - )" }, - { "punctual1.glsl", R"( + )" + }, + { + "punctual1.glsl", R"( struct Light { vec3 direction; @@ -947,8 +966,10 @@ static const lv_opengl_shader_t src_includes[] = { return rangeAttenuation * spotAttenuation * light.intensity * light.color; } - )" }, - { "punctual2.glsl", R"( + )" + }, + { + "punctual2.glsl", R"( vec3 getPunctualRadianceTransmission(vec3 normal, vec3 view, vec3 pointToLight, float alphaRoughness, vec3 baseColor, float ior) { @@ -1008,8 +1029,10 @@ static const lv_opengl_shader_t src_includes[] = { return normalize(refractionVector) * thickness * modelScale; } - )" }, - { "ibl1.glsl", R"( + )" + }, + { + "ibl1.glsl", R"( uniform float u_EnvIntensity; @@ -1083,8 +1106,10 @@ static const lv_opengl_shader_t src_includes[] = { vec3 getIBLVolumeRefraction(vec3 n, vec3 v, float perceptualRoughness, vec3 baseColor, vec3 position, mat4 modelMatrix, mat4 viewMatrix, mat4 projMatrix, float ior, float thickness, vec3 attenuationColor, float attenuationDistance, float dispersion) { - )" }, - { "ibl2.glsl", R"( + )" + }, + { + "ibl2.glsl", R"( #ifdef MATERIAL_DISPERSION // Dispersion will spread out the ior values for each r,g,b channel @@ -1169,8 +1194,10 @@ static const lv_opengl_shader_t src_includes[] = { return sheenLight * sheenColor * brdf; } - )" }, - { "material_info1.glsl", R"( + )" + }, + { + "material_info1.glsl", R"( // Metallic Roughness uniform float u_MetallicFactor; @@ -1270,8 +1297,10 @@ static const lv_opengl_shader_t src_includes[] = { float specularWeight; // product of specularFactor and specularTexture.a float transmissionFactor; - )" }, - { "material_info2.glsl", R"( + )" + }, + { + "material_info2.glsl", R"( float thickness; vec3 attenuationColor; float attenuationDistance; @@ -1375,8 +1404,10 @@ static const lv_opengl_shader_t src_includes[] = { } #endif - )" }, - { "material_info3.glsl", R"( + )" + }, + { + "material_info3.glsl", R"( vec4 getBaseColor() { vec4 baseColor = u_BaseColorFactor; @@ -1474,8 +1505,10 @@ static const lv_opengl_shader_t src_includes[] = { return info; } #endif - )" }, - { "material_info4.glsl", R"( + )" + }, + { + "material_info4.glsl", R"( #ifdef MATERIAL_VOLUME MaterialInfo getVolumeInfo(MaterialInfo info) { @@ -1531,8 +1564,10 @@ static const lv_opengl_shader_t src_includes[] = { return info; } #endif - )" }, - { "material_info5.glsl", R"( + )" + }, + { + "material_info5.glsl", R"( #ifdef MATERIAL_CLEARCOAT MaterialInfo getClearCoatInfo(MaterialInfo info, NormalInfo normalInfo) @@ -1596,8 +1631,10 @@ static const lv_opengl_shader_t src_includes[] = { return texture(u_SheenELUT, vec2(NdotV, sheenRoughnessFactor)).r; } - )" }, - { "iridescence.glsl", R"( + )" + }, + { + "iridescence.glsl", R"( const mat3 XYZ_TO_REC709 = mat3( 3.2404542, -0.9692660, 0.0556434, -1.5371385, 1.8760108, -0.2040259, @@ -1690,8 +1727,10 @@ static const lv_opengl_shader_t src_includes[] = { // Since out of gamut colors might be produced, negative color values are clamped to 0. return max(I, vec3(0.0)); } - )" }, - { "animation1.glsl", R"( + )" + }, + { + "animation1.glsl", R"( #ifdef HAS_MORPH_TARGETS uniform highp sampler2DArray u_MorphTargetsSampler; @@ -1792,8 +1831,10 @@ static const lv_opengl_shader_t src_includes[] = { #endif // !USE_SKINNING - )" }, - { "animation2.glsl", R"( + )" + }, + { + "animation2.glsl", R"( #ifdef USE_MORPHING #ifdef HAS_MORPH_TARGETS @@ -1905,8 +1946,10 @@ static const lv_opengl_shader_t src_includes[] = { } #endif // !USE_MORPHING - )" }, - { "vert_v1_chunk_00.glsl", R"( + )" + }, + { + "vert_v1_chunk_00.glsl", R"( #ifdef HAS_NORMAL_VEC3 in vec3 a_normal; @@ -1993,8 +2036,10 @@ static const lv_opengl_shader_t src_includes[] = { tangent += getTargetTangent(gl_VertexID); #endif - )" }, - { "vert_v1_chunk_01.glsl", R"( + )" + }, + { + "vert_v1_chunk_01.glsl", R"( #ifdef USE_SKINNING tangent = mat3(getSkinningMatrix()) * tangent; #endif @@ -2090,8 +2135,10 @@ static const lv_opengl_shader_t src_includes[] = { gl_Position = u_ViewProjectionMatrix * pos; } - )" }, - { "frag_v1_chunk_00.glsl", R"( + )" + }, + { + "frag_v1_chunk_00.glsl", R"( out vec4 g_finalColor; void main() { @@ -2140,8 +2187,10 @@ static const lv_opengl_shader_t src_includes[] = { #ifdef MATERIAL_SHEEN materialInfo = getSheenInfo(materialInfo); #endif - )" }, - { "frag_v1_chunk_01a.glsl", R"( + )" + }, + { + "frag_v1_chunk_01a.glsl", R"( #ifdef MATERIAL_CLEARCOAT materialInfo = getClearCoatInfo(materialInfo, normalInfo); @@ -2193,8 +2242,10 @@ static const lv_opengl_shader_t src_includes[] = { float clearcoatFactor = 0.0; vec3 clearcoatFresnel = vec3(0); - )" }, - { "frag_v1_chunk_01b.glsl", R"( + )" + }, + { + "frag_v1_chunk_01b.glsl", R"( float albedoSheenScaling = 1.0; float diffuseTransmissionThickness = 1.0; @@ -2242,8 +2293,10 @@ static const lv_opengl_shader_t src_includes[] = { materialInfo.ior, materialInfo.thickness, materialInfo.attenuationColor, materialInfo.attenuationDistance, materialInfo.dispersion); f_diffuse = mix(f_diffuse, f_specular_transmission, materialInfo.transmissionFactor); #endif - )" }, - { "frag_v1_chunk_02a.glsl", R"( + )" + }, + { + "frag_v1_chunk_02a.glsl", R"( #ifdef MATERIAL_ANISOTROPY f_specular_metal = getIBLRadianceAnisotropy(n, v, materialInfo.perceptualRoughness, materialInfo.anisotropyStrength, materialInfo.anisotropicB); @@ -2300,8 +2353,10 @@ static const lv_opengl_shader_t src_includes[] = { f_diffuse = vec3(0.0); - )" }, - { "frag_v1_chunk_02b.glsl", R"( + )" + }, + { + "frag_v1_chunk_02b.glsl", R"( f_specular_dielectric = vec3(0.0); f_specular_metal = vec3(0.0); @@ -2336,8 +2391,10 @@ static const lv_opengl_shader_t src_includes[] = { // const Type_Point = 1; // const Type_Spot = 2; ); - )" }, - { "frag_v1_chunk_03a.glsl", R"( + )" + }, + { + "frag_v1_chunk_03a.glsl", R"( u_Lights[1] = temp_keylight; u_Lights[2] = temp_filllight; @@ -2398,8 +2455,10 @@ static const lv_opengl_shader_t src_includes[] = { #endif // MATERIAL_DIFFUSE_TRANSMISSION //temp_origBaseColor.rgb = vec3(l_diffuse); - )" }, - { "frag_v1_chunk_03b.glsl", R"( + )" + }, + { + "frag_v1_chunk_03b.glsl", R"( // BTDF (Bidirectional Transmittance Distribution Function) #ifdef MATERIAL_TRANSMISSION // If the light ray travels through the geometry, use the point it exits the geometry again. @@ -2455,8 +2514,10 @@ static const lv_opengl_shader_t src_includes[] = { color += l_color; } #endif // USE_PUNCTUAL - )" }, - { "frag_v1_chunk_04.glsl", R"( + )" + }, + { + "frag_v1_chunk_04.glsl", R"( f_emissive = u_EmissiveFactor; #ifdef MATERIAL_EMISSIVE_STRENGTH f_emissive *= u_EmissiveStrength; @@ -2558,8 +2619,10 @@ static const lv_opengl_shader_t src_includes[] = { #if DEBUG == DEBUG_BASE_COLOR g_finalColor.rgb = linearTosRGB(materialInfo.baseColor); #endif - )" }, - { "frag_v1_chunk_05.glsl", R"( + )" + }, + { + "frag_v1_chunk_05.glsl", R"( // Clearcoat: #ifdef MATERIAL_CLEARCOAT #if DEBUG == DEBUG_CLEARCOAT_FACTOR @@ -2650,9 +2713,11 @@ static const lv_opengl_shader_t src_includes[] = { #endif */ } - )" }, + )" + }, - { "cubemap.vert", R"( + { + "cubemap.vert", R"( uniform mat4 u_ViewProjectionMatrix; uniform mat3 u_EnvRotation; @@ -2667,8 +2732,10 @@ static const lv_opengl_shader_t src_includes[] = { vec4 pos = mat * vec4(a_position, 1.0); gl_Position = pos.xyww; } - )" }, - { "cubemap.frag", R"( + )" + }, + { + "cubemap.frag", R"( precision highp float; #include uniform float u_EnvIntensity; @@ -2693,11 +2760,13 @@ static const lv_opengl_shader_t src_includes[] = { #endif } - )" }, + )" + }, }; static const lv_opengl_shader_t env_src_includes[] = { - { "fullscreen.vert", R"( + { + "fullscreen.vert", R"( precision highp float; out vec2 texCoord; @@ -2710,8 +2779,10 @@ static const lv_opengl_shader_t env_src_includes[] = { texCoord.y = y * 0.5; gl_Position = vec4(x - 1.0, y - 1.0, 0, 1); } - )" }, - { "panorama_to_cubemap.frag", R"( + )" + }, + { + "panorama_to_cubemap.frag", R"( #define MATH_PI 3.1415926535897932384626433832795 #define MATH_INV_PI (1.0 / MATH_PI) @@ -2768,16 +2839,20 @@ static const lv_opengl_shader_t env_src_includes[] = { fragmentColor.rgb = panoramaToCubeMap(u_currentFace, texCoord); } - )" }, - { "ibl_filtering.frag", R"( + )" + }, + { + "ibl_filtering.frag", R"( #include #include #include #include #include #include - )" }, - { "ibl_filtering1.glsl", R"( + )" + }, + { + "ibl_filtering1.glsl", R"( //#version 450 //#extension GL_ARB_separate_shader_objects : enable @@ -2864,8 +2939,10 @@ static const lv_opengl_shader_t env_src_includes[] = { bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u); return float(bits) * 2.3283064365386963e-10; // / 0x100000000 } - )" }, - { "ibl_filtering2.glsl", R"( + )" + }, + { + "ibl_filtering2.glsl", R"( // hammersley2d describes a sequence of points in the 2d unit square [0,1)^2 // that can be used for quasi Monte Carlo integration vec2 hammersley2d(int i, int N) { @@ -2955,8 +3032,10 @@ static const lv_opengl_shader_t env_src_includes[] = { float cot2 = -cos2h / (a2 * sin2h); return 1.0 / (MATH_PI * (4.0 * a2 + 1.0) * sin4h) * (4.0 * exp(cot2) + sin4h); } - )" }, - { "ibl_filtering3.glsl", R"( + )" + }, + { + "ibl_filtering3.glsl", R"( // NDF float D_Charlie(float sheenRoughness, float NdotH) { @@ -3039,8 +3118,10 @@ static const lv_opengl_shader_t env_src_includes[] = { return vec4(direction, importanceSample.pdf); } - )" }, - { "ibl_filtering4.glsl", R"( + )" + }, + { + "ibl_filtering4.glsl", R"( // Mipmap Filtered Samples (GPU Gems 3, 20.4) // https://developer.nvidia.com/gpugems/gpugems3/part-iii-rendering/chapter-20-gpu-based-importance-sampling // https://cgg.mff.cuni.cz/~jaroslav/papers/2007-sketch-fis/Final_sap_0073.pdf @@ -3135,8 +3216,10 @@ static const lv_opengl_shader_t env_src_includes[] = { return color.rgb ; } - )" }, - { "ibl_filtering5.glsl", R"( + )" + }, + { + "ibl_filtering5.glsl", R"( // From the filament docs. Geometric Shadowing function // https://google.github.io/filament/Filament.html#toc4.4.2 float V_SmithGGXCorrelated(float NoV, float NoL, float roughness) { @@ -3216,8 +3299,10 @@ static const lv_opengl_shader_t env_src_includes[] = { // Since the BRDF divide through the PDF to be normalized, the 4 can be pulled out of the integral. return vec3(4.0 * A, 4.0 * B, 4.0 * 2.0 * MATH_PI * C) / float(u_sampleCount); } - )" }, - { "ibl_filtering6.glsl", R"( + )" + }, + { + "ibl_filtering6.glsl", R"( // entry point @@ -3256,8 +3341,10 @@ static const lv_opengl_shader_t env_src_includes[] = { fragmentColor.rgb = color; } - )" }, - { "debug.frag", R"( + )" + }, + { + "debug.frag", R"( precision highp float; @@ -3313,7 +3400,8 @@ static const lv_opengl_shader_t env_src_includes[] = { } } - )" }, + )" + }, }; static const char * src_vertex_shader = R"( @@ -3418,13 +3506,13 @@ char* lv_gltf_view_shader_get_fragment(void) { void lv_gltf_view_shader_get_src(lv_opengl_shader_portions_t *portions) { - portions->all = src_includes; - portions->count = sizeof(src_includes) / sizeof(src_includes[0]); + portions->all = src_includes; + portions->count = sizeof(src_includes) / sizeof(src_includes[0]); } void lv_gltf_view_shader_get_env(lv_opengl_shader_portions_t *portions) { - portions->all = env_src_includes; - portions->count = sizeof(env_src_includes) / sizeof(env_src_includes[0]); + portions->all = env_src_includes; + portions->count = sizeof(env_src_includes) / sizeof(env_src_includes[0]); } #endif /*LV_USE_GLTF*/