AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-12-26 13:41:07 +00:00
Code Issues Projects Releases Wiki Activity
440c207146
gtk/gsk/gpu/gskglframe.c

241 lines
6.8 KiB
C
Raw Normal View History

gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
#include "config.h"
#include "gskglframeprivate.h"
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
#include "gskgpuglobalsopprivate.h"
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
#include "gskgpuopprivate.h"
gpu: Add a GL optimization Use glDrawArraysInstancedBaseInstance() to draw. (Yay for GL naming.) That allows setting up the offset in the vertex array without having to glVertexAttribPointer() everything again. However, this is only supported since GL 4.2 and not at all in stock GLES, so we need to have code that can work without it. Fortunately, it is mandatory in Vulkan, so every recent GPU supports it. And if that GPU has a proper driver, it will also expose the GL extension for it. (Hint: You can check https://opengles.gpuinfo.org/listextensions.php for how many proper drivers exist outside of Mesa.)
2023-09-24 06:40:05 +00:00
#include "gskgpushaderopprivate.h"
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
#include "gskglbufferprivate.h"
gpu: Refactor image handling Introduce a new GskGpuImageDescriptors object that tracks descriptors for a set of images that can be managed by the GPU. Then have each GskGpuShaderOp just reference the descriptors object they are using, so that the coe can set things up properly. To reference an image, the ops now just reference their descriptor - which is the uint32 we've been sending to the shaders since forever.
2023-10-03 19:04:21 +00:00
#include "gskgldescriptorsprivate.h"
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
#include "gskgldeviceprivate.h"
gpu: Add importing of GL textures to the GL renderer syncing with the GLsync is kind of a hack (because we just do it on import), but it works.
2023-11-01 16:14:43 +00:00
#include "gskglimageprivate.h"
gpu: Add support for dmabuf import to GL
2023-11-02 05:45:09 +00:00
#include "gdkdmabuftextureprivate.h"
#include "gdkglcontextprivate.h"
gpu: Add importing of GL textures to the GL renderer syncing with the GLsync is kind of a hack (because we just do it on import), but it works.
2023-11-01 16:14:43 +00:00
#include "gdkgltextureprivate.h"
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
struct _GskGLFrame
{
GskGpuFrame parent_instance;
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
GLuint globals_buffer_id;
guint next_texture_slot;
GHashTable *vaos;
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
};
struct _GskGLFrameClass
{
GskGpuFrameClass parent_class;
};
G_DEFINE_TYPE (GskGLFrame, gsk_gl_frame, GSK_TYPE_GPU_FRAME)
static gboolean
gsk_gl_frame_is_busy (GskGpuFrame *frame)
{
return FALSE;
}
static void
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
gsk_gl_frame_setup (GskGpuFrame *frame)
{
GskGLFrame *self = GSK_GL_FRAME (frame);
glGenBuffers (1, &self->globals_buffer_id);
}
static void
gsk_gl_frame_cleanup (GskGpuFrame *frame)
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
{
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
GskGLFrame *self = GSK_GL_FRAME (frame);
self->next_texture_slot = 0;
GSK_GPU_FRAME_CLASS (gsk_gl_frame_parent_class)->cleanup (frame);
}
gpu: Add importing of GL textures to the GL renderer syncing with the GLsync is kind of a hack (because we just do it on import), but it works.
2023-11-01 16:14:43 +00:00
static GskGpuImage *
gsk_gl_frame_upload_texture (GskGpuFrame *frame,
gboolean with_mipmap,
GdkTexture *texture)
{
if (GDK_IS_GL_TEXTURE (texture))
{
GdkGLTexture *gl_texture = GDK_GL_TEXTURE (texture);
if (gdk_gl_context_is_shared (GDK_GL_CONTEXT (gsk_gpu_frame_get_context (frame)),
gdk_gl_texture_get_context (gl_texture)))
{
GskGpuImage *image;
GLsync sync;
image = gsk_gl_image_new_for_texture (GSK_GL_DEVICE (gsk_gpu_frame_get_device (frame)),
texture,
gdk_gl_texture_get_id (gl_texture),
FALSE,
gdk_gl_texture_has_mipmap (gl_texture) ? (GSK_GPU_IMAGE_CAN_MIPMAP | GSK_GPU_IMAGE_MIPMAP) : 0);
/* This is a hack, but it works */
sync = gdk_gl_texture_get_sync (gl_texture);
if (sync)
glWaitSync (sync, 0, GL_TIMEOUT_IGNORED);
return image;
}
}
gpu: Add support for dmabuf import to GL
2023-11-02 05:45:09 +00:00
else if (GDK_IS_DMABUF_TEXTURE (texture))
{
gboolean external;
GLuint tex_id;
tex_id = gdk_gl_context_import_dmabuf (GDK_GL_CONTEXT (gsk_gpu_frame_get_context (frame)),
gdk_texture_get_width (texture),
gdk_texture_get_height (texture),
gdk_dmabuf_texture_get_dmabuf (GDK_DMABUF_TEXTURE (texture)),
&external);
if (tex_id)
{
return gsk_gl_image_new_for_texture (GSK_GL_DEVICE (gsk_gpu_frame_get_device (frame)),
texture,
tex_id,
TRUE,
(external ? GSK_GPU_IMAGE_EXTERNAL | GSK_GPU_IMAGE_NO_BLIT : 0));
}
}
gpu: Add importing of GL textures to the GL renderer syncing with the GLsync is kind of a hack (because we just do it on import), but it works.
2023-11-01 16:14:43 +00:00
return GSK_GPU_FRAME_CLASS (gsk_gl_frame_parent_class)->upload_texture (frame, with_mipmap, texture);
}
gpu: Refactor image handling Introduce a new GskGpuImageDescriptors object that tracks descriptors for a set of images that can be managed by the GPU. Then have each GskGpuShaderOp just reference the descriptors object they are using, so that the coe can set things up properly. To reference an image, the ops now just reference their descriptor - which is the uint32 we've been sending to the shaders since forever.
2023-10-03 19:04:21 +00:00
static GskGpuDescriptors *
gsk_gl_frame_create_descriptors (GskGpuFrame *frame)
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
{
gpu: Refactor image handling Introduce a new GskGpuImageDescriptors object that tracks descriptors for a set of images that can be managed by the GPU. Then have each GskGpuShaderOp just reference the descriptors object they are using, so that the coe can set things up properly. To reference an image, the ops now just reference their descriptor - which is the uint32 we've been sending to the shaders since forever.
2023-10-03 19:04:21 +00:00
return GSK_GPU_DESCRIPTORS (gsk_gl_descriptors_new (GSK_GL_DEVICE (gsk_gpu_frame_get_device (frame))));
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
}
static GskGpuBuffer *
gsk_gl_frame_create_vertex_buffer (GskGpuFrame *frame,
gsize size)
{
gpu: Add a GL optimization Use glDrawArraysInstancedBaseInstance() to draw. (Yay for GL naming.) That allows setting up the offset in the vertex array without having to glVertexAttribPointer() everything again. However, this is only supported since GL 4.2 and not at all in stock GLES, so we need to have code that can work without it. Fortunately, it is mandatory in Vulkan, so every recent GPU supports it. And if that GPU has a proper driver, it will also expose the GL extension for it. (Hint: You can check https://opengles.gpuinfo.org/listextensions.php for how many proper drivers exist outside of Mesa.)
2023-09-24 06:40:05 +00:00
GskGLFrame *self = GSK_GL_FRAME (frame);
/* We could also reassign them all to the new buffer here?
* Is that faster?
*/
g_hash_table_remove_all (self->vaos);
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
return gsk_gl_buffer_new (GL_ARRAY_BUFFER, size, GL_WRITE_ONLY);
}
gpu: Add float array to shaders and add an ubershader ... and use it for a naive color node implementation using both so I can test it actually works.
2023-08-30 19:57:41 +00:00
static GskGpuBuffer *
gsk_gl_frame_create_storage_buffer (GskGpuFrame *frame,
gsize size)
{
return gsk_gl_buffer_new (GL_UNIFORM_BUFFER, size, GL_WRITE_ONLY);
}
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
static void
gsk_gl_frame_submit (GskGpuFrame *frame,
GskGpuBuffer *vertex_buffer,
GskGpuOp *op)
{
GskGLFrame *self = GSK_GL_FRAME (frame);
gpu: Add a CommandState struct to the command vfuncs This way, we can make it writable and track things like the active textures and the current program. We don't do that yet, but we can.
2023-11-04 02:57:38 +00:00
GskGLCommandState state = { 0, };
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
gpu: Add scissor operation Nothing is using it yet (we don't do clipping) apart from initializing the scissor rect at startup.
2023-08-28 08:42:04 +00:00
glEnable (GL_SCISSOR_TEST);
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
glEnable (GL_DEPTH_TEST);
glDepthFunc (GL_LEQUAL);
glEnable (GL_BLEND);
gpu: Add float array to shaders and add an ubershader ... and use it for a naive color node implementation using both so I can test it actually works.
2023-08-30 19:57:41 +00:00
if (vertex_buffer)
gsk_gl_buffer_bind (GSK_GL_BUFFER (vertex_buffer));
gpu: Handle storage buffers via descriptors This makes the (currently single) storage buffer handled by GskGpuDescriptors. A side effect is that we now have support for multiple buffers in place. We just have to use it. Mixed into this commit is a complete rework of the pattern writer. Instead of writing straight into the buffer (complete with repeatedly backtracking when we have to do offscreens), write into a temporary buffer and copy into the storage buffer on committing.
2023-11-19 14:27:10 +00:00
gsk_gl_frame_bind_globals (self);
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
glBufferData (GL_UNIFORM_BUFFER,
sizeof (GskGpuGlobalsInstance),
NULL,
gpu: Use GL_STREAM_DRAW for the push constants buffer This seems to hit a bunch of optimizations and makes push constants slightly faster.
2023-10-04 01:23:42 +00:00
GL_STREAM_DRAW);
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
while (op)
{
gpu: Add a CommandState struct to the command vfuncs This way, we can make it writable and track things like the active textures and the current program. We don't do that yet, but we can.
2023-11-04 02:57:38 +00:00
op = gsk_gpu_op_gl_command (op, frame, &state);
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
}
}
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
static void
gsk_gl_frame_finalize (GObject *object)
{
GskGLFrame *self = GSK_GL_FRAME (object);
g_hash_table_unref (self->vaos);
glDeleteBuffers (1, &self->globals_buffer_id);
G_OBJECT_CLASS (gsk_gl_frame_parent_class)->finalize (object);
}
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
static void
gsk_gl_frame_class_init (GskGLFrameClass *klass)
{
GskGpuFrameClass *gpu_frame_class = GSK_GPU_FRAME_CLASS (klass);
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
GObjectClass *object_class = G_OBJECT_CLASS (klass);
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
gpu_frame_class->is_busy = gsk_gl_frame_is_busy;
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
gpu_frame_class->setup = gsk_gl_frame_setup;
gpu_frame_class->cleanup = gsk_gl_frame_cleanup;
gpu: Add importing of GL textures to the GL renderer syncing with the GLsync is kind of a hack (because we just do it on import), but it works.
2023-11-01 16:14:43 +00:00
gpu_frame_class->upload_texture = gsk_gl_frame_upload_texture;
gpu: Refactor image handling Introduce a new GskGpuImageDescriptors object that tracks descriptors for a set of images that can be managed by the GPU. Then have each GskGpuShaderOp just reference the descriptors object they are using, so that the coe can set things up properly. To reference an image, the ops now just reference their descriptor - which is the uint32 we've been sending to the shaders since forever.
2023-10-03 19:04:21 +00:00
gpu_frame_class->create_descriptors = gsk_gl_frame_create_descriptors;
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
gpu_frame_class->create_vertex_buffer = gsk_gl_frame_create_vertex_buffer;
gpu: Add float array to shaders and add an ubershader ... and use it for a naive color node implementation using both so I can test it actually works.
2023-08-30 19:57:41 +00:00
gpu_frame_class->create_storage_buffer = gsk_gl_frame_create_storage_buffer;
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
gpu_frame_class->submit = gsk_gl_frame_submit;
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
object_class->finalize = gsk_gl_frame_finalize;
}
static void
free_vao (gpointer vao)
{
glDeleteVertexArrays (1, (GLuint[1]) { GPOINTER_TO_UINT (vao) });
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
}
static void
gsk_gl_frame_init (GskGLFrame *self)
{
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
self->vaos = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, free_vao);
}
void
gsk_gl_frame_use_program (GskGLFrame *self,
const GskGpuShaderOpClass *op_class,
gpu: Introduce the concept of "variation" A variation is a #define/specialization constant that every shader can use to specialize itself as it sees fit. This commit adds the infrastrcture, future commits will add implementations.
2023-12-31 04:38:56 +00:00
guint32 variation,
gpu: Prepare GL rendering for samplerExternalEOS Carry an n_external_textures variable around when selecting programs and compile different programs for different amounts of external textures. For now, this code is unused, but dmabufs will need it.
2023-11-02 01:53:50 +00:00
GskGpuShaderClip clip,
guint n_external_textures)
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
{
GLuint vao;
gsk_gl_device_use_program (GSK_GL_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self))),
op_class,
gpu: Introduce the concept of "variation" A variation is a #define/specialization constant that every shader can use to specialize itself as it sees fit. This commit adds the infrastrcture, future commits will add implementations.
2023-12-31 04:38:56 +00:00
variation,
gpu: Prepare GL rendering for samplerExternalEOS Carry an n_external_textures variable around when selecting programs and compile different programs for different amounts of external textures. For now, this code is unused, but dmabufs will need it.
2023-11-02 01:53:50 +00:00
clip,
n_external_textures);
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
vao = GPOINTER_TO_UINT (g_hash_table_lookup (self->vaos, op_class));
if (vao)
{
gpu: Add a GL optimization Use glDrawArraysInstancedBaseInstance() to draw. (Yay for GL naming.) That allows setting up the offset in the vertex array without having to glVertexAttribPointer() everything again. However, this is only supported since GL 4.2 and not at all in stock GLES, so we need to have code that can work without it. Fortunately, it is mandatory in Vulkan, so every recent GPU supports it. And if that GPU has a proper driver, it will also expose the GL extension for it. (Hint: You can check https://opengles.gpuinfo.org/listextensions.php for how many proper drivers exist outside of Mesa.)
2023-09-24 06:40:05 +00:00
glBindVertexArray (vao);
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
return;
}
gpu: Add a GL optimization Use glDrawArraysInstancedBaseInstance() to draw. (Yay for GL naming.) That allows setting up the offset in the vertex array without having to glVertexAttribPointer() everything again. However, this is only supported since GL 4.2 and not at all in stock GLES, so we need to have code that can work without it. Fortunately, it is mandatory in Vulkan, so every recent GPU supports it. And if that GPU has a proper driver, it will also expose the GL extension for it. (Hint: You can check https://opengles.gpuinfo.org/listextensions.php for how many proper drivers exist outside of Mesa.)
2023-09-24 06:40:05 +00:00
glGenVertexArrays (1, &vao);
glBindVertexArray (vao);
op_class->setup_vao (0);
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
g_hash_table_insert (self->vaos, (gpointer) op_class, GUINT_TO_POINTER (vao));
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
}
gpu: Handle storage buffers via descriptors This makes the (currently single) storage buffer handled by GskGpuDescriptors. A side effect is that we now have support for multiple buffers in place. We just have to use it. Mixed into this commit is a complete rework of the pattern writer. Instead of writing straight into the buffer (complete with repeatedly backtracking when we have to do offscreens), write into a temporary buffer and copy into the storage buffer on committing.
2023-11-19 14:27:10 +00:00
void
gsk_gl_frame_bind_globals (GskGLFrame *self)
{
glBindBufferBase (GL_UNIFORM_BUFFER, 0, self->globals_buffer_id);
}
Reference in New Issue Copy Permalink