X-Git-Url: http://nitlanguage.org diff --git a/lib/egl.nit b/lib/egl.nit index 5c50387..5d8f4f9 100644 --- a/lib/egl.nit +++ b/lib/egl.nit @@ -14,14 +14,18 @@ # See the License for the specific language governing permissions and # limitations under the License. -# EGL is an interface between the rendering APIs OpenGL, OpenGL ES, etc. -# and the native windowing system. +# Interface between rendering APIs (OpenGL, OpenGL ES, etc.) and the native windowing system. # # Most services of this module are a direct wrapper of the underlying # C library. If a method or class is not documented in Nit, refer to # the official documentation by the Khronos Group at: # http://www.khronos.org/registry/egl/sdk/docs/man/xhtml/ -module egl is pkgconfig +module egl is + pkgconfig + ldflags("-lEGL")@android +end + +import android::aware in "C Header" `{ #include @@ -35,25 +39,20 @@ extern class EGLDisplay `{ EGLDisplay `} new current `{ return eglGetCurrentDisplay(); `} new(handle: Pointer) `{ return eglGetDisplay(handle); `} - fun is_valid: Bool `{ return recv != EGL_NO_DISPLAY; `} + fun is_valid: Bool `{ return self != EGL_NO_DISPLAY; `} fun initialize: Bool `{ - EGLBoolean r = eglInitialize(recv, NULL, NULL); - if (r == EGL_FALSE) { - fprintf(stderr, "Unable to eglInitialize"); - return 0; - } - return 1; + return eglInitialize(self, NULL, NULL); `} fun major_version: Int `{ EGLint val; - eglInitialize(recv, &val, NULL); + eglInitialize(self, &val, NULL); return val; `} fun minor_version: Int `{ EGLint val; - eglInitialize(recv, NULL, &val); + eglInitialize(self, NULL, &val); return val; `} @@ -73,22 +72,22 @@ extern class EGLDisplay `{ EGLDisplay `} } // get number of configs - EGLBoolean r = eglChooseConfig(recv, c_attribs, NULL, 0, &n_configs); + EGLBoolean r = eglChooseConfig(self, c_attribs, NULL, 0, &n_configs); if (r == EGL_FALSE) { - EGLDisplay_report_egl_error(recv, "failed to get number of available configs."); + EGLDisplay_report_egl_error(self, "failed to get number of available configs."); return null_Array_of_EGLConfig(); } else if (n_configs == 0) { - EGLDisplay_report_egl_error(recv, "no config available."); + EGLDisplay_report_egl_error(self, "no config available."); return null_Array_of_EGLConfig(); } configs = (EGLConfig*)malloc(sizeof(EGLConfig)*n_configs); - - r = eglChooseConfig(recv, c_attribs, configs, n_configs, &n_configs); + + r = eglChooseConfig(self, c_attribs, configs, n_configs, &n_configs); if (r == EGL_FALSE) { - EGLDisplay_report_egl_error(recv, "failed to load config."); + EGLDisplay_report_egl_error(self, "failed to load config."); return null_Array_of_EGLConfig(); } else { Array_of_EGLConfig array = new_Array_of_EGLConfig(); @@ -99,10 +98,16 @@ extern class EGLDisplay `{ EGLDisplay `} } `} + private fun report_egl_error(cmsg: CString) + do + var msg = cmsg.to_s + print "libEGL error: {msg}" + end + # Can be used directly, but it is preferable to use a `EGLConfigAttribs` fun config_attrib(config: EGLConfig, attribute: Int): Int `{ EGLint val; - EGLBoolean r = eglGetConfigAttrib(recv, config, attribute, &val); + EGLBoolean r = eglGetConfigAttrib(self, config, attribute, &val); if (r == EGL_FALSE) return -1; else @@ -110,33 +115,29 @@ extern class EGLDisplay `{ EGLDisplay `} `} fun terminate: Bool `{ - return eglTerminate(recv) == EGL_TRUE; + return eglTerminate(self) == EGL_TRUE; `} fun create_window_surface(config: EGLConfig, native_window: Pointer, attribs: Array[Int]): EGLSurface `{ - EGLSurface surface = eglCreateWindowSurface(recv, config, (EGLNativeWindowType)native_window, NULL); + EGLSurface surface = eglCreateWindowSurface(self, config, (EGLNativeWindowType)native_window, NULL); return surface; `} # TODO add share_context fun create_context(config: EGLConfig): EGLContext `{ EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE, EGL_NONE}; // TODO move out! - EGLContext context = eglCreateContext(recv, config, EGL_NO_CONTEXT, context_attribs); + EGLContext context = eglCreateContext(self, config, EGL_NO_CONTEXT, context_attribs); return context; `} fun make_current(draw, read: EGLSurface, context: EGLContext): Bool `{ - if (eglMakeCurrent(recv, draw, read, context) == EGL_FALSE) { - fprintf(stderr, "Unable to eglMakeCurrent"); - return 0; - } - return 1; + return eglMakeCurrent(self, draw, read, context); `} # Can be used directly, but it is preferable to use a `EGLSurfaceAttribs` fun query_surface(surface: EGLSurface, attribute: Int): Int `{ int val; - EGLBoolean r = eglQuerySurface(recv, surface, attribute, &val); + EGLBoolean r = eglQuerySurface(self, surface, attribute, &val); if (r == EGL_FALSE) return -1; else @@ -144,11 +145,11 @@ extern class EGLDisplay `{ EGLDisplay `} `} fun destroy_context(context: EGLContext): Bool `{ - return eglDestroyContext(recv, context); + return eglDestroyContext(self, context); `} fun destroy_surface(surface: EGLSurface): Bool `{ - return eglDestroySurface(recv, surface); + return eglDestroySurface(self, surface); `} fun error: EGLError `{ return eglGetError(); `} @@ -163,19 +164,19 @@ extern class EGLDisplay `{ EGLDisplay `} end end - private fun query_string(name: Int): String import NativeString.to_s `{ - return NativeString_to_s((char *)eglQueryString(recv, name)); + private fun query_string(name: Int): String import CString.to_s `{ + return CString_to_s((char *)eglQueryString(self, name)); `} fun vendor: String do return query_string(0x3053) fun version: String do return query_string(0x3054) - fun extensions: Array[String] do return query_string(0x3055).split_with(" ") + fun extensions: Array[String] do return query_string(0x3055).trim.split_with(" ") fun client_apis: Array[String] do return query_string(0x308D).split_with(" ") - fun swap_buffers(surface: EGLSurface) `{ eglSwapBuffers(recv, surface); `} + fun swap_buffers(surface: EGLSurface) `{ eglSwapBuffers(self, surface); `} end extern class EGLConfig `{ EGLConfig `} @@ -189,7 +190,7 @@ extern class EGLSurface `{ EGLSurface `} new current_read `{ return eglGetCurrentSurface(EGL_READ); `} new none `{ return EGL_NO_SURFACE; `} - fun is_ok: Bool `{ return recv != EGL_NO_SURFACE; `} + fun is_ok: Bool `{ return self != EGL_NO_SURFACE; `} fun attribs(display: EGLDisplay): EGLSurfaceAttribs do return new EGLSurfaceAttribs(display, self) @@ -200,7 +201,7 @@ extern class EGLContext `{ EGLContext `} new current `{ return eglGetCurrentContext(); `} new none `{ return EGL_NO_CONTEXT; `} - fun is_ok: Bool `{ return recv != EGL_NO_CONTEXT; `} + fun is_ok: Bool `{ return self != EGL_NO_CONTEXT; `} end # Attributes of a config for a given EGL display @@ -215,6 +216,8 @@ class EGLConfigAttribs fun red_size: Int do return display.config_attrib(config, 0x3024) fun depth_size: Int do return display.config_attrib(config, 0x3025) fun stencil_size: Int do return display.config_attrib(config, 0x3026) + fun samples: Int do return display.config_attrib(config, 0x3031) + fun sample_buffers: Int do return display.config_attrib(config, 0x3032) fun native_visual_id: Int do return display.config_attrib(config, 0x302E) fun native_visual_type: Int do return display.config_attrib(config, 0x302F) @@ -230,20 +233,20 @@ end extern class EGLConfigCaveat `{ EGLint `} new from_i(val: Int) `{ return (EGLint)val; `} - fun to_i: Int `{ return recv; `} + fun to_i: Int `{ return self; `} new none `{ return EGL_NONE; `} - fun is_none: Bool `{ return recv == EGL_NONE; `} + fun is_none: Bool `{ return self == EGL_NONE; `} new dont_care `{ return EGL_DONT_CARE; `} - fun is_dont_care: Bool `{ return recv == EGL_DONT_CARE; `} + fun is_dont_care: Bool `{ return self == EGL_DONT_CARE; `} new slow `{ return EGL_SLOW_CONFIG; `} - fun is_slow: Bool `{ return recv == EGL_SLOW_CONFIG; `} + fun is_slow: Bool `{ return self == EGL_SLOW_CONFIG; `} # Obselete since EGL 1.3, use EGL_CONFORMANT instead new non_conformant `{ return EGL_NON_CONFORMANT_CONFIG; `} - fun is_non_conformant: Bool `{ return recv == EGL_NON_CONFORMANT_CONFIG; `} + fun is_non_conformant: Bool `{ return self == EGL_NON_CONFORMANT_CONFIG; `} redef fun to_s do @@ -258,19 +261,19 @@ end extern class EGLConformant `{ EGLint `} new `{ return (EGLint)0; `} new from_i(val: Int) `{ return (EGLint)val; `} - fun to_i: Int `{ return recv; `} + fun to_i: Int `{ return self; `} - fun opengl: Bool `{ return recv & EGL_OPENGL_BIT; `} - fun with_opengl: EGLConformant `{ return recv | EGL_OPENGL_BIT; `} + fun opengl: Bool `{ return self & EGL_OPENGL_BIT; `} + fun with_opengl: EGLConformant `{ return self | EGL_OPENGL_BIT; `} - fun opengl_es: Bool `{ return recv & EGL_OPENGL_ES_BIT; `} - fun with_opengl_es: EGLConformant `{ return recv | EGL_OPENGL_ES_BIT; `} + fun opengl_es: Bool `{ return self & EGL_OPENGL_ES_BIT; `} + fun with_opengl_es: EGLConformant `{ return self | EGL_OPENGL_ES_BIT; `} - fun opengl_es2: Bool `{ return recv & EGL_OPENGL_ES2_BIT; `} - fun with_opengl_es2: EGLConformant `{ return recv | EGL_OPENGL_ES2_BIT; `} + fun opengl_es2: Bool `{ return self & EGL_OPENGL_ES2_BIT; `} + fun with_opengl_es2: EGLConformant `{ return self | EGL_OPENGL_ES2_BIT; `} - fun openvg: Bool `{ return recv & EGL_OPENVG_BIT; `} - fun with_openvg: EGLConformant `{ return recv | EGL_OPENVG_BIT; `} + fun openvg: Bool `{ return self & EGL_OPENVG_BIT; `} + fun with_openvg: EGLConformant `{ return self | EGL_OPENVG_BIT; `} fun to_a: Array[String] do @@ -308,22 +311,22 @@ class EGLSurfaceAttribs end extern class EGLError `{ EGLint `} - fun is_success: Bool `{ return recv == EGL_SUCCESS; `} - - fun is_not_initialized: Bool `{ return recv == EGL_NOT_INITIALIZED; `} - fun is_bad_access: Bool `{ return recv == EGL_BAD_ACCESS; `} - fun is_bad_alloc: Bool `{ return recv == EGL_BAD_ALLOC; `} - fun is_bad_attribute: Bool `{ return recv == EGL_BAD_ATTRIBUTE; `} - fun is_bad_config: Bool `{ return recv == EGL_BAD_CONFIG; `} - fun is_bad_context: Bool `{ return recv == EGL_BAD_CONTEXT; `} - fun is_bad_current_surface: Bool `{ return recv == EGL_BAD_CURRENT_SURFACE; `} - fun is_bad_display: Bool `{ return recv == EGL_BAD_DISPLAY; `} - fun is_bad_match: Bool `{ return recv == EGL_BAD_MATCH; `} - fun is_bad_native_pixmap: Bool `{ return recv == EGL_BAD_NATIVE_PIXMAP; `} - fun is_bad_native_window: Bool `{ return recv == EGL_BAD_NATIVE_WINDOW; `} - fun is_bad_parameter: Bool `{ return recv == EGL_BAD_PARAMETER; `} - fun is_bad_surface: Bool `{ return recv == EGL_BAD_SURFACE; `} - fun is_context_lost: Bool `{ return recv == EGL_CONTEXT_LOST; `} + fun is_success: Bool `{ return self == EGL_SUCCESS; `} + + fun is_not_initialized: Bool `{ return self == EGL_NOT_INITIALIZED; `} + fun is_bad_access: Bool `{ return self == EGL_BAD_ACCESS; `} + fun is_bad_alloc: Bool `{ return self == EGL_BAD_ALLOC; `} + fun is_bad_attribute: Bool `{ return self == EGL_BAD_ATTRIBUTE; `} + fun is_bad_config: Bool `{ return self == EGL_BAD_CONFIG; `} + fun is_bad_context: Bool `{ return self == EGL_BAD_CONTEXT; `} + fun is_bad_current_surface: Bool `{ return self == EGL_BAD_CURRENT_SURFACE; `} + fun is_bad_display: Bool `{ return self == EGL_BAD_DISPLAY; `} + fun is_bad_match: Bool `{ return self == EGL_BAD_MATCH; `} + fun is_bad_native_pixmap: Bool `{ return self == EGL_BAD_NATIVE_PIXMAP; `} + fun is_bad_native_window: Bool `{ return self == EGL_BAD_NATIVE_WINDOW; `} + fun is_bad_parameter: Bool `{ return self == EGL_BAD_PARAMETER; `} + fun is_bad_surface: Bool `{ return self == EGL_BAD_SURFACE; `} + fun is_context_lost: Bool `{ return self == EGL_CONTEXT_LOST; `} redef fun to_s do @@ -412,6 +415,12 @@ class EGLConfigChooser fun surface_type=(flag: Int) do insert_attrib_with_val(0x3033, flag) fun surface_type_egl do surface_type = 4 + # Set which client rendering APIs are supported + fun renderable_type=(flag: Int) do insert_attrib_with_val(0x3040, flag) + + # Set EGL as the only supported rendering API + fun renderable_type_egl do renderable_type = 4 + fun blue_size=(size: Int) do insert_attrib_with_val(0x3022, size) fun green_size=(size: Int) do insert_attrib_with_val(0x3023, size) fun red_size=(size: Int) do insert_attrib_with_val(0x3024, size) @@ -420,7 +429,8 @@ class EGLConfigChooser fun alpha_size=(size: Int) do insert_attrib_with_val(0x3021, size) fun depth_size=(size: Int) do insert_attrib_with_val(0x3025, size) fun stencil_size=(size: Int) do insert_attrib_with_val(0x3026, size) - fun sample_buffers=(size: Int) do insert_attrib_with_val(0x3031, size) + fun samples=(count: Int) do insert_attrib_with_val(0x3031, count) + fun sample_buffers=(size: Int) do insert_attrib_with_val(0x3032, size) fun caveat=(caveat: EGLConfigCaveat) do insert_attrib_with_val(0x3050, caveat.to_i) @@ -433,14 +443,9 @@ class EGLConfigChooser end end -redef class Object - private fun report_egl_error(cmsg: NativeString) - do - var msg = cmsg.to_s - print "libEGL error: {msg}" - end -end +fun egl_bind_opengl_api: Bool `{ return eglBindAPI(EGL_OPENGL_API); `} +fun egl_bind_opengl_es_api: Bool `{ return eglBindAPI(EGL_OPENGL_ES_API); `} +fun egl_bind_openvg_api: Bool `{ return eglBindAPI(EGL_OPENVG_API); `} -protected fun egl_bind_opengl_api: Bool `{ return eglBindAPI(EGL_OPENGL_API); `} -protected fun egl_bind_opengl_es_api: Bool `{ return eglBindAPI(EGL_OPENGL_ES_API); `} -protected fun egl_bind_openvg_api: Bool `{ return eglBindAPI(EGL_OPENVG_API); `} +# Handle to the default display to use with EGL +fun egl_default_display: Pointer `{ return EGL_DEFAULT_DISPLAY; `}