1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
// Take a look at the license at the top of the repository in the LICENSE file.

use crate::GLContext;
use crate::GLDisplay;
use crate::GLPlatform;
use crate::GLAPI;
use glib::prelude::*;
use glib::translate::*;
use libc::uintptr_t;

impl GLContext {
    /// Wraps an existing OpenGL context into a [`GLContext`][crate::GLContext].
    ///
    /// Note: The caller is responsible for ensuring that the OpenGL context
    /// represented by `handle` stays alive while the returned [`GLContext`][crate::GLContext] is
    /// active.
    ///
    /// `context_type` must not be `GST_GL_PLATFORM_NONE` or `GST_GL_PLATFORM_ANY`
    ///
    /// `available_apis` must not be `GST_GL_API_NONE` or `GST_GL_API_ANY`
    /// ## `display`
    /// a [`GLDisplay`][crate::GLDisplay]
    /// ## `handle`
    /// the OpenGL context to wrap
    /// ## `context_type`
    /// a [`GLPlatform`][crate::GLPlatform] specifying the type of context in `handle`
    /// ## `available_apis`
    /// a [`GLAPI`][crate::GLAPI] containing the available OpenGL apis in `handle`
    ///
    /// # Returns
    ///
    /// a [`GLContext`][crate::GLContext] wrapping `handle`
    pub unsafe fn new_wrapped<T: IsA<GLDisplay>>(
        display: &T,
        handle: uintptr_t,
        context_type: GLPlatform,
        available_apis: GLAPI,
    ) -> Option<Self> {
        from_glib_full(ffi::gst_gl_context_new_wrapped(
            display.as_ref().to_glib_none().0,
            handle,
            context_type.into_glib(),
            available_apis.into_glib(),
        ))
    }

    /// ## `context_type`
    /// a [`GLPlatform`][crate::GLPlatform] specifying the type of context to retrieve
    ///
    /// # Returns
    ///
    /// The OpenGL context handle current in the calling thread or [`None`]
    #[doc(alias = "get_current_gl_context")]
    #[doc(alias = "gst_gl_context_get_current_gl_context")]
    pub fn current_gl_context(context_type: GLPlatform) -> uintptr_t {
        skip_assert_initialized!();
        unsafe { ffi::gst_gl_context_get_current_gl_context(context_type.into_glib()) as uintptr_t }
    }

    /// Attempts to use the `context_type` specific GetProcAddress implementations
    /// to retrieve `name`.
    ///
    /// See also [`GLContextExtManual::proc_address()`][crate::prelude::GLContextExtManual::proc_address()].
    /// ## `context_type`
    /// a [`GLPlatform`][crate::GLPlatform]
    /// ## `gl_api`
    /// a [`GLAPI`][crate::GLAPI]
    /// ## `name`
    /// the name of the function to retrieve
    ///
    /// # Returns
    ///
    /// a function pointer for `name`, or [`None`]
    #[doc(alias = "get_proc_address_with_platform")]
    #[doc(alias = "gst_gl_context_get_proc_address_with_platform")]
    pub fn proc_address_with_platform(
        context_type: GLPlatform,
        gl_api: GLAPI,
        name: &str,
    ) -> uintptr_t {
        skip_assert_initialized!();
        unsafe {
            ffi::gst_gl_context_get_proc_address_with_platform(
                context_type.into_glib(),
                gl_api.into_glib(),
                name.to_glib_none().0,
            ) as uintptr_t
        }
    }
}

pub trait GLContextExtManual: 'static {
    /// Gets the backing OpenGL context used by `self`.
    ///
    /// # Returns
    ///
    /// The platform specific backing OpenGL context
    #[doc(alias = "get_gl_context")]
    #[doc(alias = "gst_gl_context_get_gl_context")]
    fn gl_context(&self) -> uintptr_t;

    /// Get a function pointer to a specified opengl function, `name`. If the the
    /// specific function does not exist, NULL is returned instead.
    ///
    /// Platform specific functions (names starting 'egl', 'glX', 'wgl', etc) can also
    /// be retrieved using this method.
    ///
    /// Note: This function may return valid function pointers that may not be valid
    /// to call in `self`. The caller is responsible for ensuring that the
    /// returned function is a valid function to call in `self` by either checking
    /// the OpenGL API and version or for an appropriate OpenGL extension.
    ///
    /// Note: On success, you need to cast the returned function pointer to the
    /// correct type to be able to call it correctly. On 32-bit Windows, this will
    /// include the `GSTGLAPI` identifier to use the correct calling convention.
    /// e.g.
    ///
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// void (GSTGLAPI *PFN_glGetIntegerv) (GLenum name, GLint * ret)
    /// ```
    /// ## `name`
    /// an opengl function name
    ///
    /// # Returns
    ///
    /// a function pointer or [`None`]
    #[doc(alias = "get_proc_address")]
    #[doc(alias = "gst_gl_context_get_proc_address")]
    fn proc_address(&self, name: &str) -> uintptr_t;
}

impl<O: IsA<GLContext>> GLContextExtManual for O {
    fn gl_context(&self) -> uintptr_t {
        unsafe { ffi::gst_gl_context_get_gl_context(self.as_ref().to_glib_none().0) as uintptr_t }
    }

    fn proc_address(&self, name: &str) -> uintptr_t {
        unsafe {
            ffi::gst_gl_context_get_proc_address(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            ) as uintptr_t
        }
    }
}