rt(gl): remove need for explicit external FBO object

Replaced with an internal FBO that is state tracked so as to not recreate it every frame, but will update if necessary

Author: chyyran

include/librashader.h

@@ -204,7 +204,7 @@ libra_error_t __librashader__noop_gl_filter_chain_create(
 
 libra_error_t __librashader__noop_gl_filter_chain_frame(
     libra_gl_filter_chain_t *chain, size_t frame_count,
-    struct libra_source_image_gl_t image, struct libra_output_framebuffer_gl_t out,
+    struct libra_image_gl_t image, struct libra_image_gl_t out,
     const struct libra_viewport_t *viewport, const float *mvp,
     const struct frame_gl_opt_t *opt) {
     return NULL;

include/librashader_ld.h

@@ -4,9 +4,8 @@ use crate::ctypes::{
 use crate::error::{assert_non_null, assert_some_ptr, LibrashaderError};
 use crate::ffi::extern_fn;
 use crate::LIBRASHADER_API_VERSION;
-use librashader::runtime::gl::error::FilterChainError;
 use librashader::runtime::gl::{
-    FilterChain, FilterChainOptions, FrameOptions, GLFramebuffer, GLImage,
+    FilterChain, FilterChainOptions, FrameOptions, GLImage,
 };
 use librashader::runtime::FilterChainParameters;
 use librashader::runtime::{Size, Viewport};
@@ -21,36 +20,21 @@ use std::sync::Arc;
 /// A GL function loader that librashader needs to be initialized with.
 pub type libra_gl_loader_t = unsafe extern "system" fn(*const c_char) -> *const c_void;
 
-/// OpenGL parameters for the source image.
+/// OpenGL parameters for an image.
 #[repr(C)]
-pub struct libra_source_image_gl_t {
-    /// A texture GLuint to the source image.
+pub struct libra_image_gl_t {
+    /// A texture GLuint to the texture.
     pub handle: u32,
-    /// The format of the source image.
+    /// The format of the texture.
     pub format: u32,
-    /// The width of the source image.
+    /// The width of the texture.
     pub width: u32,
-    /// The height of the source image.
+    /// The height of the texture.
     pub height: u32,
 }
 
-/// OpenGL parameters for the output framebuffer.
-#[repr(C)]
-pub struct libra_output_framebuffer_gl_t {
-    /// A framebuffer GLuint to the output framebuffer.
-    pub fbo: u32,
-    /// A texture GLuint to the logical buffer of the output framebuffer.
-    pub texture: u32,
-    /// The format of the output framebuffer.
-    pub format: u32,
-    /// The width of the output image.
-    pub width: u32,
-    /// The height of the output image.
-    pub height: u32,
-}
-
-impl From<libra_source_image_gl_t> for GLImage {
-    fn from(value: libra_source_image_gl_t) -> Self {
+impl From<libra_image_gl_t> for GLImage {
+    fn from(value: libra_image_gl_t) -> Self {
         let handle = NonZeroU32::try_from(value.handle)
             .ok()
             .map(glow::NativeTexture);
@@ -166,7 +150,7 @@ extern_fn! {
     ///
     /// - `chain` is a handle to the filter chain.
     /// - `frame_count` is the number of frames passed to the shader
-    /// - `image` is a `libra_source_image_gl_t`, containing the name of a Texture, format, and size information to
+    /// - `image` is a `libra_image_gl_t`, containing the name of a Texture, format, and size information to
     ///    to an image that will serve as the source image for the frame.
     /// - `out` is a `libra_output_framebuffer_gl_t`, containing the name of a Framebuffer, the name of a Texture, format,
     ///    and size information for the render target of the frame.
@@ -193,14 +177,16 @@ extern_fn! {
     nopanic fn libra_gl_filter_chain_frame(
         chain: *mut libra_gl_filter_chain_t,
         frame_count: usize,
-        image: libra_source_image_gl_t,
-        out: libra_output_framebuffer_gl_t,
+        image: libra_image_gl_t,
+        out: libra_image_gl_t,
         viewport: *const libra_viewport_t,
         mvp: *const f32,
         opt: *const MaybeUninit<frame_gl_opt_t>,
     ) mut |chain| {
         assert_some_ptr!(mut chain);
         let image: GLImage = image.into();
+        let out: GLImage = out.into();
+
         let mvp = if mvp.is_null() {
             None
         } else {
@@ -214,26 +200,14 @@ extern_fn! {
 
         let opt = opt.map(FromUninit::from_uninit);
 
-        let texture = NonZeroU32::try_from(out.texture)
-            .ok()
-            .map(glow::NativeTexture);
-
-        let fbo = NonZeroU32::try_from(out.fbo)
-            .ok()
-            .map(glow::NativeFramebuffer)
-            .ok_or(FilterChainError::GlInvalidFramebuffer)?;
-
-        let framebuffer = GLFramebuffer::new_from_raw(Arc::clone(chain.get_context()),
-            texture, fbo, out.format, Size::new(out.width, out.height), 1);
-
          let viewport = if viewport.is_null() {
-            Viewport::new_render_target_sized_origin(&framebuffer, mvp)?
+            Viewport::new_render_target_sized_origin(&out, mvp)?
         } else {
             let viewport = unsafe { viewport.read() };
             Viewport {
                 x: viewport.x,
                 y: viewport.y,
-                output: &framebuffer,
+                output: &out,
                 size: Size {
                     height: viewport.height,
                     width: viewport.width

librashader-capi/src/runtime/gl/filter_chain.rs

@@ -2,7 +2,8 @@ use crate::binding::{GlUniformStorage, UniformLocation, VariableLocation};
 use crate::error::FilterChainError;
 use crate::filter_pass::{FilterPass, UniformOffset};
 use crate::gl::{
-    CompileProgram, DrawQuad, FramebufferInterface, GLFramebuffer, GLInterface, LoadLut, UboRing,
+    CompileProgram, DrawQuad, FramebufferInterface, GLFramebuffer, GLInterface, LoadLut,
+    OutputFramebuffer, UboRing,
 };
 use crate::options::{FilterChainOptionsGL, FrameOptionsGL};
 use crate::samplers::SamplerSet;
@@ -39,6 +40,7 @@ pub(crate) struct FilterChainImpl<T: GLInterface> {
     output_framebuffers: Box<[GLFramebuffer]>,
     feedback_framebuffers: Box<[GLFramebuffer]>,
     history_framebuffers: VecDeque<GLFramebuffer>,
+    render_target: OutputFramebuffer,
     default_options: FrameOptionsGL,
     draw_last_pass_feedback: bool,
 }
@@ -183,6 +185,8 @@ impl<T: GLInterface> FilterChainImpl<T> {
         // create vertex objects
         let draw_quad = T::DrawQuad::new(&context)?;
 
+        let output = OutputFramebuffer::new(&context);
+
         Ok(FilterChainImpl {
             draw_last_pass_feedback: framebuffer_init.uses_final_pass_as_feedback(),
             passes: filters,
@@ -201,6 +205,7 @@ impl<T: GLInterface> FilterChainImpl<T> {
                 context,
             },
             default_options: Default::default(),
+            render_target: output,
         })
     }
 
@@ -278,7 +283,7 @@ impl<T: GLInterface> FilterChainImpl<T> {
     pub unsafe fn frame(
         &mut self,
         frame_count: usize,
-        viewport: &Viewport<&GLFramebuffer>,
+        viewport: &Viewport<&GLImage>,
         input: &GLImage,
         options: Option<&FrameOptionsGL>,
     ) -> error::Result<()> {
@@ -385,6 +390,10 @@ impl<T: GLInterface> FilterChainImpl<T> {
         assert_eq!(last.len(), 1);
         if let Some(pass) = last.iter_mut().next() {
             let index = passes_len - 1;
+            let final_viewport = self
+                .render_target
+                .ensure::<T::FramebufferInterface>(viewport.output)?;
+
             source.filter = pass.config.filter;
             source.mip_filter = pass.config.filter;
             source.wrap_mode = pass.config.wrap_mode;
@@ -411,7 +420,7 @@ impl<T: GLInterface> FilterChainImpl<T> {
                 viewport,
                 &original,
                 &source,
-                RenderTarget::viewport(viewport),
+                RenderTarget::viewport_with_output(final_viewport, viewport),
             );
             self.common.output_textures[passes_len - 1] = viewport
                 .output

librashader-runtime-gl/src/filter_chain/chain.rs

@@ -2,7 +2,7 @@ use crate::error::{FilterChainError, Result};
 use crate::filter_chain::chain::FilterChainImpl;
 use crate::filter_chain::inner::FilterChainDispatch;
 use crate::options::{FilterChainOptionsGL, FrameOptionsGL};
-use crate::{GLFramebuffer, GLImage};
+use crate::GLImage;
 use librashader_presets::ShaderPreset;
 use std::panic::catch_unwind;
 use std::path::Path;
@@ -63,7 +63,7 @@ impl FilterChainGL {
     pub unsafe fn frame(
         &mut self,
         input: &GLImage,
-        viewport: &Viewport<&GLFramebuffer>,
+        viewport: &Viewport<&GLImage>,
         frame_count: usize,
         options: Option<&FrameOptionsGL>,
     ) -> Result<()> {

librashader-runtime-gl/src/filter_chain/mod.rs

@@ -12,10 +12,10 @@ use librashader_runtime::render_target::RenderTarget;
 
 use crate::binding::{GlUniformBinder, GlUniformStorage, UniformLocation, VariableLocation};
 use crate::filter_chain::FilterCommon;
-use crate::gl::{BindTexture, GLInterface, UboRing};
+use crate::gl::{BindTexture, GLFramebuffer, GLInterface, UboRing};
 use crate::options::FrameOptionsGL;
 use crate::samplers::SamplerSet;
-use crate::GLFramebuffer;
+use crate::GLImage;
 
 use crate::texture::InputTexture;
 
@@ -82,7 +82,7 @@ impl<T: GLInterface> FilterPass<T> {
         parent: &FilterCommon,
         frame_count: u32,
         options: &FrameOptionsGL,
-        viewport: &Viewport<&GLFramebuffer>,
+        viewport: &Viewport<&GLImage>,
         original: &InputTexture,
         source: &InputTexture,
         output: RenderTarget<GLFramebuffer, i32>,
@@ -177,7 +177,7 @@ impl<T: GLInterface> FilterPass<T> {
         frame_count: u32,
         options: &FrameOptionsGL,
         fb_size: Size<u32>,
-        viewport: &Viewport<&GLFramebuffer>,
+        viewport: &Viewport<&GLImage>,
         original: &InputTexture,
         source: &InputTexture,
     ) {

librashader-runtime-gl/src/filter_pass.rs

@@ -1,4 +1,5 @@
-use librashader_common::{GetSize, Size};
+use crate::texture::InputTexture;
+use librashader_common::{FilterMode, GetSize, Size, WrapMode};
 
 /// A handle to an OpenGL texture with format and size information.
 ///
@@ -13,10 +14,29 @@ pub struct GLImage {
     pub size: Size<u32>,
 }
 
+impl GLImage {
+    pub(crate) fn as_texture(&self, filter: FilterMode, wrap_mode: WrapMode) -> InputTexture {
+        InputTexture {
+            image: *self,
+            filter,
+            mip_filter: filter,
+            wrap_mode,
+        }
+    }
+}
+
 impl GetSize<u32> for GLImage {
     type Error = std::convert::Infallible;
 
     fn size(&self) -> Result<Size<u32>, Self::Error> {
         Ok(self.size)
     }
 }
+
+impl GetSize<u32> for &GLImage {
+    type Error = std::convert::Infallible;
+
+    fn size(&self) -> Result<Size<u32>, Self::Error> {
+        Ok(self.size)
+    }
+}

librashader-runtime-gl/src/framebuffer.rs

@@ -19,7 +19,7 @@ pub struct GLFramebuffer {
     pub(crate) format: u32,
     pub(crate) max_levels: u32,
     pub(crate) mip_levels: u32,
-    pub(crate) is_raw: bool,
+    pub(crate) is_extern_image: bool,
     pub(crate) ctx: Arc<glow::Context>,
 }
 
@@ -42,7 +42,7 @@ impl GLFramebuffer {
             max_levels: miplevels,
             mip_levels: miplevels,
             fbo,
-            is_raw: true,
+            is_extern_image: true,
             ctx,
         }
     }
@@ -89,14 +89,58 @@ impl GLFramebuffer {
     }
 }
 
-impl Drop for GLFramebuffer {
-    fn drop(&mut self) {
-        if self.is_raw {
-            return;
+/// A state-checked wrapper around a raw framebuffer, used exclusively for output images.
+pub struct OutputFramebuffer {
+    framebuffer: Option<GLFramebuffer>,
+    ctx: Arc<glow::Context>,
+}
+
+impl OutputFramebuffer {
+    pub fn new(ctx: &Arc<glow::Context>) -> Self {
+        OutputFramebuffer {
+            ctx: Arc::clone(ctx),
+            framebuffer: None,
         }
+    }
+
+    /// Ensure that the renderbuffer is up to date.
+    pub fn ensure<T: FramebufferInterface>(&mut self, image: &GLImage) -> Result<&GLFramebuffer> {
+        let texture = image.handle;
+        let size = image.size;
+        let format = image.format;
+
+        let Some(framebuffer) = self.framebuffer.as_mut() else {
+            self.framebuffer = Some(T::new_raw(&self.ctx, texture, size, format, 1)?);
+            return Ok(self.framebuffer.as_ref().unwrap());
+        };
+
+        assert!(
+            framebuffer.is_extern_image,
+            "Somehow an internal image got into the renderbuffer!"
+        );
+
+        if framebuffer.image == texture && framebuffer.size == size && framebuffer.format == format
+        {
+            // Problem Case #3 :cry:
+            return Ok(self.framebuffer.as_ref().unwrap());
+        };
 
+        // Replace with a new framebuffer.
+        let new = T::new_raw(&self.ctx, texture, size, format, 1)?;
+        std::mem::swap(&mut self.framebuffer, &mut Some(new));
+        Ok(self.framebuffer.as_ref().unwrap())
+    }
+}
+
+impl Drop for GLFramebuffer {
+    fn drop(&mut self) {
         unsafe {
             self.ctx.delete_framebuffer(self.fbo);
+
+            if self.is_extern_image {
+                return;
+            }
+
             if let Some(image) = self.image {
                 self.ctx.delete_texture(image);
             }