Introduce a new OpenGL renderer
This pulls a lot of code from anvil/src/glium_drawer and replaces glium as glium has too many assumptions about the backend. (Mostly that a fixed framebuffer exists, see fix bullet point.) Depending on how picky glium is, we could try to re-introduce glium support later with a some workarounds, but for now this is actually more straight-forward to support and test. - Add a new GL renderer, that only depends on egl as an initialization platform. In particular do not depend on a surface being available. Renderers share some basic drawing functions and may bind objects to render upon. E.g. surfaces or buffers, textures, etc for the gles2 renderer. - Be explicit about extensions we require and use. Use some very very common ones to make our lives easier (e.g. BGRA and unpack to read in manditory shm formats). - Enable GL debug output - Allow more flexible rendering (e.g. 3D compositors) by allowing user-provided projection matrices. Also provide helper functions to allow easy-ish handling of surface and output transformations. - Add API for renderers to tell the wayland-frontend about supported buffer-types. - Also incoperate code from anvil/src/shm_load to handle buffer loading in the renderer (as this is a renderer dependant operation).
This commit is contained in:
Victor Brekenfeld
parent
d99108a8e6
commit
4d5d7afb5a
|
|
@ -1,51 +0,0 @@
|
|||
//! OpenGL rendering types
|
||||
|
||||
use nix::libc::c_void;
|
||||
|
||||
use super::{PixelFormat, SwapBuffersError};
|
||||
|
||||
#[allow(clippy::all, missing_docs)]
|
||||
pub(crate) mod ffi {
|
||||
include!(concat!(env!("OUT_DIR"), "/gl_bindings.rs"));
|
||||
}
|
||||
|
||||
pub use self::ffi::Gles2;
|
||||
|
||||
/// Trait that describes objects that have an OpenGL context
|
||||
/// and can be used to render upon
|
||||
pub trait GLGraphicsBackend {
|
||||
/// Swaps buffers at the end of a frame.
|
||||
fn swap_buffers(&self) -> Result<(), SwapBuffersError>;
|
||||
|
||||
/// Returns the address of an OpenGL function.
|
||||
fn get_proc_address(&self, symbol: &str) -> *const c_void;
|
||||
|
||||
/// Returns the dimensions of the window, or screen, etc in points.
|
||||
///
|
||||
/// These are the actual pixels of the underlying graphics backend.
|
||||
/// For nested compositors you will need to handle the scaling
|
||||
/// of the root compositor yourself, if you want to.
|
||||
fn get_framebuffer_dimensions(&self) -> (u32, u32);
|
||||
|
||||
/// Returns true if the OpenGL context is the current one in the thread.
|
||||
fn is_current(&self) -> bool;
|
||||
|
||||
/// Makes the OpenGL context the current context in the current thread.
|
||||
///
|
||||
/// # Safety
|
||||
///
|
||||
/// The context cannot be made current on multiple threads.
|
||||
unsafe fn make_current(&self) -> Result<(), SwapBuffersError>;
|
||||
|
||||
/// Returns the pixel format of the main framebuffer of the context.
|
||||
fn get_pixel_format(&self) -> PixelFormat;
|
||||
}
|
||||
|
||||
/// Loads a Raw GLES Interface for a given [`GLGraphicsBackend`]
|
||||
///
|
||||
/// This remains valid as long as the underlying [`GLGraphicsBackend`] is alive
|
||||
/// and may only be used in combination with the backend. Using this with any
|
||||
/// other gl context or after the backend was dropped *may* cause undefined behavior.
|
||||
pub fn load_raw_gl<B: GLGraphicsBackend>(backend: &B) -> Gles2 {
|
||||
Gles2::load_with(|s| backend.get_proc_address(s) as *const _)
|
||||
}
|
||||
|
|
@ -1,267 +0,0 @@
|
|||
//! Glium compatibility module
|
||||
|
||||
use crate::backend::graphics::{gl::GLGraphicsBackend, SwapBuffersError};
|
||||
use glium::{
|
||||
backend::{Backend, Context, Facade},
|
||||
debug::DebugCallbackBehavior,
|
||||
SwapBuffersError as GliumSwapBuffersError,
|
||||
};
|
||||
use std::{
|
||||
cell::{Cell, Ref, RefCell, RefMut},
|
||||
fmt,
|
||||
os::raw::c_void,
|
||||
rc::Rc,
|
||||
};
|
||||
|
||||
/// Wrapper to expose `Glium` compatibility
|
||||
pub struct GliumGraphicsBackend<T: GLGraphicsBackend> {
|
||||
context: Rc<Context>,
|
||||
backend: Rc<InternalBackend<T>>,
|
||||
// at least this type is not `Send` or even `Sync`.
|
||||
// while there can be multiple Frames, they cannot in parallel call `set_finish`.
|
||||
// so a buffer of the last error is sufficient, if always cleared...
|
||||
error_channel: Rc<Cell<Option<Box<dyn std::error::Error>>>>,
|
||||
}
|
||||
|
||||
// GLGraphicsBackend is a trait, so we have to impl Debug manually
|
||||
impl<T: GLGraphicsBackend> fmt::Debug for GliumGraphicsBackend<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
struct BackendDebug<'a, T: GLGraphicsBackend>(&'a Rc<InternalBackend<T>>);
|
||||
impl<'a, T: GLGraphicsBackend> fmt::Debug for BackendDebug<'a, T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
let b = &self.0 .0.borrow();
|
||||
f.debug_struct("GLGraphicsBackend")
|
||||
.field("framebuffer_dimensions", &b.get_framebuffer_dimensions())
|
||||
.field("is_current", &b.is_current())
|
||||
.field("pixel_format", &b.get_pixel_format())
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
f.debug_struct("GliumGraphicsBackend")
|
||||
.field("context", &"...")
|
||||
.field("backend", &BackendDebug(&self.backend))
|
||||
.field("error_channel", &"...")
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
struct InternalBackend<T: GLGraphicsBackend>(RefCell<T>, Rc<Cell<Option<Box<dyn std::error::Error>>>>);
|
||||
|
||||
impl<T: GLGraphicsBackend + 'static> GliumGraphicsBackend<T> {
|
||||
fn new(backend: T) -> GliumGraphicsBackend<T> {
|
||||
let error_channel = Rc::new(Cell::new(None));
|
||||
let internal = Rc::new(InternalBackend(RefCell::new(backend), error_channel.clone()));
|
||||
|
||||
GliumGraphicsBackend {
|
||||
// cannot fail
|
||||
context: unsafe {
|
||||
Context::new(internal.clone(), true, DebugCallbackBehavior::default()).unwrap()
|
||||
},
|
||||
backend: internal,
|
||||
error_channel,
|
||||
}
|
||||
}
|
||||
|
||||
/// Start drawing on the backbuffer.
|
||||
///
|
||||
/// This function returns a [`Frame`], which can be used to draw on it.
|
||||
/// When the [`Frame`] is destroyed, the buffers are swapped.
|
||||
///
|
||||
/// Note that destroying a [`Frame`] is immediate, even if vsync is enabled.
|
||||
#[inline]
|
||||
pub fn draw(&self) -> Frame {
|
||||
Frame(
|
||||
glium::Frame::new(self.context.clone(), self.backend.get_framebuffer_dimensions()),
|
||||
self.error_channel.clone(),
|
||||
)
|
||||
}
|
||||
|
||||
/// Borrow the underlying backend.
|
||||
///
|
||||
/// This follows the same semantics as [`std::cell::RefCell`](RefCell::borrow).
|
||||
/// Multiple read-only borrows are possible. Borrowing the
|
||||
/// backend while there is a mutable reference will panic.
|
||||
pub fn borrow(&self) -> Ref<'_, T> {
|
||||
self.backend.0.borrow()
|
||||
}
|
||||
|
||||
/// Borrow the underlying backend mutably.
|
||||
///
|
||||
/// This follows the same semantics as [`std::cell::RefCell`](RefCell::borrow_mut).
|
||||
/// Holding any other borrow while trying to borrow the backend
|
||||
/// mutably will panic. Note that Glium will borrow the backend
|
||||
/// (not mutably) during rendering.
|
||||
pub fn borrow_mut(&self) -> RefMut<'_, T> {
|
||||
self.backend.0.borrow_mut()
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: GLGraphicsBackend> Facade for GliumGraphicsBackend<T> {
|
||||
fn get_context(&self) -> &Rc<Context> {
|
||||
&self.context
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: GLGraphicsBackend + 'static> From<T> for GliumGraphicsBackend<T> {
|
||||
fn from(backend: T) -> Self {
|
||||
GliumGraphicsBackend::new(backend)
|
||||
}
|
||||
}
|
||||
|
||||
unsafe impl<T: GLGraphicsBackend> Backend for InternalBackend<T> {
|
||||
fn swap_buffers(&self) -> Result<(), GliumSwapBuffersError> {
|
||||
if let Err(err) = self.0.borrow().swap_buffers() {
|
||||
Err(match err {
|
||||
SwapBuffersError::ContextLost(err) => {
|
||||
self.1.set(Some(err));
|
||||
GliumSwapBuffersError::ContextLost
|
||||
}
|
||||
SwapBuffersError::TemporaryFailure(err) => {
|
||||
self.1.set(Some(err));
|
||||
GliumSwapBuffersError::AlreadySwapped
|
||||
}
|
||||
// I do not think, this may happen, but why not
|
||||
SwapBuffersError::AlreadySwapped => GliumSwapBuffersError::AlreadySwapped,
|
||||
})
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn get_proc_address(&self, symbol: &str) -> *const c_void {
|
||||
self.0.borrow().get_proc_address(symbol) as *const c_void
|
||||
}
|
||||
|
||||
fn get_framebuffer_dimensions(&self) -> (u32, u32) {
|
||||
self.0.borrow().get_framebuffer_dimensions()
|
||||
}
|
||||
|
||||
fn is_current(&self) -> bool {
|
||||
self.0.borrow().is_current()
|
||||
}
|
||||
|
||||
unsafe fn make_current(&self) {
|
||||
// TODO, if this ever blows up anvil, we should probably silently ignore this.
|
||||
// But I have no idea, if that may happen or what glium does, if the context is not current...
|
||||
// So lets leave this in to do some real world testing
|
||||
self.0.borrow().make_current().expect("Context was lost")
|
||||
}
|
||||
}
|
||||
|
||||
/// Implementation of `glium::Surface`, targeting the default framebuffer.
|
||||
///
|
||||
/// The back- and front-buffers are swapped when you call `finish`.
|
||||
///
|
||||
/// You **must** call either `finish` or `set_finish` or else the destructor will panic.
|
||||
pub struct Frame(glium::Frame, Rc<Cell<Option<Box<dyn std::error::Error>>>>);
|
||||
|
||||
impl Frame {
|
||||
/// Stop drawing, swap the buffers, and consume the Frame.
|
||||
///
|
||||
/// See the documentation of [`SwapBuffersError`] about what is being returned.
|
||||
pub fn finish(mut self) -> Result<(), SwapBuffersError> {
|
||||
self.set_finish()
|
||||
}
|
||||
|
||||
/// Stop drawing, swap the buffers.
|
||||
///
|
||||
/// The Frame can now be dropped regularly. Calling `finish()` or `set_finish()` again will cause `Err(SwapBuffersError::AlreadySwapped)` to be returned.
|
||||
pub fn set_finish(&mut self) -> Result<(), SwapBuffersError> {
|
||||
let res = self.0.set_finish();
|
||||
let err = self.1.take();
|
||||
match (res, err) {
|
||||
(Ok(()), _) => Ok(()),
|
||||
(Err(GliumSwapBuffersError::AlreadySwapped), Some(err)) => {
|
||||
Err(SwapBuffersError::TemporaryFailure(err))
|
||||
}
|
||||
(Err(GliumSwapBuffersError::AlreadySwapped), None) => Err(SwapBuffersError::AlreadySwapped),
|
||||
(Err(GliumSwapBuffersError::ContextLost), Some(err)) => Err(SwapBuffersError::ContextLost(err)),
|
||||
_ => unreachable!(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl glium::Surface for Frame {
|
||||
fn clear(
|
||||
&mut self,
|
||||
rect: Option<&glium::Rect>,
|
||||
color: Option<(f32, f32, f32, f32)>,
|
||||
color_srgb: bool,
|
||||
depth: Option<f32>,
|
||||
stencil: Option<i32>,
|
||||
) {
|
||||
self.0.clear(rect, color, color_srgb, depth, stencil)
|
||||
}
|
||||
|
||||
fn get_dimensions(&self) -> (u32, u32) {
|
||||
self.0.get_dimensions()
|
||||
}
|
||||
|
||||
fn get_depth_buffer_bits(&self) -> Option<u16> {
|
||||
self.0.get_depth_buffer_bits()
|
||||
}
|
||||
|
||||
fn get_stencil_buffer_bits(&self) -> Option<u16> {
|
||||
self.0.get_stencil_buffer_bits()
|
||||
}
|
||||
|
||||
fn draw<'a, 'b, V, I, U>(
|
||||
&mut self,
|
||||
v: V,
|
||||
i: I,
|
||||
program: &glium::Program,
|
||||
uniforms: &U,
|
||||
draw_parameters: &glium::draw_parameters::DrawParameters<'_>,
|
||||
) -> Result<(), glium::DrawError>
|
||||
where
|
||||
V: glium::vertex::MultiVerticesSource<'b>,
|
||||
I: Into<glium::index::IndicesSource<'a>>,
|
||||
U: glium::uniforms::Uniforms,
|
||||
{
|
||||
self.0.draw(v, i, program, uniforms, draw_parameters)
|
||||
}
|
||||
|
||||
fn blit_from_frame(
|
||||
&self,
|
||||
source_rect: &glium::Rect,
|
||||
target_rect: &glium::BlitTarget,
|
||||
filter: glium::uniforms::MagnifySamplerFilter,
|
||||
) {
|
||||
self.0.blit_from_frame(source_rect, target_rect, filter);
|
||||
}
|
||||
|
||||
fn blit_from_simple_framebuffer(
|
||||
&self,
|
||||
source: &glium::framebuffer::SimpleFrameBuffer<'_>,
|
||||
source_rect: &glium::Rect,
|
||||
target_rect: &glium::BlitTarget,
|
||||
filter: glium::uniforms::MagnifySamplerFilter,
|
||||
) {
|
||||
self.0
|
||||
.blit_from_simple_framebuffer(source, source_rect, target_rect, filter)
|
||||
}
|
||||
|
||||
fn blit_from_multioutput_framebuffer(
|
||||
&self,
|
||||
source: &glium::framebuffer::MultiOutputFrameBuffer<'_>,
|
||||
source_rect: &glium::Rect,
|
||||
target_rect: &glium::BlitTarget,
|
||||
filter: glium::uniforms::MagnifySamplerFilter,
|
||||
) {
|
||||
self.0
|
||||
.blit_from_multioutput_framebuffer(source, source_rect, target_rect, filter)
|
||||
}
|
||||
|
||||
fn blit_color<S>(
|
||||
&self,
|
||||
source_rect: &glium::Rect,
|
||||
target: &S,
|
||||
target_rect: &glium::BlitTarget,
|
||||
filter: glium::uniforms::MagnifySamplerFilter,
|
||||
) where
|
||||
S: glium::Surface,
|
||||
{
|
||||
self.0.blit_color(source_rect, target, target_rect, filter)
|
||||
}
|
||||
}
|
||||
|
|
@ -1,17 +0,0 @@
|
|||
//! Common traits and types used for software rendering on graphics backends
|
||||
|
||||
use std::error::Error;
|
||||
use wayland_server::protocol::wl_shm::Format;
|
||||
|
||||
/// Trait that describes objects providing a software rendering implementation
|
||||
pub trait CpuGraphicsBackend<E: Error> {
|
||||
/// Render a given buffer of a given format at a specified place in the framebuffer
|
||||
///
|
||||
/// # Error
|
||||
/// Returns an error if the buffer size does not match the required amount of pixels
|
||||
/// for the given size or if the position and size is out of scope of the framebuffer.
|
||||
fn render(&mut self, buffer: &[u8], format: Format, at: (u32, u32), size: (u32, u32)) -> Result<(), E>;
|
||||
|
||||
/// Returns the dimensions of the framebuffer
|
||||
fn get_framebuffer_dimensions(&self) -> (u32, u32);
|
||||
}
|
||||
|
|
@ -0,0 +1,568 @@
|
|||
use std::ffi::CStr;
|
||||
use std::ptr;
|
||||
use std::sync::Arc;
|
||||
|
||||
use cgmath::{prelude::*, Matrix3, Vector2};
|
||||
|
||||
mod shaders;
|
||||
use crate::backend::allocator::dmabuf::{Dmabuf, WeakDmabuf};
|
||||
use crate::backend::egl::{EGLContext, EGLSurface, ffi::egl::types::EGLImage};
|
||||
use super::{Renderer, Frame, Bind, Unbind, Transform, Texture};
|
||||
|
||||
#[cfg(feature = "wayland_frontend")]
|
||||
use wayland_server::protocol::{wl_shm, wl_buffer};
|
||||
|
||||
#[allow(clippy::all, missing_docs)]
|
||||
pub mod ffi {
|
||||
include!(concat!(env!("OUT_DIR"), "/gl_bindings.rs"));
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Gles2Program {
|
||||
program: ffi::types::GLuint,
|
||||
uniform_tex: ffi::types::GLint,
|
||||
uniform_matrix: ffi::types::GLint,
|
||||
uniform_invert_y: ffi::types::GLint,
|
||||
uniform_alpha: ffi::types::GLint,
|
||||
attrib_position: ffi::types::GLint,
|
||||
attrib_tex_coords: ffi::types::GLint,
|
||||
}
|
||||
|
||||
pub struct Gles2Texture {
|
||||
texture: ffi::types::GLuint,
|
||||
texture_kind: usize,
|
||||
is_external: bool,
|
||||
y_inverted: bool,
|
||||
width: u32,
|
||||
height: u32,
|
||||
}
|
||||
|
||||
impl Texture for Gles2Texture {
|
||||
fn width(&self) -> u32 {
|
||||
self.width
|
||||
}
|
||||
fn height(&self) -> u32 {
|
||||
self.height
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
struct WeakGles2Buffer {
|
||||
dmabuf: WeakDmabuf,
|
||||
image: EGLImage,
|
||||
rbo: ffi::types::GLuint,
|
||||
fbo: ffi::types::GLuint,
|
||||
}
|
||||
|
||||
struct Gles2Buffer {
|
||||
internal: WeakGles2Buffer,
|
||||
_dmabuf: Dmabuf,
|
||||
}
|
||||
|
||||
pub struct Gles2Renderer {
|
||||
internal: Arc<Gles2RendererInternal>,
|
||||
buffers: Vec<WeakGles2Buffer>,
|
||||
current_buffer: Option<Gles2Buffer>,
|
||||
}
|
||||
|
||||
struct Gles2RendererInternal {
|
||||
gl: ffi::Gles2,
|
||||
egl: EGLContext,
|
||||
extensions: Vec<String>,
|
||||
programs: [Gles2Program; shaders::FRAGMENT_COUNT],
|
||||
logger: Option<*mut ::slog::Logger>,
|
||||
}
|
||||
|
||||
pub struct Gles2Frame {
|
||||
internal: Arc<Gles2RendererInternal>,
|
||||
projection: Matrix3<f32>,
|
||||
}
|
||||
|
||||
#[derive(thiserror::Error, Debug)]
|
||||
pub enum Gles2Error {
|
||||
#[error("Failed to compile Shader: {0}")]
|
||||
ShaderCompileError(&'static str),
|
||||
#[error("Failed to link Program")]
|
||||
ProgramLinkError,
|
||||
#[error("Failed to bind Framebuffer")]
|
||||
FramebufferBindingError,
|
||||
#[error("Failed to load GL functions from EGL")]
|
||||
GLFunctionLoaderError,
|
||||
/// The required GL extension is not supported by the underlying implementation
|
||||
#[error("None of the following GL extensions is supported by the underlying GL implementation, at least one is required: {0:?}")]
|
||||
GLExtensionNotSupported(&'static [&'static str]),
|
||||
#[error("Failed to active egl context")]
|
||||
ContextActivationError(#[from] crate::backend::egl::MakeCurrentError),
|
||||
#[error("Failed to convert dmabuf to EGLImage")]
|
||||
BindBufferEGLError(#[source] crate::backend::egl::Error),
|
||||
#[error("Unsupported pixel format: {0:?}")]
|
||||
#[cfg(feature = "wayland_frontend")]
|
||||
UnsupportedPixelFormat(wl_shm::Format),
|
||||
#[error("Error accessing the buffer ({0:?})")]
|
||||
#[cfg(feature = "wayland_frontend")]
|
||||
BufferAccessError(crate::wayland::shm::BufferAccessError),
|
||||
}
|
||||
|
||||
extern "system" fn gl_debug_log(_source: ffi::types::GLenum,
|
||||
gltype: ffi::types::GLenum,
|
||||
_id: ffi::types::GLuint,
|
||||
_severity: ffi::types::GLenum,
|
||||
_length: ffi::types::GLsizei,
|
||||
message: *const ffi::types::GLchar,
|
||||
user_param: *mut nix::libc::c_void)
|
||||
{
|
||||
let _ = std::panic::catch_unwind(move || {
|
||||
unsafe {
|
||||
let msg = CStr::from_ptr(message);
|
||||
let log = Box::from_raw(user_param as *mut ::slog::Logger);
|
||||
let message_utf8 = msg.to_string_lossy();
|
||||
match gltype {
|
||||
ffi::DEBUG_TYPE_ERROR | ffi::DEBUG_TYPE_UNDEFINED_BEHAVIOR => error!(log, "[GL] {}", message_utf8),
|
||||
ffi::DEBUG_TYPE_DEPRECATED_BEHAVIOR => warn!(log, "[GL] {}", message_utf8),
|
||||
_ => debug!(log, "[GL] {}", message_utf8),
|
||||
};
|
||||
std::mem::forget(log);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
unsafe fn compile_shader(gl: &ffi::Gles2, variant: ffi::types::GLuint, src: &'static str) -> Result<ffi::types::GLuint, Gles2Error> {
|
||||
let shader = gl.CreateShader(variant);
|
||||
gl.ShaderSource(shader, 1, &src.as_ptr() as *const *const u8 as *const *const i8, &(src.len() as i32) as *const _);
|
||||
gl.CompileShader(shader);
|
||||
|
||||
let mut status = ffi::FALSE as i32;
|
||||
gl.GetShaderiv(shader, ffi::COMPILE_STATUS, &mut status as *mut _);
|
||||
if status == ffi::FALSE as i32 {
|
||||
gl.DeleteShader(shader);
|
||||
return Err(Gles2Error::ShaderCompileError(src));
|
||||
}
|
||||
|
||||
Ok(shader)
|
||||
}
|
||||
|
||||
unsafe fn link_program(gl: &ffi::Gles2, vert_src: &'static str, frag_src: &'static str) -> Result<ffi::types::GLuint, Gles2Error> {
|
||||
let vert = compile_shader(gl, ffi::VERTEX_SHADER, vert_src)?;
|
||||
let frag = compile_shader(gl, ffi::FRAGMENT_SHADER, frag_src)?;
|
||||
let program = gl.CreateProgram();
|
||||
gl.AttachShader(program, vert);
|
||||
gl.AttachShader(program, frag);
|
||||
gl.LinkProgram(program);
|
||||
gl.DetachShader(program, vert);
|
||||
gl.DetachShader(program, frag);
|
||||
gl.DeleteShader(vert);
|
||||
gl.DeleteShader(frag);
|
||||
|
||||
let mut status = ffi::FALSE as i32;
|
||||
gl.GetProgramiv(program, ffi::LINK_STATUS, &mut status as *mut _);
|
||||
if status == ffi::FALSE as i32 {
|
||||
gl.DeleteProgram(program);
|
||||
return Err(Gles2Error::ProgramLinkError);
|
||||
}
|
||||
|
||||
Ok(program)
|
||||
}
|
||||
|
||||
unsafe fn texture_program(gl: &ffi::Gles2, frag: &'static str) -> Result<Gles2Program, Gles2Error> {
|
||||
let program = link_program(&gl, shaders::VERTEX_SHADER, frag)?;
|
||||
|
||||
let position = CStr::from_bytes_with_nul(b"position\0").expect("NULL terminated");
|
||||
let tex_coords = CStr::from_bytes_with_nul(b"tex_coords\0").expect("NULL terminated");
|
||||
let tex = CStr::from_bytes_with_nul(b"tex\0").expect("NULL terminated");
|
||||
let matrix = CStr::from_bytes_with_nul(b"matrix\0").expect("NULL terminated");
|
||||
let invert_y = CStr::from_bytes_with_nul(b"invert_y\0").expect("NULL terminated");
|
||||
let alpha = CStr::from_bytes_with_nul(b"alpha\0").expect("NULL terminated");
|
||||
|
||||
Ok(Gles2Program {
|
||||
program,
|
||||
uniform_tex: gl.GetUniformLocation(program, tex.as_ptr() as *const i8),
|
||||
uniform_matrix: gl.GetUniformLocation(program, matrix.as_ptr() as *const i8),
|
||||
uniform_invert_y: gl.GetUniformLocation(program, invert_y.as_ptr() as *const i8),
|
||||
uniform_alpha: gl.GetUniformLocation(program, alpha.as_ptr() as *const i8),
|
||||
attrib_position: gl.GetAttribLocation(program, position.as_ptr() as *const i8),
|
||||
attrib_tex_coords: gl.GetAttribLocation(program, tex_coords.as_ptr() as *const i8),
|
||||
})
|
||||
}
|
||||
|
||||
impl Gles2Renderer {
|
||||
pub fn new<L>(context: EGLContext, logger: L) -> Result<Gles2Renderer, Gles2Error>
|
||||
where
|
||||
L: Into<Option<::slog::Logger>>
|
||||
{
|
||||
let log = crate::slog_or_fallback(logger).new(o!("smithay_module" => "renderer_gles2"));
|
||||
|
||||
unsafe { context.make_current()? };
|
||||
|
||||
let (gl, exts, logger) = unsafe {
|
||||
let gl = ffi::Gles2::load_with(|s| crate::backend::egl::get_proc_address(s) as *const _);
|
||||
let ext_ptr = gl.GetString(ffi::EXTENSIONS) as *const i8;
|
||||
if ext_ptr.is_null() {
|
||||
return Err(Gles2Error::GLFunctionLoaderError);
|
||||
}
|
||||
|
||||
let exts = {
|
||||
let p = CStr::from_ptr(ext_ptr);
|
||||
let list = String::from_utf8(p.to_bytes().to_vec()).unwrap_or_else(|_| String::new());
|
||||
list.split(' ').map(|e| e.to_string()).collect::<Vec<_>>()
|
||||
};
|
||||
|
||||
info!(log, "Initializing OpenGL ES Renderer");
|
||||
info!(log, "GL Version: {:?}", CStr::from_ptr(gl.GetString(ffi::VERSION) as *const i8));
|
||||
info!(log, "GL Vendor: {:?}", CStr::from_ptr(gl.GetString(ffi::VENDOR) as *const i8));
|
||||
info!(log, "GL Renderer: {:?}", CStr::from_ptr(gl.GetString(ffi::RENDERER) as *const i8));
|
||||
info!(log, "Supported GL Extensions: {:?}", exts);
|
||||
|
||||
// required for the manditory wl_shm formats
|
||||
if !exts.iter().any(|ext| ext == "GL_EXT_texture_format_BGRA8888") {
|
||||
return Err(Gles2Error::GLExtensionNotSupported(&["GL_EXT_texture_format_BGRA8888"]));
|
||||
}
|
||||
// required for buffers without linear memory layout
|
||||
if !exts.iter().any(|ext| ext == "GL_EXT_unpack_subimage") {
|
||||
return Err(Gles2Error::GLExtensionNotSupported(&["GL_EXT_unpack_subimage"]));
|
||||
}
|
||||
|
||||
let logger = if exts.iter().any(|ext| ext == "GL_KHR_debug") {
|
||||
let logger = Box::into_raw(Box::new(log.clone()));
|
||||
gl.Enable(ffi::DEBUG_OUTPUT);
|
||||
gl.Enable(ffi::DEBUG_OUTPUT_SYNCHRONOUS);
|
||||
gl.DebugMessageCallback(Some(gl_debug_log), logger as *mut nix::libc::c_void);
|
||||
Some(logger)
|
||||
} else { None };
|
||||
|
||||
(gl, exts, logger)
|
||||
};
|
||||
|
||||
let programs = {
|
||||
unsafe { [
|
||||
texture_program(&gl, shaders::FRAGMENT_SHADER_ABGR)?,
|
||||
texture_program(&gl, shaders::FRAGMENT_SHADER_XBGR)?,
|
||||
texture_program(&gl, shaders::FRAGMENT_SHADER_BGRA)?,
|
||||
texture_program(&gl, shaders::FRAGMENT_SHADER_BGRX)?,
|
||||
texture_program(&gl, shaders::FRAGMENT_SHADER_EXTERNAL)?,
|
||||
] }
|
||||
};
|
||||
|
||||
Ok(Gles2Renderer {
|
||||
internal: Arc::new(Gles2RendererInternal {
|
||||
gl,
|
||||
egl: context,
|
||||
extensions: exts,
|
||||
programs,
|
||||
logger,
|
||||
}),
|
||||
buffers: Vec::new(),
|
||||
current_buffer: None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl Bind<&EGLSurface> for Gles2Renderer {
|
||||
fn bind(&mut self, surface: &EGLSurface) -> Result<(), Gles2Error> {
|
||||
if self.current_buffer.is_some() {
|
||||
self.unbind()?;
|
||||
}
|
||||
|
||||
unsafe {
|
||||
self.internal.egl.make_current_with_surface(&surface)?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl Bind<Dmabuf> for Gles2Renderer {
|
||||
fn bind(&mut self, dmabuf: Dmabuf) -> Result<(), Gles2Error> {
|
||||
if self.current_buffer.is_some() {
|
||||
self.unbind()?;
|
||||
}
|
||||
|
||||
unsafe {
|
||||
self.internal.egl.make_current()?;
|
||||
}
|
||||
|
||||
// Free outdated buffer resources
|
||||
// TODO: Replace with `drain_filter` once it lands
|
||||
let mut i = 0;
|
||||
while i != self.buffers.len() {
|
||||
if self.buffers[i].dmabuf.upgrade().is_none() {
|
||||
self.buffers.remove(i);
|
||||
} else {
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
|
||||
let buffer = self.buffers
|
||||
.iter()
|
||||
.find(|buffer| dmabuf == buffer.dmabuf)
|
||||
.map(|buf| {
|
||||
let dmabuf = buf.dmabuf.upgrade().expect("Dmabuf equal check succeeded for freed buffer");
|
||||
Ok(Gles2Buffer {
|
||||
internal: buf.clone(),
|
||||
// we keep the dmabuf alive as long as we are bound
|
||||
_dmabuf: dmabuf
|
||||
})
|
||||
})
|
||||
.unwrap_or_else(|| {
|
||||
let image = self.internal.egl.display.create_image_from_dmabuf(&dmabuf).map_err(Gles2Error::BindBufferEGLError)?;
|
||||
|
||||
unsafe {
|
||||
let mut rbo = 0;
|
||||
self.internal.gl.GenRenderbuffers(1, &mut rbo as *mut _);
|
||||
self.internal.gl.BindRenderbuffer(ffi::RENDERBUFFER, rbo);
|
||||
self.internal.gl.EGLImageTargetRenderbufferStorageOES(ffi::RENDERBUFFER, image);
|
||||
self.internal.gl.BindRenderbuffer(ffi::RENDERBUFFER, 0);
|
||||
|
||||
let mut fbo = 0;
|
||||
self.internal.gl.GenFramebuffers(1, &mut fbo as *mut _);
|
||||
self.internal.gl.BindFramebuffer(ffi::FRAMEBUFFER, fbo);
|
||||
self.internal.gl.FramebufferRenderbuffer(ffi::FRAMEBUFFER, ffi::COLOR_ATTACHMENT0, ffi::RENDERBUFFER, rbo);
|
||||
let status = self.internal.gl.CheckFramebufferStatus(ffi::FRAMEBUFFER);
|
||||
self.internal.gl.BindFramebuffer(ffi::FRAMEBUFFER, 0);
|
||||
|
||||
if status != ffi::FRAMEBUFFER_COMPLETE {
|
||||
//TODO wrap image and drop here
|
||||
return Err(Gles2Error::FramebufferBindingError);
|
||||
}
|
||||
|
||||
let weak = WeakGles2Buffer {
|
||||
dmabuf: dmabuf.weak(),
|
||||
image,
|
||||
rbo,
|
||||
fbo,
|
||||
};
|
||||
|
||||
self.buffers.push(weak.clone());
|
||||
|
||||
Ok(Gles2Buffer {
|
||||
internal: weak,
|
||||
_dmabuf: dmabuf
|
||||
})
|
||||
}
|
||||
})?;
|
||||
|
||||
unsafe {
|
||||
self.internal.gl.BindFramebuffer(ffi::FRAMEBUFFER, buffer.internal.fbo);
|
||||
}
|
||||
self.current_buffer = Some(buffer);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl Unbind for Gles2Renderer {
|
||||
fn unbind(&mut self) -> Result<(), Gles2Error> {
|
||||
unsafe {
|
||||
self.internal.egl.make_current()?;
|
||||
self.internal.gl.BindFramebuffer(ffi::FRAMEBUFFER, 0);
|
||||
}
|
||||
self.current_buffer = None;
|
||||
let _ = self.internal.egl.unbind();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl Renderer for Gles2Renderer {
|
||||
type Error = Gles2Error;
|
||||
type Texture = Gles2Texture;
|
||||
type Frame = Gles2Frame;
|
||||
|
||||
fn begin(&mut self, width: u32, height: u32, transform: Transform) -> Result<Gles2Frame, Gles2Error> {
|
||||
if !self.internal.egl.is_current() {
|
||||
// Do not call this unconditionally.
|
||||
// If surfaces are in use (e.g. for winit) this would unbind them.
|
||||
unsafe { self.internal.egl.make_current()?; }
|
||||
}
|
||||
unsafe {
|
||||
self.internal.gl.Viewport(0, 0, width as i32, height as i32);
|
||||
|
||||
self.internal.gl.Enable(ffi::BLEND);
|
||||
self.internal.gl.BlendFunc(ffi::ONE, ffi::ONE_MINUS_SRC_ALPHA);
|
||||
}
|
||||
|
||||
// output transformation passed in by the user
|
||||
let mut projection = Matrix3::<f32>::identity();
|
||||
projection = projection * Matrix3::from_translation(Vector2::new(width as f32 / 2.0, height as f32 / 2.0));
|
||||
projection = projection * transform.matrix();
|
||||
let (transformed_width, transformed_height) = transform.transform_size(width, height);
|
||||
projection = projection * Matrix3::from_translation(Vector2::new(-(transformed_width as f32) / 2.0, -(transformed_height as f32) / 2.0));
|
||||
|
||||
// replicate https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glOrtho.xml
|
||||
// glOrtho(0, width, 0, height, 1, 1);
|
||||
let mut renderer = Matrix3::<f32>::identity();
|
||||
let t = Matrix3::<f32>::identity();
|
||||
let x = 2.0 / (width as f32);
|
||||
let y = 2.0 / (height as f32);
|
||||
|
||||
// Rotation & Reflection
|
||||
renderer[0][0] = x * t[0][0];
|
||||
renderer[1][0] = x * t[0][1];
|
||||
renderer[0][1] = y * -t[1][0];
|
||||
renderer[1][1] = y * -t[1][1];
|
||||
|
||||
//Translation
|
||||
renderer[2][0] = -(1.0f32.copysign(renderer[0][0] + renderer[1][0]));
|
||||
renderer[2][1] = -(1.0f32.copysign(renderer[0][1] + renderer[1][1]));
|
||||
|
||||
Ok(Gles2Frame {
|
||||
internal: self.internal.clone(),
|
||||
projection: projection * renderer,
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(feature = "wayland_frontend")]
|
||||
fn shm_formats(&self) -> &[wl_shm::Format] {
|
||||
&[
|
||||
wl_shm::Format::Abgr8888,
|
||||
wl_shm::Format::Xbgr8888,
|
||||
wl_shm::Format::Argb8888,
|
||||
wl_shm::Format::Xrgb8888,
|
||||
]
|
||||
}
|
||||
|
||||
#[cfg(feature = "wayland_frontend")]
|
||||
fn import_shm(&self, buffer: &wl_buffer::WlBuffer) -> Result<Self::Texture, Self::Error> {
|
||||
use crate::wayland::shm::with_buffer_contents;
|
||||
|
||||
with_buffer_contents(&buffer, |slice, data| {
|
||||
if !self.internal.egl.is_current() {
|
||||
unsafe { self.internal.egl.make_current()?; }
|
||||
}
|
||||
|
||||
let offset = data.offset as i32;
|
||||
let width = data.width as i32;
|
||||
let height = data.height as i32;
|
||||
let stride = data.stride as i32;
|
||||
|
||||
// number of bytes per pixel
|
||||
// TODO: compute from data.format
|
||||
let pixelsize = 4i32;
|
||||
|
||||
// ensure consistency, the SHM handler of smithay should ensure this
|
||||
assert!((offset + (height - 1) * stride + width * pixelsize) as usize <= slice.len());
|
||||
|
||||
let (gl_format, shader_idx) = match data.format {
|
||||
wl_shm::Format::Abgr8888 => (ffi::RGBA, 0),
|
||||
wl_shm::Format::Xbgr8888 => (ffi::RGBA, 1),
|
||||
wl_shm::Format::Argb8888 => (ffi::BGRA_EXT, 2),
|
||||
wl_shm::Format::Xrgb8888 => (ffi::BGRA_EXT, 3),
|
||||
format => return Err(Gles2Error::UnsupportedPixelFormat(format)),
|
||||
};
|
||||
|
||||
let mut tex = 0;
|
||||
unsafe {
|
||||
self.internal.gl.GenTextures(1, &mut tex);
|
||||
self.internal.gl.BindTexture(ffi::TEXTURE_2D, tex);
|
||||
|
||||
self.internal.gl.TexParameteri(ffi::TEXTURE_2D, ffi::TEXTURE_WRAP_S, ffi::CLAMP_TO_EDGE as i32);
|
||||
self.internal.gl.TexParameteri(ffi::TEXTURE_2D, ffi::TEXTURE_WRAP_T, ffi::CLAMP_TO_EDGE as i32);
|
||||
self.internal.gl.PixelStorei(ffi::UNPACK_ROW_LENGTH, stride / pixelsize);
|
||||
self.internal.gl.TexImage2D(ffi::TEXTURE_2D, 0, gl_format as i32, width, height, 0, gl_format, ffi::UNSIGNED_BYTE as u32, slice.as_ptr() as *const _);
|
||||
|
||||
self.internal.gl.PixelStorei(ffi::UNPACK_ROW_LENGTH, 0);
|
||||
self.internal.gl.BindTexture(ffi::TEXTURE_2D, 0);
|
||||
}
|
||||
|
||||
Ok(Gles2Texture {
|
||||
texture: tex,
|
||||
texture_kind: shader_idx,
|
||||
is_external: false,
|
||||
y_inverted: false,
|
||||
width: width as u32,
|
||||
height: height as u32,
|
||||
})
|
||||
}).map_err(Gles2Error::BufferAccessError)?
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Gles2RendererInternal {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
if self.egl.make_current().is_ok() {
|
||||
for program in &self.programs {
|
||||
self.gl.DeleteProgram(program.program);
|
||||
}
|
||||
|
||||
if self.extensions.iter().any(|ext| ext == "GL_KHR_debug") {
|
||||
self.gl.Disable(ffi::DEBUG_OUTPUT);
|
||||
self.gl.DebugMessageCallback(None, ptr::null());
|
||||
}
|
||||
if let Some(logger) = self.logger {
|
||||
let _ = Box::from_raw(logger);
|
||||
}
|
||||
|
||||
let _ = self.egl.unbind();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static VERTS: [ffi::types::GLfloat; 8] = [
|
||||
1.0, 0.0, // top right
|
||||
0.0, 0.0, // top left
|
||||
1.0, 1.0, // bottom right
|
||||
0.0, 1.0, // bottom left
|
||||
];
|
||||
|
||||
static TEX_COORDS: [ffi::types::GLfloat; 8] = [
|
||||
1.0, 0.0, // top right
|
||||
0.0, 0.0, // top left
|
||||
1.0, 1.0, // bottom right
|
||||
0.0, 1.0, // bottom left
|
||||
];
|
||||
|
||||
impl Frame for Gles2Frame {
|
||||
type Error = Gles2Error;
|
||||
type Texture = Gles2Texture;
|
||||
|
||||
fn clear(&mut self, color: [f32; 4]) -> Result<(), Self::Error> {
|
||||
unsafe {
|
||||
self.internal.gl.ClearColor(color[0], color[1], color[2], color[3]);
|
||||
self.internal.gl.Clear(ffi::COLOR_BUFFER_BIT);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn render_texture(&mut self, tex: &Self::Texture, mut matrix: Matrix3<f32>, alpha: f32) -> Result<(), Self::Error> {
|
||||
//apply output transformation
|
||||
matrix = self.projection * matrix;
|
||||
|
||||
let target = if tex.is_external { ffi::TEXTURE_EXTERNAL_OES } else { ffi::TEXTURE_2D };
|
||||
|
||||
// render
|
||||
unsafe {
|
||||
self.internal.gl.ActiveTexture(ffi::TEXTURE0);
|
||||
self.internal.gl.BindTexture(target, tex.texture);
|
||||
self.internal.gl.TexParameteri(target, ffi::TEXTURE_MIN_FILTER, ffi::LINEAR as i32);
|
||||
self.internal.gl.UseProgram(self.internal.programs[tex.texture_kind].program);
|
||||
|
||||
self.internal.gl.Uniform1i(self.internal.programs[tex.texture_kind].uniform_tex, 0);
|
||||
self.internal.gl.UniformMatrix3fv(self.internal.programs[tex.texture_kind].uniform_matrix, 1, ffi::FALSE, matrix.as_ptr());
|
||||
self.internal.gl.Uniform1i(self.internal.programs[tex.texture_kind].uniform_invert_y, if tex.y_inverted { 1 } else { 0 });
|
||||
self.internal.gl.Uniform1f(self.internal.programs[tex.texture_kind].uniform_alpha, alpha);
|
||||
|
||||
self.internal.gl.VertexAttribPointer(self.internal.programs[tex.texture_kind].attrib_position as u32, 2, ffi::FLOAT, ffi::FALSE, 0, VERTS.as_ptr() as *const _);
|
||||
self.internal.gl.VertexAttribPointer(self.internal.programs[tex.texture_kind].attrib_tex_coords as u32, 2, ffi::FLOAT, ffi::FALSE, 0, TEX_COORDS.as_ptr() as *const _);
|
||||
|
||||
self.internal.gl.EnableVertexAttribArray(self.internal.programs[tex.texture_kind].attrib_position as u32);
|
||||
self.internal.gl.EnableVertexAttribArray(self.internal.programs[tex.texture_kind].attrib_tex_coords as u32);
|
||||
|
||||
self.internal.gl.DrawArrays(ffi::TRIANGLE_STRIP, 0, 4);
|
||||
|
||||
self.internal.gl.DisableVertexAttribArray(self.internal.programs[tex.texture_kind].attrib_position as u32);
|
||||
self.internal.gl.DisableVertexAttribArray(self.internal.programs[tex.texture_kind].attrib_tex_coords as u32);
|
||||
|
||||
self.internal.gl.BindTexture(target, 0);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn finish(self) -> Result<(), crate::backend::SwapBuffersError> {
|
||||
unsafe {
|
||||
self.internal.gl.Flush();
|
||||
self.internal.gl.Disable(ffi::BLEND);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,92 @@
|
|||
/*
|
||||
* OpenGL Shaders
|
||||
*/
|
||||
pub const VERTEX_SHADER: &str = r#"
|
||||
#version 100
|
||||
uniform mat3 matrix;
|
||||
uniform bool invert_y;
|
||||
attribute vec2 position;
|
||||
attribute vec2 tex_coords;
|
||||
varying vec2 v_tex_coords;
|
||||
void main() {
|
||||
gl_Position = vec4(matrix * vec3(position, 1.0), 1.0);
|
||||
if (invert_y) {
|
||||
v_tex_coords = vec2(tex_coords.x, 1.0 - tex_coords.y);
|
||||
} else {
|
||||
v_tex_coords = tex_coords;
|
||||
}
|
||||
}"#;
|
||||
|
||||
pub const FRAGMENT_COUNT: usize = 5;
|
||||
|
||||
pub const FRAGMENT_SHADER_ABGR: &str = r#"
|
||||
#version 100
|
||||
precision mediump float;
|
||||
uniform sampler2D tex;
|
||||
uniform float alpha;
|
||||
varying vec2 v_tex_coords;
|
||||
void main() {
|
||||
vec4 color = texture2D(tex, v_tex_coords);
|
||||
gl_FragColor.r = color.w;
|
||||
gl_FragColor.g = color.z;
|
||||
gl_FragColor.b = color.y;
|
||||
gl_FragColor.a = color.x * alpha;
|
||||
}
|
||||
"#;
|
||||
|
||||
pub const FRAGMENT_SHADER_XBGR: &str = r#"
|
||||
#version 100
|
||||
precision mediump float;
|
||||
uniform sampler2D tex;
|
||||
uniform float alpha;
|
||||
varying vec2 v_tex_coords;
|
||||
void main() {
|
||||
vec4 color = texture2D(tex, v_tex_coords);
|
||||
gl_FragColor.r = color.w;
|
||||
gl_FragColor.g = color.z;
|
||||
gl_FragColor.b = color.y;
|
||||
gl_FragColor.a = alpha;
|
||||
}
|
||||
"#;
|
||||
|
||||
pub const FRAGMENT_SHADER_BGRA: &str = r#"
|
||||
#version 100
|
||||
precision mediump float;
|
||||
uniform sampler2D tex;
|
||||
uniform float alpha;
|
||||
varying vec2 v_tex_coords;
|
||||
void main() {
|
||||
vec4 color = texture2D(tex, v_tex_coords);
|
||||
gl_FragColor.r = color.z;
|
||||
gl_FragColor.g = color.y;
|
||||
gl_FragColor.b = color.x;
|
||||
gl_FragColor.a = color.w * alpha;
|
||||
}
|
||||
"#;
|
||||
|
||||
pub const FRAGMENT_SHADER_BGRX: &str = r#"
|
||||
#version 100
|
||||
precision mediump float;
|
||||
uniform sampler2D tex;
|
||||
uniform float alpha;
|
||||
varying vec2 v_tex_coords;
|
||||
void main() {
|
||||
vec4 color = texture2D(tex, v_tex_coords);
|
||||
gl_FragColor.r = color.z;
|
||||
gl_FragColor.g = color.y;
|
||||
gl_FragColor.b = color.x;
|
||||
gl_FragColor.a = alpha;
|
||||
}
|
||||
"#;
|
||||
|
||||
pub const FRAGMENT_SHADER_EXTERNAL: &str = r#"
|
||||
#version 100
|
||||
#extension GL_OES_EGL_image_external : require
|
||||
precision mediump float;
|
||||
uniform samplerExternalOES tex;
|
||||
uniform float alpha;
|
||||
varying vec2 v_tex_coords;
|
||||
void main() {
|
||||
gl_FragColor = texture2D(tex, v_tex_coords) * alpha;
|
||||
}
|
||||
"#;
|
||||
|
|
@ -0,0 +1,173 @@
|
|||
use std::error::Error;
|
||||
|
||||
use cgmath::{prelude::*, Matrix3, Vector2};
|
||||
#[cfg(feature = "wayland_frontend")]
|
||||
use wayland_server::protocol::{wl_shm, wl_buffer};
|
||||
|
||||
use crate::backend::SwapBuffersError;
|
||||
#[cfg(feature = "renderer_gl")]
|
||||
pub mod gles2;
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
|
||||
pub enum Transform {
|
||||
Normal,
|
||||
_90,
|
||||
_180,
|
||||
_270,
|
||||
Flipped,
|
||||
Flipped90,
|
||||
Flipped180,
|
||||
Flipped270,
|
||||
}
|
||||
|
||||
impl Transform {
|
||||
pub fn matrix(&self) -> Matrix3<f32> {
|
||||
match self {
|
||||
Transform::Normal => Matrix3::new(
|
||||
1.0, 0.0, 0.0,
|
||||
0.0, 1.0, 0.0,
|
||||
0.0, 0.0, 1.0,
|
||||
),
|
||||
Transform::_90 => Matrix3::new(
|
||||
0.0, -1.0, 0.0,
|
||||
1.0, 0.0, 0.0,
|
||||
0.0, 0.0, 1.0,
|
||||
),
|
||||
Transform::_180 => Matrix3::new(
|
||||
-1.0, 0.0, 0.0,
|
||||
0.0, -1.0, 0.0,
|
||||
0.0, 0.0, 1.0,
|
||||
),
|
||||
Transform::_270 => Matrix3::new(
|
||||
0.0, 1.0, 0.0,
|
||||
-1.0, 0.0, 0.0,
|
||||
0.0, 0.0, 1.0,
|
||||
),
|
||||
Transform::Flipped => Matrix3::new(
|
||||
-1.0, 0.0, 0.0,
|
||||
0.0, 1.0, 0.0,
|
||||
0.0, 0.0, 1.0,
|
||||
),
|
||||
Transform::Flipped90 => Matrix3::new(
|
||||
0.0, 1.0, 0.0,
|
||||
1.0, 0.0, 0.0,
|
||||
0.0, 0.0, 1.0,
|
||||
),
|
||||
Transform::Flipped180 => Matrix3::new(
|
||||
1.0, 0.0, 0.0,
|
||||
0.0, -1.0, 0.0,
|
||||
0.0, 0.0, 1.0,
|
||||
),
|
||||
Transform::Flipped270 => Matrix3::new(
|
||||
0.0, -1.0, 0.0,
|
||||
-1.0, 0.0, 0.0,
|
||||
0.0, 0.0, 1.0,
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn invert(&self) -> Transform {
|
||||
match self {
|
||||
Transform::Normal => Transform::Normal,
|
||||
Transform::Flipped => Transform::Flipped,
|
||||
Transform::_90 => Transform::_270,
|
||||
Transform::_180 => Transform::_180,
|
||||
Transform::_270 => Transform::_90,
|
||||
Transform::Flipped90 => Transform::Flipped270,
|
||||
Transform::Flipped180 => Transform::Flipped180,
|
||||
Transform::Flipped270 => Transform::Flipped90,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn transform_size(&self, width: u32, height: u32) -> (u32, u32) {
|
||||
if *self == Transform::_90
|
||||
|| *self == Transform::_270
|
||||
|| *self == Transform::Flipped90
|
||||
|| *self == Transform::Flipped270
|
||||
{
|
||||
(height, width)
|
||||
} else {
|
||||
(width, height)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "wayland-frontend")]
|
||||
impl From<wayland_server::protocol::wl_output::Transform> for Transform {
|
||||
fn from(transform: wayland_server::protocol::wl_output::Transform) -> Transform {
|
||||
use wayland_server::protocol::wl_output::Transform::*;
|
||||
match transform {
|
||||
Normal => Transform::Normal,
|
||||
_90 => Transform::_90,
|
||||
_180 => Transform::_180,
|
||||
_270 => Transform::_270,
|
||||
Flipped => Transform::Flipped,
|
||||
Flipped90 => Transform::Flipped90,
|
||||
Flipped180 => Transform::Flipped180,
|
||||
Flipped270 => Transform::Flipped270,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub trait Bind<Target>: Unbind {
|
||||
fn bind(&mut self, target: Target) -> Result<(), <Self as Renderer>::Error>;
|
||||
}
|
||||
|
||||
pub trait Unbind: Renderer {
|
||||
fn unbind(&mut self) -> Result<(), <Self as Renderer>::Error>;
|
||||
}
|
||||
|
||||
pub trait Texture {
|
||||
fn size(&self) -> (u32, u32) {
|
||||
(self.width(), self.height())
|
||||
}
|
||||
|
||||
fn width(&self) -> u32;
|
||||
fn height(&self) -> u32;
|
||||
}
|
||||
|
||||
pub trait Renderer {
|
||||
type Error: Error;
|
||||
type Texture: Texture;
|
||||
type Frame: Frame<Error=Self::Error, Texture=Self::Texture>;
|
||||
|
||||
#[must_use]
|
||||
fn begin(&mut self, width: u32, height: u32, transform: Transform) -> Result<Self::Frame, Self::Error>;
|
||||
|
||||
#[cfg(feature = "wayland_frontend")]
|
||||
fn shm_formats(&self) -> &[wl_shm::Format] {
|
||||
// Mandatory
|
||||
&[wl_shm::Format::Argb8888, wl_shm::Format::Xrgb8888]
|
||||
}
|
||||
#[cfg(feature = "wayland_frontend")]
|
||||
fn import_shm(&self, buffer: &wl_buffer::WlBuffer) -> Result<Self::Texture, Self::Error>;
|
||||
}
|
||||
|
||||
pub trait Frame {
|
||||
type Error: Error;
|
||||
type Texture: Texture;
|
||||
|
||||
fn clear(&mut self, color: [f32; 4]) -> Result<(), Self::Error>;
|
||||
fn render_texture(&mut self, texture: &Self::Texture, matrix: Matrix3<f32>, alpha: f32) -> Result<(), Self::Error>;
|
||||
fn render_texture_at(&mut self, texture: &Self::Texture, pos: (i32, i32), transform: Transform, alpha: f32) -> Result<(), Self::Error> {
|
||||
let mut mat = Matrix3::<f32>::identity();
|
||||
|
||||
// position and scale
|
||||
let size = texture.size();
|
||||
mat = mat * Matrix3::from_translation(Vector2::new(pos.0 as f32, pos.1 as f32));
|
||||
mat = mat * Matrix3::from_nonuniform_scale(size.0 as f32, size.1 as f32);
|
||||
|
||||
//apply surface transformation
|
||||
mat = mat * Matrix3::from_translation(Vector2::new(0.5, 0.5));
|
||||
if transform == Transform::Normal {
|
||||
assert_eq!(mat, mat * transform.invert().matrix());
|
||||
assert_eq!(transform.matrix(), Matrix3::<f32>::identity());
|
||||
}
|
||||
mat = mat * transform.invert().matrix();
|
||||
mat = mat * Matrix3::from_translation(Vector2::new(-0.5, -0.5));
|
||||
|
||||
self.render_texture(texture, mat, alpha)
|
||||
}
|
||||
|
||||
fn finish(self) -> Result<(), SwapBuffersError>;
|
||||
}
|
||||
Loading…
Reference in New Issue