[gtk/wip/chergert/glproto] ngl: rename Next to Ngl
- From: Christian Hergert <chergert src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gtk/wip/chergert/glproto] ngl: rename Next to Ngl
- Date: Tue, 23 Feb 2021 22:35:26 +0000 (UTC)
commit a2816f3efe954c23909fc425cf7121f4f1f6a2a1
Author: Christian Hergert <chergert redhat com>
Date: Tue Feb 23 14:33:41 2021 -0800
ngl: rename Next to Ngl
demos/node-editor/node-editor-window.c | 6 +-
gsk/gskglshader.c | 6 +-
gsk/gskrenderer.c | 6 +-
gsk/meson.build | 30 +-
gsk/next/gskglcommandqueueprivate.h | 362 ----
gsk/next/gskglcompilerprivate.h | 69 -
gsk/next/gskgldriverprivate.h | 234 ---
gsk/next/gskglglyphlibraryprivate.h | 119 --
gsk/next/gskgliconlibraryprivate.h | 60 -
gsk/next/gskglprogramprivate.h | 273 ---
gsk/next/gskglprograms.defs | 83 -
gsk/next/gskglrenderer.h | 47 -
gsk/next/gskglrenderjobprivate.h | 39 -
gsk/next/gskglshadowlibraryprivate.h | 44 -
gsk/next/gskgltexturelibrary.c | 315 ---
gsk/next/gskgltexturelibraryprivate.h | 201 --
gsk/next/gskgltexturepoolprivate.h | 102 -
gsk/next/gskgltypesprivate.h | 62 -
gsk/next/gskgluniformstateprivate.h | 685 -------
.../gsknglattachmentstate.c} | 32 +-
.../gsknglattachmentstateprivate.h} | 48 +-
gsk/{next/gskglbuffer.c => ngl/gsknglbuffer.c} | 18 +-
.../gsknglbufferprivate.h} | 34 +-
.../gsknglcommandqueue.c} | 520 ++---
gsk/ngl/gsknglcommandqueueprivate.h | 362 ++++
gsk/{next/gskglcompiler.c => ngl/gsknglcompiler.c} | 186 +-
gsk/ngl/gsknglcompilerprivate.h | 69 +
gsk/{next/gskgldriver.c => ngl/gskngldriver.c} | 687 +++----
gsk/ngl/gskngldriverprivate.h | 234 +++
.../gsknglglyphlibrary.c} | 138 +-
gsk/ngl/gsknglglyphlibraryprivate.h | 119 ++
.../gskgliconlibrary.c => ngl/gskngliconlibrary.c} | 62 +-
gsk/ngl/gskngliconlibraryprivate.h | 60 +
gsk/{next/gskglprogram.c => ngl/gsknglprogram.c} | 78 +-
gsk/ngl/gsknglprogramprivate.h | 273 +++
gsk/ngl/gsknglprograms.defs | 83 +
gsk/{next/gskglrenderer.c => ngl/gsknglrenderer.c} | 152 +-
gsk/ngl/gsknglrenderer.h | 46 +
.../gsknglrendererprivate.h} | 16 +-
.../gskglrenderjob.c => ngl/gsknglrenderjob.c} | 2066 ++++++++++----------
gsk/ngl/gsknglrenderjobprivate.h | 39 +
.../gsknglshadowlibrary.c} | 84 +-
gsk/ngl/gsknglshadowlibraryprivate.h | 44 +
gsk/ngl/gskngltexturelibrary.c | 315 +++
gsk/ngl/gskngltexturelibraryprivate.h | 202 ++
.../gskgltexturepool.c => ngl/gskngltexturepool.c} | 68 +-
gsk/ngl/gskngltexturepoolprivate.h | 102 +
gsk/ngl/gskngltypesprivate.h | 62 +
.../gskngluniformstate.c} | 80 +-
gsk/ngl/gskngluniformstateprivate.h | 685 +++++++
gsk/{next => ngl}/inlinearray.h | 0
gsk/{next => ngl}/ninesliceprivate.h | 20 +-
gtk/gtktestutils.c | 2 +-
gtk/inspector/general.c | 4 +-
54 files changed, 4866 insertions(+), 4867 deletions(-)
---
diff --git a/demos/node-editor/node-editor-window.c b/demos/node-editor/node-editor-window.c
index 84c9141c71..03da8c67bd 100644
--- a/demos/node-editor/node-editor-window.c
+++ b/demos/node-editor/node-editor-window.c
@@ -25,7 +25,7 @@
#include "gsk/gskrendernodeparserprivate.h"
#include "gsk/gl/gskglrenderer.h"
-#include "gsk/next/gskglrenderer.h"
+#include "gsk/ngl/gsknglrenderer.h"
#ifdef GDK_WINDOWING_BROADWAY
#include "gsk/broadway/gskbroadwayrenderer.h"
#endif
@@ -764,8 +764,8 @@ node_editor_window_realize (GtkWidget *widget)
gsk_gl_renderer_new (),
"OpenGL");
node_editor_window_add_renderer (self,
- gsk_next_renderer_new (),
- "Next");
+ gsk_ngl_renderer_new (),
+ "NGL");
#ifdef GDK_RENDERING_VULKAN
node_editor_window_add_renderer (self,
gsk_vulkan_renderer_new (),
diff --git a/gsk/gskglshader.c b/gsk/gskglshader.c
index e5c2786213..081e8ac4a7 100644
--- a/gsk/gskglshader.c
+++ b/gsk/gskglshader.c
@@ -141,7 +141,7 @@
#include "gskdebugprivate.h"
#include "gl/gskglrendererprivate.h"
-#include "next/gskglrendererprivate.h"
+#include "ngl/gsknglrendererprivate.h"
static GskGLUniformType
uniform_type_from_glsl (const char *str)
@@ -545,8 +545,8 @@ gsk_gl_shader_compile (GskGLShader *shader,
if (GSK_IS_GL_RENDERER (renderer))
return gsk_gl_renderer_try_compile_gl_shader (GSK_GL_RENDERER (renderer), shader, error);
- else if (GSK_IS_NEXT_RENDERER (renderer))
- return gsk_next_renderer_try_compile_gl_shader (GSK_NEXT_RENDERER (renderer), shader, error);
+ else if (GSK_IS_NGL_RENDERER (renderer))
+ return gsk_ngl_renderer_try_compile_gl_shader (GSK_NGL_RENDERER (renderer), shader, error);
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
"The renderer does not support gl shaders");
diff --git a/gsk/gskrenderer.c b/gsk/gskrenderer.c
index 255f92d11a..9d5dbfcb86 100644
--- a/gsk/gskrenderer.c
+++ b/gsk/gskrenderer.c
@@ -39,7 +39,7 @@
#include "gskcairorenderer.h"
#include "gskdebugprivate.h"
#include "gl/gskglrenderer.h"
-#include "next/gskglrenderer.h"
+#include "ngl/gsknglrenderer.h"
#include "gskprofilerprivate.h"
#include "gskrendernodeprivate.h"
@@ -497,8 +497,8 @@ get_renderer_for_name (const char *renderer_name)
else if (g_ascii_strcasecmp (renderer_name, "opengl") == 0
|| g_ascii_strcasecmp (renderer_name, "gl") == 0)
return GSK_TYPE_GL_RENDERER;
- else if (g_ascii_strcasecmp (renderer_name, "next") == 0)
- return GSK_TYPE_NEXT_RENDERER;
+ else if (g_ascii_strcasecmp (renderer_name, "ngl") == 0)
+ return GSK_TYPE_NGL_RENDERER;
#ifdef GDK_RENDERING_VULKAN
else if (g_ascii_strcasecmp (renderer_name, "vulkan") == 0)
return GSK_TYPE_VULKAN_RENDERER;
diff --git a/gsk/meson.build b/gsk/meson.build
index 62193a79da..dd1ac34ff9 100644
--- a/gsk/meson.build
+++ b/gsk/meson.build
@@ -31,7 +31,7 @@ gsk_public_sources = files([
'gskroundedrect.c',
'gsktransform.c',
'gl/gskglrenderer.c',
- 'next/gskglrenderer.c',
+ 'ngl/gsknglrenderer.c',
])
gsk_private_sources = files([
@@ -49,19 +49,19 @@ gsk_private_sources = files([
'gl/gskgliconcache.c',
'gl/opbuffer.c',
'gl/stb_rect_pack.c',
- 'next/gskglattachmentstate.c',
- 'next/gskglbuffer.c',
- 'next/gskglcommandqueue.c',
- 'next/gskglcompiler.c',
- 'next/gskgldriver.c',
- 'next/gskglglyphlibrary.c',
- 'next/gskgliconlibrary.c',
- 'next/gskglprogram.c',
- 'next/gskglrenderjob.c',
- 'next/gskglshadowlibrary.c',
- 'next/gskgltexturelibrary.c',
- 'next/gskgluniformstate.c',
- 'next/gskgltexturepool.c',
+ 'ngl/gsknglattachmentstate.c',
+ 'ngl/gsknglbuffer.c',
+ 'ngl/gsknglcommandqueue.c',
+ 'ngl/gsknglcompiler.c',
+ 'ngl/gskngldriver.c',
+ 'ngl/gsknglglyphlibrary.c',
+ 'ngl/gskngliconlibrary.c',
+ 'ngl/gsknglprogram.c',
+ 'ngl/gsknglrenderjob.c',
+ 'ngl/gsknglshadowlibrary.c',
+ 'ngl/gskngltexturelibrary.c',
+ 'ngl/gskngluniformstate.c',
+ 'ngl/gskngltexturepool.c',
])
gsk_public_headers = files([
@@ -79,7 +79,7 @@ install_headers(gsk_public_headers, 'gsk.h', subdir: 'gtk-4.0/gsk')
gsk_public_gl_headers = files([
'gl/gskglrenderer.h',
- 'next/gskglrenderer.h',
+ 'ngl/gsknglrenderer.h',
])
install_headers(gsk_public_gl_headers, subdir: 'gtk-4.0/gsk/gl')
gsk_public_headers += gsk_public_gl_headers
diff --git a/gsk/next/gskglattachmentstate.c b/gsk/ngl/gsknglattachmentstate.c
similarity index 72%
rename from gsk/next/gskglattachmentstate.c
rename to gsk/ngl/gsknglattachmentstate.c
index b05cc975a1..bf37087a69 100644
--- a/gsk/next/gskglattachmentstate.c
+++ b/gsk/ngl/gsknglattachmentstate.c
@@ -1,4 +1,4 @@
-/* gskglattachmentstate.c
+/* gsknglattachmentstate.c
*
* Copyright 2020 Christian Hergert <chergert redhat com>
*
@@ -20,14 +20,14 @@
#include "config.h"
-#include "gskglattachmentstateprivate.h"
+#include "gsknglattachmentstateprivate.h"
-GskGLAttachmentState *
-gsk_gl_attachment_state_new (void)
+GskNglAttachmentState *
+gsk_ngl_attachment_state_new (void)
{
- GskGLAttachmentState *self;
+ GskNglAttachmentState *self;
- self = g_atomic_rc_box_new0 (GskGLAttachmentState);
+ self = g_atomic_rc_box_new0 (GskNglAttachmentState);
self->fbo.changed = FALSE;
self->fbo.id = 0;
@@ -49,25 +49,25 @@ gsk_gl_attachment_state_new (void)
return self;
}
-GskGLAttachmentState *
-gsk_gl_attachment_state_ref (GskGLAttachmentState *self)
+GskNglAttachmentState *
+gsk_ngl_attachment_state_ref (GskNglAttachmentState *self)
{
return g_atomic_rc_box_acquire (self);
}
void
-gsk_gl_attachment_state_unref (GskGLAttachmentState *self)
+gsk_ngl_attachment_state_unref (GskNglAttachmentState *self)
{
g_atomic_rc_box_release (self);
}
void
-gsk_gl_attachment_state_bind_texture (GskGLAttachmentState *self,
- GLenum target,
- GLenum texture,
- guint id)
+gsk_ngl_attachment_state_bind_texture (GskNglAttachmentState *self,
+ GLenum target,
+ GLenum texture,
+ guint id)
{
- GskGLBindTexture *attach;
+ GskNglBindTexture *attach;
g_assert (self != NULL);
g_assert (target == GL_TEXTURE_1D ||
@@ -93,8 +93,8 @@ gsk_gl_attachment_state_bind_texture (GskGLAttachmentState *self,
}
void
-gsk_gl_attachment_state_bind_framebuffer (GskGLAttachmentState *self,
- guint id)
+gsk_ngl_attachment_state_bind_framebuffer (GskNglAttachmentState *self,
+ guint id)
{
g_assert (self != NULL);
diff --git a/gsk/next/gskglattachmentstateprivate.h b/gsk/ngl/gsknglattachmentstateprivate.h
similarity index 51%
rename from gsk/next/gskglattachmentstateprivate.h
rename to gsk/ngl/gsknglattachmentstateprivate.h
index cc71648d17..b43e91e09c 100644
--- a/gsk/next/gskglattachmentstateprivate.h
+++ b/gsk/ngl/gsknglattachmentstateprivate.h
@@ -1,4 +1,4 @@
-/* gskglattachmentstateprivate.h
+/* gsknglattachmentstateprivate.h
*
* Copyright 2020 Christian Hergert <chergert redhat com>
*
@@ -18,18 +18,18 @@
* SPDX-License-Identifier: LGPL-2.1-or-later
*/
-#ifndef __GSK_GL_ATTACHMENT_STATE_PRIVATE_H__
-#define __GSK_GL_ATTACHMENT_STATE_PRIVATE_H__
+#ifndef __GSK_NGL_ATTACHMENT_STATE_PRIVATE_H__
+#define __GSK_NGL_ATTACHMENT_STATE_PRIVATE_H__
-#include "gskgltypesprivate.h"
+#include "gskngltypesprivate.h"
G_BEGIN_DECLS
-typedef struct _GskGLAttachmentState GskGLAttachmentState;
-typedef struct _GskGLBindFramebuffer GskGLBindFramebuffer;
-typedef struct _GskGLBindTexture GskGLBindTexture;
+typedef struct _GskNglAttachmentState GskNglAttachmentState;
+typedef struct _GskNglBindFramebuffer GskNglBindFramebuffer;
+typedef struct _GskNglBindTexture GskNglBindTexture;
-struct _GskGLBindTexture
+struct _GskNglBindTexture
{
guint changed : 1;
guint initial : 1;
@@ -38,34 +38,34 @@ struct _GskGLBindTexture
guint id;
};
-G_STATIC_ASSERT (sizeof (GskGLBindTexture) == 12);
+G_STATIC_ASSERT (sizeof (GskNglBindTexture) == 12);
-struct _GskGLBindFramebuffer
+struct _GskNglBindFramebuffer
{
guint changed : 1;
guint id : 31;
};
-G_STATIC_ASSERT (sizeof (GskGLBindFramebuffer) == 4);
+G_STATIC_ASSERT (sizeof (GskNglBindFramebuffer) == 4);
-struct _GskGLAttachmentState
+struct _GskNglAttachmentState
{
- GskGLBindFramebuffer fbo;
+ GskNglBindFramebuffer fbo;
/* Increase if shaders add more textures */
- GskGLBindTexture textures[4];
+ GskNglBindTexture textures[4];
guint n_changed;
};
-GskGLAttachmentState *gsk_gl_attachment_state_new (void);
-GskGLAttachmentState *gsk_gl_attachment_state_ref (GskGLAttachmentState *self);
-void gsk_gl_attachment_state_unref (GskGLAttachmentState *self);
-void gsk_gl_attachment_state_bind_texture (GskGLAttachmentState *self,
- GLenum target,
- GLenum texture,
- guint id);
-void gsk_gl_attachment_state_bind_framebuffer (GskGLAttachmentState *self,
- guint id);
+GskNglAttachmentState *gsk_ngl_attachment_state_new (void);
+GskNglAttachmentState *gsk_ngl_attachment_state_ref (GskNglAttachmentState *self);
+void gsk_ngl_attachment_state_unref (GskNglAttachmentState *self);
+void gsk_ngl_attachment_state_bind_texture (GskNglAttachmentState *self,
+ GLenum target,
+ GLenum texture,
+ guint id);
+void gsk_ngl_attachment_state_bind_framebuffer (GskNglAttachmentState *self,
+ guint id);
G_END_DECLS
-#endif /* __GSK_GL_ATTACHMENT_STATE_PRIVATE_H__ */
+#endif /* __GSK_NGL_ATTACHMENT_STATE_PRIVATE_H__ */
diff --git a/gsk/next/gskglbuffer.c b/gsk/ngl/gsknglbuffer.c
similarity index 81%
rename from gsk/next/gskglbuffer.c
rename to gsk/ngl/gsknglbuffer.c
index 299983cde3..f65923d003 100644
--- a/gsk/next/gskglbuffer.c
+++ b/gsk/ngl/gsknglbuffer.c
@@ -1,4 +1,4 @@
-/* gskglbufferprivate.h
+/* gsknglbufferprivate.h
*
* Copyright 2020 Christian Hergert <chergert redhat com>
*
@@ -22,21 +22,21 @@
#include <string.h>
-#include "gskglbufferprivate.h"
+#include "gsknglbufferprivate.h"
/**
- * gsk_gl_buffer_init:
+ * gsk_ngl_buffer_init:
* @target: the target buffer such as %GL_ARRAY_BUFFER or %GL_UNIFORM_BUFFER
* @element_size: the size of elements within the buffer
*
- * Creates a new #GskGLBuffer which can be used to deliver data to shaders
+ * Creates a new #GskNglBuffer which can be used to deliver data to shaders
* within a GLSL program. You can use this to store vertices such as with
* %GL_ARRAY_BUFFER or uniform data with %GL_UNIFORM_BUFFER.
*/
void
-gsk_gl_buffer_init (GskGLBuffer *self,
- GLenum target,
- guint element_size)
+gsk_ngl_buffer_init (GskNglBuffer *self,
+ GLenum target,
+ guint element_size)
{
memset (self, 0, sizeof *self);
@@ -48,7 +48,7 @@ gsk_gl_buffer_init (GskGLBuffer *self,
}
GLuint
-gsk_gl_buffer_submit (GskGLBuffer *buffer)
+gsk_ngl_buffer_submit (GskNglBuffer *buffer)
{
GLuint id;
@@ -63,7 +63,7 @@ gsk_gl_buffer_submit (GskGLBuffer *buffer)
}
void
-gsk_gl_buffer_destroy (GskGLBuffer *buffer)
+gsk_ngl_buffer_destroy (GskNglBuffer *buffer)
{
g_clear_pointer (&buffer->buffer, g_free);
}
diff --git a/gsk/next/gskglbufferprivate.h b/gsk/ngl/gsknglbufferprivate.h
similarity index 67%
rename from gsk/next/gskglbufferprivate.h
rename to gsk/ngl/gsknglbufferprivate.h
index b0315724f9..fc67bc9e0b 100644
--- a/gsk/next/gskglbufferprivate.h
+++ b/gsk/ngl/gsknglbufferprivate.h
@@ -1,4 +1,4 @@
-/* gskglbufferprivate.h
+/* gsknglbufferprivate.h
*
* Copyright 2020 Christian Hergert <chergert redhat com>
*
@@ -18,14 +18,14 @@
* SPDX-License-Identifier: LGPL-2.1-or-later
*/
-#ifndef __GSK_GL_BUFFER_PRIVATE_H__
-#define __GSK_GL_BUFFER_PRIVATE_H__
+#ifndef __GSK_NGL_BUFFER_PRIVATE_H__
+#define __GSK_NGL_BUFFER_PRIVATE_H__
-#include "gskgltypesprivate.h"
+#include "gskngltypesprivate.h"
G_BEGIN_DECLS
-typedef struct _GskGLBuffer
+typedef struct _GskNglBuffer
{
guint8 *buffer;
gsize buffer_pos;
@@ -33,17 +33,17 @@ typedef struct _GskGLBuffer
guint count;
GLenum target;
guint element_size;
-} GskGLBuffer;
+} GskNglBuffer;
-void gsk_gl_buffer_init (GskGLBuffer *self,
- GLenum target,
- guint element_size);
-void gsk_gl_buffer_destroy (GskGLBuffer *buffer);
-GLuint gsk_gl_buffer_submit (GskGLBuffer *buffer);
+void gsk_ngl_buffer_init (GskNglBuffer *self,
+ GLenum target,
+ guint element_size);
+void gsk_ngl_buffer_destroy (GskNglBuffer *buffer);
+GLuint gsk_ngl_buffer_submit (GskNglBuffer *buffer);
static inline gpointer
-gsk_gl_buffer_advance (GskGLBuffer *buffer,
- guint count)
+gsk_ngl_buffer_advance (GskNglBuffer *buffer,
+ guint count)
{
gpointer ret;
gsize to_alloc = count * buffer->element_size;
@@ -63,19 +63,19 @@ gsk_gl_buffer_advance (GskGLBuffer *buffer,
}
static inline void
-gsk_gl_buffer_retract (GskGLBuffer *buffer,
- guint count)
+gsk_ngl_buffer_retract (GskNglBuffer *buffer,
+ guint count)
{
buffer->buffer_pos -= count * buffer->element_size;
buffer->count -= count;
}
static inline guint
-gsk_gl_buffer_get_offset (GskGLBuffer *buffer)
+gsk_ngl_buffer_get_offset (GskNglBuffer *buffer)
{
return buffer->count;
}
G_END_DECLS
-#endif /* __GSK_GL_BUFFER_PRIVATE_H__ */
+#endif /* __GSK_NGL_BUFFER_PRIVATE_H__ */
diff --git a/gsk/next/gskglcommandqueue.c b/gsk/ngl/gsknglcommandqueue.c
similarity index 69%
rename from gsk/next/gskglcommandqueue.c
rename to gsk/ngl/gsknglcommandqueue.c
index 583d43bbdc..9426c199b1 100644
--- a/gsk/next/gskglcommandqueue.c
+++ b/gsk/ngl/gsknglcommandqueue.c
@@ -1,4 +1,4 @@
-/* gskglcommandqueue.c
+/* gsknglcommandqueue.c
*
* Copyright 2017 Timm Bäder <mail baedert org>
* Copyright 2018 Matthias Clasen <mclasen redhat com>
@@ -31,19 +31,19 @@
#include <gsk/gskdebugprivate.h>
#include <gsk/gskroundedrectprivate.h>
-#include "gskglattachmentstateprivate.h"
-#include "gskglbufferprivate.h"
-#include "gskglcommandqueueprivate.h"
-#include "gskgluniformstateprivate.h"
+#include "gsknglattachmentstateprivate.h"
+#include "gsknglbufferprivate.h"
+#include "gsknglcommandqueueprivate.h"
+#include "gskngluniformstateprivate.h"
#include "inlinearray.h"
-G_DEFINE_TYPE (GskGLCommandQueue, gsk_gl_command_queue, G_TYPE_OBJECT)
+G_DEFINE_TYPE (GskNglCommandQueue, gsk_ngl_command_queue, G_TYPE_OBJECT)
G_GNUC_UNUSED static inline void
-print_uniform (GskGLUniformFormat format,
- guint array_count,
- gconstpointer valueptr)
+print_uniform (GskNglUniformFormat format,
+ guint array_count,
+ gconstpointer valueptr)
{
const union {
graphene_matrix_t matrix[0];
@@ -55,46 +55,46 @@ print_uniform (GskGLUniformFormat format,
switch (format)
{
- case GSK_GL_UNIFORM_FORMAT_1F:
+ case GSK_NGL_UNIFORM_FORMAT_1F:
g_printerr ("1f<%f>", data->fval[0]);
break;
- case GSK_GL_UNIFORM_FORMAT_2F:
+ case GSK_NGL_UNIFORM_FORMAT_2F:
g_printerr ("2f<%f,%f>", data->fval[0], data->fval[1]);
break;
- case GSK_GL_UNIFORM_FORMAT_3F:
+ case GSK_NGL_UNIFORM_FORMAT_3F:
g_printerr ("3f<%f,%f,%f>", data->fval[0], data->fval[1], data->fval[2]);
break;
- case GSK_GL_UNIFORM_FORMAT_4F:
+ case GSK_NGL_UNIFORM_FORMAT_4F:
g_printerr ("4f<%f,%f,%f,%f>", data->fval[0], data->fval[1], data->fval[2], data->fval[3]);
break;
- case GSK_GL_UNIFORM_FORMAT_1I:
- case GSK_GL_UNIFORM_FORMAT_TEXTURE:
+ case GSK_NGL_UNIFORM_FORMAT_1I:
+ case GSK_NGL_UNIFORM_FORMAT_TEXTURE:
g_printerr ("1i<%d>", data->ival[0]);
break;
- case GSK_GL_UNIFORM_FORMAT_1UI:
+ case GSK_NGL_UNIFORM_FORMAT_1UI:
g_printerr ("1ui<%u>", data->uval[0]);
break;
- case GSK_GL_UNIFORM_FORMAT_COLOR: {
+ case GSK_NGL_UNIFORM_FORMAT_COLOR: {
char *str = gdk_rgba_to_string (valueptr);
g_printerr ("%s", str);
g_free (str);
break;
}
- case GSK_GL_UNIFORM_FORMAT_ROUNDED_RECT: {
+ case GSK_NGL_UNIFORM_FORMAT_ROUNDED_RECT: {
char *str = gsk_rounded_rect_to_string (valueptr);
g_printerr ("%s", str);
g_free (str);
break;
}
- case GSK_GL_UNIFORM_FORMAT_MATRIX: {
+ case GSK_NGL_UNIFORM_FORMAT_MATRIX: {
float mat[16];
graphene_matrix_to_float (&data->matrix[0], mat);
g_printerr ("matrix<");
@@ -104,10 +104,10 @@ print_uniform (GskGLUniformFormat format,
break;
}
- case GSK_GL_UNIFORM_FORMAT_1FV:
- case GSK_GL_UNIFORM_FORMAT_2FV:
- case GSK_GL_UNIFORM_FORMAT_3FV:
- case GSK_GL_UNIFORM_FORMAT_4FV:
+ case GSK_NGL_UNIFORM_FORMAT_1FV:
+ case GSK_NGL_UNIFORM_FORMAT_2FV:
+ case GSK_NGL_UNIFORM_FORMAT_3FV:
+ case GSK_NGL_UNIFORM_FORMAT_4FV:
/* non-V variants are -4 from V variants */
format -= 4;
g_printerr ("[");
@@ -116,42 +116,42 @@ print_uniform (GskGLUniformFormat format,
print_uniform (format, 0, valueptr);
if (i + 1 != array_count)
g_printerr (",");
- valueptr = ((guint8*)valueptr + gsk_gl_uniform_format_size (format));
+ valueptr = ((guint8*)valueptr + gsk_ngl_uniform_format_size (format));
}
g_printerr ("]");
break;
- case GSK_GL_UNIFORM_FORMAT_2I:
+ case GSK_NGL_UNIFORM_FORMAT_2I:
g_printerr ("2i<%d,%d>", data->ival[0], data->ival[1]);
break;
- case GSK_GL_UNIFORM_FORMAT_3I:
+ case GSK_NGL_UNIFORM_FORMAT_3I:
g_printerr ("3i<%d,%d,%d>", data->ival[0], data->ival[1], data->ival[2]);
break;
- case GSK_GL_UNIFORM_FORMAT_4I:
+ case GSK_NGL_UNIFORM_FORMAT_4I:
g_printerr ("3i<%d,%d,%d,%d>", data->ival[0], data->ival[1], data->ival[2], data->ival[3]);
break;
- case GSK_GL_UNIFORM_FORMAT_LAST:
+ case GSK_NGL_UNIFORM_FORMAT_LAST:
default:
g_assert_not_reached ();
}
}
G_GNUC_UNUSED static inline void
-gsk_gl_command_queue_print_batch (GskGLCommandQueue *self,
- const GskGLCommandBatch *batch)
+gsk_ngl_command_queue_print_batch (GskNglCommandQueue *self,
+ const GskNglCommandBatch *batch)
{
static const char *command_kinds[] = { "Clear", NULL, NULL, "Draw", };
guint framebuffer_id;
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self));
g_assert (batch != NULL);
- if (batch->any.kind == GSK_GL_COMMAND_KIND_CLEAR)
+ if (batch->any.kind == GSK_NGL_COMMAND_KIND_CLEAR)
framebuffer_id = batch->clear.framebuffer;
- else if (batch->any.kind == GSK_GL_COMMAND_KIND_DRAW)
+ else if (batch->any.kind == GSK_NGL_COMMAND_KIND_DRAW)
framebuffer_id = batch->draw.framebuffer;
else
return;
@@ -161,28 +161,28 @@ gsk_gl_command_queue_print_batch (GskGLCommandQueue *self,
g_printerr (" Viewport: %dx%d\n", batch->any.viewport.width, batch->any.viewport.height);
g_printerr (" Framebuffer: %d\n", framebuffer_id);
- if (batch->any.kind == GSK_GL_COMMAND_KIND_DRAW)
+ if (batch->any.kind == GSK_NGL_COMMAND_KIND_DRAW)
{
g_printerr (" Program: %d\n", batch->any.program);
g_printerr (" Vertices: %d\n", batch->draw.vbo_count);
for (guint i = 0; i < batch->draw.bind_count; i++)
{
- const GskGLCommandBind *bind = &self->batch_binds.items[batch->draw.bind_offset + i];
+ const GskNglCommandBind *bind = &self->batch_binds.items[batch->draw.bind_offset + i];
g_print (" Bind[%d]: %u\n", bind->texture, bind->id);
}
for (guint i = 0; i < batch->draw.uniform_count; i++)
{
- const GskGLCommandUniform *uniform = &self->batch_uniforms.items[batch->draw.uniform_offset + i];
+ const GskNglCommandUniform *uniform = &self->batch_uniforms.items[batch->draw.uniform_offset + i];
g_printerr (" Uniform[%02d]: ", uniform->location);
print_uniform (uniform->info.format,
uniform->info.array_count,
- gsk_gl_uniform_state_get_uniform_data (self->uniforms, uniform->info.offset));
+ gsk_ngl_uniform_state_get_uniform_data (self->uniforms, uniform->info.offset));
g_printerr ("\n");
}
}
- else if (batch->any.kind == GSK_GL_COMMAND_KIND_CLEAR)
+ else if (batch->any.kind == GSK_NGL_COMMAND_KIND_CLEAR)
{
g_printerr (" Bits: 0x%x\n", batch->clear.bits);
}
@@ -191,17 +191,17 @@ gsk_gl_command_queue_print_batch (GskGLCommandQueue *self,
}
G_GNUC_UNUSED static inline void
-gsk_gl_command_queue_capture_png (GskGLCommandQueue *self,
- const char *filename,
- guint width,
- guint height,
- gboolean flip_y)
+gsk_ngl_command_queue_capture_png (GskNglCommandQueue *self,
+ const char *filename,
+ guint width,
+ guint height,
+ gboolean flip_y)
{
cairo_surface_t *surface;
guint8 *data;
guint stride;
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self));
g_assert (filename != NULL);
stride = cairo_format_stride_for_width (CAIRO_FORMAT_ARGB32, width);
@@ -230,7 +230,7 @@ gsk_gl_command_queue_capture_png (GskGLCommandQueue *self,
}
static inline gboolean
-will_ignore_batch (GskGLCommandQueue *self)
+will_ignore_batch (GskNglCommandQueue *self)
{
if G_LIKELY (self->batches.len < G_MAXINT16)
return FALSE;
@@ -245,10 +245,10 @@ will_ignore_batch (GskGLCommandQueue *self)
}
static inline guint
-snapshot_attachments (const GskGLAttachmentState *state,
- GskGLCommandBinds *array)
+snapshot_attachments (const GskNglAttachmentState *state,
+ GskNglCommandBinds *array)
{
- GskGLCommandBind *bind = gsk_gl_command_binds_append_n (array, G_N_ELEMENTS (state->textures));
+ GskNglCommandBind *bind = gsk_ngl_command_binds_append_n (array, G_N_ELEMENTS (state->textures));
guint count = 0;
for (guint i = 0; i < G_N_ELEMENTS (state->textures); i++)
@@ -268,17 +268,17 @@ snapshot_attachments (const GskGLAttachmentState *state,
}
static inline guint
-snapshot_uniforms (GskGLUniformState *state,
- GskGLUniformProgram *program,
- GskGLCommandUniforms *array)
+snapshot_uniforms (GskNglUniformState *state,
+ GskNglUniformProgram *program,
+ GskNglCommandUniforms *array)
{
- GskGLCommandUniform *uniform = gsk_gl_command_uniforms_append_n (array, program->n_sparse);
+ GskNglCommandUniform *uniform = gsk_ngl_command_uniforms_append_n (array, program->n_sparse);
guint count = 0;
for (guint i = 0; i < program->n_sparse; i++)
{
guint location = program->sparse[i];
- const GskGLUniformInfo *info = &program->uniforms[location].info;
+ const GskNglUniformInfo *info = &program->uniforms[location].info;
if (!info->initial)
{
@@ -295,9 +295,9 @@ snapshot_uniforms (GskGLUniformState *state,
}
static inline gboolean
-snapshots_equal (GskGLCommandQueue *self,
- GskGLCommandBatch *first,
- GskGLCommandBatch *second)
+snapshots_equal (GskNglCommandQueue *self,
+ GskNglCommandBatch *first,
+ GskNglCommandBatch *second)
{
if (first->draw.bind_count != second->draw.bind_count ||
first->draw.uniform_count != second->draw.uniform_count)
@@ -305,8 +305,8 @@ snapshots_equal (GskGLCommandQueue *self,
for (guint i = 0; i < first->draw.bind_count; i++)
{
- const GskGLCommandBind *fb = &self->batch_binds.items[first->draw.bind_offset+i];
- const GskGLCommandBind *sb = &self->batch_binds.items[second->draw.bind_offset+i];
+ const GskNglCommandBind *fb = &self->batch_binds.items[first->draw.bind_offset+i];
+ const GskNglCommandBind *sb = &self->batch_binds.items[second->draw.bind_offset+i];
if (fb->id != sb->id || fb->texture != sb->texture)
return FALSE;
@@ -314,8 +314,8 @@ snapshots_equal (GskGLCommandQueue *self,
for (guint i = 0; i < first->draw.uniform_count; i++)
{
- const GskGLCommandUniform *fu = &self->batch_uniforms.items[first->draw.uniform_offset+i];
- const GskGLCommandUniform *su = &self->batch_uniforms.items[second->draw.uniform_offset+i];
+ const GskNglCommandUniform *fu = &self->batch_uniforms.items[first->draw.uniform_offset+i];
+ const GskNglCommandUniform *su = &self->batch_uniforms.items[second->draw.uniform_offset+i];
gconstpointer fdata;
gconstpointer sdata;
gsize len;
@@ -328,47 +328,47 @@ snapshots_equal (GskGLCommandQueue *self,
fu->info.array_count != su->info.array_count)
return FALSE;
- fdata = gsk_gl_uniform_state_get_uniform_data (self->uniforms, fu->info.offset);
- sdata = gsk_gl_uniform_state_get_uniform_data (self->uniforms, su->info.offset);
+ fdata = gsk_ngl_uniform_state_get_uniform_data (self->uniforms, fu->info.offset);
+ sdata = gsk_ngl_uniform_state_get_uniform_data (self->uniforms, su->info.offset);
switch (fu->info.format)
{
- case GSK_GL_UNIFORM_FORMAT_1F:
- case GSK_GL_UNIFORM_FORMAT_1FV:
- case GSK_GL_UNIFORM_FORMAT_1I:
- case GSK_GL_UNIFORM_FORMAT_TEXTURE:
- case GSK_GL_UNIFORM_FORMAT_1UI:
+ case GSK_NGL_UNIFORM_FORMAT_1F:
+ case GSK_NGL_UNIFORM_FORMAT_1FV:
+ case GSK_NGL_UNIFORM_FORMAT_1I:
+ case GSK_NGL_UNIFORM_FORMAT_TEXTURE:
+ case GSK_NGL_UNIFORM_FORMAT_1UI:
len = 4;
break;
- case GSK_GL_UNIFORM_FORMAT_2F:
- case GSK_GL_UNIFORM_FORMAT_2FV:
- case GSK_GL_UNIFORM_FORMAT_2I:
+ case GSK_NGL_UNIFORM_FORMAT_2F:
+ case GSK_NGL_UNIFORM_FORMAT_2FV:
+ case GSK_NGL_UNIFORM_FORMAT_2I:
len = 8;
break;
- case GSK_GL_UNIFORM_FORMAT_3F:
- case GSK_GL_UNIFORM_FORMAT_3FV:
- case GSK_GL_UNIFORM_FORMAT_3I:
+ case GSK_NGL_UNIFORM_FORMAT_3F:
+ case GSK_NGL_UNIFORM_FORMAT_3FV:
+ case GSK_NGL_UNIFORM_FORMAT_3I:
len = 12;
break;
- case GSK_GL_UNIFORM_FORMAT_4F:
- case GSK_GL_UNIFORM_FORMAT_4FV:
- case GSK_GL_UNIFORM_FORMAT_4I:
+ case GSK_NGL_UNIFORM_FORMAT_4F:
+ case GSK_NGL_UNIFORM_FORMAT_4FV:
+ case GSK_NGL_UNIFORM_FORMAT_4I:
len = 16;
break;
- case GSK_GL_UNIFORM_FORMAT_MATRIX:
+ case GSK_NGL_UNIFORM_FORMAT_MATRIX:
len = sizeof (float) * 16;
break;
- case GSK_GL_UNIFORM_FORMAT_ROUNDED_RECT:
+ case GSK_NGL_UNIFORM_FORMAT_ROUNDED_RECT:
len = sizeof (float) * 12;
break;
- case GSK_GL_UNIFORM_FORMAT_COLOR:
+ case GSK_NGL_UNIFORM_FORMAT_COLOR:
len = sizeof (float) * 4;
break;
@@ -386,66 +386,66 @@ snapshots_equal (GskGLCommandQueue *self,
}
static void
-gsk_gl_command_queue_dispose (GObject *object)
+gsk_ngl_command_queue_dispose (GObject *object)
{
- GskGLCommandQueue *self = (GskGLCommandQueue *)object;
+ GskNglCommandQueue *self = (GskNglCommandQueue *)object;
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self));
g_clear_object (&self->profiler);
g_clear_object (&self->gl_profiler);
g_clear_object (&self->context);
- g_clear_pointer (&self->attachments, gsk_gl_attachment_state_unref);
- g_clear_pointer (&self->uniforms, gsk_gl_uniform_state_unref);
+ g_clear_pointer (&self->attachments, gsk_ngl_attachment_state_unref);
+ g_clear_pointer (&self->uniforms, gsk_ngl_uniform_state_unref);
- gsk_gl_command_batches_clear (&self->batches);
- gsk_gl_command_binds_clear (&self->batch_binds);
- gsk_gl_command_uniforms_clear (&self->batch_uniforms);
+ gsk_ngl_command_batches_clear (&self->batches);
+ gsk_ngl_command_binds_clear (&self->batch_binds);
+ gsk_ngl_command_uniforms_clear (&self->batch_uniforms);
- gsk_gl_buffer_destroy (&self->vertices);
+ gsk_ngl_buffer_destroy (&self->vertices);
- G_OBJECT_CLASS (gsk_gl_command_queue_parent_class)->dispose (object);
+ G_OBJECT_CLASS (gsk_ngl_command_queue_parent_class)->dispose (object);
}
static void
-gsk_gl_command_queue_class_init (GskGLCommandQueueClass *klass)
+gsk_ngl_command_queue_class_init (GskNglCommandQueueClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
- object_class->dispose = gsk_gl_command_queue_dispose;
+ object_class->dispose = gsk_ngl_command_queue_dispose;
}
static void
-gsk_gl_command_queue_init (GskGLCommandQueue *self)
+gsk_ngl_command_queue_init (GskNglCommandQueue *self)
{
self->max_texture_size = -1;
- gsk_gl_command_batches_init (&self->batches, 128);
- gsk_gl_command_binds_init (&self->batch_binds, 1024);
- gsk_gl_command_uniforms_init (&self->batch_uniforms, 2048);
+ gsk_ngl_command_batches_init (&self->batches, 128);
+ gsk_ngl_command_binds_init (&self->batch_binds, 1024);
+ gsk_ngl_command_uniforms_init (&self->batch_uniforms, 2048);
self->debug_groups = g_string_chunk_new (4096);
- gsk_gl_buffer_init (&self->vertices, GL_ARRAY_BUFFER, sizeof (GskGLDrawVertex));
+ gsk_ngl_buffer_init (&self->vertices, GL_ARRAY_BUFFER, sizeof (GskNglDrawVertex));
}
-GskGLCommandQueue *
-gsk_gl_command_queue_new (GdkGLContext *context,
- GskGLUniformState *uniforms)
+GskNglCommandQueue *
+gsk_ngl_command_queue_new (GdkGLContext *context,
+ GskNglUniformState *uniforms)
{
- GskGLCommandQueue *self;
+ GskNglCommandQueue *self;
g_return_val_if_fail (GDK_IS_GL_CONTEXT (context), NULL);
self = g_object_new (GSK_TYPE_GL_COMMAND_QUEUE, NULL);
self->context = g_object_ref (context);
- self->attachments = gsk_gl_attachment_state_new ();
+ self->attachments = gsk_ngl_attachment_state_new ();
/* Use shared uniform state if we're provided one */
if (uniforms != NULL)
- self->uniforms = gsk_gl_uniform_state_ref (uniforms);
+ self->uniforms = gsk_ngl_uniform_state_ref (uniforms);
else
- self->uniforms = gsk_gl_uniform_state_new ();
+ self->uniforms = gsk_ngl_uniform_state_new ();
/* Determine max texture size immediately and restore context */
gdk_gl_context_make_current (context);
@@ -454,14 +454,14 @@ gsk_gl_command_queue_new (GdkGLContext *context,
return g_steal_pointer (&self);
}
-static inline GskGLCommandBatch *
-begin_next_batch (GskGLCommandQueue *self)
+static inline GskNglCommandBatch *
+begin_next_batch (GskNglCommandQueue *self)
{
- GskGLCommandBatch *batch;
+ GskNglCommandBatch *batch;
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self));
- /* GskGLCommandBatch contains an embedded linked list using integers into the
+ /* GskNglCommandBatch contains an embedded linked list using integers into the
* self->batches array. We can't use pointer because the batches could be
* realloc()'d at runtime.
*
@@ -474,7 +474,7 @@ begin_next_batch (GskGLCommandQueue *self)
* proper order.
*/
- batch = gsk_gl_command_batches_append (&self->batches);
+ batch = gsk_ngl_command_batches_append (&self->batches);
batch->any.next_batch_index = -1;
batch->any.prev_batch_index = self->tail_batch_index;
@@ -482,11 +482,11 @@ begin_next_batch (GskGLCommandQueue *self)
}
static void
-enqueue_batch (GskGLCommandQueue *self)
+enqueue_batch (GskNglCommandQueue *self)
{
guint index;
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self));
g_assert (self->batches.len > 0);
/* Batches are linked lists but using indexes into the batches array instead
@@ -503,7 +503,7 @@ enqueue_batch (GskGLCommandQueue *self)
if (self->tail_batch_index != -1)
{
- GskGLCommandBatch *prev = &self->batches.items[self->tail_batch_index];
+ GskNglCommandBatch *prev = &self->batches.items[self->tail_batch_index];
prev->any.next_batch_index = index;
}
@@ -512,23 +512,23 @@ enqueue_batch (GskGLCommandQueue *self)
}
static void
-discard_batch (GskGLCommandQueue *self)
+discard_batch (GskNglCommandQueue *self)
{
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self));
g_assert (self->batches.len > 0);
self->batches.len--;
}
void
-gsk_gl_command_queue_begin_draw (GskGLCommandQueue *self,
- GskGLUniformProgram *program,
- guint width,
- guint height)
+gsk_ngl_command_queue_begin_draw (GskNglCommandQueue *self,
+ GskNglUniformProgram *program,
+ guint width,
+ guint height)
{
- GskGLCommandBatch *batch;
+ GskNglCommandBatch *batch;
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self));
g_assert (self->in_draw == FALSE);
g_assert (width <= G_MAXUINT16);
g_assert (height <= G_MAXUINT16);
@@ -542,7 +542,7 @@ gsk_gl_command_queue_begin_draw (GskGLCommandQueue *self,
self->program_info = program;
batch = begin_next_batch (self);
- batch->any.kind = GSK_GL_COMMAND_KIND_DRAW;
+ batch->any.kind = GSK_NGL_COMMAND_KIND_DRAW;
batch->any.program = program->program_id;
batch->any.next_batch_index = -1;
batch->any.viewport.width = width;
@@ -553,7 +553,7 @@ gsk_gl_command_queue_begin_draw (GskGLCommandQueue *self,
batch->draw.bind_count = 0;
batch->draw.bind_offset = self->batch_binds.len;
batch->draw.vbo_count = 0;
- batch->draw.vbo_offset = gsk_gl_buffer_get_offset (&self->vertices);
+ batch->draw.vbo_offset = gsk_ngl_buffer_get_offset (&self->vertices);
self->fbo_max = MAX (self->fbo_max, batch->draw.framebuffer);
@@ -561,21 +561,21 @@ gsk_gl_command_queue_begin_draw (GskGLCommandQueue *self,
}
void
-gsk_gl_command_queue_end_draw (GskGLCommandQueue *self)
+gsk_ngl_command_queue_end_draw (GskNglCommandQueue *self)
{
- GskGLCommandBatch *last_batch;
- GskGLCommandBatch *batch;
+ GskNglCommandBatch *last_batch;
+ GskNglCommandBatch *batch;
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self));
g_assert (self->batches.len > 0);
if (will_ignore_batch (self))
return;
- batch = gsk_gl_command_batches_tail (&self->batches);
+ batch = gsk_ngl_command_batches_tail (&self->batches);
g_assert (self->in_draw == TRUE);
- g_assert (batch->any.kind == GSK_GL_COMMAND_KIND_DRAW);
+ g_assert (batch->any.kind == GSK_NGL_COMMAND_KIND_DRAW);
if G_UNLIKELY (batch->draw.vbo_count == 0)
{
@@ -614,7 +614,7 @@ gsk_gl_command_queue_end_draw (GskGLCommandQueue *self)
/* Do simple chaining of draw to last batch. */
if (last_batch != NULL &&
- last_batch->any.kind == GSK_GL_COMMAND_KIND_DRAW &&
+ last_batch->any.kind == GSK_NGL_COMMAND_KIND_DRAW &&
last_batch->any.program == batch->any.program &&
last_batch->any.viewport.width == batch->any.viewport.width &&
last_batch->any.viewport.height == batch->any.viewport.height &&
@@ -635,52 +635,52 @@ gsk_gl_command_queue_end_draw (GskGLCommandQueue *self)
}
/**
- * gsk_gl_command_queue_split_draw:
- * @self a #GskGLCommandQueue
+ * gsk_ngl_command_queue_split_draw:
+ * @self a #GskNglCommandQueue
*
- * This function is like calling gsk_gl_command_queue_end_draw() followed by
- * a gsk_gl_command_queue_begin_draw() with the same parameters as a
+ * This function is like calling gsk_ngl_command_queue_end_draw() followed by
+ * a gsk_ngl_command_queue_begin_draw() with the same parameters as a
* previous begin draw (if shared uniforms where not changed further).
*
* This is useful to avoid comparisons inside of loops where we know shared
* uniforms are not changing.
*
- * This generally should just be called from gsk_gl_program_split_draw()
+ * This generally should just be called from gsk_ngl_program_split_draw()
* as that is where the begin/end flow happens from the render job.
*/
void
-gsk_gl_command_queue_split_draw (GskGLCommandQueue *self)
+gsk_ngl_command_queue_split_draw (GskNglCommandQueue *self)
{
- GskGLCommandBatch *batch;
- GskGLUniformProgram *program;
+ GskNglCommandBatch *batch;
+ GskNglUniformProgram *program;
guint width;
guint height;
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self));
g_assert (self->batches.len > 0);
g_assert (self->in_draw == TRUE);
program = self->program_info;
- batch = gsk_gl_command_batches_tail (&self->batches);
+ batch = gsk_ngl_command_batches_tail (&self->batches);
- g_assert (batch->any.kind == GSK_GL_COMMAND_KIND_DRAW);
+ g_assert (batch->any.kind == GSK_NGL_COMMAND_KIND_DRAW);
width = batch->any.viewport.width;
height = batch->any.viewport.height;
- gsk_gl_command_queue_end_draw (self);
- gsk_gl_command_queue_begin_draw (self, program, width, height);
+ gsk_ngl_command_queue_end_draw (self);
+ gsk_ngl_command_queue_begin_draw (self, program, width, height);
}
void
-gsk_gl_command_queue_clear (GskGLCommandQueue *self,
- guint clear_bits,
- const graphene_rect_t *viewport)
+gsk_ngl_command_queue_clear (GskNglCommandQueue *self,
+ guint clear_bits,
+ const graphene_rect_t *viewport)
{
- GskGLCommandBatch *batch;
+ GskNglCommandBatch *batch;
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self));
g_assert (self->in_draw == FALSE);
if (will_ignore_batch (self))
@@ -690,7 +690,7 @@ gsk_gl_command_queue_clear (GskGLCommandQueue *self,
clear_bits = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
batch = begin_next_batch (self);
- batch->any.kind = GSK_GL_COMMAND_KIND_CLEAR;
+ batch->any.kind = GSK_NGL_COMMAND_KIND_CLEAR;
batch->any.viewport.width = viewport->size.width;
batch->any.viewport.height = viewport->size.height;
batch->clear.bits = clear_bits;
@@ -706,35 +706,35 @@ gsk_gl_command_queue_clear (GskGLCommandQueue *self,
}
GdkGLContext *
-gsk_gl_command_queue_get_context (GskGLCommandQueue *self)
+gsk_ngl_command_queue_get_context (GskNglCommandQueue *self)
{
- g_return_val_if_fail (GSK_IS_GL_COMMAND_QUEUE (self), NULL);
+ g_return_val_if_fail (GSK_IS_NGL_COMMAND_QUEUE (self), NULL);
return self->context;
}
void
-gsk_gl_command_queue_make_current (GskGLCommandQueue *self)
+gsk_ngl_command_queue_make_current (GskNglCommandQueue *self)
{
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self));
g_assert (GDK_IS_GL_CONTEXT (self->context));
gdk_gl_context_make_current (self->context);
}
void
-gsk_gl_command_queue_delete_program (GskGLCommandQueue *self,
- guint program)
+gsk_ngl_command_queue_delete_program (GskNglCommandQueue *self,
+ guint program)
{
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self));
glDeleteProgram (program);
}
static inline void
-apply_uniform (gconstpointer dataptr,
- GskGLUniformInfo info,
- guint location)
+apply_uniform (gconstpointer dataptr,
+ GskNglUniformInfo info,
+ guint location)
{
g_assert (dataptr != NULL);
g_assert (info.format > 0);
@@ -742,60 +742,60 @@ apply_uniform (gconstpointer dataptr,
switch (info.format)
{
- case GSK_GL_UNIFORM_FORMAT_1F:
+ case GSK_NGL_UNIFORM_FORMAT_1F:
glUniform1fv (location, 1, dataptr);
break;
- case GSK_GL_UNIFORM_FORMAT_2F:
+ case GSK_NGL_UNIFORM_FORMAT_2F:
glUniform2fv (location, 1, dataptr);
break;
- case GSK_GL_UNIFORM_FORMAT_3F:
+ case GSK_NGL_UNIFORM_FORMAT_3F:
glUniform3fv (location, 1, dataptr);
break;
- case GSK_GL_UNIFORM_FORMAT_4F:
+ case GSK_NGL_UNIFORM_FORMAT_4F:
glUniform4fv (location, 1, dataptr);
break;
- case GSK_GL_UNIFORM_FORMAT_1FV:
+ case GSK_NGL_UNIFORM_FORMAT_1FV:
glUniform1fv (location, info.array_count, dataptr);
break;
- case GSK_GL_UNIFORM_FORMAT_2FV:
+ case GSK_NGL_UNIFORM_FORMAT_2FV:
glUniform2fv (location, info.array_count, dataptr);
break;
- case GSK_GL_UNIFORM_FORMAT_3FV:
+ case GSK_NGL_UNIFORM_FORMAT_3FV:
glUniform3fv (location, info.array_count, dataptr);
break;
- case GSK_GL_UNIFORM_FORMAT_4FV:
+ case GSK_NGL_UNIFORM_FORMAT_4FV:
glUniform4fv (location, info.array_count, dataptr);
break;
- case GSK_GL_UNIFORM_FORMAT_1I:
- case GSK_GL_UNIFORM_FORMAT_TEXTURE:
+ case GSK_NGL_UNIFORM_FORMAT_1I:
+ case GSK_NGL_UNIFORM_FORMAT_TEXTURE:
glUniform1iv (location, 1, dataptr);
break;
- case GSK_GL_UNIFORM_FORMAT_2I:
+ case GSK_NGL_UNIFORM_FORMAT_2I:
glUniform2iv (location, 1, dataptr);
break;
- case GSK_GL_UNIFORM_FORMAT_3I:
+ case GSK_NGL_UNIFORM_FORMAT_3I:
glUniform3iv (location, 1, dataptr);
break;
- case GSK_GL_UNIFORM_FORMAT_4I:
+ case GSK_NGL_UNIFORM_FORMAT_4I:
glUniform4iv (location, 1, dataptr);
break;
- case GSK_GL_UNIFORM_FORMAT_1UI:
+ case GSK_NGL_UNIFORM_FORMAT_1UI:
glUniform1uiv (location, 1, dataptr);
break;
- case GSK_GL_UNIFORM_FORMAT_MATRIX: {
+ case GSK_NGL_UNIFORM_FORMAT_MATRIX: {
float mat[16];
graphene_matrix_to_float (dataptr, mat);
glUniformMatrix4fv (location, 1, GL_FALSE, mat);
@@ -810,11 +810,11 @@ apply_uniform (gconstpointer dataptr,
}
break;
- case GSK_GL_UNIFORM_FORMAT_COLOR:
+ case GSK_NGL_UNIFORM_FORMAT_COLOR:
glUniform4fv (location, 1, dataptr);
break;
- case GSK_GL_UNIFORM_FORMAT_ROUNDED_RECT:
+ case GSK_NGL_UNIFORM_FORMAT_ROUNDED_RECT:
glUniform4fv (location, 3, dataptr);
break;
@@ -868,8 +868,8 @@ apply_scissor (gboolean *state,
}
static inline gboolean
-apply_framebuffer (int *framebuffer,
- guint new_framebuffer)
+apply_framebuffer (int *framebuffer,
+ guint new_framebuffer)
{
if G_UNLIKELY (new_framebuffer != *framebuffer)
{
@@ -882,8 +882,8 @@ apply_framebuffer (int *framebuffer,
}
static inline void
-gsk_gl_command_queue_unlink (GskGLCommandQueue *self,
- GskGLCommandBatch *batch)
+gsk_ngl_command_queue_unlink (GskNglCommandQueue *self,
+ GskNglCommandBatch *batch)
{
if (batch->any.prev_batch_index == -1)
self->head_batch_index = batch->any.next_batch_index;
@@ -900,9 +900,9 @@ gsk_gl_command_queue_unlink (GskGLCommandQueue *self,
}
static inline void
-gsk_gl_command_queue_insert_before (GskGLCommandQueue *self,
- GskGLCommandBatch *batch,
- GskGLCommandBatch *sibling)
+gsk_ngl_command_queue_insert_before (GskNglCommandQueue *self,
+ GskNglCommandBatch *batch,
+ GskNglCommandBatch *sibling)
{
int sibling_index;
int index;
@@ -912,8 +912,8 @@ gsk_gl_command_queue_insert_before (GskGLCommandQueue *self,
g_assert (sibling >= self->batches.items);
g_assert (sibling < &self->batches.items[self->batches.len]);
- index = gsk_gl_command_batches_index_of (&self->batches, batch);
- sibling_index = gsk_gl_command_batches_index_of (&self->batches, sibling);
+ index = gsk_ngl_command_batches_index_of (&self->batches, batch);
+ sibling_index = gsk_ngl_command_batches_index_of (&self->batches, sibling);
batch->any.next_batch_index = sibling_index;
batch->any.prev_batch_index = sibling->any.prev_batch_index;
@@ -928,13 +928,13 @@ gsk_gl_command_queue_insert_before (GskGLCommandQueue *self,
}
static void
-gsk_gl_command_queue_sort_batches (GskGLCommandQueue *self)
+gsk_ngl_command_queue_sort_batches (GskNglCommandQueue *self)
{
int *seen;
int *seen_free = NULL;
int index;
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self));
g_assert (self->tail_batch_index >= 0);
g_assert (self->fbo_max >= 0);
@@ -959,7 +959,7 @@ gsk_gl_command_queue_sort_batches (GskGLCommandQueue *self)
while (index >= 0)
{
- GskGLCommandBatch *batch = &self->batches.items[index];
+ GskNglCommandBatch *batch = &self->batches.items[index];
int cur_index = index;
int fbo = -1;
@@ -968,11 +968,11 @@ gsk_gl_command_queue_sort_batches (GskGLCommandQueue *self)
switch (batch->any.kind)
{
- case GSK_GL_COMMAND_KIND_DRAW:
+ case GSK_NGL_COMMAND_KIND_DRAW:
fbo = batch->draw.framebuffer;
break;
- case GSK_GL_COMMAND_KIND_CLEAR:
+ case GSK_NGL_COMMAND_KIND_CLEAR:
fbo = batch->clear.framebuffer;
break;
@@ -996,16 +996,16 @@ gsk_gl_command_queue_sort_batches (GskGLCommandQueue *self)
if (seen[fbo] != -1 && seen[fbo] != batch->any.next_batch_index)
{
int mru_index = seen[fbo];
- GskGLCommandBatch *mru = &self->batches.items[mru_index];
+ GskNglCommandBatch *mru = &self->batches.items[mru_index];
g_assert (mru_index > -1);
- gsk_gl_command_queue_unlink (self, batch);
+ gsk_ngl_command_queue_unlink (self, batch);
g_assert (batch->any.prev_batch_index == -1);
g_assert (batch->any.next_batch_index == -1);
- gsk_gl_command_queue_insert_before (self, batch, mru);
+ gsk_ngl_command_queue_insert_before (self, batch, mru);
g_assert (batch->any.prev_batch_index > -1 ||
self->head_batch_index == cur_index);
@@ -1022,8 +1022,8 @@ gsk_gl_command_queue_sort_batches (GskGLCommandQueue *self)
}
/**
- * gsk_gl_command_queue_execute:
- * @self: a #GskGLCommandQueue
+ * gsk_ngl_command_queue_execute:
+ * @self: a #GskNglCommandQueue
* @surface_height: the height of the backing surface
* @scale_factor: the scale factor of the backing surface
* #scissor: (nullable): the scissor clip if any
@@ -1031,10 +1031,10 @@ gsk_gl_command_queue_sort_batches (GskGLCommandQueue *self)
* Executes all of the batches in the command queue.
*/
void
-gsk_gl_command_queue_execute (GskGLCommandQueue *self,
- guint surface_height,
- guint scale_factor,
- const cairo_region_t *scissor)
+gsk_ngl_command_queue_execute (GskNglCommandQueue *self,
+ guint surface_height,
+ guint scale_factor,
+ const cairo_region_t *scissor)
{
G_GNUC_UNUSED guint count = 0;
graphene_rect_t scissor_test;
@@ -1053,7 +1053,7 @@ gsk_gl_command_queue_execute (GskGLCommandQueue *self,
int next_batch_index;
int active = -1;
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self));
g_assert (self->in_draw == FALSE);
if (self->batches.len == 0)
@@ -1062,9 +1062,9 @@ gsk_gl_command_queue_execute (GskGLCommandQueue *self,
for (guint i = 0; i < G_N_ELEMENTS (textures); i++)
textures[i] = -1;
- gsk_gl_command_queue_sort_batches (self);
+ gsk_ngl_command_queue_sort_batches (self);
- gsk_gl_command_queue_make_current (self);
+ gsk_ngl_command_queue_make_current (self);
#ifdef G_ENABLE_DEBUG
gsk_gl_profiler_begin_gpu_region (self->gl_profiler);
@@ -1082,19 +1082,19 @@ gsk_gl_command_queue_execute (GskGLCommandQueue *self,
glGenVertexArrays (1, &vao_id);
glBindVertexArray (vao_id);
- vbo_id = gsk_gl_buffer_submit (&self->vertices);
+ vbo_id = gsk_ngl_buffer_submit (&self->vertices);
/* 0 = position location */
glEnableVertexAttribArray (0);
glVertexAttribPointer (0, 2, GL_FLOAT, GL_FALSE,
- sizeof (GskGLDrawVertex),
- (void *) G_STRUCT_OFFSET (GskGLDrawVertex, position));
+ sizeof (GskNglDrawVertex),
+ (void *) G_STRUCT_OFFSET (GskNglDrawVertex, position));
/* 1 = texture coord location */
glEnableVertexAttribArray (1);
glVertexAttribPointer (1, 2, GL_FLOAT, GL_FALSE,
- sizeof (GskGLDrawVertex),
- (void *) G_STRUCT_OFFSET (GskGLDrawVertex, uv));
+ sizeof (GskNglDrawVertex),
+ (void *) G_STRUCT_OFFSET (GskNglDrawVertex, uv));
/* Setup initial scissor clip */
if (scissor != NULL)
@@ -1114,7 +1114,7 @@ gsk_gl_command_queue_execute (GskGLCommandQueue *self,
while (next_batch_index >= 0)
{
- const GskGLCommandBatch *batch = &self->batches.items[next_batch_index];
+ const GskNglCommandBatch *batch = &self->batches.items[next_batch_index];
g_assert (next_batch_index >= 0);
g_assert (next_batch_index < self->batches.len);
@@ -1124,7 +1124,7 @@ gsk_gl_command_queue_execute (GskGLCommandQueue *self,
switch (batch->any.kind)
{
- case GSK_GL_COMMAND_KIND_CLEAR:
+ case GSK_NGL_COMMAND_KIND_CLEAR:
if (apply_framebuffer (&framebuffer, batch->clear.framebuffer))
{
apply_scissor (&scissor_state, framebuffer, &scissor_test, has_scissor);
@@ -1140,7 +1140,7 @@ gsk_gl_command_queue_execute (GskGLCommandQueue *self,
glClear (batch->clear.bits);
break;
- case GSK_GL_COMMAND_KIND_DRAW:
+ case GSK_NGL_COMMAND_KIND_DRAW:
if (batch->any.program != program)
{
program = batch->any.program;
@@ -1160,7 +1160,7 @@ gsk_gl_command_queue_execute (GskGLCommandQueue *self,
if G_UNLIKELY (batch->draw.bind_count > 0)
{
- const GskGLCommandBind *bind = &self->batch_binds.items[batch->draw.bind_offset];
+ const GskNglCommandBind *bind = &self->batch_binds.items[batch->draw.bind_offset];
for (guint i = 0; i < batch->draw.bind_count; i++)
{
@@ -1184,10 +1184,10 @@ gsk_gl_command_queue_execute (GskGLCommandQueue *self,
if (batch->draw.uniform_count > 0)
{
- const GskGLCommandUniform *u = &self->batch_uniforms.items[batch->draw.uniform_offset];
+ const GskNglCommandUniform *u = &self->batch_uniforms.items[batch->draw.uniform_offset];
for (guint i = 0; i < batch->draw.uniform_count; i++, u++)
- apply_uniform (gsk_gl_uniform_state_get_uniform_data (self->uniforms, u->info.offset),
+ apply_uniform (gsk_ngl_uniform_state_get_uniform_data (self->uniforms, u->info.offset),
u->info, u->location);
n_uniforms += batch->draw.uniform_count;
@@ -1202,20 +1202,20 @@ gsk_gl_command_queue_execute (GskGLCommandQueue *self,
}
#if 0
- if (batch->any.kind == GSK_GL_COMMAND_KIND_DRAW ||
- batch->any.kind == GSK_GL_COMMAND_KIND_CLEAR)
+ if (batch->any.kind == GSK_NGL_COMMAND_KIND_DRAW ||
+ batch->any.kind == GSK_NGL_COMMAND_KIND_CLEAR)
{
char filename[128];
g_snprintf (filename, sizeof filename,
"capture%03u_batch%03d_kind%u_program%u_u%u_b%u_fb%u_ctx%p.png",
count, next_batch_index,
batch->any.kind, batch->any.program,
- batch->any.kind == GSK_GL_COMMAND_KIND_DRAW ? batch->draw.uniform_count : 0,
- batch->any.kind == GSK_GL_COMMAND_KIND_DRAW ? batch->draw.bind_count : 0,
+ batch->any.kind == GSK_NGL_COMMAND_KIND_DRAW ? batch->draw.uniform_count : 0,
+ batch->any.kind == GSK_NGL_COMMAND_KIND_DRAW ? batch->draw.bind_count : 0,
framebuffer,
gdk_gl_context_get_current ());
- gsk_gl_command_queue_capture_png (self, filename, width, height, TRUE);
- gsk_gl_command_queue_print_batch (self, batch);
+ gsk_ngl_command_queue_capture_png (self, filename, width, height, TRUE);
+ gsk_ngl_command_queue_print_batch (self, batch);
}
#endif
@@ -1247,12 +1247,12 @@ gsk_gl_command_queue_execute (GskGLCommandQueue *self,
}
void
-gsk_gl_command_queue_begin_frame (GskGLCommandQueue *self)
+gsk_ngl_command_queue_begin_frame (GskNglCommandQueue *self)
{
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self));
g_assert (self->batches.len == 0);
- gsk_gl_command_queue_make_current (self);
+ gsk_ngl_command_queue_make_current (self);
self->fbo_max = 0;
self->tail_batch_index = -1;
@@ -1261,8 +1261,8 @@ gsk_gl_command_queue_begin_frame (GskGLCommandQueue *self)
}
/**
- * gsk_gl_command_queue_end_frame:
- * @self: a #GskGLCommandQueue
+ * gsk_ngl_command_queue_end_frame:
+ * @self: a #GskNglCommandQueue
*
* This function performs cleanup steps that need to be done after
* a frame has finished. This is not performed as part of the command
@@ -1273,12 +1273,12 @@ gsk_gl_command_queue_begin_frame (GskGLCommandQueue *self)
* has been called to swap the OpenGL framebuffers.
*/
void
-gsk_gl_command_queue_end_frame (GskGLCommandQueue *self)
+gsk_ngl_command_queue_end_frame (GskNglCommandQueue *self)
{
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self));
- gsk_gl_command_queue_make_current (self);
- gsk_gl_uniform_state_end_frame (self->uniforms);
+ gsk_ngl_command_queue_make_current (self);
+ gsk_ngl_uniform_state_end_frame (self->uniforms);
/* Reset attachments so we don't hold on to any textures
* that might be released after the frame.
@@ -1307,26 +1307,26 @@ gsk_gl_command_queue_end_frame (GskGLCommandQueue *self)
}
gboolean
-gsk_gl_command_queue_create_render_target (GskGLCommandQueue *self,
- int width,
- int height,
- int min_filter,
- int mag_filter,
- guint *out_fbo_id,
- guint *out_texture_id)
+gsk_ngl_command_queue_create_render_target (GskNglCommandQueue *self,
+ int width,
+ int height,
+ int min_filter,
+ int mag_filter,
+ guint *out_fbo_id,
+ guint *out_texture_id)
{
GLuint fbo_id = 0;
GLint texture_id;
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self));
g_assert (width > 0);
g_assert (height > 0);
g_assert (out_fbo_id != NULL);
g_assert (out_texture_id != NULL);
- texture_id = gsk_gl_command_queue_create_texture (self,
- width, height,
- min_filter, mag_filter);
+ texture_id = gsk_ngl_command_queue_create_texture (self,
+ width, height,
+ min_filter, mag_filter);
if (texture_id == -1)
{
@@ -1335,7 +1335,7 @@ gsk_gl_command_queue_create_render_target (GskGLCommandQueue *self,
return FALSE;
}
- fbo_id = gsk_gl_command_queue_create_framebuffer (self);
+ fbo_id = gsk_ngl_command_queue_create_framebuffer (self);
glBindFramebuffer (GL_FRAMEBUFFER, fbo_id);
glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_id, 0);
@@ -1348,15 +1348,15 @@ gsk_gl_command_queue_create_render_target (GskGLCommandQueue *self,
}
int
-gsk_gl_command_queue_create_texture (GskGLCommandQueue *self,
- int width,
- int height,
- int min_filter,
- int mag_filter)
+gsk_ngl_command_queue_create_texture (GskNglCommandQueue *self,
+ int width,
+ int height,
+ int min_filter,
+ int mag_filter)
{
GLuint texture_id = 0;
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self));
if G_UNLIKELY (self->max_texture_size == -1)
glGetIntegerv (GL_MAX_TEXTURE_SIZE, &self->max_texture_size);
@@ -1387,11 +1387,11 @@ gsk_gl_command_queue_create_texture (GskGLCommandQueue *self,
}
guint
-gsk_gl_command_queue_create_framebuffer (GskGLCommandQueue *self)
+gsk_ngl_command_queue_create_framebuffer (GskNglCommandQueue *self)
{
GLuint fbo_id;
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self));
glGenFramebuffers (1, &fbo_id);
@@ -1399,14 +1399,14 @@ gsk_gl_command_queue_create_framebuffer (GskGLCommandQueue *self)
}
int
-gsk_gl_command_queue_upload_texture (GskGLCommandQueue *self,
- GdkTexture *texture,
- guint x_offset,
- guint y_offset,
- guint width,
- guint height,
- int min_filter,
- int mag_filter)
+gsk_ngl_command_queue_upload_texture (GskNglCommandQueue *self,
+ GdkTexture *texture,
+ guint x_offset,
+ guint y_offset,
+ guint width,
+ guint height,
+ int min_filter,
+ int mag_filter)
{
G_GNUC_UNUSED gint64 start_time = GDK_PROFILER_CURRENT_TIME;
cairo_surface_t *surface = NULL;
@@ -1416,7 +1416,7 @@ gsk_gl_command_queue_upload_texture (GskGLCommandQueue *self,
gsize bpp;
int texture_id;
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self));
g_assert (!GDK_IS_GL_TEXTURE (texture));
g_assert (x_offset + width <= gdk_texture_get_width (texture));
g_assert (y_offset + height <= gdk_texture_get_height (texture));
@@ -1432,7 +1432,7 @@ gsk_gl_command_queue_upload_texture (GskGLCommandQueue *self,
height = MAX (height, self->max_texture_size);
}
- texture_id = gsk_gl_command_queue_create_texture (self, width, height, min_filter, mag_filter);
+ texture_id = gsk_ngl_command_queue_create_texture (self, width, height, min_filter, mag_filter);
if (texture_id == -1)
return texture_id;
@@ -1482,11 +1482,11 @@ gsk_gl_command_queue_upload_texture (GskGLCommandQueue *self,
}
void
-gsk_gl_command_queue_set_profiler (GskGLCommandQueue *self,
- GskProfiler *profiler)
+gsk_ngl_command_queue_set_profiler (GskNglCommandQueue *self,
+ GskProfiler *profiler)
{
#ifdef G_ENABLE_DEBUG
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self));
g_assert (GSK_IS_PROFILER (profiler));
if (g_set_object (&self->profiler, profiler))
diff --git a/gsk/ngl/gsknglcommandqueueprivate.h b/gsk/ngl/gsknglcommandqueueprivate.h
new file mode 100644
index 0000000000..9a35326cee
--- /dev/null
+++ b/gsk/ngl/gsknglcommandqueueprivate.h
@@ -0,0 +1,362 @@
+/* gsknglcommandqueueprivate.h
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ */
+
+#ifndef __GSK_NGL_COMMAND_QUEUE_PRIVATE_H__
+#define __GSK_NGL_COMMAND_QUEUE_PRIVATE_H__
+
+#include <gsk/gskprofilerprivate.h>
+
+#include "gskngltypesprivate.h"
+#include "gsknglbufferprivate.h"
+#include "gsknglattachmentstateprivate.h"
+#include "gskngluniformstateprivate.h"
+
+#include "inlinearray.h"
+
+#include "../gl/gskglprofilerprivate.h"
+
+G_BEGIN_DECLS
+
+#define GSK_TYPE_GL_COMMAND_QUEUE (gsk_ngl_command_queue_get_type())
+
+G_DECLARE_FINAL_TYPE (GskNglCommandQueue, gsk_ngl_command_queue, GSK, NGL_COMMAND_QUEUE, GObject)
+
+typedef enum _GskNglCommandKind
+{
+ /* The batch will perform a glClear() */
+ GSK_NGL_COMMAND_KIND_CLEAR,
+
+ /* The batch will perform a glDrawArrays() */
+ GSK_NGL_COMMAND_KIND_DRAW,
+} GskNglCommandKind;
+
+typedef struct _GskNglCommandBind
+{
+ /* @texture is the value passed to glActiveTexture(), the "slot" the
+ * texture will be placed into. We always use GL_TEXTURE_2D so we don't
+ * waste any bits here to indicate that.
+ */
+ guint texture : 5;
+
+ /* The identifier for the texture created with glGenTextures(). */
+ guint id : 27;
+} GskNglCommandBind;
+
+G_STATIC_ASSERT (sizeof (GskNglCommandBind) == 4);
+
+typedef struct _GskNglCommandBatchAny
+{
+ /* A GskNglCommandKind indicating what the batch will do */
+ guint kind : 8;
+
+ /* The program's identifier to use for determining if we can merge two
+ * batches together into a single set of draw operations. We put this
+ * here instead of the GskNglCommandDraw so that we can use the extra
+ * bits here without making the structure larger.
+ */
+ guint program : 24;
+
+ /* The index of the next batch following this one. This is used
+ * as a sort of integer-based linked list to simplify out-of-order
+ * batching without moving memory around. -1 indicates last batch.
+ */
+ gint16 next_batch_index;
+
+ /* Same but for reverse direction as we sort in reverse to get the
+ * batches ordered by framebuffer.
+ */
+ gint16 prev_batch_index;
+
+ /* The viewport size of the batch. We check this as we process
+ * batches to determine if we need to resize the viewport.
+ */
+ struct {
+ guint16 width;
+ guint16 height;
+ } viewport;
+} GskNglCommandBatchAny;
+
+G_STATIC_ASSERT (sizeof (GskNglCommandBatchAny) == 12);
+
+typedef struct _GskNglCommandDraw
+{
+ GskNglCommandBatchAny head;
+
+ /* There doesn't seem to be a limit on the framebuffer identifier that
+ * can be returned, so we have to use a whole unsigned for the framebuffer
+ * we are drawing to. When processing batches, we check to see if this
+ * changes and adjust the render target accordingly. Some sorting is
+ * performed to reduce the amount we change framebuffers.
+ */
+ guint framebuffer;
+
+ /* The number of uniforms to change. This must be less than or equal to
+ * GL_MAX_UNIFORM_LOCATIONS but only guaranteed up to 1024 by any OpenGL
+ * implementation to be conformant.
+ */
+ guint uniform_count : 11;
+
+ /* The number of textures to bind, which is only guaranteed up to 16
+ * by the OpenGL specification to be conformant.
+ */
+ guint bind_count : 5;
+
+ /* GL_MAX_ELEMENTS_VERTICES specifies 33000 for this which requires 16-bit
+ * to address all possible counts <= GL_MAX_ELEMENTS_VERTICES.
+ */
+ guint vbo_count : 16;
+
+ /* The offset within the VBO containing @vbo_count vertices to send with
+ * glDrawArrays().
+ */
+ guint vbo_offset;
+
+ /* The offset within the array of uniform changes to be made containing
+ * @uniform_count #GskNglCommandUniform elements to apply.
+ */
+ guint uniform_offset;
+
+ /* The offset within the array of bind changes to be made containing
+ * @bind_count #GskNglCommandBind elements to apply.
+ */
+ guint bind_offset;
+} GskNglCommandDraw;
+
+G_STATIC_ASSERT (sizeof (GskNglCommandDraw) == 32);
+
+typedef struct _GskNglCommandClear
+{
+ GskNglCommandBatchAny any;
+ guint bits;
+ guint framebuffer;
+} GskNglCommandClear;
+
+G_STATIC_ASSERT (sizeof (GskNglCommandClear) == 20);
+
+typedef struct _GskNglCommandUniform
+{
+ GskNglUniformInfo info;
+ guint location;
+} GskNglCommandUniform;
+
+G_STATIC_ASSERT (sizeof (GskNglCommandUniform) == 8);
+
+typedef union _GskNglCommandBatch
+{
+ GskNglCommandBatchAny any;
+ GskNglCommandDraw draw;
+ GskNglCommandClear clear;
+} GskNglCommandBatch;
+
+G_STATIC_ASSERT (sizeof (GskNglCommandBatch) == 32);
+
+DEFINE_INLINE_ARRAY (GskNglCommandBatches, gsk_ngl_command_batches, GskNglCommandBatch)
+DEFINE_INLINE_ARRAY (GskNglCommandBinds, gsk_ngl_command_binds, GskNglCommandBind)
+DEFINE_INLINE_ARRAY (GskNglCommandUniforms, gsk_ngl_command_uniforms, GskNglCommandUniform)
+
+struct _GskNglCommandQueue
+{
+ GObject parent_instance;
+
+ /* The GdkGLContext we make current before executing GL commands. */
+ GdkGLContext *context;
+
+ /* Array of GskNglCommandBatch which is a fixed size structure that will
+ * point into offsets of other arrays so that all similar data is stored
+ * together. The idea here is that we reduce the need for pointers so that
+ * using g_realloc()'d arrays is fine.
+ */
+ GskNglCommandBatches batches;
+
+ /* Contains array of vertices and some wrapper code to help upload them
+ * to the GL driver. We can also tweak this to use double buffered arrays
+ * if we find that to be faster on some hardware and/or drivers.
+ */
+ GskNglBuffer vertices;
+
+ /* The GskNglAttachmentState contains information about our FBO and texture
+ * attachments as we process incoming operations. We snapshot them into
+ * various batches so that we can compare differences between merge
+ * candidates.
+ */
+ GskNglAttachmentState *attachments;
+
+ /* The uniform state across all programs. We snapshot this into batches so
+ * that we can compare uniform state between batches to give us more
+ * chances at merging draw commands.
+ */
+ GskNglUniformState *uniforms;
+
+ /* Current program if we are in a draw so that we can send commands
+ * to the uniform state as needed.
+ */
+ GskNglUniformProgram *program_info;
+
+ /* The profiler instance to deliver timing/etc data */
+ GskProfiler *profiler;
+ GskGLProfiler *gl_profiler;
+
+ /* Array of GskNglCommandBind which denote what textures need to be attached
+ * to which slot. GskNglCommandDraw.bind_offset and bind_count reference this
+ * array to determine what to attach.
+ */
+ GskNglCommandBinds batch_binds;
+
+ /* Array of GskNglCommandUniform denoting which uniforms must be updated
+ * before the glDrawArrays() may be called. These are referenced from the
+ * GskNglCommandDraw.uniform_offset and uniform_count fields.
+ */
+ GskNglCommandUniforms batch_uniforms;
+
+ /* String storage for debug groups */
+ GStringChunk *debug_groups;
+
+ /* Discovered max texture size when loading the command queue so that we
+ * can either scale down or slice textures to fit within this size. Assumed
+ * to be both height and width.
+ */
+ int max_texture_size;
+
+ /* The index of the last batch in @batches, which may not be the element
+ * at the end of the array, as batches can be reordered. This is used to
+ * update the "next" index when adding a new batch.
+ */
+ gint16 tail_batch_index;
+ gint16 head_batch_index;
+
+ /* Max framebuffer we used, so we can sort items faster */
+ guint fbo_max;
+
+ /* Various GSK and GDK metric counter ids */
+ struct {
+ GQuark n_frames;
+ GQuark cpu_time;
+ GQuark gpu_time;
+ guint n_binds;
+ guint n_fbos;
+ guint n_uniforms;
+ guint n_uploads;
+ guint queue_depth;
+ } metrics;
+
+ /* Counter for uploads on the frame */
+ guint n_uploads;
+
+ /* If we're inside a begin/end_frame pair */
+ guint in_frame : 1;
+
+ /* If we're inside of a begin_draw()/end_draw() pair. */
+ guint in_draw : 1;
+
+ /* If we've warned about truncating batches */
+ guint have_truncated : 1;
+};
+
+GskNglCommandQueue *gsk_ngl_command_queue_new (GdkGLContext *context,
+ GskNglUniformState *uniforms);
+void gsk_ngl_command_queue_set_profiler (GskNglCommandQueue *self,
+ GskProfiler *profiler);
+GdkGLContext *gsk_ngl_command_queue_get_context (GskNglCommandQueue *self);
+void gsk_ngl_command_queue_make_current (GskNglCommandQueue *self);
+void gsk_ngl_command_queue_begin_frame (GskNglCommandQueue *self);
+void gsk_ngl_command_queue_end_frame (GskNglCommandQueue *self);
+void gsk_ngl_command_queue_execute (GskNglCommandQueue *self,
+ guint surface_height,
+ guint scale_factor,
+ const cairo_region_t *scissor);
+int gsk_ngl_command_queue_upload_texture (GskNglCommandQueue *self,
+ GdkTexture *texture,
+ guint x_offset,
+ guint y_offset,
+ guint width,
+ guint height,
+ int min_filter,
+ int mag_filter);
+int gsk_ngl_command_queue_create_texture (GskNglCommandQueue *self,
+ int width,
+ int height,
+ int min_filter,
+ int mag_filter);
+guint gsk_ngl_command_queue_create_framebuffer (GskNglCommandQueue *self);
+gboolean gsk_ngl_command_queue_create_render_target (GskNglCommandQueue *self,
+ int width,
+ int height,
+ int min_filter,
+ int mag_filter,
+ guint *out_fbo_id,
+ guint *out_texture_id);
+void gsk_ngl_command_queue_delete_program (GskNglCommandQueue *self,
+ guint program_id);
+void gsk_ngl_command_queue_clear (GskNglCommandQueue *self,
+ guint clear_bits,
+ const graphene_rect_t *viewport);
+void gsk_ngl_command_queue_begin_draw (GskNglCommandQueue *self,
+ GskNglUniformProgram *program_info,
+ guint width,
+ guint height);
+void gsk_ngl_command_queue_end_draw (GskNglCommandQueue *self);
+void gsk_ngl_command_queue_split_draw (GskNglCommandQueue *self);
+
+static inline GskNglCommandBatch *
+gsk_ngl_command_queue_get_batch (GskNglCommandQueue *self)
+{
+ return gsk_ngl_command_batches_tail (&self->batches);
+}
+
+static inline GskNglDrawVertex *
+gsk_ngl_command_queue_add_vertices (GskNglCommandQueue *self)
+{
+ gsk_ngl_command_queue_get_batch (self)->draw.vbo_count += GSK_NGL_N_VERTICES;
+ return gsk_ngl_buffer_advance (&self->vertices, GSK_NGL_N_VERTICES);
+}
+
+static inline GskNglDrawVertex *
+gsk_ngl_command_queue_add_n_vertices (GskNglCommandQueue *self,
+ guint count)
+{
+ /* This is a batch form of gsk_ngl_command_queue_add_vertices(). Note that
+ * it does *not* add the count to .draw.vbo_count as the caller is responsible
+ * for that.
+ */
+ return gsk_ngl_buffer_advance (&self->vertices, GSK_NGL_N_VERTICES * count);
+}
+
+static inline void
+gsk_ngl_command_queue_retract_n_vertices (GskNglCommandQueue *self,
+ guint count)
+{
+ /* Like gsk_ngl_command_queue_add_n_vertices(), this does not tweak
+ * the draw vbo_count.
+ */
+ gsk_ngl_buffer_retract (&self->vertices, GSK_NGL_N_VERTICES * count);
+}
+
+static inline guint
+gsk_ngl_command_queue_bind_framebuffer (GskNglCommandQueue *self,
+ guint framebuffer)
+{
+ guint ret = self->attachments->fbo.id;
+ gsk_ngl_attachment_state_bind_framebuffer (self->attachments, framebuffer);
+ return ret;
+}
+
+G_END_DECLS
+
+#endif /* __GSK_NGL_COMMAND_QUEUE_PRIVATE_H__ */
diff --git a/gsk/next/gskglcompiler.c b/gsk/ngl/gsknglcompiler.c
similarity index 75%
rename from gsk/next/gskglcompiler.c
rename to gsk/ngl/gsknglcompiler.c
index d51d10fc3a..c033775c48 100644
--- a/gsk/next/gskglcompiler.c
+++ b/gsk/ngl/gsknglcompiler.c
@@ -1,4 +1,4 @@
-/* gskglcompiler.c
+/* gsknglcompiler.c
*
* Copyright 2020 Christian Hergert <chergert redhat com>
*
@@ -24,20 +24,20 @@
#include <gio/gio.h>
#include <string.h>
-#include "gskglcommandqueueprivate.h"
-#include "gskglcompilerprivate.h"
-#include "gskglprogramprivate.h"
+#include "gsknglcommandqueueprivate.h"
+#include "gsknglcompilerprivate.h"
+#include "gsknglprogramprivate.h"
#define SHADER_VERSION_GLES 100
#define SHADER_VERSION_GL2_LEGACY 110
#define SHADER_VERSION_GL3_LEGACY 130
#define SHADER_VERSION_GL3 150
-struct _GskGLCompiler
+struct _GskNglCompiler
{
GObject parent_instance;
- GskNextDriver *driver;
+ GskNglDriver *driver;
GBytes *all_preamble;
GBytes *fragment_preamble;
@@ -57,20 +57,20 @@ struct _GskGLCompiler
guint debug_shaders : 1;
};
-typedef struct _GskGLProgramAttrib
+typedef struct _GskNglProgramAttrib
{
const char *name;
- guint location;
-} GskGLProgramAttrib;
+ guint location;
+} GskNglProgramAttrib;
static GBytes *empty_bytes;
-G_DEFINE_TYPE (GskGLCompiler, gsk_gl_compiler, G_TYPE_OBJECT)
+G_DEFINE_TYPE (GskNglCompiler, gsk_ngl_compiler, G_TYPE_OBJECT)
static void
-gsk_gl_compiler_finalize (GObject *object)
+gsk_ngl_compiler_finalize (GObject *object)
{
- GskGLCompiler *self = (GskGLCompiler *)object;
+ GskNglCompiler *self = (GskNglCompiler *)object;
g_clear_pointer (&self->all_preamble, g_bytes_unref);
g_clear_pointer (&self->fragment_preamble, g_bytes_unref);
@@ -82,24 +82,24 @@ gsk_gl_compiler_finalize (GObject *object)
g_clear_pointer (&self->attrib_locations, g_array_unref);
g_clear_object (&self->driver);
- G_OBJECT_CLASS (gsk_gl_compiler_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gsk_ngl_compiler_parent_class)->finalize (object);
}
static void
-gsk_gl_compiler_class_init (GskGLCompilerClass *klass)
+gsk_ngl_compiler_class_init (GskNglCompilerClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
- object_class->finalize = gsk_gl_compiler_finalize;
+ object_class->finalize = gsk_ngl_compiler_finalize;
empty_bytes = g_bytes_new (NULL, 0);
}
static void
-gsk_gl_compiler_init (GskGLCompiler *self)
+gsk_ngl_compiler_init (GskNglCompiler *self)
{
self->glsl_version = 150;
- self->attrib_locations = g_array_new (FALSE, FALSE, sizeof (GskGLProgramAttrib));
+ self->attrib_locations = g_array_new (FALSE, FALSE, sizeof (GskNglProgramAttrib));
self->all_preamble = g_bytes_ref (empty_bytes);
self->vertex_preamble = g_bytes_ref (empty_bytes);
self->fragment_preamble = g_bytes_ref (empty_bytes);
@@ -109,21 +109,21 @@ gsk_gl_compiler_init (GskGLCompiler *self)
self->fragment_suffix = g_bytes_ref (empty_bytes);
}
-GskGLCompiler *
-gsk_gl_compiler_new (GskNextDriver *driver,
- gboolean debug_shaders)
+GskNglCompiler *
+gsk_ngl_compiler_new (GskNglDriver *driver,
+ gboolean debug_shaders)
{
- GskGLCompiler *self;
+ GskNglCompiler *self;
GdkGLContext *context;
- g_return_val_if_fail (GSK_IS_NEXT_DRIVER (driver), NULL);
+ g_return_val_if_fail (GSK_IS_NGL_DRIVER (driver), NULL);
g_return_val_if_fail (driver->shared_command_queue != NULL, NULL);
self = g_object_new (GSK_TYPE_GL_COMPILER, NULL);
self->driver = g_object_ref (driver);
self->debug_shaders = !!debug_shaders;
- context = gsk_gl_command_queue_get_context (self->driver->shared_command_queue);
+ context = gsk_ngl_command_queue_get_context (self->driver->shared_command_queue);
if (gdk_gl_context_get_use_es (context))
{
@@ -149,19 +149,19 @@ gsk_gl_compiler_new (GskNextDriver *driver,
self->gl3 = TRUE;
}
- gsk_gl_command_queue_make_current (self->driver->shared_command_queue);
+ gsk_ngl_command_queue_make_current (self->driver->shared_command_queue);
return g_steal_pointer (&self);
}
void
-gsk_gl_compiler_bind_attribute (GskGLCompiler *self,
- const char *name,
- guint location)
+gsk_ngl_compiler_bind_attribute (GskNglCompiler *self,
+ const char *name,
+ guint location)
{
- GskGLProgramAttrib attrib;
+ GskNglProgramAttrib attrib;
- g_return_if_fail (GSK_IS_GL_COMPILER (self));
+ g_return_if_fail (GSK_IS_NGL_COMPILER (self));
g_return_if_fail (name != NULL);
g_return_if_fail (location < 32);
@@ -172,28 +172,28 @@ gsk_gl_compiler_bind_attribute (GskGLCompiler *self,
}
void
-gsk_gl_compiler_clear_attributes (GskGLCompiler *self)
+gsk_ngl_compiler_clear_attributes (GskNglCompiler *self)
{
- g_return_if_fail (GSK_IS_GL_COMPILER (self));
+ g_return_if_fail (GSK_IS_NGL_COMPILER (self));
g_array_set_size (self->attrib_locations, 0);
}
void
-gsk_gl_compiler_set_preamble (GskGLCompiler *self,
- GskGLCompilerKind kind,
- GBytes *preamble_bytes)
+gsk_ngl_compiler_set_preamble (GskNglCompiler *self,
+ GskNglCompilerKind kind,
+ GBytes *preamble_bytes)
{
GBytes **loc = NULL;
- g_return_if_fail (GSK_IS_GL_COMPILER (self));
+ g_return_if_fail (GSK_IS_NGL_COMPILER (self));
g_return_if_fail (preamble_bytes != NULL);
- if (kind == GSK_GL_COMPILER_ALL)
+ if (kind == GSK_NGL_COMPILER_ALL)
loc = &self->all_preamble;
- else if (kind == GSK_GL_COMPILER_FRAGMENT)
+ else if (kind == GSK_NGL_COMPILER_FRAGMENT)
loc = &self->fragment_preamble;
- else if (kind == GSK_GL_COMPILER_VERTEX)
+ else if (kind == GSK_NGL_COMPILER_VERTEX)
loc = &self->vertex_preamble;
else
g_return_if_reached ();
@@ -208,17 +208,17 @@ gsk_gl_compiler_set_preamble (GskGLCompiler *self,
}
void
-gsk_gl_compiler_set_preamble_from_resource (GskGLCompiler *self,
- GskGLCompilerKind kind,
- const char *resource_path)
+gsk_ngl_compiler_set_preamble_from_resource (GskNglCompiler *self,
+ GskNglCompilerKind kind,
+ const char *resource_path)
{
GError *error = NULL;
GBytes *bytes;
- g_return_if_fail (GSK_IS_GL_COMPILER (self));
- g_return_if_fail (kind == GSK_GL_COMPILER_ALL ||
- kind == GSK_GL_COMPILER_VERTEX ||
- kind == GSK_GL_COMPILER_FRAGMENT);
+ g_return_if_fail (GSK_IS_NGL_COMPILER (self));
+ g_return_if_fail (kind == GSK_NGL_COMPILER_ALL ||
+ kind == GSK_NGL_COMPILER_VERTEX ||
+ kind == GSK_NGL_COMPILER_FRAGMENT);
g_return_if_fail (resource_path != NULL);
bytes = g_resources_lookup_data (resource_path,
@@ -228,23 +228,23 @@ gsk_gl_compiler_set_preamble_from_resource (GskGLCompiler *self,
if (bytes == NULL)
g_warning ("Cannot set shader from resource: %s", error->message);
else
- gsk_gl_compiler_set_preamble (self, kind, bytes);
+ gsk_ngl_compiler_set_preamble (self, kind, bytes);
g_clear_pointer (&bytes, g_bytes_unref);
g_clear_error (&error);
}
void
-gsk_gl_compiler_set_source (GskGLCompiler *self,
- GskGLCompilerKind kind,
- GBytes *source_bytes)
+gsk_ngl_compiler_set_source (GskNglCompiler *self,
+ GskNglCompilerKind kind,
+ GBytes *source_bytes)
{
GBytes **loc = NULL;
- g_return_if_fail (GSK_IS_GL_COMPILER (self));
- g_return_if_fail (kind == GSK_GL_COMPILER_ALL ||
- kind == GSK_GL_COMPILER_VERTEX ||
- kind == GSK_GL_COMPILER_FRAGMENT);
+ g_return_if_fail (GSK_IS_NGL_COMPILER (self));
+ g_return_if_fail (kind == GSK_NGL_COMPILER_ALL ||
+ kind == GSK_NGL_COMPILER_VERTEX ||
+ kind == GSK_NGL_COMPILER_FRAGMENT);
if (source_bytes == NULL)
source_bytes = empty_bytes;
@@ -256,7 +256,7 @@ gsk_gl_compiler_set_source (GskGLCompiler *self,
* use GBytes which reference the original bytes instead of
* copying them.
*/
- if (kind == GSK_GL_COMPILER_ALL)
+ if (kind == GSK_NGL_COMPILER_ALL)
{
gsize len = 0;
const char *source;
@@ -305,8 +305,8 @@ gsk_gl_compiler_set_source (GskGLCompiler *self,
fragment_shader_start - source,
endpos - fragment_shader_start);
- gsk_gl_compiler_set_source (self, GSK_GL_COMPILER_VERTEX, vertex_bytes);
- gsk_gl_compiler_set_source (self, GSK_GL_COMPILER_FRAGMENT, fragment_bytes);
+ gsk_ngl_compiler_set_source (self, GSK_NGL_COMPILER_VERTEX, vertex_bytes);
+ gsk_ngl_compiler_set_source (self, GSK_NGL_COMPILER_FRAGMENT, fragment_bytes);
g_bytes_unref (fragment_bytes);
g_bytes_unref (vertex_bytes);
@@ -314,9 +314,9 @@ gsk_gl_compiler_set_source (GskGLCompiler *self,
return;
}
- if (kind == GSK_GL_COMPILER_FRAGMENT)
+ if (kind == GSK_NGL_COMPILER_FRAGMENT)
loc = &self->fragment_source;
- else if (kind == GSK_GL_COMPILER_VERTEX)
+ else if (kind == GSK_NGL_COMPILER_VERTEX)
loc = &self->vertex_source;
else
g_return_if_reached ();
@@ -329,17 +329,17 @@ gsk_gl_compiler_set_source (GskGLCompiler *self,
}
void
-gsk_gl_compiler_set_source_from_resource (GskGLCompiler *self,
- GskGLCompilerKind kind,
- const char *resource_path)
+gsk_ngl_compiler_set_source_from_resource (GskNglCompiler *self,
+ GskNglCompilerKind kind,
+ const char *resource_path)
{
GError *error = NULL;
GBytes *bytes;
- g_return_if_fail (GSK_IS_GL_COMPILER (self));
- g_return_if_fail (kind == GSK_GL_COMPILER_ALL ||
- kind == GSK_GL_COMPILER_VERTEX ||
- kind == GSK_GL_COMPILER_FRAGMENT);
+ g_return_if_fail (GSK_IS_NGL_COMPILER (self));
+ g_return_if_fail (kind == GSK_NGL_COMPILER_ALL ||
+ kind == GSK_NGL_COMPILER_VERTEX ||
+ kind == GSK_NGL_COMPILER_FRAGMENT);
g_return_if_fail (resource_path != NULL);
bytes = g_resources_lookup_data (resource_path,
@@ -349,30 +349,30 @@ gsk_gl_compiler_set_source_from_resource (GskGLCompiler *self,
if (bytes == NULL)
g_warning ("Cannot set shader from resource: %s", error->message);
else
- gsk_gl_compiler_set_source (self, kind, bytes);
+ gsk_ngl_compiler_set_source (self, kind, bytes);
g_clear_pointer (&bytes, g_bytes_unref);
g_clear_error (&error);
}
void
-gsk_gl_compiler_set_suffix (GskGLCompiler *self,
- GskGLCompilerKind kind,
- GBytes *suffix_bytes)
+gsk_ngl_compiler_set_suffix (GskNglCompiler *self,
+ GskNglCompilerKind kind,
+ GBytes *suffix_bytes)
{
GBytes **loc;
- g_return_if_fail (GSK_IS_GL_COMPILER (self));
- g_return_if_fail (kind == GSK_GL_COMPILER_VERTEX ||
- kind == GSK_GL_COMPILER_FRAGMENT);
+ g_return_if_fail (GSK_IS_NGL_COMPILER (self));
+ g_return_if_fail (kind == GSK_NGL_COMPILER_VERTEX ||
+ kind == GSK_NGL_COMPILER_FRAGMENT);
g_return_if_fail (suffix_bytes != NULL);
if (suffix_bytes == NULL)
suffix_bytes = empty_bytes;
- if (kind == GSK_GL_COMPILER_FRAGMENT)
+ if (kind == GSK_NGL_COMPILER_FRAGMENT)
loc = &self->fragment_suffix;
- else if (kind == GSK_GL_COMPILER_VERTEX)
+ else if (kind == GSK_NGL_COMPILER_VERTEX)
loc = &self->vertex_suffix;
else
g_return_if_reached ();
@@ -385,16 +385,16 @@ gsk_gl_compiler_set_suffix (GskGLCompiler *self,
}
void
-gsk_gl_compiler_set_suffix_from_resource (GskGLCompiler *self,
- GskGLCompilerKind kind,
- const char *resource_path)
+gsk_ngl_compiler_set_suffix_from_resource (GskNglCompiler *self,
+ GskNglCompilerKind kind,
+ const char *resource_path)
{
GError *error = NULL;
GBytes *bytes;
- g_return_if_fail (GSK_IS_GL_COMPILER (self));
- g_return_if_fail (kind == GSK_GL_COMPILER_VERTEX ||
- kind == GSK_GL_COMPILER_FRAGMENT);
+ g_return_if_fail (GSK_IS_NGL_COMPILER (self));
+ g_return_if_fail (kind == GSK_NGL_COMPILER_VERTEX ||
+ kind == GSK_NGL_COMPILER_FRAGMENT);
g_return_if_fail (resource_path != NULL);
bytes = g_resources_lookup_data (resource_path,
@@ -404,7 +404,7 @@ gsk_gl_compiler_set_suffix_from_resource (GskGLCompiler *self,
if (bytes == NULL)
g_warning ("Cannot set suffix from resource: %s", error->message);
else
- gsk_gl_compiler_set_suffix (self, kind, bytes);
+ gsk_ngl_compiler_set_suffix (self, kind, bytes);
g_clear_pointer (&bytes, g_bytes_unref);
g_clear_error (&error);
@@ -435,7 +435,7 @@ prepend_line_numbers (char *code,
}
static gboolean
-check_shader_error (int shader_id,
+check_shader_error (int shader_id,
GError **error)
{
GLint status;
@@ -520,10 +520,10 @@ get_shader_string (GBytes *bytes)
return str ? str : "";
}
-GskGLProgram *
-gsk_gl_compiler_compile (GskGLCompiler *self,
- const char *name,
- GError **error)
+GskNglProgram *
+gsk_ngl_compiler_compile (GskNglCompiler *self,
+ const char *name,
+ GError **error)
{
char version[32];
const char *debug = "";
@@ -535,7 +535,7 @@ gsk_gl_compiler_compile (GskGLCompiler *self,
int fragment_id;
int status;
- g_return_val_if_fail (GSK_IS_GL_COMPILER (self), NULL);
+ g_return_val_if_fail (GSK_IS_NGL_COMPILER (self), NULL);
g_return_val_if_fail (self->all_preamble != NULL, NULL);
g_return_val_if_fail (self->fragment_preamble != NULL, NULL);
g_return_val_if_fail (self->vertex_preamble != NULL, NULL);
@@ -543,7 +543,7 @@ gsk_gl_compiler_compile (GskGLCompiler *self,
g_return_val_if_fail (self->vertex_source != NULL, NULL);
g_return_val_if_fail (self->driver != NULL, NULL);
- gsk_gl_command_queue_make_current (self->driver->command_queue);
+ gsk_ngl_command_queue_make_current (self->driver->command_queue);
g_snprintf (version, sizeof version, "#version %d\n", self->glsl_version);
@@ -554,10 +554,10 @@ gsk_gl_compiler_compile (GskGLCompiler *self,
legacy = "#define GSK_LEGACY 1\n";
if (self->gles)
- gles = "#define GSK_GLES 1\n";
+ gles = "#define GSK_NGLES 1\n";
if (self->gl3)
- gl3 = "#define GSK_GL3 1\n";
+ gl3 = "#define GSK_NGL3 1\n";
vertex_id = glCreateShader (GL_VERTEX_SHADER);
glShaderSource (vertex_id,
@@ -628,9 +628,9 @@ gsk_gl_compiler_compile (GskGLCompiler *self,
for (guint i = 0; i < self->attrib_locations->len; i++)
{
- const GskGLProgramAttrib *attrib;
+ const GskNglProgramAttrib *attrib;
- attrib = &g_array_index (self->attrib_locations, GskGLProgramAttrib, i);
+ attrib = &g_array_index (self->attrib_locations, GskNglProgramAttrib, i);
glBindAttribLocation (program_id, attrib->location, attrib->name);
}
@@ -674,5 +674,5 @@ gsk_gl_compiler_compile (GskGLCompiler *self,
return NULL;
}
- return gsk_gl_program_new (self->driver, name, program_id);
+ return gsk_ngl_program_new (self->driver, name, program_id);
}
diff --git a/gsk/ngl/gsknglcompilerprivate.h b/gsk/ngl/gsknglcompilerprivate.h
new file mode 100644
index 0000000000..d61dce2697
--- /dev/null
+++ b/gsk/ngl/gsknglcompilerprivate.h
@@ -0,0 +1,69 @@
+/* gsknglcompilerprivate.h
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ */
+
+#ifndef __GSK_NGL_COMPILER_PRIVATE_H__
+#define __GSK_NGL_COMPILER_PRIVATE_H__
+
+#include "gskngltypesprivate.h"
+
+G_BEGIN_DECLS
+
+typedef enum _GskNglCompilerKind
+{
+ GSK_NGL_COMPILER_ALL,
+ GSK_NGL_COMPILER_FRAGMENT,
+ GSK_NGL_COMPILER_VERTEX,
+} GskNglCompilerKind;
+
+#define GSK_TYPE_GL_COMPILER (gsk_ngl_compiler_get_type())
+
+G_DECLARE_FINAL_TYPE (GskNglCompiler, gsk_ngl_compiler, GSK, NGL_COMPILER, GObject)
+
+GskNglCompiler *gsk_ngl_compiler_new (GskNglDriver *driver,
+ gboolean debug);
+void gsk_ngl_compiler_set_preamble (GskNglCompiler *self,
+ GskNglCompilerKind kind,
+ GBytes *preamble_bytes);
+void gsk_ngl_compiler_set_preamble_from_resource (GskNglCompiler *self,
+ GskNglCompilerKind kind,
+ const char *resource_path);
+void gsk_ngl_compiler_set_source (GskNglCompiler *self,
+ GskNglCompilerKind kind,
+ GBytes *source_bytes);
+void gsk_ngl_compiler_set_source_from_resource (GskNglCompiler *self,
+ GskNglCompilerKind kind,
+ const char *resource_path);
+void gsk_ngl_compiler_set_suffix (GskNglCompiler *self,
+ GskNglCompilerKind kind,
+ GBytes *suffix_bytes);
+void gsk_ngl_compiler_set_suffix_from_resource (GskNglCompiler *self,
+ GskNglCompilerKind kind,
+ const char *resource_path);
+void gsk_ngl_compiler_bind_attribute (GskNglCompiler *self,
+ const char *name,
+ guint location);
+void gsk_ngl_compiler_clear_attributes (GskNglCompiler *self);
+GskNglProgram *gsk_ngl_compiler_compile (GskNglCompiler *self,
+ const char *name,
+ GError **error);
+
+G_END_DECLS
+
+#endif /* __GSK_NGL_COMPILER_PRIVATE_H__ */
diff --git a/gsk/next/gskgldriver.c b/gsk/ngl/gskngldriver.c
similarity index 57%
rename from gsk/next/gskgldriver.c
rename to gsk/ngl/gskngldriver.c
index a5eaaedac9..a6720754be 100644
--- a/gsk/next/gskgldriver.c
+++ b/gsk/ngl/gskngldriver.c
@@ -1,4 +1,4 @@
-/* gskgldriver.c
+/* gskngldriver.c
*
* Copyright 2017 Timm Bäder <mail baedert org>
* Copyright 2018 Matthias Clasen <mclasen redhat com>
@@ -29,24 +29,24 @@
#include <gsk/gskglshaderprivate.h>
#include <gsk/gskrendererprivate.h>
-#include "gskglcommandqueueprivate.h"
-#include "gskglcompilerprivate.h"
-#include "gskgldriverprivate.h"
-#include "gskglglyphlibraryprivate.h"
-#include "gskgliconlibraryprivate.h"
-#include "gskglprogramprivate.h"
-#include "gskglshadowlibraryprivate.h"
-#include "gskgltexturepoolprivate.h"
+#include "gsknglcommandqueueprivate.h"
+#include "gsknglcompilerprivate.h"
+#include "gskngldriverprivate.h"
+#include "gsknglglyphlibraryprivate.h"
+#include "gskngliconlibraryprivate.h"
+#include "gsknglprogramprivate.h"
+#include "gsknglshadowlibraryprivate.h"
+#include "gskngltexturepoolprivate.h"
#define ATLAS_SIZE 512
-typedef struct _GskGLTextureState
+typedef struct _GskNglTextureState
{
GdkGLContext *context;
GLuint texture_id;
-} GskGLTextureState;
+} GskNglTextureState;
-G_DEFINE_TYPE (GskNextDriver, gsk_next_driver, G_TYPE_OBJECT)
+G_DEFINE_TYPE (GskNglDriver, gsk_ngl_driver, G_TYPE_OBJECT)
static guint
texture_key_hash (gconstpointer v)
@@ -68,7 +68,8 @@ texture_key_hash (gconstpointer v)
}
static gboolean
-texture_key_equal (gconstpointer v1, gconstpointer v2)
+texture_key_equal (gconstpointer v1,
+ gconstpointer v2)
{
const GskTextureKey *k1 = (const GskTextureKey *)v1;
const GskTextureKey *k2 = (const GskTextureKey *)v2;
@@ -82,12 +83,12 @@ texture_key_equal (gconstpointer v1, gconstpointer v2)
}
static void
-remove_texture_key_for_id (GskNextDriver *self,
- guint texture_id)
+remove_texture_key_for_id (GskNglDriver *self,
+ guint texture_id)
{
GskTextureKey *key;
- g_assert (GSK_IS_NEXT_DRIVER (self));
+ g_assert (GSK_IS_NGL_DRIVER (self));
g_assert (texture_id > 0);
/* g_hash_table_remove() will cause @key to be freed */
@@ -99,28 +100,28 @@ remove_texture_key_for_id (GskNextDriver *self,
}
static void
-gsk_gl_texture_destroyed (gpointer data)
+gsk_ngl_texture_destroyed (gpointer data)
{
- ((GskGLTexture *)data)->user = NULL;
+ ((GskNglTexture *)data)->user = NULL;
}
static guint
-gsk_next_driver_collect_unused_textures (GskNextDriver *self,
- gint64 watermark)
+gsk_ngl_driver_collect_unused_textures (GskNglDriver *self,
+ gint64 watermark)
{
GHashTableIter iter;
gpointer k, v;
guint old_size;
guint collected;
- g_assert (GSK_IS_NEXT_DRIVER (self));
+ g_assert (GSK_IS_NGL_DRIVER (self));
old_size = g_hash_table_size (self->textures);
g_hash_table_iter_init (&iter, self->textures);
while (g_hash_table_iter_next (&iter, &k, &v))
{
- GskGLTexture *t = v;
+ GskNglTexture *t = v;
if (t->user || t->permanent)
continue;
@@ -135,7 +136,7 @@ gsk_next_driver_collect_unused_textures (GskNextDriver *self,
/* Steal this texture and put it back into the pool */
remove_texture_key_for_id (self, t->texture_id);
- gsk_gl_texture_pool_put (&self->texture_pool, t);
+ gsk_ngl_texture_pool_put (&self->texture_pool, t);
}
}
@@ -145,7 +146,7 @@ gsk_next_driver_collect_unused_textures (GskNextDriver *self,
}
static void
-gsk_gl_texture_atlas_free (GskGLTextureAtlas *atlas)
+gsk_ngl_texture_atlas_free (GskNglTextureAtlas *atlas)
{
if (atlas->texture_id != 0)
{
@@ -154,28 +155,28 @@ gsk_gl_texture_atlas_free (GskGLTextureAtlas *atlas)
}
g_clear_pointer (&atlas->nodes, g_free);
- g_slice_free (GskGLTextureAtlas, atlas);
+ g_slice_free (GskNglTextureAtlas, atlas);
}
-GskGLTextureAtlas *
-gsk_next_driver_create_atlas (GskNextDriver *self)
+GskNglTextureAtlas *
+gsk_ngl_driver_create_atlas (GskNglDriver *self)
{
- GskGLTextureAtlas *atlas;
+ GskNglTextureAtlas *atlas;
- g_return_val_if_fail (GSK_IS_NEXT_DRIVER (self), NULL);
+ g_return_val_if_fail (GSK_IS_NGL_DRIVER (self), NULL);
- atlas = g_slice_new0 (GskGLTextureAtlas);
+ atlas = g_slice_new0 (GskNglTextureAtlas);
atlas->width = ATLAS_SIZE;
atlas->height = ATLAS_SIZE;
/* TODO: We might want to change the strategy about the amount of
* nodes here? stb_rect_pack.h says width is optimal. */
atlas->nodes = g_malloc0_n (atlas->width, sizeof (struct stbrp_node));
stbrp_init_target (&atlas->context, atlas->width, atlas->height, atlas->nodes, atlas->width);
- atlas->texture_id = gsk_gl_command_queue_create_texture (self->command_queue,
- atlas->width,
- atlas->height,
- GL_LINEAR,
- GL_LINEAR);
+ atlas->texture_id = gsk_ngl_command_queue_create_texture (self->command_queue,
+ atlas->width,
+ atlas->height,
+ GL_LINEAR,
+ GL_LINEAR);
gdk_gl_context_label_object_printf (gdk_gl_context_get_current (),
GL_TEXTURE, atlas->texture_id,
@@ -190,49 +191,49 @@ gsk_next_driver_create_atlas (GskNextDriver *self)
static void
remove_program (gpointer data)
{
- GskGLProgram *program = data;
+ GskNglProgram *program = data;
- g_assert (!program || GSK_IS_GL_PROGRAM (program));
+ g_assert (!program || GSK_IS_NGL_PROGRAM (program));
if (program != NULL)
{
- gsk_gl_program_delete (program);
+ gsk_ngl_program_delete (program);
g_object_unref (program);
}
}
static void
-gsk_next_driver_shader_weak_cb (gpointer data,
- GObject *where_object_was)
+gsk_ngl_driver_shader_weak_cb (gpointer data,
+ GObject *where_object_was)
{
- GskNextDriver *self = data;
+ GskNglDriver *self = data;
- g_assert (GSK_IS_NEXT_DRIVER (self));
+ g_assert (GSK_IS_NGL_DRIVER (self));
if (self->shader_cache != NULL)
g_hash_table_remove (self->shader_cache, where_object_was);
}
static void
-gsk_next_driver_dispose (GObject *object)
+gsk_ngl_driver_dispose (GObject *object)
{
- GskNextDriver *self = (GskNextDriver *)object;
+ GskNglDriver *self = (GskNglDriver *)object;
- g_assert (GSK_IS_NEXT_DRIVER (self));
+ g_assert (GSK_IS_NGL_DRIVER (self));
g_assert (self->in_frame == FALSE);
-#define GSK_GL_NO_UNIFORMS
-#define GSK_GL_ADD_UNIFORM(pos, KEY, name)
-#define GSK_GL_DEFINE_PROGRAM(name, resource, uniforms) \
+#define GSK_NGL_NO_UNIFORMS
+#define GSK_NGL_ADD_UNIFORM(pos, KEY, name)
+#define GSK_NGL_DEFINE_PROGRAM(name, resource, uniforms) \
G_STMT_START { \
if (self->name) \
- gsk_gl_program_delete (self->name); \
+ gsk_ngl_program_delete (self->name); \
g_clear_object (&self->name); \
} G_STMT_END;
-# include "gskglprograms.defs"
-#undef GSK_GL_NO_UNIFORMS
-#undef GSK_GL_ADD_UNIFORM
-#undef GSK_GL_DEFINE_PROGRAM
+# include "gsknglprograms.defs"
+#undef GSK_NGL_NO_UNIFORMS
+#undef GSK_NGL_ADD_UNIFORM
+#undef GSK_NGL_DEFINE_PROGRAM
if (self->shader_cache != NULL)
{
@@ -244,7 +245,7 @@ gsk_next_driver_dispose (GObject *object)
{
GskGLShader *shader = k;
g_object_weak_unref (G_OBJECT (shader),
- gsk_next_driver_shader_weak_cb,
+ gsk_ngl_driver_shader_weak_cb,
self);
g_hash_table_iter_remove (&iter);
}
@@ -254,8 +255,8 @@ gsk_next_driver_dispose (GObject *object)
if (self->command_queue != NULL)
{
- gsk_gl_command_queue_make_current (self->command_queue);
- gsk_next_driver_collect_unused_textures (self, 0);
+ gsk_ngl_command_queue_make_current (self->command_queue);
+ gsk_ngl_driver_collect_unused_textures (self, 0);
g_clear_object (&self->command_queue);
}
@@ -266,7 +267,7 @@ gsk_next_driver_dispose (GObject *object)
self->autorelease_framebuffers->len = 0;
}
- gsk_gl_texture_pool_clear (&self->texture_pool);
+ gsk_ngl_texture_pool_clear (&self->texture_pool);
g_assert (!self->textures || g_hash_table_size (self->textures) == 0);
g_assert (!self->texture_id_to_key || g_hash_table_size (self->texture_id_to_key) == 0);
@@ -288,96 +289,96 @@ gsk_next_driver_dispose (GObject *object)
g_clear_object (&self->command_queue);
g_clear_object (&self->shared_command_queue);
- G_OBJECT_CLASS (gsk_next_driver_parent_class)->dispose (object);
+ G_OBJECT_CLASS (gsk_ngl_driver_parent_class)->dispose (object);
}
static void
-gsk_next_driver_class_init (GskNextDriverClass *klass)
+gsk_ngl_driver_class_init (GskNglDriverClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
- object_class->dispose = gsk_next_driver_dispose;
+ object_class->dispose = gsk_ngl_driver_dispose;
}
static void
-gsk_next_driver_init (GskNextDriver *self)
+gsk_ngl_driver_init (GskNglDriver *self)
{
self->autorelease_framebuffers = g_array_new (FALSE, FALSE, sizeof (guint));
self->textures = g_hash_table_new_full (NULL, NULL, NULL,
- (GDestroyNotify)gsk_gl_texture_free);
+ (GDestroyNotify)gsk_ngl_texture_free);
self->texture_id_to_key = g_hash_table_new (NULL, NULL);
self->key_to_texture_id = g_hash_table_new_full (texture_key_hash,
texture_key_equal,
g_free,
NULL);
self->shader_cache = g_hash_table_new_full (NULL, NULL, NULL, remove_program);
- gsk_gl_texture_pool_init (&self->texture_pool);
+ gsk_ngl_texture_pool_init (&self->texture_pool);
self->render_targets = g_ptr_array_new ();
- self->atlases = g_ptr_array_new_with_free_func ((GDestroyNotify)gsk_gl_texture_atlas_free);
+ self->atlases = g_ptr_array_new_with_free_func ((GDestroyNotify)gsk_ngl_texture_atlas_free);
}
static gboolean
-gsk_next_driver_load_programs (GskNextDriver *self,
- GError **error)
+gsk_ngl_driver_load_programs (GskNglDriver *self,
+ GError **error)
{
- GskGLCompiler *compiler;
+ GskNglCompiler *compiler;
gboolean ret = FALSE;
- g_assert (GSK_IS_NEXT_DRIVER (self));
- g_assert (GSK_IS_GL_COMMAND_QUEUE (self->command_queue));
+ g_assert (GSK_IS_NGL_DRIVER (self));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (self->command_queue));
- compiler = gsk_gl_compiler_new (self, self->debug);
+ compiler = gsk_ngl_compiler_new (self, self->debug);
/* Setup preambles that are shared by all shaders */
- gsk_gl_compiler_set_preamble_from_resource (compiler,
- GSK_GL_COMPILER_ALL,
- "/org/gtk/libgsk/glsl/preamble.glsl");
- gsk_gl_compiler_set_preamble_from_resource (compiler,
- GSK_GL_COMPILER_VERTEX,
- "/org/gtk/libgsk/glsl/preamble.vs.glsl");
- gsk_gl_compiler_set_preamble_from_resource (compiler,
- GSK_GL_COMPILER_FRAGMENT,
- "/org/gtk/libgsk/glsl/preamble.fs.glsl");
+ gsk_ngl_compiler_set_preamble_from_resource (compiler,
+ GSK_NGL_COMPILER_ALL,
+ "/org/gtk/libgsk/glsl/preamble.glsl");
+ gsk_ngl_compiler_set_preamble_from_resource (compiler,
+ GSK_NGL_COMPILER_VERTEX,
+ "/org/gtk/libgsk/glsl/preamble.vs.glsl");
+ gsk_ngl_compiler_set_preamble_from_resource (compiler,
+ GSK_NGL_COMPILER_FRAGMENT,
+ "/org/gtk/libgsk/glsl/preamble.fs.glsl");
/* Setup attributes that are provided via VBO */
- gsk_gl_compiler_bind_attribute (compiler, "aPosition", 0);
- gsk_gl_compiler_bind_attribute (compiler, "aUv", 1);
+ gsk_ngl_compiler_bind_attribute (compiler, "aPosition", 0);
+ gsk_ngl_compiler_bind_attribute (compiler, "aUv", 1);
/* Use XMacros to register all of our programs and their uniforms */
-#define GSK_GL_NO_UNIFORMS
-#define GSK_GL_ADD_UNIFORM(pos, KEY, name) \
- gsk_gl_program_add_uniform (program, #name, UNIFORM_##KEY);
-#define GSK_GL_DEFINE_PROGRAM(name, resource, uniforms) \
+#define GSK_NGL_NO_UNIFORMS
+#define GSK_NGL_ADD_UNIFORM(pos, KEY, name) \
+ gsk_ngl_program_add_uniform (program, #name, UNIFORM_##KEY);
+#define GSK_NGL_DEFINE_PROGRAM(name, resource, uniforms) \
G_STMT_START { \
- GskGLProgram *program; \
+ GskNglProgram *program; \
gboolean have_alpha; \
gboolean have_source; \
\
- gsk_gl_compiler_set_source_from_resource (compiler, GSK_GL_COMPILER_ALL, resource); \
+ gsk_ngl_compiler_set_source_from_resource (compiler, GSK_NGL_COMPILER_ALL, resource); \
\
- if (!(program = gsk_gl_compiler_compile (compiler, #name, error))) \
+ if (!(program = gsk_ngl_compiler_compile (compiler, #name, error))) \
goto failure; \
\
- have_alpha = gsk_gl_program_add_uniform (program, "u_alpha", UNIFORM_SHARED_ALPHA); \
- have_source = gsk_gl_program_add_uniform (program, "u_source", UNIFORM_SHARED_SOURCE); \
- gsk_gl_program_add_uniform (program, "u_clip_rect", UNIFORM_SHARED_CLIP_RECT); \
- gsk_gl_program_add_uniform (program, "u_viewport", UNIFORM_SHARED_VIEWPORT); \
- gsk_gl_program_add_uniform (program, "u_projection", UNIFORM_SHARED_PROJECTION); \
- gsk_gl_program_add_uniform (program, "u_modelview", UNIFORM_SHARED_MODELVIEW); \
+ have_alpha = gsk_ngl_program_add_uniform (program, "u_alpha", UNIFORM_SHARED_ALPHA); \
+ have_source = gsk_ngl_program_add_uniform (program, "u_source", UNIFORM_SHARED_SOURCE); \
+ gsk_ngl_program_add_uniform (program, "u_clip_rect", UNIFORM_SHARED_CLIP_RECT); \
+ gsk_ngl_program_add_uniform (program, "u_viewport", UNIFORM_SHARED_VIEWPORT); \
+ gsk_ngl_program_add_uniform (program, "u_projection", UNIFORM_SHARED_PROJECTION); \
+ gsk_ngl_program_add_uniform (program, "u_modelview", UNIFORM_SHARED_MODELVIEW); \
\
uniforms \
\
- gsk_gl_program_uniforms_added (program, have_source); \
+ gsk_ngl_program_uniforms_added (program, have_source); \
\
if (have_alpha) \
- gsk_gl_program_set_uniform1f (program, UNIFORM_SHARED_ALPHA, 0, 1.0f); \
+ gsk_ngl_program_set_uniform1f (program, UNIFORM_SHARED_ALPHA, 0, 1.0f); \
\
- *(GskGLProgram **)(((guint8 *)self) + G_STRUCT_OFFSET (GskNextDriver, name)) = \
+ *(GskNglProgram **)(((guint8 *)self) + G_STRUCT_OFFSET (GskNglDriver, name)) = \
g_steal_pointer (&program); \
} G_STMT_END;
-# include "gskglprograms.defs"
-#undef GSK_GL_DEFINE_PROGRAM
-#undef GSK_GL_ADD_UNIFORM
+# include "gsknglprograms.defs"
+#undef GSK_NGL_DEFINE_PROGRAM
+#undef GSK_NGL_ADD_UNIFORM
ret = TRUE;
@@ -388,55 +389,55 @@ failure:
}
/**
- * gsk_next_driver_autorelease_framebuffer:
- * @self: a #GskNextDriver
+ * gsk_ngl_driver_autorelease_framebuffer:
+ * @self: a #GskNglDriver
* @framebuffer_id: the id of the OpenGL framebuffer
*
* Marks @framebuffer_id to be deleted when the current frame has cmopleted.
*/
static void
-gsk_next_driver_autorelease_framebuffer (GskNextDriver *self,
- guint framebuffer_id)
+gsk_ngl_driver_autorelease_framebuffer (GskNglDriver *self,
+ guint framebuffer_id)
{
- g_assert (GSK_IS_NEXT_DRIVER (self));
+ g_assert (GSK_IS_NGL_DRIVER (self));
g_array_append_val (self->autorelease_framebuffers, framebuffer_id);
}
-static GskNextDriver *
-gsk_next_driver_new (GskGLCommandQueue *command_queue,
- gboolean debug_shaders,
- GError **error)
+static GskNglDriver *
+gsk_ngl_driver_new (GskNglCommandQueue *command_queue,
+ gboolean debug_shaders,
+ GError **error)
{
- GskNextDriver *self;
+ GskNglDriver *self;
GdkGLContext *context;
- g_return_val_if_fail (GSK_IS_GL_COMMAND_QUEUE (command_queue), NULL);
+ g_return_val_if_fail (GSK_IS_NGL_COMMAND_QUEUE (command_queue), NULL);
- context = gsk_gl_command_queue_get_context (command_queue);
+ context = gsk_ngl_command_queue_get_context (command_queue);
gdk_gl_context_make_current (context);
- self = g_object_new (GSK_TYPE_NEXT_DRIVER, NULL);
+ self = g_object_new (GSK_TYPE_NGL_DRIVER, NULL);
self->command_queue = g_object_ref (command_queue);
self->shared_command_queue = g_object_ref (command_queue);
self->debug = !!debug_shaders;
- if (!gsk_next_driver_load_programs (self, error))
+ if (!gsk_ngl_driver_load_programs (self, error))
{
g_object_unref (self);
return NULL;
}
- self->glyphs = gsk_gl_glyph_library_new (self);
- self->icons = gsk_gl_icon_library_new (self);
- self->shadows = gsk_gl_shadow_library_new (self);
+ self->glyphs = gsk_ngl_glyph_library_new (self);
+ self->icons = gsk_ngl_icon_library_new (self);
+ self->shadows = gsk_ngl_shadow_library_new (self);
return g_steal_pointer (&self);
}
/**
- * gsk_next_driver_from_shared_context:
+ * gsk_ngl_driver_from_shared_context:
* @context: a shared #GdkGLContext retrieved with gdk_gl_context_get_shared_context()
* @debug_shaders: if debug information for shaders should be displayed
* @error: location for error information
@@ -444,20 +445,20 @@ gsk_next_driver_new (GskGLCommandQueue *command_queue,
* Retrieves a driver for a shared context. Generally this is shared across all GL
* contexts for a display so that fewer programs are necessary for driving output.
*
- * Returns: (transfer full): a #GskNextDriver if successful; otherwise %NULL and
+ * Returns: (transfer full): a #GskNglDriver if successful; otherwise %NULL and
* @error is set.
*/
-GskNextDriver *
-gsk_next_driver_from_shared_context (GdkGLContext *context,
- gboolean debug_shaders,
- GError **error)
+GskNglDriver *
+gsk_ngl_driver_from_shared_context (GdkGLContext *context,
+ gboolean debug_shaders,
+ GError **error)
{
- GskGLCommandQueue *command_queue = NULL;
- GskNextDriver *driver;
+ GskNglCommandQueue *command_queue = NULL;
+ GskNglDriver *driver;
g_return_val_if_fail (GDK_IS_GL_CONTEXT (context), NULL);
- if ((driver = g_object_get_data (G_OBJECT (context), "GSK_NEXT_DRIVER")))
+ if ((driver = g_object_get_data (G_OBJECT (context), "GSK_NGL_DRIVER")))
return g_object_ref (driver);
gdk_gl_context_make_current (context);
@@ -468,13 +469,13 @@ gsk_next_driver_from_shared_context (GdkGLContext *context,
* shared context, all other contexts sharing with it will have access
* to those programs.
*/
- command_queue = gsk_gl_command_queue_new (context, NULL);
+ command_queue = gsk_ngl_command_queue_new (context, NULL);
- if (!(driver = gsk_next_driver_new (command_queue, debug_shaders, error)))
+ if (!(driver = gsk_ngl_driver_new (command_queue, debug_shaders, error)))
goto failure;
g_object_set_data_full (G_OBJECT (context),
- "GSK_NEXT_DRIVER",
+ "GSK_NGL_DRIVER",
g_object_ref (driver),
g_object_unref);
@@ -485,9 +486,9 @@ failure:
}
/**
- * gsk_next_driver_begin_frame:
- * @self: a #GskNextDriver
- * @command_queue: A #GskGLCommandQueue from the renderer
+ * gsk_ngl_driver_begin_frame:
+ * @self: a #GskNglDriver
+ * @command_queue: A #GskNglCommandQueue from the renderer
*
* Begin a new frame.
*
@@ -496,13 +497,13 @@ failure:
* target context to be drawn into (the context of the renderer's surface).
*/
void
-gsk_next_driver_begin_frame (GskNextDriver *self,
- GskGLCommandQueue *command_queue)
+gsk_ngl_driver_begin_frame (GskNglDriver *self,
+ GskNglCommandQueue *command_queue)
{
gint64 last_frame_id;
- g_return_if_fail (GSK_IS_NEXT_DRIVER (self));
- g_return_if_fail (GSK_IS_GL_COMMAND_QUEUE (command_queue));
+ g_return_if_fail (GSK_IS_NGL_DRIVER (self));
+ g_return_if_fail (GSK_IS_NGL_COMMAND_QUEUE (command_queue));
g_return_if_fail (self->in_frame == FALSE);
last_frame_id = self->current_frame_id;
@@ -512,46 +513,46 @@ gsk_next_driver_begin_frame (GskNextDriver *self,
g_set_object (&self->command_queue, command_queue);
- gsk_gl_command_queue_begin_frame (self->command_queue);
+ gsk_ngl_command_queue_begin_frame (self->command_queue);
- gsk_gl_texture_library_begin_frame (GSK_GL_TEXTURE_LIBRARY (self->icons));
- gsk_gl_texture_library_begin_frame (GSK_GL_TEXTURE_LIBRARY (self->glyphs));
- gsk_gl_shadow_library_begin_frame (self->shadows);
+ gsk_ngl_texture_library_begin_frame (GSK_NGL_TEXTURE_LIBRARY (self->icons));
+ gsk_ngl_texture_library_begin_frame (GSK_NGL_TEXTURE_LIBRARY (self->glyphs));
+ gsk_ngl_shadow_library_begin_frame (self->shadows);
/* Remove all textures that are from a previous frame or are no
* longer used by linked GdkTexture. We do this at the beginning
* of the following frame instead of the end so that we reduce chances
* we block on any resources while delivering our frames.
*/
- gsk_next_driver_collect_unused_textures (self, last_frame_id - 1);
+ gsk_ngl_driver_collect_unused_textures (self, last_frame_id - 1);
}
/**
- * gsk_next_driver_end_frame:
- * @self: a #GskNextDriver
+ * gsk_ngl_driver_end_frame:
+ * @self: a #GskNglDriver
*
* Clean up resources from drawing the current frame.
*
* Temporary resources used while drawing will be released.
*/
void
-gsk_next_driver_end_frame (GskNextDriver *self)
+gsk_ngl_driver_end_frame (GskNglDriver *self)
{
- g_return_if_fail (GSK_IS_NEXT_DRIVER (self));
+ g_return_if_fail (GSK_IS_NGL_DRIVER (self));
g_return_if_fail (self->in_frame == TRUE);
- gsk_gl_command_queue_make_current (self->command_queue);
- gsk_gl_command_queue_end_frame (self->command_queue);
+ gsk_ngl_command_queue_make_current (self->command_queue);
+ gsk_ngl_command_queue_end_frame (self->command_queue);
- gsk_gl_texture_library_end_frame (GSK_GL_TEXTURE_LIBRARY (self->icons));
- gsk_gl_texture_library_end_frame (GSK_GL_TEXTURE_LIBRARY (self->glyphs));
+ gsk_ngl_texture_library_end_frame (GSK_NGL_TEXTURE_LIBRARY (self->icons));
+ gsk_ngl_texture_library_end_frame (GSK_NGL_TEXTURE_LIBRARY (self->glyphs));
self->in_frame = FALSE;
}
/**
- * gsk_next_driver_after_frame:
- * @self: a #GskNextDriver
+ * gsk_ngl_driver_after_frame:
+ * @self: a #GskNglDriver
*
* This function does post-frame cleanup operations.
*
@@ -559,9 +560,9 @@ gsk_next_driver_end_frame (GskNextDriver *self)
* after the frame has swapped buffers.
*/
void
-gsk_next_driver_after_frame (GskNextDriver *self)
+gsk_ngl_driver_after_frame (GskNglDriver *self)
{
- g_return_if_fail (GSK_IS_NEXT_DRIVER (self));
+ g_return_if_fail (GSK_IS_NGL_DRIVER (self));
g_return_if_fail (self->in_frame == FALSE);
/* Release any render targets (possibly adding them to
@@ -570,11 +571,11 @@ gsk_next_driver_after_frame (GskNextDriver *self)
*/
while (self->render_targets->len > 0)
{
- GskGLRenderTarget *render_target = g_ptr_array_index (self->render_targets, self->render_targets->len
- 1);
+ GskNglRenderTarget *render_target = g_ptr_array_index (self->render_targets, self->render_targets->len
- 1);
- gsk_next_driver_autorelease_framebuffer (self, render_target->framebuffer_id);
+ gsk_ngl_driver_autorelease_framebuffer (self, render_target->framebuffer_id);
glDeleteTextures (1, &render_target->texture_id);
- g_slice_free (GskGLRenderTarget, render_target);
+ g_slice_free (GskNglRenderTarget, render_target);
self->render_targets->len--;
}
@@ -588,7 +589,7 @@ gsk_next_driver_after_frame (GskNextDriver *self)
}
/* Release any cached textures we used during the frame */
- gsk_gl_texture_pool_clear (&self->texture_pool);
+ gsk_ngl_texture_pool_clear (&self->texture_pool);
/* Reset command queue to our shared queue incase we have operations
* that need to be processed outside of a frame (such as callbacks
@@ -598,36 +599,36 @@ gsk_next_driver_after_frame (GskNextDriver *self)
}
GdkGLContext *
-gsk_next_driver_get_context (GskNextDriver *self)
+gsk_ngl_driver_get_context (GskNglDriver *self)
{
- g_return_val_if_fail (GSK_IS_NEXT_DRIVER (self), NULL);
- g_return_val_if_fail (GSK_IS_GL_COMMAND_QUEUE (self->command_queue), NULL);
+ g_return_val_if_fail (GSK_IS_NGL_DRIVER (self), NULL);
+ g_return_val_if_fail (GSK_IS_NGL_COMMAND_QUEUE (self->command_queue), NULL);
- return gsk_gl_command_queue_get_context (self->command_queue);
+ return gsk_ngl_command_queue_get_context (self->command_queue);
}
/**
- * gsk_next_driver_cache_texture:
- * @self: a #GskNextDriver
+ * gsk_ngl_driver_cache_texture:
+ * @self: a #GskNglDriver
* @key: the key for the texture
* @texture_id: the id of the texture to be cached
*
* Inserts @texture_id into the texture cache using @key.
*
* Textures can be looked up by @key after calling this function using
- * gsk_next_driver_lookup_texture().
+ * gsk_ngl_driver_lookup_texture().
*
* Textures that have not been used within a number of frames will be
* purged from the texture cache automatically.
*/
void
-gsk_next_driver_cache_texture (GskNextDriver *self,
- const GskTextureKey *key,
- guint texture_id)
+gsk_ngl_driver_cache_texture (GskNglDriver *self,
+ const GskTextureKey *key,
+ guint texture_id)
{
GskTextureKey *k;
- g_assert (GSK_IS_NEXT_DRIVER (self));
+ g_assert (GSK_IS_NGL_DRIVER (self));
g_assert (key != NULL);
g_assert (texture_id > 0);
g_assert (g_hash_table_contains (self->textures, GUINT_TO_POINTER (texture_id)));
@@ -639,7 +640,7 @@ gsk_next_driver_cache_texture (GskNextDriver *self,
}
/**
- * gsk_next_driver_load_texture:
+ * gsk_ngl_driver_load_texture:
* @self: a #GdkTexture
* @texture: a #GdkTexture
* @min_filter: GL_NEAREST or GL_LINEAR
@@ -662,22 +663,22 @@ gsk_next_driver_cache_texture (GskNextDriver *self,
* Returns: a texture identifier
*/
guint
-gsk_next_driver_load_texture (GskNextDriver *self,
- GdkTexture *texture,
- int min_filter,
- int mag_filter)
+gsk_ngl_driver_load_texture (GskNglDriver *self,
+ GdkTexture *texture,
+ int min_filter,
+ int mag_filter)
{
GdkGLContext *context;
GdkTexture *downloaded_texture = NULL;
GdkTexture *source_texture;
- GskGLTexture *t;
+ GskNglTexture *t;
guint texture_id;
int height;
int width;
- g_return_val_if_fail (GSK_IS_NEXT_DRIVER (self), 0);
+ g_return_val_if_fail (GSK_IS_NGL_DRIVER (self), 0);
g_return_val_if_fail (GDK_IS_TEXTURE (texture), 0);
- g_return_val_if_fail (GSK_IS_GL_COMMAND_QUEUE (self->command_queue), 0);
+ g_return_val_if_fail (GSK_IS_NGL_COMMAND_QUEUE (self->command_queue), 0);
context = self->command_queue->context;
@@ -726,22 +727,22 @@ gsk_next_driver_load_texture (GskNextDriver *self,
width = gdk_texture_get_width (texture);
height = gdk_texture_get_height (texture);
- texture_id = gsk_gl_command_queue_upload_texture (self->command_queue,
- source_texture,
- 0,
- 0,
- width,
- height,
- min_filter,
- mag_filter);
-
- t = gsk_gl_texture_new (texture_id,
- width, height, min_filter, mag_filter,
- self->current_frame_id);
+ texture_id = gsk_ngl_command_queue_upload_texture (self->command_queue,
+ source_texture,
+ 0,
+ 0,
+ width,
+ height,
+ min_filter,
+ mag_filter);
+
+ t = gsk_ngl_texture_new (texture_id,
+ width, height, min_filter, mag_filter,
+ self->current_frame_id);
g_hash_table_insert (self->textures, GUINT_TO_POINTER (texture_id), t);
- if (gdk_texture_set_render_data (texture, self, t, gsk_gl_texture_destroyed))
+ if (gdk_texture_set_render_data (texture, self, t, gsk_ngl_texture_destroyed))
t->user = texture;
gdk_gl_context_label_object_printf (context, GL_TEXTURE, t->texture_id,
@@ -753,8 +754,8 @@ gsk_next_driver_load_texture (GskNextDriver *self,
}
/**
- * gsk_next_driver_create_texture:
- * @self: a #GskNextDriver
+ * gsk_ngl_driver_create_texture:
+ * @self: a #GskNglDriver
* @width: the width of the texture
* @height: the height of the texture
* @min_filter: GL_NEAREST or GL_LINEAR
@@ -764,26 +765,26 @@ gsk_next_driver_load_texture (GskNextDriver *self,
* to upload data, map to a framebuffer, or other uses which may
* modify the texture immediately.
*
- * Use gsk_next_driver_release_texture() to release this texture back into
+ * Use gsk_ngl_driver_release_texture() to release this texture back into
* the pool so it may be reused later in the pipeline.
*
- * Returns: a #GskGLTexture which can be returned to the pool with
- * gsk_next_driver_release_texture().
+ * Returns: a #GskNglTexture which can be returned to the pool with
+ * gsk_ngl_driver_release_texture().
*/
-GskGLTexture *
-gsk_next_driver_create_texture (GskNextDriver *self,
- float width,
- float height,
- int min_filter,
- int mag_filter)
+GskNglTexture *
+gsk_ngl_driver_create_texture (GskNglDriver *self,
+ float width,
+ float height,
+ int min_filter,
+ int mag_filter)
{
- GskGLTexture *texture;
+ GskNglTexture *texture;
- g_return_val_if_fail (GSK_IS_NEXT_DRIVER (self), NULL);
+ g_return_val_if_fail (GSK_IS_NGL_DRIVER (self), NULL);
- texture = gsk_gl_texture_pool_get (&self->texture_pool,
- width, height,
- min_filter, mag_filter);
+ texture = gsk_ngl_texture_pool_get (&self->texture_pool,
+ width, height,
+ min_filter, mag_filter);
g_hash_table_insert (self->textures,
GUINT_TO_POINTER (texture->texture_id),
texture);
@@ -792,9 +793,9 @@ gsk_next_driver_create_texture (GskNextDriver *self,
}
/**
- * gsk_next_driver_release_texture:
- * @self: a #GskNextDriver
- * @texture: a #GskGLTexture
+ * gsk_ngl_driver_release_texture:
+ * @self: a #GskNglDriver
+ * @texture: a #GskNglTexture
*
* Releases @texture back into the pool so that it can be used later
* in the command stream by future batches. This helps reduce VRAM
@@ -804,12 +805,12 @@ gsk_next_driver_create_texture (GskNextDriver *self,
* to free additional VRAM back to the system.
*/
void
-gsk_next_driver_release_texture (GskNextDriver *self,
- GskGLTexture *texture)
+gsk_ngl_driver_release_texture (GskNglDriver *self,
+ GskNglTexture *texture)
{
guint texture_id;
- g_assert (GSK_IS_NEXT_DRIVER (self));
+ g_assert (GSK_IS_NGL_DRIVER (self));
g_assert (texture != NULL);
texture_id = texture->texture_id;
@@ -818,12 +819,12 @@ gsk_next_driver_release_texture (GskNextDriver *self,
remove_texture_key_for_id (self, texture_id);
g_hash_table_steal (self->textures, GUINT_TO_POINTER (texture_id));
- gsk_gl_texture_pool_put (&self->texture_pool, texture);
+ gsk_ngl_texture_pool_put (&self->texture_pool, texture);
}
/**
- * gsk_next_driver_create_render_target:
- * @self: a #GskNextDriver
+ * gsk_ngl_driver_create_render_target:
+ * @self: a #GskNglDriver
* @width: the width for the render target
* @height: the height for the render target
* @min_filter: the min filter to use for the texture
@@ -834,7 +835,7 @@ gsk_next_driver_release_texture (GskNextDriver *self,
* bound to that framebuffer of the size @width x @height and using the
* appropriate filters.
*
- * Use gsk_next_driver_release_render_target() when you are finished with
+ * Use gsk_ngl_driver_release_render_target() when you are finished with
* the render target to release it. You may steal the texture from the
* render target when releasing it.
*
@@ -842,18 +843,18 @@ gsk_next_driver_release_texture (GskNextDriver *self,
* @out_texture_id are undefined.
*/
gboolean
-gsk_next_driver_create_render_target (GskNextDriver *self,
- int width,
- int height,
- int min_filter,
- int mag_filter,
- GskGLRenderTarget **out_render_target)
+gsk_ngl_driver_create_render_target (GskNglDriver *self,
+ int width,
+ int height,
+ int min_filter,
+ int mag_filter,
+ GskNglRenderTarget **out_render_target)
{
guint framebuffer_id;
guint texture_id;
- g_return_val_if_fail (GSK_IS_NEXT_DRIVER (self), FALSE);
- g_return_val_if_fail (GSK_IS_GL_COMMAND_QUEUE (self->command_queue), FALSE);
+ g_return_val_if_fail (GSK_IS_NGL_DRIVER (self), FALSE);
+ g_return_val_if_fail (GSK_IS_NGL_COMMAND_QUEUE (self->command_queue), FALSE);
g_return_val_if_fail (out_render_target != NULL, FALSE);
#if 0
@@ -861,7 +862,7 @@ gsk_next_driver_create_render_target (GskNextDriver *self,
{
for (guint i = self->render_targets->len; i > 0; i--)
{
- GskGLRenderTarget *render_target = g_ptr_array_index (self->render_targets, i-1);
+ GskNglRenderTarget *render_target = g_ptr_array_index (self->render_targets, i-1);
if (render_target->width == width &&
render_target->height == height &&
@@ -875,14 +876,14 @@ gsk_next_driver_create_render_target (GskNextDriver *self,
}
#endif
- if (gsk_gl_command_queue_create_render_target (self->command_queue,
- width, height,
- min_filter, mag_filter,
- &framebuffer_id, &texture_id))
+ if (gsk_ngl_command_queue_create_render_target (self->command_queue,
+ width, height,
+ min_filter, mag_filter,
+ &framebuffer_id, &texture_id))
{
- GskGLRenderTarget *render_target;
+ GskNglRenderTarget *render_target;
- render_target = g_slice_new0 (GskGLRenderTarget);
+ render_target = g_slice_new0 (GskNglRenderTarget);
render_target->min_filter = min_filter;
render_target->mag_filter = mag_filter;
render_target->width = width;
@@ -901,10 +902,10 @@ gsk_next_driver_create_render_target (GskNextDriver *self,
}
/**
- * gsk_next_driver_release_render_target:
- * @self: a #GskNextDriver
- * @render_target: a #GskGLRenderTarget created with
- * gsk_next_driver_create_render_target().
+ * gsk_ngl_driver_release_render_target:
+ * @self: a #GskNglDriver
+ * @render_target: a #GskNglRenderTarget created with
+ * gsk_ngl_driver_create_render_target().
* @release_texture: if the texture should also be released
*
* Releases a render target that was previously created. An attempt may
@@ -921,13 +922,13 @@ gsk_next_driver_create_render_target (GskNextDriver *self,
* Returns: a texture id if @release_texture is %FALSE, otherwise zero.
*/
guint
-gsk_next_driver_release_render_target (GskNextDriver *self,
- GskGLRenderTarget *render_target,
- gboolean release_texture)
+gsk_ngl_driver_release_render_target (GskNglDriver *self,
+ GskNglRenderTarget *render_target,
+ gboolean release_texture)
{
guint texture_id;
- g_return_val_if_fail (GSK_IS_NEXT_DRIVER (self), 0);
+ g_return_val_if_fail (GSK_IS_NGL_DRIVER (self), 0);
g_return_val_if_fail (render_target != NULL, 0);
if (release_texture)
@@ -937,22 +938,22 @@ gsk_next_driver_release_render_target (GskNextDriver *self,
}
else
{
- GskGLTexture *texture;
+ GskNglTexture *texture;
texture_id = render_target->texture_id;
- texture = gsk_gl_texture_new (render_target->texture_id,
- render_target->width,
- render_target->height,
- render_target->min_filter,
- render_target->mag_filter,
- self->current_frame_id);
+ texture = gsk_ngl_texture_new (render_target->texture_id,
+ render_target->width,
+ render_target->height,
+ render_target->min_filter,
+ render_target->mag_filter,
+ self->current_frame_id);
g_hash_table_insert (self->textures,
GUINT_TO_POINTER (texture_id),
g_steal_pointer (&texture));
- gsk_next_driver_autorelease_framebuffer (self, render_target->framebuffer_id);
- g_slice_free (GskGLRenderTarget, render_target);
+ gsk_ngl_driver_autorelease_framebuffer (self, render_target->framebuffer_id);
+ g_slice_free (GskNglRenderTarget, render_target);
}
@@ -960,8 +961,8 @@ gsk_next_driver_release_render_target (GskNextDriver *self,
}
/**
- * gsk_next_driver_lookup_shader:
- * @self: a #GskNextDriver
+ * gsk_ngl_driver_lookup_shader:
+ * @self: a #GskNglDriver
* @shader: the shader to lookup or load
* @error: a location for a #GError, or %NULL
*
@@ -972,12 +973,12 @@ gsk_next_driver_release_render_target (GskNextDriver *self,
* Returns: (transfer none): a #GskGLShader if successful; otherwise
* %NULL and @error is set.
*/
-GskGLProgram *
-gsk_next_driver_lookup_shader (GskNextDriver *self,
- GskGLShader *shader,
- GError **error)
+GskNglProgram *
+gsk_ngl_driver_lookup_shader (GskNglDriver *self,
+ GskGLShader *shader,
+ GError **error)
{
- GskGLProgram *program;
+ GskNglProgram *program;
g_return_val_if_fail (self != NULL, NULL);
g_return_val_if_fail (shader != NULL, NULL);
@@ -987,7 +988,7 @@ gsk_next_driver_lookup_shader (GskNextDriver *self,
if (program == NULL)
{
const GskGLUniform *uniforms;
- GskGLCompiler *compiler;
+ GskNglCompiler *compiler;
GBytes *suffix;
int n_required_textures;
int n_uniforms;
@@ -1016,64 +1017,64 @@ gsk_next_driver_lookup_shader (GskNextDriver *self,
return NULL;
}
- compiler = gsk_gl_compiler_new (self, FALSE);
+ compiler = gsk_ngl_compiler_new (self, FALSE);
suffix = gsk_gl_shader_get_source (shader);
- gsk_gl_compiler_set_preamble_from_resource (compiler,
- GSK_GL_COMPILER_ALL,
- "/org/gtk/libgsk/glsl/preamble.glsl");
- gsk_gl_compiler_set_preamble_from_resource (compiler,
- GSK_GL_COMPILER_VERTEX,
- "/org/gtk/libgsk/glsl/preamble.vs.glsl");
- gsk_gl_compiler_set_preamble_from_resource (compiler,
- GSK_GL_COMPILER_FRAGMENT,
- "/org/gtk/libgsk/glsl/preamble.fs.glsl");
- gsk_gl_compiler_set_source_from_resource (compiler,
- GSK_GL_COMPILER_ALL,
- "/org/gtk/libgsk/glsl/custom.glsl");
- gsk_gl_compiler_set_suffix (compiler, GSK_GL_COMPILER_FRAGMENT, suffix);
+ gsk_ngl_compiler_set_preamble_from_resource (compiler,
+ GSK_NGL_COMPILER_ALL,
+ "/org/gtk/libgsk/glsl/preamble.glsl");
+ gsk_ngl_compiler_set_preamble_from_resource (compiler,
+ GSK_NGL_COMPILER_VERTEX,
+ "/org/gtk/libgsk/glsl/preamble.vs.glsl");
+ gsk_ngl_compiler_set_preamble_from_resource (compiler,
+ GSK_NGL_COMPILER_FRAGMENT,
+ "/org/gtk/libgsk/glsl/preamble.fs.glsl");
+ gsk_ngl_compiler_set_source_from_resource (compiler,
+ GSK_NGL_COMPILER_ALL,
+ "/org/gtk/libgsk/glsl/custom.glsl");
+ gsk_ngl_compiler_set_suffix (compiler, GSK_NGL_COMPILER_FRAGMENT, suffix);
/* Setup attributes that are provided via VBO */
- gsk_gl_compiler_bind_attribute (compiler, "aPosition", 0);
- gsk_gl_compiler_bind_attribute (compiler, "aUv", 1);
+ gsk_ngl_compiler_bind_attribute (compiler, "aPosition", 0);
+ gsk_ngl_compiler_bind_attribute (compiler, "aUv", 1);
- if ((program = gsk_gl_compiler_compile (compiler, NULL, error)))
+ if ((program = gsk_ngl_compiler_compile (compiler, NULL, error)))
{
gboolean have_alpha;
- gsk_gl_program_add_uniform (program, "u_source", UNIFORM_SHARED_SOURCE);
- gsk_gl_program_add_uniform (program, "u_clip_rect", UNIFORM_SHARED_CLIP_RECT);
- gsk_gl_program_add_uniform (program, "u_viewport", UNIFORM_SHARED_VIEWPORT);
- gsk_gl_program_add_uniform (program, "u_projection", UNIFORM_SHARED_PROJECTION);
- gsk_gl_program_add_uniform (program, "u_modelview", UNIFORM_SHARED_MODELVIEW);
- have_alpha = gsk_gl_program_add_uniform (program, "u_alpha", UNIFORM_SHARED_ALPHA);
-
- gsk_gl_program_add_uniform (program, "u_size", UNIFORM_CUSTOM_SIZE);
- gsk_gl_program_add_uniform (program, "u_texture1", UNIFORM_CUSTOM_TEXTURE1);
- gsk_gl_program_add_uniform (program, "u_texture2", UNIFORM_CUSTOM_TEXTURE2);
- gsk_gl_program_add_uniform (program, "u_texture3", UNIFORM_CUSTOM_TEXTURE3);
- gsk_gl_program_add_uniform (program, "u_texture4", UNIFORM_CUSTOM_TEXTURE4);
+ gsk_ngl_program_add_uniform (program, "u_source", UNIFORM_SHARED_SOURCE);
+ gsk_ngl_program_add_uniform (program, "u_clip_rect", UNIFORM_SHARED_CLIP_RECT);
+ gsk_ngl_program_add_uniform (program, "u_viewport", UNIFORM_SHARED_VIEWPORT);
+ gsk_ngl_program_add_uniform (program, "u_projection", UNIFORM_SHARED_PROJECTION);
+ gsk_ngl_program_add_uniform (program, "u_modelview", UNIFORM_SHARED_MODELVIEW);
+ have_alpha = gsk_ngl_program_add_uniform (program, "u_alpha", UNIFORM_SHARED_ALPHA);
+
+ gsk_ngl_program_add_uniform (program, "u_size", UNIFORM_CUSTOM_SIZE);
+ gsk_ngl_program_add_uniform (program, "u_texture1", UNIFORM_CUSTOM_TEXTURE1);
+ gsk_ngl_program_add_uniform (program, "u_texture2", UNIFORM_CUSTOM_TEXTURE2);
+ gsk_ngl_program_add_uniform (program, "u_texture3", UNIFORM_CUSTOM_TEXTURE3);
+ gsk_ngl_program_add_uniform (program, "u_texture4", UNIFORM_CUSTOM_TEXTURE4);
for (guint i = 0; i < n_uniforms; i++)
- gsk_gl_program_add_uniform (program, uniforms[i].name, UNIFORM_CUSTOM_LAST+i);
+ gsk_ngl_program_add_uniform (program, uniforms[i].name, UNIFORM_CUSTOM_LAST+i);
- program->size_location = gsk_gl_program_get_uniform_location (program, UNIFORM_CUSTOM_SIZE);
- program->texture_locations[0] = gsk_gl_program_get_uniform_location (program,
UNIFORM_CUSTOM_TEXTURE1);
- program->texture_locations[1] = gsk_gl_program_get_uniform_location (program,
UNIFORM_CUSTOM_TEXTURE2);
- program->texture_locations[2] = gsk_gl_program_get_uniform_location (program,
UNIFORM_CUSTOM_TEXTURE3);
- program->texture_locations[3] = gsk_gl_program_get_uniform_location (program,
UNIFORM_CUSTOM_TEXTURE4);
+ program->size_location = gsk_ngl_program_get_uniform_location (program, UNIFORM_CUSTOM_SIZE);
+ program->texture_locations[0] = gsk_ngl_program_get_uniform_location (program,
UNIFORM_CUSTOM_TEXTURE1);
+ program->texture_locations[1] = gsk_ngl_program_get_uniform_location (program,
UNIFORM_CUSTOM_TEXTURE2);
+ program->texture_locations[2] = gsk_ngl_program_get_uniform_location (program,
UNIFORM_CUSTOM_TEXTURE3);
+ program->texture_locations[3] = gsk_ngl_program_get_uniform_location (program,
UNIFORM_CUSTOM_TEXTURE4);
for (guint i = 0; i < n_uniforms; i++)
- program->args_locations[i] = gsk_gl_program_get_uniform_location (program,
UNIFORM_CUSTOM_LAST+i);
+ program->args_locations[i] = gsk_ngl_program_get_uniform_location (program,
UNIFORM_CUSTOM_LAST+i);
for (guint i = n_uniforms; i < G_N_ELEMENTS (program->args_locations); i++)
program->args_locations[i] = -1;
- gsk_gl_program_uniforms_added (program, TRUE);
+ gsk_ngl_program_uniforms_added (program, TRUE);
if (have_alpha)
- gsk_gl_program_set_uniform1f (program, UNIFORM_SHARED_ALPHA, 0, 1.0f);
+ gsk_ngl_program_set_uniform1f (program, UNIFORM_SHARED_ALPHA, 0, 1.0f);
g_hash_table_insert (self->shader_cache, shader, program);
g_object_weak_ref (G_OBJECT (shader),
- gsk_next_driver_shader_weak_cb,
+ gsk_ngl_driver_shader_weak_cb,
self);
}
@@ -1085,8 +1086,8 @@ gsk_next_driver_lookup_shader (GskNextDriver *self,
#ifdef G_ENABLE_DEBUG
static void
-write_atlas_to_png (GskGLTextureAtlas *atlas,
- const char *filename)
+write_atlas_to_png (GskNglTextureAtlas *atlas,
+ const char *filename)
{
int stride = cairo_format_stride_for_width (CAIRO_FORMAT_ARGB32, atlas->width);
guchar *data = g_malloc (atlas->height * stride);
@@ -1102,17 +1103,17 @@ write_atlas_to_png (GskGLTextureAtlas *atlas,
}
void
-gsk_next_driver_save_atlases_to_png (GskNextDriver *self,
- const char *directory)
+gsk_ngl_driver_save_atlases_to_png (GskNglDriver *self,
+ const char *directory)
{
- g_return_if_fail (GSK_IS_NEXT_DRIVER (self));
+ g_return_if_fail (GSK_IS_NGL_DRIVER (self));
if (directory == NULL)
directory = ".";
for (guint i = 0; i < self->atlases->len; i++)
{
- GskGLTextureAtlas *atlas = g_ptr_array_index (self->atlases, i);
+ GskNglTextureAtlas *atlas = g_ptr_array_index (self->atlases, i);
char *filename = g_strdup_printf ("%s%sframe-%d-atlas-%d.png",
directory,
G_DIR_SEPARATOR_S,
@@ -1124,25 +1125,25 @@ gsk_next_driver_save_atlases_to_png (GskNextDriver *self,
}
#endif
-GskGLCommandQueue *
-gsk_next_driver_create_command_queue (GskNextDriver *self,
- GdkGLContext *context)
+GskNglCommandQueue *
+gsk_ngl_driver_create_command_queue (GskNglDriver *self,
+ GdkGLContext *context)
{
- g_return_val_if_fail (GSK_IS_NEXT_DRIVER (self), NULL);
+ g_return_val_if_fail (GSK_IS_NGL_DRIVER (self), NULL);
g_return_val_if_fail (GDK_IS_GL_CONTEXT (context), NULL);
- return gsk_gl_command_queue_new (context, self->shared_command_queue->uniforms);
+ return gsk_ngl_command_queue_new (context, self->shared_command_queue->uniforms);
}
void
-gsk_next_driver_add_texture_slices (GskNextDriver *self,
- GdkTexture *texture,
- GskGLTextureSlice **out_slices,
- guint *out_n_slices)
+gsk_ngl_driver_add_texture_slices (GskNglDriver *self,
+ GdkTexture *texture,
+ GskNglTextureSlice **out_slices,
+ guint *out_n_slices)
{
int max_texture_size;
- GskGLTextureSlice *slices;
- GskGLTexture *t;
+ GskNglTextureSlice *slices;
+ GskNglTexture *t;
guint n_slices;
guint cols;
guint rows;
@@ -1150,7 +1151,7 @@ gsk_next_driver_add_texture_slices (GskNextDriver *self,
int tex_height;
int x = 0, y = 0;
- g_assert (GSK_IS_NEXT_DRIVER (self));
+ g_assert (GSK_IS_NGL_DRIVER (self));
g_assert (GDK_IS_TEXTURE (texture));
g_assert (out_slices != NULL);
g_assert (out_n_slices != NULL);
@@ -1171,7 +1172,7 @@ gsk_next_driver_add_texture_slices (GskNextDriver *self,
}
n_slices = cols * rows;
- slices = g_new0 (GskGLTextureSlice, n_slices);
+ slices = g_new0 (GskNglTextureSlice, n_slices);
for (guint col = 0; col < cols; col ++)
{
@@ -1183,11 +1184,11 @@ gsk_next_driver_add_texture_slices (GskNextDriver *self,
int slice_index = (col * rows) + row;
guint texture_id;
- texture_id = gsk_gl_command_queue_upload_texture (self->command_queue,
- texture,
- x, y,
- slice_width, slice_height,
- GL_NEAREST, GL_NEAREST);
+ texture_id = gsk_ngl_command_queue_upload_texture (self->command_queue,
+ texture,
+ x, y,
+ slice_width, slice_height,
+ GL_NEAREST, GL_NEAREST);
slices[slice_index].rect.x = x;
slices[slice_index].rect.y = y;
@@ -1203,28 +1204,28 @@ gsk_next_driver_add_texture_slices (GskNextDriver *self,
}
/* Allocate one Texture for the entire thing. */
- t = gsk_gl_texture_new (0,
- tex_width, tex_height,
- GL_NEAREST, GL_NEAREST,
- self->current_frame_id);
+ t = gsk_ngl_texture_new (0,
+ tex_width, tex_height,
+ GL_NEAREST, GL_NEAREST,
+ self->current_frame_id);
- /* Use gsk_gl_texture_free() as destroy notify here since we are
- * not inserting this GskGLTexture into self->textures!
+ /* Use gsk_ngl_texture_free() as destroy notify here since we are
+ * not inserting this GskNglTexture into self->textures!
*/
gdk_texture_set_render_data (texture, self, t,
- (GDestroyNotify)gsk_gl_texture_free);
+ (GDestroyNotify)gsk_ngl_texture_free);
t->slices = *out_slices = slices;
t->n_slices = *out_n_slices = n_slices;
}
-GskGLTexture *
-gsk_next_driver_mark_texture_permanent (GskNextDriver *self,
- guint texture_id)
+GskNglTexture *
+gsk_ngl_driver_mark_texture_permanent (GskNglDriver *self,
+ guint texture_id)
{
- GskGLTexture *t;
+ GskNglTexture *t;
- g_return_val_if_fail (GSK_IS_NEXT_DRIVER (self), NULL);
+ g_return_val_if_fail (GSK_IS_NGL_DRIVER (self), NULL);
g_return_val_if_fail (texture_id > 0, NULL);
if ((t = g_hash_table_lookup (self->textures, GUINT_TO_POINTER (texture_id))))
@@ -1234,25 +1235,25 @@ gsk_next_driver_mark_texture_permanent (GskNextDriver *self,
}
void
-gsk_next_driver_release_texture_by_id (GskNextDriver *self,
- guint texture_id)
+gsk_ngl_driver_release_texture_by_id (GskNglDriver *self,
+ guint texture_id)
{
- GskGLTexture *texture;
+ GskNglTexture *texture;
- g_return_if_fail (GSK_IS_NEXT_DRIVER (self));
+ g_return_if_fail (GSK_IS_NGL_DRIVER (self));
g_return_if_fail (texture_id > 0);
remove_texture_key_for_id (self, texture_id);
if ((texture = g_hash_table_lookup (self->textures, GUINT_TO_POINTER (texture_id))))
- gsk_next_driver_release_texture (self, texture);
+ gsk_ngl_driver_release_texture (self, texture);
}
static void
create_texture_from_texture_destroy (gpointer data)
{
- GskGLTextureState *state = data;
+ GskNglTextureState *state = data;
g_assert (state != NULL);
g_assert (GDK_IS_GL_CONTEXT (state->context));
@@ -1260,17 +1261,17 @@ create_texture_from_texture_destroy (gpointer data)
gdk_gl_context_make_current (state->context);
glDeleteTextures (1, &state->texture_id);
g_clear_object (&state->context);
- g_slice_free (GskGLTextureState, state);
+ g_slice_free (GskNglTextureState, state);
}
GdkTexture *
-gsk_next_driver_create_gdk_texture (GskNextDriver *self,
- guint texture_id)
+gsk_ngl_driver_create_gdk_texture (GskNglDriver *self,
+ guint texture_id)
{
- GskGLTextureState *state;
- GskGLTexture *texture;
+ GskNglTextureState *state;
+ GskNglTexture *texture;
- g_return_val_if_fail (GSK_IS_NEXT_DRIVER (self), NULL);
+ g_return_val_if_fail (GSK_IS_NGL_DRIVER (self), NULL);
g_return_val_if_fail (self->command_queue != NULL, NULL);
g_return_val_if_fail (GDK_IS_GL_CONTEXT (self->command_queue->context), NULL);
g_return_val_if_fail (texture_id > 0, NULL);
@@ -1280,7 +1281,7 @@ gsk_next_driver_create_gdk_texture (GskNextDriver *self,
if (!(texture = g_hash_table_lookup (self->textures, GUINT_TO_POINTER (texture_id))))
g_return_val_if_reached (NULL);
- state = g_slice_new0 (GskGLTextureState);
+ state = g_slice_new0 (GskNglTextureState);
state->texture_id = texture_id;
state->context = g_object_ref (self->command_queue->context);
diff --git a/gsk/ngl/gskngldriverprivate.h b/gsk/ngl/gskngldriverprivate.h
new file mode 100644
index 0000000000..e5cda21adc
--- /dev/null
+++ b/gsk/ngl/gskngldriverprivate.h
@@ -0,0 +1,234 @@
+/* gskngldriverprivate.h
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * This file is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or (at your option)
+ * any later version.
+ *
+ * This file is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ */
+
+#ifndef __GSK_NGL_DRIVER_PRIVATE_H__
+#define __GSK_NGL_DRIVER_PRIVATE_H__
+
+#include <gdk/gdkgltextureprivate.h>
+
+#include "gskngltypesprivate.h"
+#include "gskngltexturepoolprivate.h"
+
+G_BEGIN_DECLS
+
+enum {
+ UNIFORM_SHARED_ALPHA,
+ UNIFORM_SHARED_SOURCE,
+ UNIFORM_SHARED_CLIP_RECT,
+ UNIFORM_SHARED_VIEWPORT,
+ UNIFORM_SHARED_PROJECTION,
+ UNIFORM_SHARED_MODELVIEW,
+
+ UNIFORM_SHARED_LAST
+};
+
+enum {
+ UNIFORM_CUSTOM_SIZE = UNIFORM_SHARED_LAST,
+ UNIFORM_CUSTOM_TEXTURE1,
+ UNIFORM_CUSTOM_TEXTURE2,
+ UNIFORM_CUSTOM_TEXTURE3,
+ UNIFORM_CUSTOM_TEXTURE4,
+
+ UNIFORM_CUSTOM_LAST
+};
+
+typedef struct {
+ gconstpointer pointer;
+ float scale_x;
+ float scale_y;
+ int filter;
+ int pointer_is_child;
+ graphene_rect_t parent_rect; /* Valid when pointer_is_child */
+} GskTextureKey;
+
+#define GSL_GK_NO_UNIFORMS UNIFORM_INVALID_##__COUNTER__
+#define GSK_NGL_ADD_UNIFORM(pos, KEY, name) UNIFORM_##KEY = UNIFORM_SHARED_LAST + pos,
+#define GSK_NGL_DEFINE_PROGRAM(name, resource, uniforms) enum { uniforms };
+# include "gsknglprograms.defs"
+#undef GSK_NGL_DEFINE_PROGRAM
+#undef GSK_NGL_ADD_UNIFORM
+#undef GSL_GK_NO_UNIFORMS
+
+#define GSK_TYPE_NGL_DRIVER (gsk_ngl_driver_get_type())
+
+G_DECLARE_FINAL_TYPE (GskNglDriver, gsk_ngl_driver, GSK, NGL_DRIVER, GObject)
+
+struct _GskNglRenderTarget
+{
+ guint framebuffer_id;
+ guint texture_id;
+ int min_filter;
+ int mag_filter;
+ int width;
+ int height;
+};
+
+struct _GskNglDriver
+{
+ GObject parent_instance;
+
+ GskNglCommandQueue *shared_command_queue;
+ GskNglCommandQueue *command_queue;
+
+ GskNglTexturePool texture_pool;
+
+ GskNglGlyphLibrary *glyphs;
+ GskNglIconLibrary *icons;
+ GskNglShadowLibrary *shadows;
+
+ GHashTable *textures;
+ GHashTable *key_to_texture_id;
+ GHashTable *texture_id_to_key;
+
+ GPtrArray *atlases;
+
+ GHashTable *shader_cache;
+
+ GArray *autorelease_framebuffers;
+ GPtrArray *render_targets;
+
+#define GSK_NGL_NO_UNIFORMS
+#define GSK_NGL_ADD_UNIFORM(pos, KEY, name)
+#define GSK_NGL_DEFINE_PROGRAM(name, resource, uniforms) GskNglProgram *name;
+# include "gsknglprograms.defs"
+#undef GSK_NGL_NO_UNIFORMS
+#undef GSK_NGL_ADD_UNIFORM
+#undef GSK_NGL_DEFINE_PROGRAM
+
+ gint64 current_frame_id;
+
+ /* Used to reduce number of comparisons */
+ guint stamps[UNIFORM_SHARED_LAST];
+
+ guint debug : 1;
+ guint in_frame : 1;
+};
+
+GskNglDriver *gsk_ngl_driver_from_shared_context (GdkGLContext *context,
+ gboolean debug_shaders,
+ GError **error);
+GskNglCommandQueue *gsk_ngl_driver_create_command_queue (GskNglDriver *self,
+ GdkGLContext *context);
+GdkGLContext *gsk_ngl_driver_get_context (GskNglDriver *self);
+gboolean gsk_ngl_driver_create_render_target (GskNglDriver *self,
+ int width,
+ int height,
+ int min_filter,
+ int mag_filter,
+ GskNglRenderTarget **render_target);
+guint gsk_ngl_driver_release_render_target (GskNglDriver *self,
+ GskNglRenderTarget *render_target,
+ gboolean release_texture);
+void gsk_ngl_driver_begin_frame (GskNglDriver *self,
+ GskNglCommandQueue *command_queue);
+void gsk_ngl_driver_end_frame (GskNglDriver *self);
+void gsk_ngl_driver_after_frame (GskNglDriver *self);
+GdkTexture *gsk_ngl_driver_create_gdk_texture (GskNglDriver *self,
+ guint texture_id);
+void gsk_ngl_driver_cache_texture (GskNglDriver *self,
+ const GskTextureKey *key,
+ guint texture_id);
+guint gsk_ngl_driver_load_texture (GskNglDriver *self,
+ GdkTexture *texture,
+ int min_filter,
+ int mag_filter);
+GskNglTexture *gsk_ngl_driver_create_texture (GskNglDriver *self,
+ float width,
+ float height,
+ int min_filter,
+ int mag_filter);
+void gsk_ngl_driver_release_texture (GskNglDriver *self,
+ GskNglTexture *texture);
+void gsk_ngl_driver_release_texture_by_id (GskNglDriver *self,
+ guint texture_id);
+GskNglTexture *gsk_ngl_driver_mark_texture_permanent (GskNglDriver *self,
+ guint texture_id);
+void gsk_ngl_driver_add_texture_slices (GskNglDriver *self,
+ GdkTexture *texture,
+ GskNglTextureSlice **out_slices,
+ guint *out_n_slices);
+GskNglProgram *gsk_ngl_driver_lookup_shader (GskNglDriver *self,
+ GskGLShader *shader,
+ GError **error);
+GskNglTextureAtlas *gsk_ngl_driver_create_atlas (GskNglDriver *self);
+
+#ifdef G_ENABLE_DEBUG
+void gsk_ngl_driver_save_atlases_to_png (GskNglDriver *self,
+ const char *directory);
+#endif
+
+static inline GskNglTexture *
+gsk_ngl_driver_get_texture_by_id (GskNglDriver *self,
+ guint texture_id)
+{
+ return g_hash_table_lookup (self->textures, GUINT_TO_POINTER (texture_id));
+}
+
+/**
+ * gsk_ngl_driver_lookup_texture:
+ * @self: a #GskNglDriver
+ * @key: the key for the texture
+ *
+ * Looks up a texture in the texture cache by @key.
+ *
+ * If the texture could not be found, then zero is returned.
+ *
+ * Returns: a positive integer if the texture was found; otherwise 0.
+ */
+static inline guint
+gsk_ngl_driver_lookup_texture (GskNglDriver *self,
+ const GskTextureKey *key)
+{
+ gpointer id;
+
+ if (g_hash_table_lookup_extended (self->key_to_texture_id, key, NULL, &id))
+ {
+ GskNglTexture *texture = g_hash_table_lookup (self->textures, id);
+
+ if (texture != NULL)
+ texture->last_used_in_frame = self->current_frame_id;
+
+ return GPOINTER_TO_UINT (id);
+ }
+
+ return 0;
+}
+
+static inline void
+gsk_ngl_driver_slice_texture (GskNglDriver *self,
+ GdkTexture *texture,
+ GskNglTextureSlice **out_slices,
+ guint *out_n_slices)
+{
+ GskNglTexture *t;
+
+ if ((t = gdk_texture_get_render_data (texture, self)))
+ {
+ *out_slices = t->slices;
+ *out_n_slices = t->n_slices;
+ return;
+ }
+
+ gsk_ngl_driver_add_texture_slices (self, texture, out_slices, out_n_slices);
+}
+
+G_END_DECLS
+
+#endif /* __GSK_NGL_DRIVER_PRIVATE_H__ */
diff --git a/gsk/next/gskglglyphlibrary.c b/gsk/ngl/gsknglglyphlibrary.c
similarity index 63%
rename from gsk/next/gskglglyphlibrary.c
rename to gsk/ngl/gsknglglyphlibrary.c
index e432aad9cd..5cb2a3fe3b 100644
--- a/gsk/next/gskglglyphlibrary.c
+++ b/gsk/ngl/gsknglglyphlibrary.c
@@ -1,4 +1,4 @@
-/* gskglglyphlibrary.c
+/* gsknglglyphlibrary.c
*
* Copyright 2020 Christian Hergert <chergert redhat com>
*
@@ -24,18 +24,18 @@
#include <gdk/gdkmemorytextureprivate.h>
#include <gdk/gdkprofilerprivate.h>
-#include "gskglcommandqueueprivate.h"
-#include "gskgldriverprivate.h"
-#include "gskglglyphlibraryprivate.h"
+#include "gsknglcommandqueueprivate.h"
+#include "gskngldriverprivate.h"
+#include "gsknglglyphlibraryprivate.h"
#define MAX_GLYPH_SIZE 128
-G_DEFINE_TYPE (GskGLGlyphLibrary, gsk_gl_glyph_library, GSK_TYPE_GL_TEXTURE_LIBRARY)
+G_DEFINE_TYPE (GskNglGlyphLibrary, gsk_ngl_glyph_library, GSK_TYPE_GL_TEXTURE_LIBRARY)
-GskGLGlyphLibrary *
-gsk_gl_glyph_library_new (GskNextDriver *driver)
+GskNglGlyphLibrary *
+gsk_ngl_glyph_library_new (GskNglDriver *driver)
{
- g_return_val_if_fail (GSK_IS_NEXT_DRIVER (driver), NULL);
+ g_return_val_if_fail (GSK_IS_NGL_DRIVER (driver), NULL);
return g_object_new (GSK_TYPE_GL_GLYPH_LIBRARY,
"driver", driver,
@@ -43,13 +43,13 @@ gsk_gl_glyph_library_new (GskNextDriver *driver)
}
static guint
-gsk_gl_glyph_key_hash (gconstpointer data)
+gsk_ngl_glyph_key_hash (gconstpointer data)
{
- const GskGLGlyphKey *key = data;
+ const GskNglGlyphKey *key = data;
/* We do not store the hash within the key because GHashTable will already
* store the hash value for us and so this is called only a single time per
- * cached item. This saves an extra 4 bytes per GskGLGlyphKey which means on
+ * cached item. This saves an extra 4 bytes per GskNglGlyphKey which means on
* 64-bit, we fit nicely within 2 pointers (the smallest allocation size
* for GSlice).
*/
@@ -62,68 +62,68 @@ gsk_gl_glyph_key_hash (gconstpointer data)
}
static gboolean
-gsk_gl_glyph_key_equal (gconstpointer v1,
- gconstpointer v2)
+gsk_ngl_glyph_key_equal (gconstpointer v1,
+ gconstpointer v2)
{
- return memcmp (v1, v2, sizeof (GskGLGlyphKey)) == 0;
+ return memcmp (v1, v2, sizeof (GskNglGlyphKey)) == 0;
}
static void
-gsk_gl_glyph_key_free (gpointer data)
+gsk_ngl_glyph_key_free (gpointer data)
{
- GskGLGlyphKey *key = data;
+ GskNglGlyphKey *key = data;
g_clear_object (&key->font);
- g_slice_free (GskGLGlyphKey, key);
+ g_slice_free (GskNglGlyphKey, key);
}
static void
-gsk_gl_glyph_value_free (gpointer data)
+gsk_ngl_glyph_value_free (gpointer data)
{
- g_slice_free (GskGLGlyphValue, data);
+ g_slice_free (GskNglGlyphValue, data);
}
static void
-gsk_gl_glyph_library_finalize (GObject *object)
+gsk_ngl_glyph_library_finalize (GObject *object)
{
- GskGLGlyphLibrary *self = (GskGLGlyphLibrary *)object;
+ GskNglGlyphLibrary *self = (GskNglGlyphLibrary *)object;
g_clear_pointer (&self->hash_table, g_hash_table_unref);
g_clear_pointer (&self->surface_data, g_free);
- G_OBJECT_CLASS (gsk_gl_glyph_library_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gsk_ngl_glyph_library_parent_class)->finalize (object);
}
static void
-gsk_gl_glyph_library_class_init (GskGLGlyphLibraryClass *klass)
+gsk_ngl_glyph_library_class_init (GskNglGlyphLibraryClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
- object_class->finalize = gsk_gl_glyph_library_finalize;
+ object_class->finalize = gsk_ngl_glyph_library_finalize;
}
static void
-gsk_gl_glyph_library_init (GskGLGlyphLibrary *self)
+gsk_ngl_glyph_library_init (GskNglGlyphLibrary *self)
{
- GSK_GL_TEXTURE_LIBRARY (self)->max_entry_size = MAX_GLYPH_SIZE;
- gsk_gl_texture_library_set_funcs (GSK_GL_TEXTURE_LIBRARY (self),
- gsk_gl_glyph_key_hash,
- gsk_gl_glyph_key_equal,
- gsk_gl_glyph_key_free,
- gsk_gl_glyph_value_free);
+ GSK_NGL_TEXTURE_LIBRARY (self)->max_entry_size = MAX_GLYPH_SIZE;
+ gsk_ngl_texture_library_set_funcs (GSK_NGL_TEXTURE_LIBRARY (self),
+ gsk_ngl_glyph_key_hash,
+ gsk_ngl_glyph_key_equal,
+ gsk_ngl_glyph_key_free,
+ gsk_ngl_glyph_value_free);
}
static cairo_surface_t *
-gsk_gl_glyph_library_create_surface (GskGLGlyphLibrary *self,
- int stride,
- int width,
- int height,
- double device_scale)
+gsk_ngl_glyph_library_create_surface (GskNglGlyphLibrary *self,
+ int stride,
+ int width,
+ int height,
+ double device_scale)
{
cairo_surface_t *surface;
gsize n_bytes;
- g_assert (GSK_IS_GL_GLYPH_LIBRARY (self));
+ g_assert (GSK_IS_NGL_GLYPH_LIBRARY (self));
g_assert (width > 0);
g_assert (height > 0);
@@ -147,8 +147,8 @@ gsk_gl_glyph_library_create_surface (GskGLGlyphLibrary *self,
static void
render_glyph (cairo_surface_t *surface,
const cairo_scaled_font_t *scaled_font,
- const GskGLGlyphKey *key,
- const GskGLGlyphValue *value)
+ const GskNglGlyphKey *key,
+ const GskNglGlyphValue *value)
{
cairo_t *cr;
PangoGlyphString glyph_string;
@@ -179,16 +179,16 @@ render_glyph (cairo_surface_t *surface,
}
static void
-gsk_gl_glyph_library_upload_glyph (GskGLGlyphLibrary *self,
- const GskGLGlyphKey *key,
- const GskGLGlyphValue *value,
- int width,
- int height,
- double device_scale)
+gsk_ngl_glyph_library_upload_glyph (GskNglGlyphLibrary *self,
+ const GskNglGlyphKey *key,
+ const GskNglGlyphValue *value,
+ int width,
+ int height,
+ double device_scale)
{
G_GNUC_UNUSED gint64 start_time = GDK_PROFILER_CURRENT_TIME;
cairo_scaled_font_t *scaled_font;
- GskGLTextureAtlas *atlas;
+ GskNglTextureAtlas *atlas;
cairo_surface_t *surface;
guchar *pixel_data;
guchar *free_data = NULL;
@@ -198,7 +198,7 @@ gsk_gl_glyph_library_upload_glyph (GskGLGlyphLibrary *self,
gsize stride;
int x, y;
- g_assert (GSK_IS_GL_GLYPH_LIBRARY (self));
+ g_assert (GSK_IS_NGL_GLYPH_LIBRARY (self));
g_assert (key != NULL);
g_assert (value != NULL);
@@ -214,10 +214,10 @@ gsk_gl_glyph_library_upload_glyph (GskGLGlyphLibrary *self,
"Uploading glyph %d",
key->glyph);
- surface = gsk_gl_glyph_library_create_surface (self, stride, width, height, device_scale);
+ surface = gsk_ngl_glyph_library_create_surface (self, stride, width, height, device_scale);
render_glyph (surface, scaled_font, key, value);
- texture_id = GSK_GL_TEXTURE_ATLAS_ENTRY_TEXTURE (value);
+ texture_id = GSK_NGL_TEXTURE_ATLAS_ENTRY_TEXTURE (value);
g_assert (texture_id > 0);
@@ -264,7 +264,7 @@ gsk_gl_glyph_library_upload_glyph (GskGLGlyphLibrary *self,
gdk_gl_context_pop_debug_group (gdk_gl_context_get_current ());
- GSK_GL_TEXTURE_LIBRARY (self)->driver->command_queue->n_uploads++;
+ GSK_NGL_TEXTURE_LIBRARY (self)->driver->command_queue->n_uploads++;
if (gdk_profiler_is_running ())
{
@@ -275,18 +275,18 @@ gsk_gl_glyph_library_upload_glyph (GskGLGlyphLibrary *self,
}
gboolean
-gsk_gl_glyph_library_add (GskGLGlyphLibrary *self,
- GskGLGlyphKey *key,
- const GskGLGlyphValue **out_value)
+gsk_ngl_glyph_library_add (GskNglGlyphLibrary *self,
+ GskNglGlyphKey *key,
+ const GskNglGlyphValue **out_value)
{
PangoRectangle ink_rect;
- GskGLGlyphValue *value;
+ GskNglGlyphValue *value;
int width;
int height;
guint packed_x;
guint packed_y;
- g_assert (GSK_IS_GL_GLYPH_LIBRARY (self));
+ g_assert (GSK_IS_NGL_GLYPH_LIBRARY (self));
g_assert (key != NULL);
g_assert (out_value != NULL);
@@ -301,25 +301,25 @@ gsk_gl_glyph_library_add (GskGLGlyphLibrary *self,
width = ink_rect.width * key->scale / 1024;
height = ink_rect.height * key->scale / 1024;
- value = gsk_gl_texture_library_pack (GSK_GL_TEXTURE_LIBRARY (self),
- key,
- sizeof *value,
- width,
- height,
- 0,
- &packed_x, &packed_y);
+ value = gsk_ngl_texture_library_pack (GSK_NGL_TEXTURE_LIBRARY (self),
+ key,
+ sizeof *value,
+ width,
+ height,
+ 0,
+ &packed_x, &packed_y);
memcpy (&value->ink_rect, &ink_rect, sizeof ink_rect);
if (key->scale > 0 && width > 0 && height > 0)
- gsk_gl_glyph_library_upload_glyph (self,
- key,
- value,
- width,
- height,
- key->scale / 1024.0);
+ gsk_ngl_glyph_library_upload_glyph (self,
+ key,
+ value,
+ width,
+ height,
+ key->scale / 1024.0);
*out_value = value;
- return GSK_GL_TEXTURE_ATLAS_ENTRY_TEXTURE (value) != 0;
+ return GSK_NGL_TEXTURE_ATLAS_ENTRY_TEXTURE (value) != 0;
}
diff --git a/gsk/ngl/gsknglglyphlibraryprivate.h b/gsk/ngl/gsknglglyphlibraryprivate.h
new file mode 100644
index 0000000000..9df9526f99
--- /dev/null
+++ b/gsk/ngl/gsknglglyphlibraryprivate.h
@@ -0,0 +1,119 @@
+/* gsknglglyphlibraryprivate.h
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ */
+
+#ifndef __GSK_NGL_GLYPH_LIBRARY_PRIVATE_H__
+#define __GSK_NGL_GLYPH_LIBRARY_PRIVATE_H__
+
+#include <pango/pango.h>
+
+#include "gskngltexturelibraryprivate.h"
+
+G_BEGIN_DECLS
+
+#define GSK_TYPE_GL_GLYPH_LIBRARY (gsk_ngl_glyph_library_get_type())
+
+typedef struct _GskNglGlyphKey
+{
+ PangoFont *font;
+ PangoGlyph glyph;
+ guint xshift : 3;
+ guint yshift : 3;
+ guint scale : 26; /* times 1024 */
+} GskNglGlyphKey;
+
+typedef struct _GskNglGlyphValue
+{
+ GskNglTextureAtlasEntry entry;
+ PangoRectangle ink_rect;
+} GskNglGlyphValue;
+
+#if GLIB_SIZEOF_VOID_P == 8
+G_STATIC_ASSERT (sizeof (GskNglGlyphKey) == 16);
+#elif GLIB_SIZEOF_VOID_P == 4
+G_STATIC_ASSERT (sizeof (GskNglGlyphKey) == 12);
+#endif
+
+G_DECLARE_FINAL_TYPE (GskNglGlyphLibrary, gsk_ngl_glyph_library, GSK, NGL_GLYPH_LIBRARY,
GskNglTextureLibrary)
+
+struct _GskNglGlyphLibrary
+{
+ GskNglTextureLibrary parent_instance;
+ GHashTable *hash_table;
+ guint8 *surface_data;
+ gsize surface_data_len;
+ struct {
+ GskNglGlyphKey key;
+ const GskNglGlyphValue *value;
+ } front[256];
+};
+
+GskNglGlyphLibrary *gsk_ngl_glyph_library_new (GskNglDriver *driver);
+gboolean gsk_ngl_glyph_library_add (GskNglGlyphLibrary *self,
+ GskNglGlyphKey *key,
+ const GskNglGlyphValue **out_value);
+
+static inline int
+gsk_ngl_glyph_key_phase (float value)
+{
+ return floor (4 * (value + 0.125)) - 4 * floor (value + 0.125);
+}
+
+static inline void
+gsk_ngl_glyph_key_set_glyph_and_shift (GskNglGlyphKey *key,
+ PangoGlyph glyph,
+ float x,
+ float y)
+{
+ key->glyph = glyph;
+ key->xshift = gsk_ngl_glyph_key_phase (x);
+ key->yshift = gsk_ngl_glyph_key_phase (y);
+}
+
+static inline gboolean
+gsk_ngl_glyph_library_lookup_or_add (GskNglGlyphLibrary *self,
+ const GskNglGlyphKey *key,
+ const GskNglGlyphValue **out_value)
+{
+ GskNglTextureAtlasEntry *entry;
+ guint front_index = key->glyph & 0xFF;
+
+ if (memcmp (key, &self->front[front_index], sizeof *key) == 0)
+ {
+ *out_value = self->front[front_index].value;
+ }
+ else if (gsk_ngl_texture_library_lookup ((GskNglTextureLibrary *)self, key, &entry))
+ {
+ *out_value = (GskNglGlyphValue *)entry;
+ self->front[front_index].key = *key;
+ self->front[front_index].value = *out_value;
+ }
+ else
+ {
+ GskNglGlyphKey *k = g_slice_copy (sizeof *key, key);
+ g_object_ref (k->font);
+ gsk_ngl_glyph_library_add (self, k, out_value);
+ }
+
+ return GSK_NGL_TEXTURE_ATLAS_ENTRY_TEXTURE (*out_value) != 0;
+}
+
+G_END_DECLS
+
+#endif /* __GSK_NGL_GLYPH_LIBRARY_PRIVATE_H__ */
diff --git a/gsk/next/gskgliconlibrary.c b/gsk/ngl/gskngliconlibrary.c
similarity index 76%
rename from gsk/next/gskgliconlibrary.c
rename to gsk/ngl/gskngliconlibrary.c
index 05afbbe4c7..4d84cb2354 100644
--- a/gsk/next/gskgliconlibrary.c
+++ b/gsk/ngl/gskngliconlibrary.c
@@ -1,4 +1,4 @@
-/* gskgliconlibrary.c
+/* gskngliconlibrary.c
*
* Copyright 2020 Christian Hergert <chergert redhat com>
*
@@ -25,21 +25,21 @@
#include <gdk/gdkprofilerprivate.h>
#include <gdk/gdktextureprivate.h>
-#include "gskglcommandqueueprivate.h"
-#include "gskgldriverprivate.h"
-#include "gskgliconlibraryprivate.h"
+#include "gsknglcommandqueueprivate.h"
+#include "gskngldriverprivate.h"
+#include "gskngliconlibraryprivate.h"
-struct _GskGLIconLibrary
+struct _GskNglIconLibrary
{
- GskGLTextureLibrary parent_instance;
+ GskNglTextureLibrary parent_instance;
};
-G_DEFINE_TYPE (GskGLIconLibrary, gsk_gl_icon_library, GSK_TYPE_GL_TEXTURE_LIBRARY)
+G_DEFINE_TYPE (GskNglIconLibrary, gsk_ngl_icon_library, GSK_TYPE_GL_TEXTURE_LIBRARY)
-GskGLIconLibrary *
-gsk_gl_icon_library_new (GskNextDriver *driver)
+GskNglIconLibrary *
+gsk_ngl_icon_library_new (GskNglDriver *driver)
{
- g_return_val_if_fail (GSK_IS_NEXT_DRIVER (driver), NULL);
+ g_return_val_if_fail (GSK_IS_NGL_DRIVER (driver), NULL);
return g_object_new (GSK_TYPE_GL_ICON_LIBRARY,
"driver", driver,
@@ -47,36 +47,36 @@ gsk_gl_icon_library_new (GskNextDriver *driver)
}
static void
-gsk_gl_icon_data_free (gpointer data)
+gsk_ngl_icon_data_free (gpointer data)
{
- GskGLIconData *icon_data = data;
+ GskNglIconData *icon_data = data;
g_clear_object (&icon_data->source_texture);
- g_slice_free (GskGLIconData, icon_data);
+ g_slice_free (GskNglIconData, icon_data);
}
static void
-gsk_gl_icon_library_class_init (GskGLIconLibraryClass *klass)
+gsk_ngl_icon_library_class_init (GskNglIconLibraryClass *klass)
{
}
static void
-gsk_gl_icon_library_init (GskGLIconLibrary *self)
+gsk_ngl_icon_library_init (GskNglIconLibrary *self)
{
- GSK_GL_TEXTURE_LIBRARY (self)->max_entry_size = 128;
- gsk_gl_texture_library_set_funcs (GSK_GL_TEXTURE_LIBRARY (self),
- NULL, NULL, NULL,
- gsk_gl_icon_data_free);
+ GSK_NGL_TEXTURE_LIBRARY (self)->max_entry_size = 128;
+ gsk_ngl_texture_library_set_funcs (GSK_NGL_TEXTURE_LIBRARY (self),
+ NULL, NULL, NULL,
+ gsk_ngl_icon_data_free);
}
void
-gsk_gl_icon_library_add (GskGLIconLibrary *self,
- GdkTexture *key,
- const GskGLIconData **out_value)
+gsk_ngl_icon_library_add (GskNglIconLibrary *self,
+ GdkTexture *key,
+ const GskNglIconData **out_value)
{
G_GNUC_UNUSED gint64 start_time = GDK_PROFILER_CURRENT_TIME;
cairo_surface_t *surface;
- GskGLIconData *icon_data;
+ GskNglIconData *icon_data;
guint8 *pixel_data;
guint8 *surface_data;
guint8 *free_data = NULL;
@@ -88,18 +88,18 @@ gsk_gl_icon_library_add (GskGLIconLibrary *self,
int height;
guint texture_id;
- g_assert (GSK_IS_GL_ICON_LIBRARY (self));
+ g_assert (GSK_IS_NGL_ICON_LIBRARY (self));
g_assert (GDK_IS_TEXTURE (key));
g_assert (out_value != NULL);
width = key->width;
height = key->height;
- icon_data = gsk_gl_texture_library_pack (GSK_GL_TEXTURE_LIBRARY (self),
- key,
- sizeof (GskGLIconData),
- width, height, 1,
- &packed_x, &packed_y);
+ icon_data = gsk_ngl_texture_library_pack (GSK_NGL_TEXTURE_LIBRARY (self),
+ key,
+ sizeof (GskNglIconData),
+ width, height, 1,
+ &packed_x, &packed_y);
icon_data->source_texture = g_object_ref (key);
/* actually upload the texture */
@@ -125,7 +125,7 @@ gsk_gl_icon_library_add (GskGLIconLibrary *self,
gl_type = GL_UNSIGNED_INT_8_8_8_8_REV;
}
- texture_id = GSK_GL_TEXTURE_ATLAS_ENTRY_TEXTURE (icon_data);
+ texture_id = GSK_NGL_TEXTURE_ATLAS_ENTRY_TEXTURE (icon_data);
glBindTexture (GL_TEXTURE_2D, texture_id);
@@ -202,7 +202,7 @@ gsk_gl_icon_library_add (GskGLIconLibrary *self,
cairo_surface_destroy (surface);
g_free (free_data);
- GSK_GL_TEXTURE_LIBRARY (self)->driver->command_queue->n_uploads++;
+ GSK_NGL_TEXTURE_LIBRARY (self)->driver->command_queue->n_uploads++;
if (gdk_profiler_is_running ())
{
diff --git a/gsk/ngl/gskngliconlibraryprivate.h b/gsk/ngl/gskngliconlibraryprivate.h
new file mode 100644
index 0000000000..5fd1cb273d
--- /dev/null
+++ b/gsk/ngl/gskngliconlibraryprivate.h
@@ -0,0 +1,60 @@
+/* gskngliconlibraryprivate.h
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ */
+
+#ifndef __GSK_NGL_ICON_LIBRARY_PRIVATE_H__
+#define __GSK_NGL_ICON_LIBRARY_PRIVATE_H__
+
+#include <pango/pango.h>
+
+#include "gskngltexturelibraryprivate.h"
+
+G_BEGIN_DECLS
+
+#define GSK_TYPE_GL_ICON_LIBRARY (gsk_ngl_icon_library_get_type())
+
+typedef struct _GskNglIconData
+{
+ GskNglTextureAtlasEntry entry;
+ GdkTexture *source_texture;
+} GskNglIconData;
+
+G_DECLARE_FINAL_TYPE (GskNglIconLibrary, gsk_ngl_icon_library, GSK, NGL_ICON_LIBRARY, GskNglTextureLibrary)
+
+GskNglIconLibrary *gsk_ngl_icon_library_new (GskNglDriver *driver);
+void gsk_ngl_icon_library_add (GskNglIconLibrary *self,
+ GdkTexture *key,
+ const GskNglIconData **out_value);
+
+static inline void
+gsk_ngl_icon_library_lookup_or_add (GskNglIconLibrary *self,
+ GdkTexture *key,
+ const GskNglIconData **out_value)
+{
+ GskNglTextureAtlasEntry *entry;
+
+ if G_LIKELY (gsk_ngl_texture_library_lookup ((GskNglTextureLibrary *)self, key, &entry))
+ *out_value = (GskNglIconData *)entry;
+ else
+ gsk_ngl_icon_library_add (self, key, out_value);
+}
+
+G_END_DECLS
+
+#endif /* __GSK_NGL_ICON_LIBRARY_PRIVATE_H__ */
diff --git a/gsk/next/gskglprogram.c b/gsk/ngl/gsknglprogram.c
similarity index 63%
rename from gsk/next/gskglprogram.c
rename to gsk/ngl/gsknglprogram.c
index 679a704f7a..1343eb35a4 100644
--- a/gsk/next/gskglprogram.c
+++ b/gsk/ngl/gsknglprogram.c
@@ -1,4 +1,4 @@
-/* gskglprogram.c
+/* gsknglprogram.c
*
* Copyright 2020 Christian Hergert <chergert redhat com>
*
@@ -20,20 +20,20 @@
#include "config.h"
-#include "gskglcommandqueueprivate.h"
-#include "gskglprogramprivate.h"
-#include "gskgluniformstateprivate.h"
+#include "gsknglcommandqueueprivate.h"
+#include "gsknglprogramprivate.h"
+#include "gskngluniformstateprivate.h"
-G_DEFINE_TYPE (GskGLProgram, gsk_gl_program, G_TYPE_OBJECT)
+G_DEFINE_TYPE (GskNglProgram, gsk_ngl_program, G_TYPE_OBJECT)
-GskGLProgram *
-gsk_gl_program_new (GskNextDriver *driver,
- const char *name,
- int program_id)
+GskNglProgram *
+gsk_ngl_program_new (GskNglDriver *driver,
+ const char *name,
+ int program_id)
{
- GskGLProgram *self;
+ GskNglProgram *self;
- g_return_val_if_fail (GSK_IS_NEXT_DRIVER (driver), NULL);
+ g_return_val_if_fail (GSK_IS_NGL_DRIVER (driver), NULL);
g_return_val_if_fail (program_id >= -1, NULL);
self = g_object_new (GSK_TYPE_GL_PROGRAM, NULL);
@@ -46,9 +46,9 @@ gsk_gl_program_new (GskNextDriver *driver,
}
static void
-gsk_gl_program_finalize (GObject *object)
+gsk_ngl_program_finalize (GObject *object)
{
- GskGLProgram *self = (GskGLProgram *)object;
+ GskNglProgram *self = (GskNglProgram *)object;
if (self->id >= 0)
g_warning ("Leaking GLSL program %d (%s)",
@@ -58,19 +58,19 @@ gsk_gl_program_finalize (GObject *object)
g_clear_pointer (&self->name, g_free);
g_clear_object (&self->driver);
- G_OBJECT_CLASS (gsk_gl_program_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gsk_ngl_program_parent_class)->finalize (object);
}
static void
-gsk_gl_program_class_init (GskGLProgramClass *klass)
+gsk_ngl_program_class_init (GskNglProgramClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
- object_class->finalize = gsk_gl_program_finalize;
+ object_class->finalize = gsk_ngl_program_finalize;
}
static void
-gsk_gl_program_init (GskGLProgram *self)
+gsk_ngl_program_init (GskNglProgram *self)
{
self->id = -1;
@@ -79,8 +79,8 @@ gsk_gl_program_init (GskGLProgram *self)
}
/**
- * gsk_gl_program_add_uniform:
- * @self: a #GskGLProgram
+ * gsk_ngl_program_add_uniform:
+ * @self: a #GskNglProgram
* @name: the name of the uniform such as "u_source"
* @key: the identifier to use for the uniform
*
@@ -93,26 +93,26 @@ gsk_gl_program_init (GskGLProgram *self)
* program and then register each of them like:
*
* ```
- * gsk_gl_program_add_uniform (program, "u_source", UNIFORM_SOURCE);
+ * gsk_ngl_program_add_uniform (program, "u_source", UNIFORM_SOURCE);
* ```
*
* That allows you to set values for the program with something
* like the following:
*
* ```
- * gsk_gl_program_set_uniform1i (program, UNIFORM_SOURCE, 1);
+ * gsk_ngl_program_set_uniform1i (program, UNIFORM_SOURCE, 1);
* ```
*
* Returns: %TRUE if the uniform was found; otherwise %FALSE
*/
gboolean
-gsk_gl_program_add_uniform (GskGLProgram *self,
- const char *name,
- guint key)
+gsk_ngl_program_add_uniform (GskNglProgram *self,
+ const char *name,
+ guint key)
{
GLint location;
- g_return_val_if_fail (GSK_IS_GL_PROGRAM (self), FALSE);
+ g_return_val_if_fail (GSK_IS_NGL_PROGRAM (self), FALSE);
g_return_val_if_fail (name != NULL, FALSE);
g_return_val_if_fail (key < 1024, FALSE);
@@ -133,44 +133,44 @@ gsk_gl_program_add_uniform (GskGLProgram *self,
}
/**
- * gsk_gl_program_delete:
- * @self: a #GskGLProgram
+ * gsk_ngl_program_delete:
+ * @self: a #GskNglProgram
*
* Deletes the GLSL program.
*
- * You must call gsk_gl_program_use() before and
- * gsk_gl_program_unuse() after this function.
+ * You must call gsk_ngl_program_use() before and
+ * gsk_ngl_program_unuse() after this function.
*/
void
-gsk_gl_program_delete (GskGLProgram *self)
+gsk_ngl_program_delete (GskNglProgram *self)
{
- g_return_if_fail (GSK_IS_GL_PROGRAM (self));
+ g_return_if_fail (GSK_IS_NGL_PROGRAM (self));
g_return_if_fail (self->driver->command_queue != NULL);
- gsk_gl_command_queue_delete_program (self->driver->command_queue, self->id);
+ gsk_ngl_command_queue_delete_program (self->driver->command_queue, self->id);
self->id = -1;
}
/**
- * gsk_gl_program_uniforms_added:
- * @self: a #GskGLProgram
+ * gsk_ngl_program_uniforms_added:
+ * @self: a #GskNglProgram
* @has_attachments: if any uniform is for a bind/texture attachment
*
* This function should be called after all of the uniforms ahve
- * been added with gsk_gl_program_add_uniform().
+ * been added with gsk_ngl_program_add_uniform().
*
* This function will setup the uniform state so that the program
* has fast access to the data buffers without as many lookups at
* runtime for comparison data.
*/
void
-gsk_gl_program_uniforms_added (GskGLProgram *self,
- gboolean has_attachments)
+gsk_ngl_program_uniforms_added (GskNglProgram *self,
+ gboolean has_attachments)
{
- g_return_if_fail (GSK_IS_GL_PROGRAM (self));
+ g_return_if_fail (GSK_IS_NGL_PROGRAM (self));
g_return_if_fail (self->uniforms == NULL);
self->uniforms = self->driver->command_queue->uniforms;
- self->program_info = gsk_gl_uniform_state_get_program (self->uniforms, self->id, self->n_uniforms);
+ self->program_info = gsk_ngl_uniform_state_get_program (self->uniforms, self->id, self->n_uniforms);
self->program_info->has_attachments = has_attachments;
}
diff --git a/gsk/ngl/gsknglprogramprivate.h b/gsk/ngl/gsknglprogramprivate.h
new file mode 100644
index 0000000000..47bb0e314f
--- /dev/null
+++ b/gsk/ngl/gsknglprogramprivate.h
@@ -0,0 +1,273 @@
+/* gsknglprogramprivate.h
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ */
+
+#ifndef __GSK_NGL_PROGRAM_PRIVATE_H__
+#define __GSK_NGL_PROGRAM_PRIVATE_H__
+
+#include "gskngltypesprivate.h"
+
+#include "gsknglcommandqueueprivate.h"
+#include "gskngldriverprivate.h"
+
+G_BEGIN_DECLS
+
+#define GSK_TYPE_GL_PROGRAM (gsk_ngl_program_get_type())
+
+G_DECLARE_FINAL_TYPE (GskNglProgram, gsk_ngl_program, GSK, NGL_PROGRAM, GObject)
+
+struct _GskNglProgram
+{
+ GObject parent_instance;
+
+ int id;
+ char *name;
+ GskNglDriver *driver;
+
+ /* In reality, this is the largest uniform position
+ * as returned after linking so that we can use direct
+ * indexes based on location.
+ */
+ guint n_uniforms;
+
+ /* Cached pointer to avoid lots of pointer chasing/lookups */
+ GskNglUniformState *uniforms;
+ GskNglUniformProgram *program_info;
+
+ /* For custom programs */
+ int texture_locations[4];
+ int args_locations[8];
+ int size_location;
+
+ /* Static array for key->location transforms */
+ int uniform_locations[32];
+};
+
+GskNglProgram *gsk_ngl_program_new (GskNglDriver *driver,
+ const char *name,
+ int program_id);
+gboolean gsk_ngl_program_add_uniform (GskNglProgram *self,
+ const char *name,
+ guint key);
+void gsk_ngl_program_uniforms_added (GskNglProgram *self,
+ gboolean has_attachments);
+void gsk_ngl_program_delete (GskNglProgram *self);
+
+#define gsk_ngl_program_get_uniform_location(s,k) ((s)->uniform_locations[(k)])
+
+static inline void
+gsk_ngl_program_set_uniform1fv (GskNglProgram *self,
+ guint key,
+ guint stamp,
+ guint count,
+ const float *values)
+{
+ gsk_ngl_uniform_state_set1fv (self->uniforms, self->program_info,
+ gsk_ngl_program_get_uniform_location (self, key),
+ stamp, count, values);
+}
+
+static inline void
+gsk_ngl_program_set_uniform2fv (GskNglProgram *self,
+ guint key,
+ guint stamp,
+ guint count,
+ const float *values)
+{
+ gsk_ngl_uniform_state_set2fv (self->uniforms, self->program_info,
+ gsk_ngl_program_get_uniform_location (self, key),
+ stamp, count, values);
+}
+
+static inline void
+gsk_ngl_program_set_uniform4fv (GskNglProgram *self,
+ guint key,
+ guint stamp,
+ guint count,
+ const float *values)
+{
+ gsk_ngl_uniform_state_set4fv (self->uniforms, self->program_info,
+ gsk_ngl_program_get_uniform_location (self, key),
+ stamp, count, values);
+}
+
+static inline void
+gsk_ngl_program_set_uniform_rounded_rect (GskNglProgram *self,
+ guint key,
+ guint stamp,
+ const GskRoundedRect *rounded_rect)
+{
+ gsk_ngl_uniform_state_set_rounded_rect (self->uniforms, self->program_info,
+ gsk_ngl_program_get_uniform_location (self, key),
+ stamp, rounded_rect);
+}
+
+static inline void
+gsk_ngl_program_set_uniform1i (GskNglProgram *self,
+ guint key,
+ guint stamp,
+ int value0)
+{
+ gsk_ngl_uniform_state_set1i (self->uniforms,
+ self->program_info,
+ gsk_ngl_program_get_uniform_location (self, key),
+ stamp, value0);
+}
+
+static inline void
+gsk_ngl_program_set_uniform2i (GskNglProgram *self,
+ guint key,
+ guint stamp,
+ int value0,
+ int value1)
+{
+ gsk_ngl_uniform_state_set2i (self->uniforms,
+ self->program_info,
+ gsk_ngl_program_get_uniform_location (self, key),
+ stamp, value0, value1);
+}
+
+static inline void
+gsk_ngl_program_set_uniform3i (GskNglProgram *self,
+ guint key,
+ guint stamp,
+ int value0,
+ int value1,
+ int value2)
+{
+ gsk_ngl_uniform_state_set3i (self->uniforms,
+ self->program_info,
+ gsk_ngl_program_get_uniform_location (self, key),
+ stamp, value0, value1, value2);
+}
+
+static inline void
+gsk_ngl_program_set_uniform4i (GskNglProgram *self,
+ guint key,
+ guint stamp,
+ int value0,
+ int value1,
+ int value2,
+ int value3)
+{
+ gsk_ngl_uniform_state_set4i (self->uniforms,
+ self->program_info,
+ gsk_ngl_program_get_uniform_location (self, key),
+ stamp, value0, value1, value2, value3);
+}
+
+static inline void
+gsk_ngl_program_set_uniform1f (GskNglProgram *self,
+ guint key,
+ guint stamp,
+ float value0)
+{
+ gsk_ngl_uniform_state_set1f (self->uniforms,
+ self->program_info,
+ gsk_ngl_program_get_uniform_location (self, key),
+ stamp, value0);
+}
+
+static inline void
+gsk_ngl_program_set_uniform2f (GskNglProgram *self,
+ guint key,
+ guint stamp,
+ float value0,
+ float value1)
+{
+ gsk_ngl_uniform_state_set2f (self->uniforms,
+ self->program_info,
+ gsk_ngl_program_get_uniform_location (self, key),
+ stamp, value0, value1);
+}
+
+static inline void
+gsk_ngl_program_set_uniform3f (GskNglProgram *self,
+ guint key,
+ guint stamp,
+ float value0,
+ float value1,
+ float value2)
+{
+ gsk_ngl_uniform_state_set3f (self->uniforms,
+ self->program_info,
+ gsk_ngl_program_get_uniform_location (self, key),
+ stamp, value0, value1, value2);
+}
+
+static inline void
+gsk_ngl_program_set_uniform4f (GskNglProgram *self,
+ guint key,
+ guint stamp,
+ float value0,
+ float value1,
+ float value2,
+ float value3)
+{
+ gsk_ngl_uniform_state_set4f (self->uniforms,
+ self->program_info,
+ gsk_ngl_program_get_uniform_location (self, key),
+ stamp, value0, value1, value2, value3);
+}
+
+static inline void
+gsk_ngl_program_set_uniform_color (GskNglProgram *self,
+ guint key,
+ guint stamp,
+ const GdkRGBA *color)
+{
+ gsk_ngl_uniform_state_set_color (self->uniforms,
+ self->program_info,
+ gsk_ngl_program_get_uniform_location (self, key),
+ stamp, color);
+}
+
+static inline void
+gsk_ngl_program_set_uniform_texture (GskNglProgram *self,
+ guint key,
+ guint stamp,
+ GLenum texture_target,
+ GLenum texture_slot,
+ guint texture_id)
+{
+ gsk_ngl_attachment_state_bind_texture (self->driver->command_queue->attachments,
+ texture_target,
+ texture_slot,
+ texture_id);
+ gsk_ngl_uniform_state_set_texture (self->uniforms,
+ self->program_info,
+ gsk_ngl_program_get_uniform_location (self, key),
+ stamp, texture_slot);
+}
+
+static inline void
+gsk_ngl_program_set_uniform_matrix (GskNglProgram *self,
+ guint key,
+ guint stamp,
+ const graphene_matrix_t *matrix)
+{
+ gsk_ngl_uniform_state_set_matrix (self->uniforms,
+ self->program_info,
+ gsk_ngl_program_get_uniform_location (self, key),
+ stamp, matrix);
+}
+
+G_END_DECLS
+
+#endif /* __GSK_NGL_PROGRAM_PRIVATE_H__ */
diff --git a/gsk/ngl/gsknglprograms.defs b/gsk/ngl/gsknglprograms.defs
new file mode 100644
index 0000000000..b0b797f0e9
--- /dev/null
+++ b/gsk/ngl/gsknglprograms.defs
@@ -0,0 +1,83 @@
+GSK_NGL_DEFINE_PROGRAM (blend,
+ "/org/gtk/libgsk/glsl/blend.glsl",
+ GSK_NGL_ADD_UNIFORM (1, BLEND_SOURCE2, u_source2)
+ GSK_NGL_ADD_UNIFORM (2, BLEND_MODE, u_mode))
+
+GSK_NGL_DEFINE_PROGRAM (blit,
+ "/org/gtk/libgsk/glsl/blit.glsl",
+ GSK_NGL_NO_UNIFORMS)
+
+GSK_NGL_DEFINE_PROGRAM (blur,
+ "/org/gtk/libgsk/glsl/blur.glsl",
+ GSK_NGL_ADD_UNIFORM (1, BLUR_RADIUS, u_blur_radius)
+ GSK_NGL_ADD_UNIFORM (2, BLUR_SIZE, u_blur_size)
+ GSK_NGL_ADD_UNIFORM (3, BLUR_DIR, u_blur_dir))
+
+GSK_NGL_DEFINE_PROGRAM (border,
+ "/org/gtk/libgsk/glsl/border.glsl",
+ GSK_NGL_ADD_UNIFORM (1, BORDER_COLOR, u_color)
+ GSK_NGL_ADD_UNIFORM (2, BORDER_WIDTHS, u_widths)
+ GSK_NGL_ADD_UNIFORM (3, BORDER_OUTLINE_RECT, u_outline_rect))
+
+GSK_NGL_DEFINE_PROGRAM (color,
+ "/org/gtk/libgsk/glsl/color.glsl",
+ GSK_NGL_ADD_UNIFORM (1, COLOR_COLOR, u_color))
+
+GSK_NGL_DEFINE_PROGRAM (coloring,
+ "/org/gtk/libgsk/glsl/coloring.glsl",
+ GSK_NGL_ADD_UNIFORM (1, COLORING_COLOR, u_color))
+
+GSK_NGL_DEFINE_PROGRAM (color_matrix,
+ "/org/gtk/libgsk/glsl/color_matrix.glsl",
+ GSK_NGL_ADD_UNIFORM (1, COLOR_MATRIX_COLOR_MATRIX, u_color_matrix)
+ GSK_NGL_ADD_UNIFORM (2, COLOR_MATRIX_COLOR_OFFSET, u_color_offset))
+
+GSK_NGL_DEFINE_PROGRAM (conic_gradient,
+ "/org/gtk/libgsk/glsl/conic_gradient.glsl",
+ GSK_NGL_ADD_UNIFORM (1, CONIC_GRADIENT_COLOR_STOPS, u_color_stops)
+ GSK_NGL_ADD_UNIFORM (2, CONIC_GRADIENT_NUM_COLOR_STOPS, u_num_color_stops)
+ GSK_NGL_ADD_UNIFORM (3, CONIC_GRADIENT_GEOMETRY, u_geometry))
+
+GSK_NGL_DEFINE_PROGRAM (cross_fade,
+ "/org/gtk/libgsk/glsl/cross_fade.glsl",
+ GSK_NGL_ADD_UNIFORM (1, CROSS_FADE_PROGRESS, u_progress)
+ GSK_NGL_ADD_UNIFORM (2, CROSS_FADE_SOURCE2, u_source2))
+
+GSK_NGL_DEFINE_PROGRAM (inset_shadow,
+ "/org/gtk/libgsk/glsl/inset_shadow.glsl",
+ GSK_NGL_ADD_UNIFORM (1, INSET_SHADOW_COLOR, u_color)
+ GSK_NGL_ADD_UNIFORM (2, INSET_SHADOW_SPREAD, u_spread)
+ GSK_NGL_ADD_UNIFORM (3, INSET_SHADOW_OFFSET, u_offset)
+ GSK_NGL_ADD_UNIFORM (4, INSET_SHADOW_OUTLINE_RECT, u_outline_rect))
+
+GSK_NGL_DEFINE_PROGRAM (linear_gradient,
+ "/org/gtk/libgsk/glsl/linear_gradient.glsl",
+ GSK_NGL_ADD_UNIFORM (1, LINEAR_GRADIENT_COLOR_STOPS, u_color_stops)
+ GSK_NGL_ADD_UNIFORM (2, LINEAR_GRADIENT_NUM_COLOR_STOPS, u_num_color_stops)
+ GSK_NGL_ADD_UNIFORM (3, LINEAR_GRADIENT_POINTS, u_points)
+ GSK_NGL_ADD_UNIFORM (4, LINEAR_GRADIENT_REPEAT, u_repeat))
+
+GSK_NGL_DEFINE_PROGRAM (outset_shadow,
+ "/org/gtk/libgsk/glsl/outset_shadow.glsl",
+ GSK_NGL_ADD_UNIFORM (1, OUTSET_SHADOW_COLOR, u_color)
+ GSK_NGL_ADD_UNIFORM (2, OUTSET_SHADOW_OUTLINE_RECT, u_outline_rect))
+
+GSK_NGL_DEFINE_PROGRAM (radial_gradient,
+ "/org/gtk/libgsk/glsl/radial_gradient.glsl",
+ GSK_NGL_ADD_UNIFORM (1, RADIAL_GRADIENT_COLOR_STOPS, u_color_stops)
+ GSK_NGL_ADD_UNIFORM (2, RADIAL_GRADIENT_NUM_COLOR_STOPS, u_num_color_stops)
+ GSK_NGL_ADD_UNIFORM (3, RADIAL_GRADIENT_REPEAT, u_repeat)
+ GSK_NGL_ADD_UNIFORM (4, RADIAL_GRADIENT_RANGE, u_range)
+ GSK_NGL_ADD_UNIFORM (5, RADIAL_GRADIENT_GEOMETRY, u_geometry))
+
+GSK_NGL_DEFINE_PROGRAM (repeat,
+ "/org/gtk/libgsk/glsl/repeat.glsl",
+ GSK_NGL_ADD_UNIFORM (1, REPEAT_CHILD_BOUNDS, u_child_bounds)
+ GSK_NGL_ADD_UNIFORM (2, REPEAT_TEXTURE_RECT, u_texture_rect))
+
+GSK_NGL_DEFINE_PROGRAM (unblurred_outset_shadow,
+ "/org/gtk/libgsk/glsl/unblurred_outset_shadow.glsl",
+ GSK_NGL_ADD_UNIFORM (1, UNBLURRED_OUTSET_SHADOW_COLOR, u_color)
+ GSK_NGL_ADD_UNIFORM (2, UNBLURRED_OUTSET_SHADOW_SPREAD, u_spread)
+ GSK_NGL_ADD_UNIFORM (3, UNBLURRED_OUTSET_SHADOW_OFFSET, u_offset)
+ GSK_NGL_ADD_UNIFORM (4, UNBLURRED_OUTSET_SHADOW_OUTLINE_RECT, u_outline_rect))
diff --git a/gsk/next/gskglrenderer.c b/gsk/ngl/gsknglrenderer.c
similarity index 59%
rename from gsk/next/gskglrenderer.c
rename to gsk/ngl/gsknglrenderer.c
index d082ffb733..c20660f09e 100644
--- a/gsk/next/gskglrenderer.c
+++ b/gsk/ngl/gsknglrenderer.c
@@ -1,4 +1,4 @@
-/* gskglrenderer.c
+/* gsknglrenderer.c
*
* Copyright 2020 Christian Hergert <chergert redhat com>
*
@@ -25,18 +25,18 @@
#include <gsk/gskdebugprivate.h>
#include <gsk/gskrendererprivate.h>
-#include "gskglcommandqueueprivate.h"
-#include "gskgldriverprivate.h"
-#include "gskglprogramprivate.h"
-#include "gskglrenderjobprivate.h"
-#include "gskglrendererprivate.h"
+#include "gsknglcommandqueueprivate.h"
+#include "gskngldriverprivate.h"
+#include "gsknglprogramprivate.h"
+#include "gsknglrenderjobprivate.h"
+#include "gsknglrendererprivate.h"
-struct _GskNextRendererClass
+struct _GskNglRendererClass
{
GskRendererClass parent_class;
};
-struct _GskNextRenderer
+struct _GskNglRenderer
{
GskRenderer parent_instance;
@@ -52,37 +52,37 @@ struct _GskNextRenderer
* contexts from other renderers on the display, texture atlases,
* programs, and other objects are available to them all.
*/
- GskGLCommandQueue *command_queue;
+ GskNglCommandQueue *command_queue;
/* The driver manages our program state and command queues. It also
* deals with caching textures, shaders, shadows, glyph, and icon
* caches through various helpers.
*/
- GskNextDriver *driver;
+ GskNglDriver *driver;
};
-G_DEFINE_TYPE (GskNextRenderer, gsk_next_renderer, GSK_TYPE_RENDERER)
+G_DEFINE_TYPE (GskNglRenderer, gsk_ngl_renderer, GSK_TYPE_RENDERER)
GskRenderer *
-gsk_next_renderer_new (void)
+gsk_ngl_renderer_new (void)
{
- return g_object_new (GSK_TYPE_NEXT_RENDERER, NULL);
+ return g_object_new (GSK_TYPE_NGL_RENDERER, NULL);
}
static gboolean
-gsk_next_renderer_realize (GskRenderer *renderer,
- GdkSurface *surface,
- GError **error)
+gsk_ngl_renderer_realize (GskRenderer *renderer,
+ GdkSurface *surface,
+ GError **error)
{
G_GNUC_UNUSED gint64 start_time = GDK_PROFILER_CURRENT_TIME;
- GskNextRenderer *self = (GskNextRenderer *)renderer;
+ GskNglRenderer *self = (GskNglRenderer *)renderer;
GdkGLContext *context = NULL;
GdkGLContext *shared_context;
- GskNextDriver *driver = NULL;
+ GskNglDriver *driver = NULL;
gboolean ret = FALSE;
gboolean debug_shaders = FALSE;
- g_assert (GSK_IS_NEXT_RENDERER (self));
+ g_assert (GSK_IS_NGL_RENDERER (self));
g_assert (GDK_IS_SURFACE (surface));
if (self->context != NULL)
@@ -110,15 +110,15 @@ gsk_next_renderer_realize (GskRenderer *renderer,
debug_shaders = TRUE;
#endif
- if (!(driver = gsk_next_driver_from_shared_context (shared_context, debug_shaders, error)))
+ if (!(driver = gsk_ngl_driver_from_shared_context (shared_context, debug_shaders, error)))
goto failure;
- self->command_queue = gsk_next_driver_create_command_queue (driver, context);
+ self->command_queue = gsk_ngl_driver_create_command_queue (driver, context);
self->context = g_steal_pointer (&context);
self->driver = g_steal_pointer (&driver);
- gsk_gl_command_queue_set_profiler (self->command_queue,
- gsk_renderer_get_profiler (renderer));
+ gsk_ngl_command_queue_set_profiler (self->command_queue,
+ gsk_renderer_get_profiler (renderer));
ret = TRUE;
@@ -126,17 +126,17 @@ failure:
g_clear_object (&driver);
g_clear_object (&context);
- gdk_profiler_end_mark (start_time, "GskNextRenderer realize", NULL);
+ gdk_profiler_end_mark (start_time, "GskNglRenderer realize", NULL);
return ret;
}
static void
-gsk_next_renderer_unrealize (GskRenderer *renderer)
+gsk_ngl_renderer_unrealize (GskRenderer *renderer)
{
- GskNextRenderer *self = (GskNextRenderer *)renderer;
+ GskNglRenderer *self = (GskNglRenderer *)renderer;
- g_assert (GSK_IS_NEXT_RENDERER (renderer));
+ g_assert (GSK_IS_NGL_RENDERER (renderer));
g_clear_object (&self->driver);
g_clear_object (&self->context);
@@ -177,18 +177,18 @@ get_render_region (GdkSurface *surface,
}
static void
-gsk_next_renderer_render (GskRenderer *renderer,
- GskRenderNode *root,
- const cairo_region_t *update_area)
+gsk_ngl_renderer_render (GskRenderer *renderer,
+ GskRenderNode *root,
+ const cairo_region_t *update_area)
{
- GskNextRenderer *self = (GskNextRenderer *)renderer;
+ GskNglRenderer *self = (GskNglRenderer *)renderer;
cairo_region_t *render_region;
graphene_rect_t viewport;
- GskGLRenderJob *job;
+ GskNglRenderJob *job;
GdkSurface *surface;
float scale_factor;
- g_assert (GSK_IS_NEXT_RENDERER (renderer));
+ g_assert (GSK_IS_NGL_RENDERER (renderer));
g_assert (root != NULL);
surface = gdk_draw_context_get_surface (GDK_DRAW_CONTEXT (self->context));
@@ -205,108 +205,108 @@ gsk_next_renderer_render (GskRenderer *renderer,
/* Must be called *AFTER* gdk_draw_context_begin_frame() */
render_region = get_render_region (surface, self->context);
- gsk_next_driver_begin_frame (self->driver, self->command_queue);
- job = gsk_gl_render_job_new (self->driver, &viewport, scale_factor, render_region, 0);
+ gsk_ngl_driver_begin_frame (self->driver, self->command_queue);
+ job = gsk_ngl_render_job_new (self->driver, &viewport, scale_factor, render_region, 0);
#ifdef G_ENABLE_DEBUG
if (GSK_RENDERER_DEBUG_CHECK (GSK_RENDERER (self), FALLBACK))
- gsk_gl_render_job_set_debug_fallback (job, TRUE);
+ gsk_ngl_render_job_set_debug_fallback (job, TRUE);
#endif
- gsk_gl_render_job_render (job, root);
- gsk_next_driver_end_frame (self->driver);
- gsk_gl_render_job_free (job);
+ gsk_ngl_render_job_render (job, root);
+ gsk_ngl_driver_end_frame (self->driver);
+ gsk_ngl_render_job_free (job);
gdk_gl_context_make_current (self->context);
gdk_draw_context_end_frame (GDK_DRAW_CONTEXT (self->context));
- gsk_next_driver_after_frame (self->driver);
+ gsk_ngl_driver_after_frame (self->driver);
cairo_region_destroy (render_region);
}
static GdkTexture *
-gsk_next_renderer_render_texture (GskRenderer *renderer,
- GskRenderNode *root,
- const graphene_rect_t *viewport)
+gsk_ngl_renderer_render_texture (GskRenderer *renderer,
+ GskRenderNode *root,
+ const graphene_rect_t *viewport)
{
- GskNextRenderer *self = (GskNextRenderer *)renderer;
- GskGLRenderTarget *render_target;
- GskGLRenderJob *job;
+ GskNglRenderer *self = (GskNglRenderer *)renderer;
+ GskNglRenderTarget *render_target;
+ GskNglRenderJob *job;
GdkTexture *texture = NULL;
guint texture_id;
int width;
int height;
- g_assert (GSK_IS_NEXT_RENDERER (renderer));
+ g_assert (GSK_IS_NGL_RENDERER (renderer));
g_assert (root != NULL);
width = ceilf (viewport->size.width);
height = ceilf (viewport->size.height);
- if (gsk_next_driver_create_render_target (self->driver,
- width, height,
- GL_NEAREST, GL_NEAREST,
- &render_target))
+ if (gsk_ngl_driver_create_render_target (self->driver,
+ width, height,
+ GL_NEAREST, GL_NEAREST,
+ &render_target))
{
- gsk_next_driver_begin_frame (self->driver, self->command_queue);
- job = gsk_gl_render_job_new (self->driver, viewport, 1, NULL, render_target->framebuffer_id);
+ gsk_ngl_driver_begin_frame (self->driver, self->command_queue);
+ job = gsk_ngl_render_job_new (self->driver, viewport, 1, NULL, render_target->framebuffer_id);
#ifdef G_ENABLE_DEBUG
if (GSK_RENDERER_DEBUG_CHECK (GSK_RENDERER (self), FALLBACK))
- gsk_gl_render_job_set_debug_fallback (job, TRUE);
+ gsk_ngl_render_job_set_debug_fallback (job, TRUE);
#endif
- gsk_gl_render_job_render_flipped (job, root);
- texture_id = gsk_next_driver_release_render_target (self->driver, render_target, FALSE);
- texture = gsk_next_driver_create_gdk_texture (self->driver, texture_id);
- gsk_next_driver_end_frame (self->driver);
- gsk_gl_render_job_free (job);
+ gsk_ngl_render_job_render_flipped (job, root);
+ texture_id = gsk_ngl_driver_release_render_target (self->driver, render_target, FALSE);
+ texture = gsk_ngl_driver_create_gdk_texture (self->driver, texture_id);
+ gsk_ngl_driver_end_frame (self->driver);
+ gsk_ngl_render_job_free (job);
- gsk_next_driver_after_frame (self->driver);
+ gsk_ngl_driver_after_frame (self->driver);
}
return g_steal_pointer (&texture);
}
static void
-gsk_next_renderer_dispose (GObject *object)
+gsk_ngl_renderer_dispose (GObject *object)
{
#ifdef G_ENABLE_DEBUG
- GskNextRenderer *self = (GskNextRenderer *)object;
+ GskNglRenderer *self = (GskNglRenderer *)object;
g_assert (self->driver == NULL);
#endif
- G_OBJECT_CLASS (gsk_next_renderer_parent_class)->dispose (object);
+ G_OBJECT_CLASS (gsk_ngl_renderer_parent_class)->dispose (object);
}
static void
-gsk_next_renderer_class_init (GskNextRendererClass *klass)
+gsk_ngl_renderer_class_init (GskNglRendererClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GskRendererClass *renderer_class = GSK_RENDERER_CLASS (klass);
- object_class->dispose = gsk_next_renderer_dispose;
+ object_class->dispose = gsk_ngl_renderer_dispose;
- renderer_class->realize = gsk_next_renderer_realize;
- renderer_class->unrealize = gsk_next_renderer_unrealize;
- renderer_class->render = gsk_next_renderer_render;
- renderer_class->render_texture = gsk_next_renderer_render_texture;
+ renderer_class->realize = gsk_ngl_renderer_realize;
+ renderer_class->unrealize = gsk_ngl_renderer_unrealize;
+ renderer_class->render = gsk_ngl_renderer_render;
+ renderer_class->render_texture = gsk_ngl_renderer_render_texture;
}
static void
-gsk_next_renderer_init (GskNextRenderer *self)
+gsk_ngl_renderer_init (GskNglRenderer *self)
{
}
gboolean
-gsk_next_renderer_try_compile_gl_shader (GskNextRenderer *renderer,
- GskGLShader *shader,
- GError **error)
+gsk_ngl_renderer_try_compile_gl_shader (GskNglRenderer *renderer,
+ GskGLShader *shader,
+ GError **error)
{
- GskGLProgram *program;
+ GskNglProgram *program;
- g_return_val_if_fail (GSK_IS_NEXT_RENDERER (renderer), FALSE);
+ g_return_val_if_fail (GSK_IS_NGL_RENDERER (renderer), FALSE);
g_return_val_if_fail (shader != NULL, FALSE);
- program = gsk_next_driver_lookup_shader (renderer->driver, shader, error);
+ program = gsk_ngl_driver_lookup_shader (renderer->driver, shader, error);
return program != NULL;
}
diff --git a/gsk/ngl/gsknglrenderer.h b/gsk/ngl/gsknglrenderer.h
new file mode 100644
index 0000000000..014c7755c8
--- /dev/null
+++ b/gsk/ngl/gsknglrenderer.h
@@ -0,0 +1,46 @@
+/* gsknglrenderer.h
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ */
+
+#ifndef __GSK_NGL_RENDERER_H__
+#define __GSK_NGL_RENDERER_H__
+
+#include <gsk/gskrenderer.h>
+
+G_BEGIN_DECLS
+
+#define GSK_TYPE_NGL_RENDERER (gsk_ngl_renderer_get_type())
+
+#define GSK_NGL_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GSK_TYPE_NGL_RENDERER,
GskNglRenderer))
+#define GSK_IS_NGL_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GSK_TYPE_NGL_RENDERER))
+#define GSK_NGL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GSK_TYPE_NGL_RENDERER,
GskNglRendererClass))
+#define GSK_IS_NGL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GSK_TYPE_NGL_RENDERER))
+#define GSK_NGL_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GSK_TYPE_NGL_RENDERER,
GskNglRendererClass))
+
+typedef struct _GskNglRenderer GskNglRenderer;
+typedef struct _GskNglRendererClass GskNglRendererClass;
+
+GDK_AVAILABLE_IN_ALL
+GType gsk_ngl_renderer_get_type (void) G_GNUC_CONST;
+GDK_AVAILABLE_IN_ALL
+GskRenderer *gsk_ngl_renderer_new (void);
+
+G_END_DECLS
+
+#endif /* __GSK_NGL_RENDERER__ */
diff --git a/gsk/next/gskglrendererprivate.h b/gsk/ngl/gsknglrendererprivate.h
similarity index 66%
rename from gsk/next/gskglrendererprivate.h
rename to gsk/ngl/gsknglrendererprivate.h
index fc8ad12236..a0a861f0aa 100644
--- a/gsk/next/gskglrendererprivate.h
+++ b/gsk/ngl/gsknglrendererprivate.h
@@ -1,4 +1,4 @@
-/* gskglrendererprivate.h
+/* gsknglrendererprivate.h
*
* Copyright 2021 Christian Hergert <chergert redhat com>
*
@@ -18,17 +18,17 @@
* SPDX-License-Identifier: LGPL-2.1-or-later
*/
-#ifndef __GSK_NEXT_RENDERER_PRIVATE_H__
-#define __GSK_NEXT_RENDERER_PRIVATE_H__
+#ifndef __GSK_NGL_RENDERER_PRIVATE_H__
+#define __GSK_NGL_RENDERER_PRIVATE_H__
-#include "gskglrenderer.h"
+#include "gsknglrenderer.h"
G_BEGIN_DECLS
-gboolean gsk_next_renderer_try_compile_gl_shader (GskNextRenderer *renderer,
- GskGLShader *shader,
- GError **error);
+gboolean gsk_ngl_renderer_try_compile_gl_shader (GskNglRenderer *renderer,
+ GskGLShader *shader,
+ GError **error);
G_END_DECLS
-#endif /* __GSK_NEXT_RENDERER_PRIVATE_H__ */
+#endif /* __GSK_NGL_RENDERER_PRIVATE_H__ */
diff --git a/gsk/next/gskglrenderjob.c b/gsk/ngl/gsknglrenderjob.c
similarity index 57%
rename from gsk/next/gskglrenderjob.c
rename to gsk/ngl/gsknglrenderjob.c
index bfba8a7a7b..b8f983f862 100644
--- a/gsk/next/gskglrenderjob.c
+++ b/gsk/ngl/gsknglrenderjob.c
@@ -1,4 +1,4 @@
-/* gskglrenderjob.c
+/* gsknglrenderjob.c
*
* Copyright 2017 Timm Bäder <mail baedert org>
* Copyright 2018 Matthias Clasen <mclasen redhat com>
@@ -34,13 +34,13 @@
#include <math.h>
#include <string.h>
-#include "gskglcommandqueueprivate.h"
-#include "gskgldriverprivate.h"
-#include "gskglglyphlibraryprivate.h"
-#include "gskgliconlibraryprivate.h"
-#include "gskglprogramprivate.h"
-#include "gskglrenderjobprivate.h"
-#include "gskglshadowlibraryprivate.h"
+#include "gsknglcommandqueueprivate.h"
+#include "gskngldriverprivate.h"
+#include "gsknglglyphlibraryprivate.h"
+#include "gskngliconlibraryprivate.h"
+#include "gsknglprogramprivate.h"
+#include "gsknglrenderjobprivate.h"
+#include "gsknglshadowlibraryprivate.h"
#include "ninesliceprivate.h"
@@ -50,7 +50,7 @@
#define SHADOW_EXTRA_SIZE 4
/* Make sure gradient stops fits in packed array_count */
-G_STATIC_ASSERT ((MAX_GRADIENT_STOPS * 5) < (1 << GSK_GL_UNIFORM_ARRAY_BITS));
+G_STATIC_ASSERT ((MAX_GRADIENT_STOPS * 5) < (1 << GSK_NGL_UNIFORM_ARRAY_BITS));
#define rounded_rect_top_left(r) \
(GRAPHENE_RECT_INIT(r->bounds.origin.x, \
@@ -76,13 +76,13 @@ G_STATIC_ASSERT ((MAX_GRADIENT_STOPS * 5) < (1 << GSK_GL_UNIFORM_ARRAY_BITS));
#define ALPHA_IS_CLEAR(alpha) ((alpha) < ((float) 0x00ff / (float) 0xffff))
#define RGBA_IS_CLEAR(rgba) ALPHA_IS_CLEAR((rgba)->alpha)
-typedef struct _GskGLRenderClip
+typedef struct _GskNglRenderClip
{
GskRoundedRect rect;
guint is_rectilinear : 1;
-} GskGLRenderClip;
+} GskNglRenderClip;
-typedef struct _GskGLRenderModelview
+typedef struct _GskNglRenderModelview
{
GskTransform *transform;
float scale_x;
@@ -90,25 +90,25 @@ typedef struct _GskGLRenderModelview
float offset_x_before;
float offset_y_before;
graphene_matrix_t matrix;
-} GskGLRenderModelview;
+} GskNglRenderModelview;
-struct _GskGLRenderJob
+struct _GskNglRenderJob
{
/* The context containing the framebuffer we are drawing to. Generally this
* is the context of the surface but may be a shared context if rendering to
- * an offscreen texture such as gsk_gl_renderer_render_texture().
+ * an offscreen texture such as gsk_ngl_renderer_render_texture().
*/
GdkGLContext *context;
/* The driver to be used. This is shared among all the renderers on a given
* GdkDisplay and uses the shared GL context to send commands.
*/
- GskNextDriver *driver;
+ GskNglDriver *driver;
/* The command queue (which is just a faster pointer to the driver's
* command queue.
*/
- GskGLCommandQueue *command_queue;
+ GskNglCommandQueue *command_queue;
/* The region that we are clipping. Normalized to a single rectangle region. */
cairo_region_t *region;
@@ -128,12 +128,12 @@ struct _GskGLRenderJob
/* The current projection, updated as we process nodes */
graphene_matrix_t projection;
- /* An array of GskGLRenderModelview updated as nodes are processed. The
+ /* An array of GskNglRenderModelview updated as nodes are processed. The
* current modelview is the last element.
*/
GArray *modelview;
- /* An array of GskGLRenderClip updated as nodes are processed. The
+ /* An array of GskNglRenderClip updated as nodes are processed. The
* current clip is the last element.
*/
GArray *clip;
@@ -152,14 +152,14 @@ struct _GskGLRenderJob
float scale_y;
/* Cached pointers */
- const GskGLRenderClip *current_clip;
- const GskGLRenderModelview *current_modelview;
+ const GskNglRenderClip *current_clip;
+ const GskNglRenderModelview *current_modelview;
/* If we should be rendering red zones over fallback nodes */
guint debug_fallback : 1;
};
-typedef struct _GskGLRenderOffscreen
+typedef struct _GskNglRenderOffscreen
{
const graphene_rect_t *bounds;
struct {
@@ -174,16 +174,16 @@ typedef struct _GskGLRenderOffscreen
guint do_not_cache : 1;
guint linear_filter : 1;
guint was_offscreen : 1;
-} GskGLRenderOffscreen;
+} GskNglRenderOffscreen;
-static void gsk_gl_render_job_visit_node (GskGLRenderJob *job,
- const GskRenderNode *node);
-static gboolean gsk_gl_render_job_visit_node_with_offscreen (GskGLRenderJob *job,
- const GskRenderNode *node,
- GskGLRenderOffscreen *offscreen);
+static void gsk_ngl_render_job_visit_node (GskNglRenderJob *job,
+ const GskRenderNode *node);
+static gboolean gsk_ngl_render_job_visit_node_with_offscreen (GskNglRenderJob *job,
+ const GskRenderNode *node,
+ GskNglRenderOffscreen *offscreen);
static inline void
-init_full_texture_region (GskGLRenderOffscreen *offscreen)
+init_full_texture_region (GskNglRenderOffscreen *offscreen)
{
offscreen->area.x = 0;
offscreen->area.y = 0;
@@ -379,8 +379,8 @@ init_projection_matrix (graphene_matrix_t *projection,
}
static inline float
-gsk_gl_render_job_set_alpha (GskGLRenderJob *job,
- float alpha)
+gsk_ngl_render_job_set_alpha (GskNglRenderJob *job,
+ float alpha)
{
if (job->alpha != alpha)
{
@@ -394,7 +394,7 @@ gsk_gl_render_job_set_alpha (GskGLRenderJob *job,
}
static void
-extract_matrix_metadata (GskGLRenderModelview *modelview)
+extract_matrix_metadata (GskNglRenderModelview *modelview)
{
float dummy;
graphene_matrix_t m;
@@ -446,10 +446,10 @@ extract_matrix_metadata (GskGLRenderModelview *modelview)
}
static void
-gsk_gl_render_job_set_modelview (GskGLRenderJob *job,
- GskTransform *transform)
+gsk_ngl_render_job_set_modelview (GskNglRenderJob *job,
+ GskTransform *transform)
{
- GskGLRenderModelview *modelview;
+ GskNglRenderModelview *modelview;
g_assert (job != NULL);
g_assert (job->modelview != NULL);
@@ -459,7 +459,7 @@ gsk_gl_render_job_set_modelview (GskGLRenderJob *job,
g_array_set_size (job->modelview, job->modelview->len + 1);
modelview = &g_array_index (job->modelview,
- GskGLRenderModelview,
+ GskNglRenderModelview,
job->modelview->len - 1);
modelview->transform = transform;
@@ -478,10 +478,10 @@ gsk_gl_render_job_set_modelview (GskGLRenderJob *job,
}
static void
-gsk_gl_render_job_push_modelview (GskGLRenderJob *job,
- GskTransform *transform)
+gsk_ngl_render_job_push_modelview (GskNglRenderJob *job,
+ GskTransform *transform)
{
- GskGLRenderModelview *modelview;
+ GskNglRenderModelview *modelview;
g_assert (job != NULL);
g_assert (job->modelview != NULL);
@@ -492,16 +492,16 @@ gsk_gl_render_job_push_modelview (GskGLRenderJob *job,
g_array_set_size (job->modelview, job->modelview->len + 1);
modelview = &g_array_index (job->modelview,
- GskGLRenderModelview,
+ GskNglRenderModelview,
job->modelview->len - 1);
if G_LIKELY (job->modelview->len > 1)
{
- GskGLRenderModelview *last;
+ GskNglRenderModelview *last;
GskTransform *t = NULL;
last = &g_array_index (job->modelview,
- GskGLRenderModelview,
+ GskNglRenderModelview,
job->modelview->len - 2);
/* Multiply given matrix with our previews modelview */
@@ -532,9 +532,9 @@ gsk_gl_render_job_push_modelview (GskGLRenderJob *job,
}
static void
-gsk_gl_render_job_pop_modelview (GskGLRenderJob *job)
+gsk_ngl_render_job_pop_modelview (GskNglRenderJob *job)
{
- const GskGLRenderModelview *head;
+ const GskNglRenderModelview *head;
g_assert (job != NULL);
g_assert (job->modelview);
@@ -553,7 +553,7 @@ gsk_gl_render_job_pop_modelview (GskGLRenderJob *job)
if (job->modelview->len >= 1)
{
- head = &g_array_index (job->modelview, GskGLRenderModelview, job->modelview->len - 1);
+ head = &g_array_index (job->modelview, GskNglRenderModelview, job->modelview->len - 1);
job->scale_x = head->scale_x;
job->scale_y = head->scale_y;
@@ -567,10 +567,10 @@ gsk_gl_render_job_pop_modelview (GskGLRenderJob *job)
}
static void
-gsk_gl_render_job_push_clip (GskGLRenderJob *job,
- const GskRoundedRect *rect)
+gsk_ngl_render_job_push_clip (GskNglRenderJob *job,
+ const GskRoundedRect *rect)
{
- GskGLRenderClip *clip;
+ GskNglRenderClip *clip;
g_assert (job != NULL);
g_assert (job->clip != NULL);
@@ -580,7 +580,7 @@ gsk_gl_render_job_push_clip (GskGLRenderJob *job,
g_array_set_size (job->clip, job->clip->len + 1);
- clip = &g_array_index (job->clip, GskGLRenderClip, job->clip->len - 1);
+ clip = &g_array_index (job->clip, GskNglRenderClip, job->clip->len - 1);
memcpy (&clip->rect, rect, sizeof *rect);
clip->is_rectilinear = gsk_rounded_rect_is_rectilinear (rect);
@@ -588,7 +588,7 @@ gsk_gl_render_job_push_clip (GskGLRenderJob *job,
}
static void
-gsk_gl_render_job_pop_clip (GskGLRenderJob *job)
+gsk_ngl_render_job_pop_clip (GskNglRenderJob *job)
{
g_assert (job != NULL);
g_assert (job->clip != NULL);
@@ -600,9 +600,9 @@ gsk_gl_render_job_pop_clip (GskGLRenderJob *job)
}
static inline void
-gsk_gl_render_job_offset (GskGLRenderJob *job,
- float offset_x,
- float offset_y)
+gsk_ngl_render_job_offset (GskNglRenderJob *job,
+ float offset_x,
+ float offset_y)
{
if (offset_x || offset_y)
{
@@ -612,17 +612,17 @@ gsk_gl_render_job_offset (GskGLRenderJob *job,
}
static inline void
-gsk_gl_render_job_set_projection (GskGLRenderJob *job,
- const graphene_matrix_t *projection)
+gsk_ngl_render_job_set_projection (GskNglRenderJob *job,
+ const graphene_matrix_t *projection)
{
memcpy (&job->projection, projection, sizeof job->projection);
job->driver->stamps[UNIFORM_SHARED_PROJECTION]++;
}
static inline void
-gsk_gl_render_job_set_projection_from_rect (GskGLRenderJob *job,
- const graphene_rect_t *rect,
- graphene_matrix_t *prev_projection)
+gsk_ngl_render_job_set_projection_from_rect (GskNglRenderJob *job,
+ const graphene_rect_t *rect,
+ graphene_matrix_t *prev_projection)
{
if (prev_projection)
memcpy (prev_projection, &job->projection, sizeof *prev_projection);
@@ -631,10 +631,10 @@ gsk_gl_render_job_set_projection_from_rect (GskGLRenderJob *job,
}
static inline void
-gsk_gl_render_job_set_projection_for_size (GskGLRenderJob *job,
- float width,
- float height,
- graphene_matrix_t *prev_projection)
+gsk_ngl_render_job_set_projection_for_size (GskNglRenderJob *job,
+ float width,
+ float height,
+ graphene_matrix_t *prev_projection)
{
if (prev_projection)
memcpy (prev_projection, &job->projection, sizeof *prev_projection);
@@ -644,9 +644,9 @@ gsk_gl_render_job_set_projection_for_size (GskGLRenderJob *job,
}
static inline void
-gsk_gl_render_job_set_viewport (GskGLRenderJob *job,
- const graphene_rect_t *viewport,
- graphene_rect_t *prev_viewport)
+gsk_ngl_render_job_set_viewport (GskNglRenderJob *job,
+ const graphene_rect_t *viewport,
+ graphene_rect_t *prev_viewport)
{
if (prev_viewport)
memcpy (prev_viewport, &job->viewport, sizeof *prev_viewport);
@@ -655,10 +655,10 @@ gsk_gl_render_job_set_viewport (GskGLRenderJob *job,
}
static inline void
-gsk_gl_render_job_set_viewport_for_size (GskGLRenderJob *job,
- float width,
- float height,
- graphene_rect_t *prev_viewport)
+gsk_ngl_render_job_set_viewport_for_size (GskNglRenderJob *job,
+ float width,
+ float height,
+ graphene_rect_t *prev_viewport)
{
if (prev_viewport)
memcpy (prev_viewport, &job->viewport, sizeof *prev_viewport);
@@ -670,9 +670,9 @@ gsk_gl_render_job_set_viewport_for_size (GskGLRenderJob *job,
}
static inline void
-gsk_gl_render_job_transform_bounds (GskGLRenderJob *job,
- const graphene_rect_t *rect,
- graphene_rect_t *out_rect)
+gsk_ngl_render_job_transform_bounds (GskNglRenderJob *job,
+ const graphene_rect_t *rect,
+ graphene_rect_t *out_rect)
{
GskTransform *transform;
GskTransformCategory category;
@@ -731,9 +731,9 @@ gsk_gl_render_job_transform_bounds (GskGLRenderJob *job,
}
static inline void
-gsk_gl_render_job_transform_rounded_rect (GskGLRenderJob *job,
- const GskRoundedRect *rect,
- GskRoundedRect *out_rect)
+gsk_ngl_render_job_transform_rounded_rect (GskNglRenderJob *job,
+ const GskRoundedRect *rect,
+ GskRoundedRect *out_rect)
{
out_rect->bounds.origin.x = job->offset_x + rect->bounds.origin.x;
out_rect->bounds.origin.y = job->offset_y + rect->bounds.origin.y;
@@ -743,21 +743,21 @@ gsk_gl_render_job_transform_rounded_rect (GskGLRenderJob *job,
}
static inline gboolean
-gsk_gl_render_job_node_overlaps_clip (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_node_overlaps_clip (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
graphene_rect_t transformed_bounds;
- gsk_gl_render_job_transform_bounds (job, &node->bounds, &transformed_bounds);
+ gsk_ngl_render_job_transform_bounds (job, &node->bounds, &transformed_bounds);
return rect_intersects (&job->current_clip->rect.bounds, &transformed_bounds);
}
/* load_vertex_data_with_region */
static inline void
-gsk_gl_render_job_load_vertices_from_offscreen (GskGLRenderJob *job,
- const graphene_rect_t *bounds,
- const GskGLRenderOffscreen *offscreen)
+gsk_ngl_render_job_load_vertices_from_offscreen (GskNglRenderJob *job,
+ const graphene_rect_t *bounds,
+ const GskNglRenderOffscreen *offscreen)
{
- GskGLDrawVertex *vertices = gsk_gl_command_queue_add_vertices (job->command_queue);
+ GskNglDrawVertex *vertices = gsk_ngl_command_queue_add_vertices (job->command_queue);
float min_x = job->offset_x + bounds->origin.x;
float min_y = job->offset_y + bounds->origin.y;
float max_x = min_x + bounds->size.width;
@@ -798,13 +798,13 @@ gsk_gl_render_job_load_vertices_from_offscreen (GskGLRenderJob *job,
/* load_float_vertex_data */
static inline void
-gsk_gl_render_job_draw (GskGLRenderJob *job,
- float x,
- float y,
- float width,
- float height)
+gsk_ngl_render_job_draw (GskNglRenderJob *job,
+ float x,
+ float y,
+ float width,
+ float height)
{
- GskGLDrawVertex *vertices = gsk_gl_command_queue_add_vertices (job->command_queue);
+ GskNglDrawVertex *vertices = gsk_ngl_command_queue_add_vertices (job->command_queue);
float min_x = job->offset_x + x;
float min_y = job->offset_y + y;
float max_x = min_x + width;
@@ -843,25 +843,25 @@ gsk_gl_render_job_draw (GskGLRenderJob *job,
/* load_vertex_data */
static inline void
-gsk_gl_render_job_draw_rect (GskGLRenderJob *job,
- const graphene_rect_t *bounds)
+gsk_ngl_render_job_draw_rect (GskNglRenderJob *job,
+ const graphene_rect_t *bounds)
{
- gsk_gl_render_job_draw (job,
- bounds->origin.x,
- bounds->origin.y,
- bounds->size.width,
- bounds->size.height);
+ gsk_ngl_render_job_draw (job,
+ bounds->origin.x,
+ bounds->origin.y,
+ bounds->size.width,
+ bounds->size.height);
}
/* fill_vertex_data */
static void
-gsk_gl_render_job_draw_coords (GskGLRenderJob *job,
- float min_x,
- float min_y,
- float max_x,
- float max_y)
+gsk_ngl_render_job_draw_coords (GskNglRenderJob *job,
+ float min_x,
+ float min_y,
+ float max_x,
+ float max_y)
{
- GskGLDrawVertex *vertices = gsk_gl_command_queue_add_vertices (job->command_queue);
+ GskNglDrawVertex *vertices = gsk_ngl_command_queue_add_vertices (job->command_queue);
vertices[0].position[0] = min_x;
vertices[0].position[1] = min_y;
@@ -896,78 +896,78 @@ gsk_gl_render_job_draw_coords (GskGLRenderJob *job,
/* load_offscreen_vertex_data */
static inline void
-gsk_gl_render_job_draw_offscreen_rect (GskGLRenderJob *job,
- const graphene_rect_t *bounds)
+gsk_ngl_render_job_draw_offscreen_rect (GskNglRenderJob *job,
+ const graphene_rect_t *bounds)
{
float min_x = job->offset_x + bounds->origin.x;
float min_y = job->offset_y + bounds->origin.y;
float max_x = min_x + bounds->size.width;
float max_y = min_y + bounds->size.height;
- gsk_gl_render_job_draw_coords (job, min_x, min_y, max_x, max_y);
+ gsk_ngl_render_job_draw_coords (job, min_x, min_y, max_x, max_y);
}
static inline void
-gsk_gl_render_job_begin_draw (GskGLRenderJob *job,
- GskGLProgram *program)
+gsk_ngl_render_job_begin_draw (GskNglRenderJob *job,
+ GskNglProgram *program)
{
- gsk_gl_command_queue_begin_draw (job->command_queue,
- program->program_info,
- job->viewport.size.width,
- job->viewport.size.height);
+ gsk_ngl_command_queue_begin_draw (job->command_queue,
+ program->program_info,
+ job->viewport.size.width,
+ job->viewport.size.height);
if (program->uniform_locations[UNIFORM_SHARED_VIEWPORT] > -1)
- gsk_gl_uniform_state_set4fv (program->uniforms,
- program->program_info,
- program->uniform_locations[UNIFORM_SHARED_VIEWPORT],
- job->driver->stamps[UNIFORM_SHARED_VIEWPORT],
- 1,
- (const float *)&job->viewport);
+ gsk_ngl_uniform_state_set4fv (program->uniforms,
+ program->program_info,
+ program->uniform_locations[UNIFORM_SHARED_VIEWPORT],
+ job->driver->stamps[UNIFORM_SHARED_VIEWPORT],
+ 1,
+ (const float *)&job->viewport);
if (program->uniform_locations[UNIFORM_SHARED_MODELVIEW] > -1)
- gsk_gl_uniform_state_set_matrix (program->uniforms,
- program->program_info,
- program->uniform_locations[UNIFORM_SHARED_MODELVIEW],
- job->driver->stamps[UNIFORM_SHARED_MODELVIEW],
- &job->current_modelview->matrix);
+ gsk_ngl_uniform_state_set_matrix (program->uniforms,
+ program->program_info,
+ program->uniform_locations[UNIFORM_SHARED_MODELVIEW],
+ job->driver->stamps[UNIFORM_SHARED_MODELVIEW],
+ &job->current_modelview->matrix);
if (program->uniform_locations[UNIFORM_SHARED_PROJECTION] > -1)
- gsk_gl_uniform_state_set_matrix (program->uniforms,
- program->program_info,
- program->uniform_locations[UNIFORM_SHARED_PROJECTION],
- job->driver->stamps[UNIFORM_SHARED_PROJECTION],
- &job->projection);
+ gsk_ngl_uniform_state_set_matrix (program->uniforms,
+ program->program_info,
+ program->uniform_locations[UNIFORM_SHARED_PROJECTION],
+ job->driver->stamps[UNIFORM_SHARED_PROJECTION],
+ &job->projection);
if (program->uniform_locations[UNIFORM_SHARED_CLIP_RECT] > -1)
- gsk_gl_uniform_state_set_rounded_rect (program->uniforms,
- program->program_info,
- program->uniform_locations[UNIFORM_SHARED_CLIP_RECT],
- job->driver->stamps[UNIFORM_SHARED_CLIP_RECT],
- &job->current_clip->rect);
+ gsk_ngl_uniform_state_set_rounded_rect (program->uniforms,
+ program->program_info,
+ program->uniform_locations[UNIFORM_SHARED_CLIP_RECT],
+ job->driver->stamps[UNIFORM_SHARED_CLIP_RECT],
+ &job->current_clip->rect);
if (program->uniform_locations[UNIFORM_SHARED_ALPHA] > -1)
- gsk_gl_uniform_state_set1f (program->uniforms,
- program->program_info,
- program->uniform_locations[UNIFORM_SHARED_ALPHA],
- job->driver->stamps[UNIFORM_SHARED_ALPHA],
- job->alpha);
+ gsk_ngl_uniform_state_set1f (program->uniforms,
+ program->program_info,
+ program->uniform_locations[UNIFORM_SHARED_ALPHA],
+ job->driver->stamps[UNIFORM_SHARED_ALPHA],
+ job->alpha);
}
static inline void
-gsk_gl_render_job_split_draw (GskGLRenderJob *job)
+gsk_ngl_render_job_split_draw (GskNglRenderJob *job)
{
- gsk_gl_command_queue_split_draw (job->command_queue);
+ gsk_ngl_command_queue_split_draw (job->command_queue);
}
static inline void
-gsk_gl_render_job_end_draw (GskGLRenderJob *job)
+gsk_ngl_render_job_end_draw (GskNglRenderJob *job)
{
- gsk_gl_command_queue_end_draw (job->command_queue);
+ gsk_ngl_command_queue_end_draw (job->command_queue);
}
static inline void
-gsk_gl_render_job_visit_as_fallback (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_as_fallback (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
float scale_x = job->scale_x;
float scale_y = job->scale_y;
@@ -990,16 +990,16 @@ gsk_gl_render_job_visit_as_fallback (GskGLRenderJob *job,
key.scale_y = scale_y;
key.filter = GL_NEAREST;
- cached_id = gsk_next_driver_lookup_texture (job->driver, &key);
+ cached_id = gsk_ngl_driver_lookup_texture (job->driver, &key);
if (cached_id != 0)
{
- gsk_gl_render_job_begin_draw (job, job->driver->blit);
- gsk_gl_program_set_uniform_texture (job->driver->blit,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D, GL_TEXTURE0, cached_id);
- gsk_gl_render_job_draw_offscreen_rect (job, &node->bounds);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->blit);
+ gsk_ngl_program_set_uniform_texture (job->driver->blit,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D, GL_TEXTURE0, cached_id);
+ gsk_ngl_render_job_draw_offscreen_rect (job, &node->bounds);
+ gsk_ngl_render_job_end_draw (job);
return;
}
@@ -1058,8 +1058,8 @@ gsk_gl_render_job_visit_as_fallback (GskGLRenderJob *job,
/* Create texture to upload */
texture = gdk_texture_new_for_surface (surface);
- texture_id = gsk_next_driver_load_texture (job->driver, texture,
- GL_NEAREST, GL_NEAREST);
+ texture_id = gsk_ngl_driver_load_texture (job->driver, texture,
+ GL_NEAREST, GL_NEAREST);
if (gdk_gl_context_has_debug (job->command_queue->context))
gdk_gl_context_label_object_printf (job->command_queue->context, GL_TEXTURE, texture_id,
@@ -1071,29 +1071,29 @@ gsk_gl_render_job_visit_as_fallback (GskGLRenderJob *job,
cairo_surface_destroy (surface);
cairo_surface_destroy (rendered_surface);
- gsk_next_driver_cache_texture (job->driver, &key, texture_id);
+ gsk_ngl_driver_cache_texture (job->driver, &key, texture_id);
- gsk_gl_render_job_begin_draw (job, job->driver->blit);
- gsk_gl_program_set_uniform_texture (job->driver->blit,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0,
- texture_id);
- gsk_gl_render_job_draw_offscreen_rect (job, &node->bounds);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->blit);
+ gsk_ngl_program_set_uniform_texture (job->driver->blit,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0,
+ texture_id);
+ gsk_ngl_render_job_draw_offscreen_rect (job, &node->bounds);
+ gsk_ngl_render_job_end_draw (job);
}
static guint
-blur_offscreen (GskGLRenderJob *job,
- GskGLRenderOffscreen *offscreen,
+blur_offscreen (GskNglRenderJob *job,
+ GskNglRenderOffscreen *offscreen,
int texture_to_blur_width,
int texture_to_blur_height,
float blur_radius_x,
float blur_radius_y)
{
const GskRoundedRect new_clip = GSK_ROUNDED_RECT_INIT (0, 0, texture_to_blur_width,
texture_to_blur_height);
- GskGLRenderTarget *pass1;
- GskGLRenderTarget *pass2;
+ GskNglRenderTarget *pass1;
+ GskNglRenderTarget *pass2;
graphene_matrix_t prev_projection;
graphene_rect_t prev_viewport;
guint prev_fbo;
@@ -1104,7 +1104,7 @@ blur_offscreen (GskGLRenderJob *job,
g_assert (offscreen->area.x2 > offscreen->area.x);
g_assert (offscreen->area.y2 > offscreen->area.y);
- if (!gsk_next_driver_create_render_target (job->driver,
+ if (!gsk_ngl_driver_create_render_target (job->driver,
MAX (texture_to_blur_width, 1),
MAX (texture_to_blur_height, 1),
GL_NEAREST, GL_NEAREST,
@@ -1112,84 +1112,84 @@ blur_offscreen (GskGLRenderJob *job,
return 0;
if (texture_to_blur_width <= 0 || texture_to_blur_height <= 0)
- return gsk_next_driver_release_render_target (job->driver, pass1, FALSE);
+ return gsk_ngl_driver_release_render_target (job->driver, pass1, FALSE);
- if (!gsk_next_driver_create_render_target (job->driver,
+ if (!gsk_ngl_driver_create_render_target (job->driver,
texture_to_blur_width,
texture_to_blur_height,
GL_NEAREST, GL_NEAREST,
&pass2))
- return gsk_next_driver_release_render_target (job->driver, pass1, FALSE);
+ return gsk_ngl_driver_release_render_target (job->driver, pass1, FALSE);
- gsk_gl_render_job_set_viewport (job, &new_clip.bounds, &prev_viewport);
- gsk_gl_render_job_set_projection_from_rect (job, &new_clip.bounds, &prev_projection);
- gsk_gl_render_job_set_modelview (job, NULL);
- gsk_gl_render_job_push_clip (job, &new_clip);
+ gsk_ngl_render_job_set_viewport (job, &new_clip.bounds, &prev_viewport);
+ gsk_ngl_render_job_set_projection_from_rect (job, &new_clip.bounds, &prev_projection);
+ gsk_ngl_render_job_set_modelview (job, NULL);
+ gsk_ngl_render_job_push_clip (job, &new_clip);
/* Bind new framebuffer and clear it */
- prev_fbo = gsk_gl_command_queue_bind_framebuffer (job->command_queue, pass1->framebuffer_id);
- gsk_gl_command_queue_clear (job->command_queue, 0, &job->viewport);
+ prev_fbo = gsk_ngl_command_queue_bind_framebuffer (job->command_queue, pass1->framebuffer_id);
+ gsk_ngl_command_queue_clear (job->command_queue, 0, &job->viewport);
/* Begin drawing the first horizontal pass, using offscreen as the
* source texture for the program.
*/
- gsk_gl_render_job_begin_draw (job, job->driver->blur);
- gsk_gl_program_set_uniform_texture (job->driver->blur,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0,
- offscreen->texture_id);
- gsk_gl_program_set_uniform1f (job->driver->blur,
- UNIFORM_BLUR_RADIUS, 0,
- blur_radius_x);
- gsk_gl_program_set_uniform2f (job->driver->blur,
- UNIFORM_BLUR_SIZE, 0,
- texture_to_blur_width,
- texture_to_blur_height);
- gsk_gl_program_set_uniform2f (job->driver->blur,
- UNIFORM_BLUR_DIR, 0,
- 1, 0);
- gsk_gl_render_job_draw_coords (job, 0, 0, texture_to_blur_width, texture_to_blur_height);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->blur);
+ gsk_ngl_program_set_uniform_texture (job->driver->blur,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0,
+ offscreen->texture_id);
+ gsk_ngl_program_set_uniform1f (job->driver->blur,
+ UNIFORM_BLUR_RADIUS, 0,
+ blur_radius_x);
+ gsk_ngl_program_set_uniform2f (job->driver->blur,
+ UNIFORM_BLUR_SIZE, 0,
+ texture_to_blur_width,
+ texture_to_blur_height);
+ gsk_ngl_program_set_uniform2f (job->driver->blur,
+ UNIFORM_BLUR_DIR, 0,
+ 1, 0);
+ gsk_ngl_render_job_draw_coords (job, 0, 0, texture_to_blur_width, texture_to_blur_height);
+ gsk_ngl_render_job_end_draw (job);
/* Bind second pass framebuffer and clear it */
- gsk_gl_command_queue_bind_framebuffer (job->command_queue, pass2->framebuffer_id);
- gsk_gl_command_queue_clear (job->command_queue, 0, &job->viewport);
+ gsk_ngl_command_queue_bind_framebuffer (job->command_queue, pass2->framebuffer_id);
+ gsk_ngl_command_queue_clear (job->command_queue, 0, &job->viewport);
/* Draw using blur program with first pass as source texture */
- gsk_gl_render_job_begin_draw (job, job->driver->blur);
- gsk_gl_program_set_uniform_texture (job->driver->blur,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0,
- pass1->texture_id);
- gsk_gl_program_set_uniform1f (job->driver->blur,
- UNIFORM_BLUR_RADIUS, 0,
- blur_radius_y);
- gsk_gl_program_set_uniform2f (job->driver->blur,
- UNIFORM_BLUR_SIZE, 0,
- texture_to_blur_width,
- texture_to_blur_height);
- gsk_gl_program_set_uniform2f (job->driver->blur,
- UNIFORM_BLUR_DIR, 0,
- 0, 1);
- gsk_gl_render_job_draw_coords (job, 0, 0, texture_to_blur_width, texture_to_blur_height);
- gsk_gl_render_job_end_draw (job);
-
- gsk_gl_render_job_pop_modelview (job);
- gsk_gl_render_job_pop_clip (job);
- gsk_gl_render_job_set_viewport (job, &prev_viewport, NULL);
- gsk_gl_render_job_set_projection (job, &prev_projection);
- gsk_gl_command_queue_bind_framebuffer (job->command_queue, prev_fbo);
-
- gsk_next_driver_release_render_target (job->driver, pass1, TRUE);
-
- return gsk_next_driver_release_render_target (job->driver, pass2, FALSE);
+ gsk_ngl_render_job_begin_draw (job, job->driver->blur);
+ gsk_ngl_program_set_uniform_texture (job->driver->blur,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0,
+ pass1->texture_id);
+ gsk_ngl_program_set_uniform1f (job->driver->blur,
+ UNIFORM_BLUR_RADIUS, 0,
+ blur_radius_y);
+ gsk_ngl_program_set_uniform2f (job->driver->blur,
+ UNIFORM_BLUR_SIZE, 0,
+ texture_to_blur_width,
+ texture_to_blur_height);
+ gsk_ngl_program_set_uniform2f (job->driver->blur,
+ UNIFORM_BLUR_DIR, 0,
+ 0, 1);
+ gsk_ngl_render_job_draw_coords (job, 0, 0, texture_to_blur_width, texture_to_blur_height);
+ gsk_ngl_render_job_end_draw (job);
+
+ gsk_ngl_render_job_pop_modelview (job);
+ gsk_ngl_render_job_pop_clip (job);
+ gsk_ngl_render_job_set_viewport (job, &prev_viewport, NULL);
+ gsk_ngl_render_job_set_projection (job, &prev_projection);
+ gsk_ngl_command_queue_bind_framebuffer (job->command_queue, prev_fbo);
+
+ gsk_ngl_driver_release_render_target (job->driver, pass1, TRUE);
+
+ return gsk_ngl_driver_release_render_target (job->driver, pass2, FALSE);
}
static void
-blur_node (GskGLRenderJob *job,
- GskGLRenderOffscreen *offscreen,
+blur_node (GskNglRenderJob *job,
+ GskNglRenderOffscreen *offscreen,
const GskRenderNode *node,
float blur_radius,
float *min_x,
@@ -1221,7 +1221,7 @@ blur_node (GskGLRenderJob *job,
offscreen->reset_clip = TRUE;
offscreen->force_offscreen = TRUE;
- if (!gsk_gl_render_job_visit_node_with_offscreen (job, node, offscreen))
+ if (!gsk_ngl_render_job_visit_node_with_offscreen (job, node, offscreen))
g_assert_not_reached ();
/* Ensure that we actually got a real texture_id */
@@ -1243,20 +1243,20 @@ blur_node (GskGLRenderJob *job,
}
static inline void
-gsk_gl_render_job_visit_color_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_color_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
- gsk_gl_render_job_begin_draw (job, job->driver->color);
- gsk_gl_program_set_uniform_color (job->driver->color,
- UNIFORM_COLOR_COLOR, 0,
- gsk_color_node_get_color (node));
- gsk_gl_render_job_draw_rect (job, &node->bounds);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->color);
+ gsk_ngl_program_set_uniform_color (job->driver->color,
+ UNIFORM_COLOR_COLOR, 0,
+ gsk_color_node_get_color (node));
+ gsk_ngl_render_job_draw_rect (job, &node->bounds);
+ gsk_ngl_render_job_end_draw (job);
}
static inline void
-gsk_gl_render_job_visit_linear_gradient_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_linear_gradient_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
const GskColorStop *stops = gsk_linear_gradient_node_get_color_stops (node, NULL);
const graphene_point_t *start = gsk_linear_gradient_node_get_start (node);
@@ -1270,27 +1270,27 @@ gsk_gl_render_job_visit_linear_gradient_node (GskGLRenderJob *job,
g_assert (n_color_stops < MAX_GRADIENT_STOPS);
- gsk_gl_render_job_begin_draw (job, job->driver->linear_gradient);
- gsk_gl_program_set_uniform1i (job->driver->linear_gradient,
- UNIFORM_LINEAR_GRADIENT_NUM_COLOR_STOPS, 0,
- n_color_stops);
- gsk_gl_program_set_uniform1fv (job->driver->linear_gradient,
- UNIFORM_LINEAR_GRADIENT_COLOR_STOPS, 0,
- n_color_stops * 5,
- (const float *)stops);
- gsk_gl_program_set_uniform4f (job->driver->linear_gradient,
- UNIFORM_LINEAR_GRADIENT_POINTS, 0,
- x1, y1, x2 - x1, y2 - y1);
- gsk_gl_program_set_uniform1i (job->driver->linear_gradient,
- UNIFORM_LINEAR_GRADIENT_REPEAT, 0,
- repeat);
- gsk_gl_render_job_draw_rect (job, &node->bounds);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->linear_gradient);
+ gsk_ngl_program_set_uniform1i (job->driver->linear_gradient,
+ UNIFORM_LINEAR_GRADIENT_NUM_COLOR_STOPS, 0,
+ n_color_stops);
+ gsk_ngl_program_set_uniform1fv (job->driver->linear_gradient,
+ UNIFORM_LINEAR_GRADIENT_COLOR_STOPS, 0,
+ n_color_stops * 5,
+ (const float *)stops);
+ gsk_ngl_program_set_uniform4f (job->driver->linear_gradient,
+ UNIFORM_LINEAR_GRADIENT_POINTS, 0,
+ x1, y1, x2 - x1, y2 - y1);
+ gsk_ngl_program_set_uniform1i (job->driver->linear_gradient,
+ UNIFORM_LINEAR_GRADIENT_REPEAT, 0,
+ repeat);
+ gsk_ngl_render_job_draw_rect (job, &node->bounds);
+ gsk_ngl_render_job_end_draw (job);
}
static inline void
-gsk_gl_render_job_visit_conic_gradient_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_conic_gradient_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
static const float scale = 0.5f * M_1_PI;
@@ -1302,27 +1302,27 @@ gsk_gl_render_job_visit_conic_gradient_node (GskGLRenderJob *job,
g_assert (n_color_stops < MAX_GRADIENT_STOPS);
- gsk_gl_render_job_begin_draw (job, job->driver->conic_gradient);
- gsk_gl_program_set_uniform1i (job->driver->conic_gradient,
- UNIFORM_CONIC_GRADIENT_NUM_COLOR_STOPS, 0,
- n_color_stops);
- gsk_gl_program_set_uniform1fv (job->driver->conic_gradient,
- UNIFORM_CONIC_GRADIENT_COLOR_STOPS, 0,
- n_color_stops * 5,
- (const float *)stops);
- gsk_gl_program_set_uniform4f (job->driver->conic_gradient,
- UNIFORM_CONIC_GRADIENT_GEOMETRY, 0,
- job->offset_x + center->x,
- job->offset_y + center->y,
- scale,
- bias);
- gsk_gl_render_job_draw_rect (job, &node->bounds);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->conic_gradient);
+ gsk_ngl_program_set_uniform1i (job->driver->conic_gradient,
+ UNIFORM_CONIC_GRADIENT_NUM_COLOR_STOPS, 0,
+ n_color_stops);
+ gsk_ngl_program_set_uniform1fv (job->driver->conic_gradient,
+ UNIFORM_CONIC_GRADIENT_COLOR_STOPS, 0,
+ n_color_stops * 5,
+ (const float *)stops);
+ gsk_ngl_program_set_uniform4f (job->driver->conic_gradient,
+ UNIFORM_CONIC_GRADIENT_GEOMETRY, 0,
+ job->offset_x + center->x,
+ job->offset_y + center->y,
+ scale,
+ bias);
+ gsk_ngl_render_job_draw_rect (job, &node->bounds);
+ gsk_ngl_render_job_end_draw (job);
}
static inline void
-gsk_gl_render_job_visit_radial_gradient_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_radial_gradient_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
int n_color_stops = gsk_radial_gradient_node_get_n_color_stops (node);
const GskColorStop *stops = gsk_radial_gradient_node_get_color_stops (node, NULL);
@@ -1337,39 +1337,39 @@ gsk_gl_render_job_visit_radial_gradient_node (GskGLRenderJob *job,
g_assert (n_color_stops < MAX_GRADIENT_STOPS);
- gsk_gl_render_job_begin_draw (job, job->driver->radial_gradient);
- gsk_gl_program_set_uniform1i (job->driver->radial_gradient,
- UNIFORM_RADIAL_GRADIENT_NUM_COLOR_STOPS, 0,
- n_color_stops);
- gsk_gl_program_set_uniform1fv (job->driver->radial_gradient,
- UNIFORM_RADIAL_GRADIENT_COLOR_STOPS, 0,
- n_color_stops * 5,
- (const float *)stops);
- gsk_gl_program_set_uniform1i (job->driver->radial_gradient,
- UNIFORM_RADIAL_GRADIENT_REPEAT, 0,
- repeat);
- gsk_gl_program_set_uniform2f (job->driver->radial_gradient,
- UNIFORM_RADIAL_GRADIENT_RANGE, 0,
- scale, bias);
- gsk_gl_program_set_uniform4f (job->driver->radial_gradient,
- UNIFORM_RADIAL_GRADIENT_GEOMETRY, 0,
- job->offset_x + center->x,
- job->offset_y + center->y,
- 1.0f / (hradius * job->scale_x),
- 1.0f / (vradius * job->scale_y));
- gsk_gl_render_job_draw_rect (job, &node->bounds);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->radial_gradient);
+ gsk_ngl_program_set_uniform1i (job->driver->radial_gradient,
+ UNIFORM_RADIAL_GRADIENT_NUM_COLOR_STOPS, 0,
+ n_color_stops);
+ gsk_ngl_program_set_uniform1fv (job->driver->radial_gradient,
+ UNIFORM_RADIAL_GRADIENT_COLOR_STOPS, 0,
+ n_color_stops * 5,
+ (const float *)stops);
+ gsk_ngl_program_set_uniform1i (job->driver->radial_gradient,
+ UNIFORM_RADIAL_GRADIENT_REPEAT, 0,
+ repeat);
+ gsk_ngl_program_set_uniform2f (job->driver->radial_gradient,
+ UNIFORM_RADIAL_GRADIENT_RANGE, 0,
+ scale, bias);
+ gsk_ngl_program_set_uniform4f (job->driver->radial_gradient,
+ UNIFORM_RADIAL_GRADIENT_GEOMETRY, 0,
+ job->offset_x + center->x,
+ job->offset_y + center->y,
+ 1.0f / (hradius * job->scale_x),
+ 1.0f / (vradius * job->scale_y));
+ gsk_ngl_render_job_draw_rect (job, &node->bounds);
+ gsk_ngl_render_job_end_draw (job);
}
static inline void
-gsk_gl_render_job_visit_clipped_child (GskGLRenderJob *job,
- const GskRenderNode *child,
- const graphene_rect_t *clip)
+gsk_ngl_render_job_visit_clipped_child (GskNglRenderJob *job,
+ const GskRenderNode *child,
+ const graphene_rect_t *clip)
{
graphene_rect_t transformed_clip;
GskRoundedRect intersection;
- gsk_gl_render_job_transform_bounds (job, clip, &transformed_clip);
+ gsk_ngl_render_job_transform_bounds (job, clip, &transformed_clip);
if (job->current_clip->is_rectilinear)
{
@@ -1378,22 +1378,22 @@ gsk_gl_render_job_visit_clipped_child (GskGLRenderJob *job,
&job->current_clip->rect.bounds,
&intersection.bounds);
- gsk_gl_render_job_push_clip (job, &intersection);
- gsk_gl_render_job_visit_node (job, child);
- gsk_gl_render_job_pop_clip (job);
+ gsk_ngl_render_job_push_clip (job, &intersection);
+ gsk_ngl_render_job_visit_node (job, child);
+ gsk_ngl_render_job_pop_clip (job);
}
else if (intersect_rounded_rectilinear (&transformed_clip,
&job->current_clip->rect,
&intersection))
{
- gsk_gl_render_job_push_clip (job, &intersection);
- gsk_gl_render_job_visit_node (job, child);
- gsk_gl_render_job_pop_clip (job);
+ gsk_ngl_render_job_push_clip (job, &intersection);
+ gsk_ngl_render_job_visit_node (job, child);
+ gsk_ngl_render_job_pop_clip (job);
}
else
{
GskRoundedRect scaled_clip;
- GskGLRenderOffscreen offscreen = {0};
+ GskNglRenderOffscreen offscreen = {0};
offscreen.bounds = &child->bounds;
offscreen.force_offscreen = TRUE;
@@ -1403,36 +1403,36 @@ gsk_gl_render_job_visit_clipped_child (GskGLRenderJob *job,
clip->size.width * job->scale_x,
clip->size.height * job->scale_y);
- gsk_gl_render_job_push_clip (job, &scaled_clip);
- gsk_gl_render_job_visit_node_with_offscreen (job, child, &offscreen);
- gsk_gl_render_job_pop_clip (job);
+ gsk_ngl_render_job_push_clip (job, &scaled_clip);
+ gsk_ngl_render_job_visit_node_with_offscreen (job, child, &offscreen);
+ gsk_ngl_render_job_pop_clip (job);
g_assert (offscreen.texture_id);
- gsk_gl_render_job_begin_draw (job, job->driver->blit);
- gsk_gl_program_set_uniform_texture (job->driver->blit,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0,
- offscreen.texture_id);
- gsk_gl_render_job_draw_offscreen_rect (job, &child->bounds);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->blit);
+ gsk_ngl_program_set_uniform_texture (job->driver->blit,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0,
+ offscreen.texture_id);
+ gsk_ngl_render_job_draw_offscreen_rect (job, &child->bounds);
+ gsk_ngl_render_job_end_draw (job);
}
}
static inline void
-gsk_gl_render_job_visit_clip_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_clip_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
const graphene_rect_t *clip = gsk_clip_node_get_clip (node);
const GskRenderNode *child = gsk_clip_node_get_child (node);
- gsk_gl_render_job_visit_clipped_child (job, child, clip);
+ gsk_ngl_render_job_visit_clipped_child (job, child, clip);
}
static inline void
-gsk_gl_render_job_visit_rounded_clip_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_rounded_clip_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
const GskRenderNode *child = gsk_rounded_clip_node_get_child (node);
const GskRoundedRect *clip = gsk_rounded_clip_node_get_clip (node);
@@ -1444,7 +1444,7 @@ gsk_gl_render_job_visit_rounded_clip_node (GskGLRenderJob *job,
if (node_is_invisible (child))
return;
- gsk_gl_render_job_transform_bounds (job, &clip->bounds, &transformed_clip.bounds);
+ gsk_ngl_render_job_transform_bounds (job, &clip->bounds, &transformed_clip.bounds);
for (guint i = 0; i < G_N_ELEMENTS (transformed_clip.corner); i++)
{
@@ -1460,9 +1460,9 @@ gsk_gl_render_job_visit_rounded_clip_node (GskGLRenderJob *job,
&transformed_clip,
&intersected_clip))
{
- gsk_gl_render_job_push_clip (job, &intersected_clip);
- gsk_gl_render_job_visit_node (job, child);
- gsk_gl_render_job_pop_clip (job);
+ gsk_ngl_render_job_push_clip (job, &intersected_clip);
+ gsk_ngl_render_job_visit_node (job, child);
+ gsk_ngl_render_job_pop_clip (job);
return;
}
}
@@ -1485,36 +1485,36 @@ gsk_gl_render_job_visit_rounded_clip_node (GskGLRenderJob *job,
*/
if (rounded_inner_rect_contains_rect (&transformed_clip, &job->current_clip->rect.bounds))
{
- gsk_gl_render_job_visit_node (job, child);
+ gsk_ngl_render_job_visit_node (job, child);
return;
}
- gsk_gl_render_job_push_clip (job, &transformed_clip);
- gsk_gl_render_job_visit_node (job, child);
- gsk_gl_render_job_pop_clip (job);
+ gsk_ngl_render_job_push_clip (job, &transformed_clip);
+ gsk_ngl_render_job_visit_node (job, child);
+ gsk_ngl_render_job_pop_clip (job);
}
else
{
- GskGLRenderOffscreen offscreen = {0};
+ GskNglRenderOffscreen offscreen = {0};
offscreen.bounds = &node->bounds;
offscreen.force_offscreen = TRUE;
- gsk_gl_render_job_push_clip (job, &transformed_clip);
- if (!gsk_gl_render_job_visit_node_with_offscreen (job, child, &offscreen))
+ gsk_ngl_render_job_push_clip (job, &transformed_clip);
+ if (!gsk_ngl_render_job_visit_node_with_offscreen (job, child, &offscreen))
g_assert_not_reached ();
- gsk_gl_render_job_pop_clip (job);
+ gsk_ngl_render_job_pop_clip (job);
g_assert (offscreen.texture_id);
- gsk_gl_render_job_begin_draw (job, job->driver->blit);
- gsk_gl_program_set_uniform_texture (job->driver->blit,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0,
- offscreen.texture_id);
- gsk_gl_render_job_load_vertices_from_offscreen (job, &node->bounds, &offscreen);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->blit);
+ gsk_ngl_program_set_uniform_texture (job->driver->blit,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0,
+ offscreen.texture_id);
+ gsk_ngl_render_job_load_vertices_from_offscreen (job, &node->bounds, &offscreen);
+ gsk_ngl_render_job_end_draw (job);
}
}
@@ -1550,36 +1550,36 @@ sort_border_sides (const GdkRGBA *colors,
}
static inline void
-gsk_gl_render_job_visit_uniform_border_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_uniform_border_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
const GskRoundedRect *rounded_outline = gsk_border_node_get_outline (node);
const GdkRGBA *colors = gsk_border_node_get_colors (node);
const float *widths = gsk_border_node_get_widths (node);
GskRoundedRect outline;
- gsk_gl_render_job_transform_rounded_rect (job, rounded_outline, &outline);
-
- gsk_gl_render_job_begin_draw (job, job->driver->inset_shadow);
- gsk_gl_program_set_uniform_rounded_rect (job->driver->inset_shadow,
- UNIFORM_INSET_SHADOW_OUTLINE_RECT, 0,
- &outline);
- gsk_gl_program_set_uniform_color (job->driver->inset_shadow,
- UNIFORM_INSET_SHADOW_COLOR, 0,
- &colors[0]);
- gsk_gl_program_set_uniform1f (job->driver->inset_shadow,
- UNIFORM_INSET_SHADOW_SPREAD, 0,
- widths[0]);
- gsk_gl_program_set_uniform2f (job->driver->inset_shadow,
- UNIFORM_INSET_SHADOW_OFFSET, 0,
- 0, 0);
- gsk_gl_render_job_draw_rect (job, &node->bounds);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_transform_rounded_rect (job, rounded_outline, &outline);
+
+ gsk_ngl_render_job_begin_draw (job, job->driver->inset_shadow);
+ gsk_ngl_program_set_uniform_rounded_rect (job->driver->inset_shadow,
+ UNIFORM_INSET_SHADOW_OUTLINE_RECT, 0,
+ &outline);
+ gsk_ngl_program_set_uniform_color (job->driver->inset_shadow,
+ UNIFORM_INSET_SHADOW_COLOR, 0,
+ &colors[0]);
+ gsk_ngl_program_set_uniform1f (job->driver->inset_shadow,
+ UNIFORM_INSET_SHADOW_SPREAD, 0,
+ widths[0]);
+ gsk_ngl_program_set_uniform2f (job->driver->inset_shadow,
+ UNIFORM_INSET_SHADOW_OFFSET, 0,
+ 0, 0);
+ gsk_ngl_render_job_draw_rect (job, &node->bounds);
+ gsk_ngl_render_job_end_draw (job);
}
static inline void
-gsk_gl_render_job_visit_border_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_border_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
const GskRoundedRect *rounded_outline = gsk_border_node_get_outline (node);
const GdkRGBA *colors = gsk_border_node_get_colors (node);
@@ -1639,7 +1639,7 @@ gsk_gl_render_job_visit_border_node (GskGLRenderJob *job,
float min_y = job->offset_y + node->bounds.origin.y;
float max_x = min_x + node->bounds.size.width;
float max_y = min_y + node->bounds.size.height;
- const GskGLDrawVertex side_data[4][6] = {
+ const GskNglDrawVertex side_data[4][6] = {
/* Top */
{
{ { min_x, min_y }, { 0, 1 }, }, /* Upper left */
@@ -1688,31 +1688,31 @@ gsk_gl_render_job_visit_border_node (GskGLRenderJob *job,
sort_border_sides (colors, indices);
/* Prepare outline */
- gsk_gl_render_job_transform_rounded_rect (job, rounded_outline, &outline);
+ gsk_ngl_render_job_transform_rounded_rect (job, rounded_outline, &outline);
- gsk_gl_program_set_uniform4fv (job->driver->border,
- UNIFORM_BORDER_WIDTHS, 0,
- 1,
- widths);
- gsk_gl_program_set_uniform_rounded_rect (job->driver->border,
- UNIFORM_BORDER_OUTLINE_RECT, 0,
- &outline);
+ gsk_ngl_program_set_uniform4fv (job->driver->border,
+ UNIFORM_BORDER_WIDTHS, 0,
+ 1,
+ widths);
+ gsk_ngl_program_set_uniform_rounded_rect (job->driver->border,
+ UNIFORM_BORDER_OUTLINE_RECT, 0,
+ &outline);
for (guint i = 0; i < 4; i++)
{
- GskGLDrawVertex *vertices;
+ GskNglDrawVertex *vertices;
if (widths[indices[i]] <= 0)
continue;
- gsk_gl_render_job_begin_draw (job, job->driver->border);
- gsk_gl_program_set_uniform4fv (job->driver->border,
- UNIFORM_BORDER_COLOR, 0,
- 1,
- (const float *)&colors[indices[i]]);
- vertices = gsk_gl_command_queue_add_vertices (job->command_queue);
- memcpy (vertices, side_data[indices[i]], sizeof (GskGLDrawVertex) * GSK_GL_N_VERTICES);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->border);
+ gsk_ngl_program_set_uniform4fv (job->driver->border,
+ UNIFORM_BORDER_COLOR, 0,
+ 1,
+ (const float *)&colors[indices[i]]);
+ vertices = gsk_ngl_command_queue_add_vertices (job->command_queue);
+ memcpy (vertices, side_data[indices[i]], sizeof (GskNglDrawVertex) * GSK_NGL_N_VERTICES);
+ gsk_ngl_render_job_end_draw (job);
}
}
}
@@ -1749,8 +1749,8 @@ result_is_axis_aligned (GskTransform *transform,
}
static inline void
-gsk_gl_render_job_visit_transform_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_transform_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
GskTransform *transform = gsk_transform_node_get_transform (node);
const GskTransformCategory category = gsk_transform_get_category (transform);
@@ -1759,7 +1759,7 @@ gsk_gl_render_job_visit_transform_node (GskGLRenderJob *job,
switch (category)
{
case GSK_TRANSFORM_CATEGORY_IDENTITY:
- gsk_gl_render_job_visit_node (job, child);
+ gsk_ngl_render_job_visit_node (job, child);
break;
case GSK_TRANSFORM_CATEGORY_2D_TRANSLATE:
@@ -1767,17 +1767,17 @@ gsk_gl_render_job_visit_transform_node (GskGLRenderJob *job,
float dx, dy;
gsk_transform_to_translate (transform, &dx, &dy);
- gsk_gl_render_job_offset (job, dx, dy);
- gsk_gl_render_job_visit_node (job, child);
- gsk_gl_render_job_offset (job, -dx, -dy);
+ gsk_ngl_render_job_offset (job, dx, dy);
+ gsk_ngl_render_job_visit_node (job, child);
+ gsk_ngl_render_job_offset (job, -dx, -dy);
}
break;
case GSK_TRANSFORM_CATEGORY_2D_AFFINE:
{
- gsk_gl_render_job_push_modelview (job, transform);
- gsk_gl_render_job_visit_node (job, child);
- gsk_gl_render_job_pop_modelview (job);
+ gsk_ngl_render_job_push_modelview (job, transform);
+ gsk_ngl_render_job_visit_node (job, child);
+ gsk_ngl_render_job_pop_modelview (job);
}
break;
@@ -1787,13 +1787,13 @@ gsk_gl_render_job_visit_transform_node (GskGLRenderJob *job,
case GSK_TRANSFORM_CATEGORY_UNKNOWN:
if (node_supports_transform (child))
{
- gsk_gl_render_job_push_modelview (job, transform);
- gsk_gl_render_job_visit_node (job, child);
- gsk_gl_render_job_pop_modelview (job);
+ gsk_ngl_render_job_push_modelview (job, transform);
+ gsk_ngl_render_job_visit_node (job, child);
+ gsk_ngl_render_job_pop_modelview (job);
}
else
{
- GskGLRenderOffscreen offscreen = {0};
+ GskNglRenderOffscreen offscreen = {0};
offscreen.bounds = &child->bounds;
offscreen.reset_clip = TRUE;
@@ -1801,7 +1801,7 @@ gsk_gl_render_job_visit_transform_node (GskGLRenderJob *job,
if (!result_is_axis_aligned (transform, &child->bounds))
offscreen.linear_filter = TRUE;
- if (gsk_gl_render_job_visit_node_with_offscreen (job, child, &offscreen))
+ if (gsk_ngl_render_job_visit_node_with_offscreen (job, child, &offscreen))
{
/* For non-trivial transforms, we draw everything on a texture and then
* draw the texture transformed. */
@@ -1809,18 +1809,18 @@ gsk_gl_render_job_visit_transform_node (GskGLRenderJob *job,
* part (e.g. the rotation) and use that. We want to keep the scale
* for the texture.
*/
- gsk_gl_render_job_push_modelview (job, transform);
-
- gsk_gl_render_job_begin_draw (job, job->driver->blit);
- gsk_gl_program_set_uniform_texture (job->driver->blit,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0,
- offscreen.texture_id);
- gsk_gl_render_job_load_vertices_from_offscreen (job, &child->bounds, &offscreen);
- gsk_gl_render_job_end_draw (job);
-
- gsk_gl_render_job_pop_modelview (job);
+ gsk_ngl_render_job_push_modelview (job, transform);
+
+ gsk_ngl_render_job_begin_draw (job, job->driver->blit);
+ gsk_ngl_program_set_uniform_texture (job->driver->blit,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0,
+ offscreen.texture_id);
+ gsk_ngl_render_job_load_vertices_from_offscreen (job, &child->bounds, &offscreen);
+ gsk_ngl_render_job_end_draw (job);
+
+ gsk_ngl_render_job_pop_modelview (job);
}
}
break;
@@ -1831,35 +1831,35 @@ gsk_gl_render_job_visit_transform_node (GskGLRenderJob *job,
}
static inline void
-gsk_gl_render_job_visit_unblurred_inset_shadow_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_unblurred_inset_shadow_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
const GskRoundedRect *outline = gsk_inset_shadow_node_get_outline (node);
GskRoundedRect transformed_outline;
- gsk_gl_render_job_transform_rounded_rect (job, outline, &transformed_outline);
-
- gsk_gl_render_job_begin_draw (job, job->driver->inset_shadow);
- gsk_gl_program_set_uniform_rounded_rect (job->driver->inset_shadow,
- UNIFORM_INSET_SHADOW_OUTLINE_RECT, 0,
- &transformed_outline);
- gsk_gl_program_set_uniform_color (job->driver->inset_shadow,
- UNIFORM_INSET_SHADOW_COLOR, 0,
- gsk_inset_shadow_node_get_color (node));
- gsk_gl_program_set_uniform1f (job->driver->inset_shadow,
- UNIFORM_INSET_SHADOW_SPREAD, 0,
- gsk_inset_shadow_node_get_spread (node));
- gsk_gl_program_set_uniform2f (job->driver->inset_shadow,
- UNIFORM_INSET_SHADOW_OFFSET, 0,
- gsk_inset_shadow_node_get_dx (node),
- gsk_inset_shadow_node_get_dy (node));
- gsk_gl_render_job_draw_rect (job, &node->bounds);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_transform_rounded_rect (job, outline, &transformed_outline);
+
+ gsk_ngl_render_job_begin_draw (job, job->driver->inset_shadow);
+ gsk_ngl_program_set_uniform_rounded_rect (job->driver->inset_shadow,
+ UNIFORM_INSET_SHADOW_OUTLINE_RECT, 0,
+ &transformed_outline);
+ gsk_ngl_program_set_uniform_color (job->driver->inset_shadow,
+ UNIFORM_INSET_SHADOW_COLOR, 0,
+ gsk_inset_shadow_node_get_color (node));
+ gsk_ngl_program_set_uniform1f (job->driver->inset_shadow,
+ UNIFORM_INSET_SHADOW_SPREAD, 0,
+ gsk_inset_shadow_node_get_spread (node));
+ gsk_ngl_program_set_uniform2f (job->driver->inset_shadow,
+ UNIFORM_INSET_SHADOW_OFFSET, 0,
+ gsk_inset_shadow_node_get_dx (node),
+ gsk_inset_shadow_node_get_dy (node));
+ gsk_ngl_render_job_draw_rect (job, &node->bounds);
+ gsk_ngl_render_job_end_draw (job);
}
static inline void
-gsk_gl_render_job_visit_blurred_inset_shadow_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_blurred_inset_shadow_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
const GskRoundedRect *node_outline = gsk_inset_shadow_node_get_outline (node);
float blur_radius = gsk_inset_shadow_node_get_blur_radius (node);
@@ -1873,7 +1873,7 @@ gsk_gl_render_job_visit_blurred_inset_shadow_node (GskGLRenderJob *job,
float texture_height;
int blurred_texture_id;
GskTextureKey key;
- GskGLRenderOffscreen offscreen = {0};
+ GskNglRenderOffscreen offscreen = {0};
g_assert (blur_radius > 0);
@@ -1886,14 +1886,14 @@ gsk_gl_render_job_visit_blurred_inset_shadow_node (GskGLRenderJob *job,
key.scale_y = scale_y;
key.filter = GL_NEAREST;
- blurred_texture_id = gsk_next_driver_lookup_texture (job->driver, &key);
+ blurred_texture_id = gsk_ngl_driver_lookup_texture (job->driver, &key);
if (blurred_texture_id == 0)
{
float spread = gsk_inset_shadow_node_get_spread (node) + half_blur_extra;
GskRoundedRect transformed_outline;
GskRoundedRect outline_to_blur;
- GskGLRenderTarget *render_target;
+ GskNglRenderTarget *render_target;
graphene_matrix_t prev_projection;
graphene_rect_t prev_viewport;
guint prev_fbo;
@@ -1925,45 +1925,45 @@ gsk_gl_render_job_visit_blurred_inset_shadow_node (GskGLRenderJob *job,
outline_to_blur.corner[i].height *= scale_y;
}
- if (!gsk_next_driver_create_render_target (job->driver,
+ if (!gsk_ngl_driver_create_render_target (job->driver,
texture_width, texture_height,
GL_NEAREST, GL_NEAREST,
&render_target))
g_assert_not_reached ();
- gsk_gl_render_job_set_viewport_for_size (job, texture_width, texture_height, &prev_viewport);
- gsk_gl_render_job_set_projection_for_size (job, texture_width, texture_height, &prev_projection);
- gsk_gl_render_job_set_modelview (job, NULL);
- gsk_gl_render_job_push_clip (job, &GSK_ROUNDED_RECT_INIT (0, 0, texture_width, texture_height));
+ gsk_ngl_render_job_set_viewport_for_size (job, texture_width, texture_height, &prev_viewport);
+ gsk_ngl_render_job_set_projection_for_size (job, texture_width, texture_height, &prev_projection);
+ gsk_ngl_render_job_set_modelview (job, NULL);
+ gsk_ngl_render_job_push_clip (job, &GSK_ROUNDED_RECT_INIT (0, 0, texture_width, texture_height));
- prev_fbo = gsk_gl_command_queue_bind_framebuffer (job->command_queue, render_target->framebuffer_id);
- gsk_gl_command_queue_clear (job->command_queue, 0, &job->viewport);
+ prev_fbo = gsk_ngl_command_queue_bind_framebuffer (job->command_queue, render_target->framebuffer_id);
+ gsk_ngl_command_queue_clear (job->command_queue, 0, &job->viewport);
- gsk_gl_render_job_transform_rounded_rect (job, &outline_to_blur, &transformed_outline);
+ gsk_ngl_render_job_transform_rounded_rect (job, &outline_to_blur, &transformed_outline);
/* Actual inset shadow outline drawing */
- gsk_gl_render_job_begin_draw (job, job->driver->inset_shadow);
- gsk_gl_program_set_uniform_rounded_rect (job->driver->inset_shadow,
- UNIFORM_INSET_SHADOW_OUTLINE_RECT, 0,
- &transformed_outline);
- gsk_gl_program_set_uniform_color (job->driver->inset_shadow,
- UNIFORM_INSET_SHADOW_COLOR, 0,
- gsk_inset_shadow_node_get_color (node));
- gsk_gl_program_set_uniform1f (job->driver->inset_shadow,
- UNIFORM_INSET_SHADOW_SPREAD, 0,
- spread * MAX (scale_x, scale_y));
- gsk_gl_program_set_uniform2f (job->driver->inset_shadow,
- UNIFORM_INSET_SHADOW_OFFSET, 0,
- offset_x * scale_x,
- offset_y * scale_y);
- gsk_gl_render_job_draw (job, 0, 0, texture_width, texture_height);
- gsk_gl_render_job_end_draw (job);
-
- gsk_gl_render_job_pop_modelview (job);
- gsk_gl_render_job_pop_clip (job);
- gsk_gl_render_job_set_projection (job, &prev_projection);
- gsk_gl_render_job_set_viewport (job, &prev_viewport, NULL);
- gsk_gl_command_queue_bind_framebuffer (job->command_queue, prev_fbo);
+ gsk_ngl_render_job_begin_draw (job, job->driver->inset_shadow);
+ gsk_ngl_program_set_uniform_rounded_rect (job->driver->inset_shadow,
+ UNIFORM_INSET_SHADOW_OUTLINE_RECT, 0,
+ &transformed_outline);
+ gsk_ngl_program_set_uniform_color (job->driver->inset_shadow,
+ UNIFORM_INSET_SHADOW_COLOR, 0,
+ gsk_inset_shadow_node_get_color (node));
+ gsk_ngl_program_set_uniform1f (job->driver->inset_shadow,
+ UNIFORM_INSET_SHADOW_SPREAD, 0,
+ spread * MAX (scale_x, scale_y));
+ gsk_ngl_program_set_uniform2f (job->driver->inset_shadow,
+ UNIFORM_INSET_SHADOW_OFFSET, 0,
+ offset_x * scale_x,
+ offset_y * scale_y);
+ gsk_ngl_render_job_draw (job, 0, 0, texture_width, texture_height);
+ gsk_ngl_render_job_end_draw (job);
+
+ gsk_ngl_render_job_pop_modelview (job);
+ gsk_ngl_render_job_pop_clip (job);
+ gsk_ngl_render_job_set_projection (job, &prev_projection);
+ gsk_ngl_render_job_set_viewport (job, &prev_viewport, NULL);
+ gsk_ngl_command_queue_bind_framebuffer (job->command_queue, prev_fbo);
offscreen.texture_id = render_target->texture_id;
init_full_texture_region (&offscreen);
@@ -1975,9 +1975,9 @@ gsk_gl_render_job_visit_blurred_inset_shadow_node (GskGLRenderJob *job,
blur_radius * scale_x,
blur_radius * scale_y);
- gsk_next_driver_release_render_target (job->driver, render_target, TRUE);
+ gsk_ngl_driver_release_render_target (job->driver, render_target, TRUE);
- gsk_next_driver_cache_texture (job->driver, &key, blurred_texture_id);
+ gsk_ngl_driver_cache_texture (job->driver, &key, blurred_texture_id);
}
g_assert (blurred_texture_id != 0);
@@ -1995,7 +1995,7 @@ gsk_gl_render_job_visit_blurred_inset_shadow_node (GskGLRenderJob *job,
{
GskRoundedRect node_clip;
- gsk_gl_render_job_transform_bounds (job, &node_outline->bounds, &node_clip.bounds);
+ gsk_ngl_render_job_transform_bounds (job, &node_outline->bounds, &node_clip.bounds);
for (guint i = 0; i < 4; i ++)
{
@@ -2003,7 +2003,7 @@ gsk_gl_render_job_visit_blurred_inset_shadow_node (GskGLRenderJob *job,
node_clip.corner[i].height = node_outline->corner[i].height * scale_y;
}
- gsk_gl_render_job_push_clip (job, &node_clip);
+ gsk_ngl_render_job_push_clip (job, &node_clip);
}
offscreen.was_offscreen = TRUE;
@@ -2012,23 +2012,23 @@ gsk_gl_render_job_visit_blurred_inset_shadow_node (GskGLRenderJob *job,
offscreen.area.x2 = tx2;
offscreen.area.y2 = ty2;
- gsk_gl_render_job_begin_draw (job, job->driver->blit);
- gsk_gl_program_set_uniform_texture (job->driver->blit,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0,
- blurred_texture_id);
- gsk_gl_render_job_load_vertices_from_offscreen (job, &node->bounds, &offscreen);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->blit);
+ gsk_ngl_program_set_uniform_texture (job->driver->blit,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0,
+ blurred_texture_id);
+ gsk_ngl_render_job_load_vertices_from_offscreen (job, &node->bounds, &offscreen);
+ gsk_ngl_render_job_end_draw (job);
if (needs_clip)
- gsk_gl_render_job_pop_clip (job);
+ gsk_ngl_render_job_pop_clip (job);
}
}
static inline void
-gsk_gl_render_job_visit_unblurred_outset_shadow_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_unblurred_outset_shadow_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
const GskRoundedRect *outline = gsk_outset_shadow_node_get_outline (node);
GskRoundedRect transformed_outline;
@@ -2049,63 +2049,63 @@ gsk_gl_render_job_visit_unblurred_outset_shadow_node (GskGLRenderJob *job,
{ outline->corner[3].width + spread - dx, outline->corner[3].height + spread + dy },
};
- gsk_gl_render_job_transform_rounded_rect (job, outline, &transformed_outline);
-
- gsk_gl_render_job_begin_draw (job, job->driver->unblurred_outset_shadow);
- gsk_gl_program_set_uniform_rounded_rect (job->driver->unblurred_outset_shadow,
- UNIFORM_UNBLURRED_OUTSET_SHADOW_OUTLINE_RECT, 0,
- &transformed_outline);
- gsk_gl_program_set_uniform_color (job->driver->unblurred_outset_shadow,
- UNIFORM_UNBLURRED_OUTSET_SHADOW_COLOR, 0,
- gsk_outset_shadow_node_get_color (node));
- gsk_gl_program_set_uniform1f (job->driver->unblurred_outset_shadow,
- UNIFORM_UNBLURRED_OUTSET_SHADOW_SPREAD, 0,
- spread);
- gsk_gl_program_set_uniform2f (job->driver->unblurred_outset_shadow,
- UNIFORM_UNBLURRED_OUTSET_SHADOW_OFFSET, 0,
- dx, dy);
+ gsk_ngl_render_job_transform_rounded_rect (job, outline, &transformed_outline);
+
+ gsk_ngl_render_job_begin_draw (job, job->driver->unblurred_outset_shadow);
+ gsk_ngl_program_set_uniform_rounded_rect (job->driver->unblurred_outset_shadow,
+ UNIFORM_UNBLURRED_OUTSET_SHADOW_OUTLINE_RECT, 0,
+ &transformed_outline);
+ gsk_ngl_program_set_uniform_color (job->driver->unblurred_outset_shadow,
+ UNIFORM_UNBLURRED_OUTSET_SHADOW_COLOR, 0,
+ gsk_outset_shadow_node_get_color (node));
+ gsk_ngl_program_set_uniform1f (job->driver->unblurred_outset_shadow,
+ UNIFORM_UNBLURRED_OUTSET_SHADOW_SPREAD, 0,
+ spread);
+ gsk_ngl_program_set_uniform2f (job->driver->unblurred_outset_shadow,
+ UNIFORM_UNBLURRED_OUTSET_SHADOW_OFFSET, 0,
+ dx, dy);
/* Corners... */
if (corner_sizes[0][0] > 0 && corner_sizes[0][1] > 0) /* Top left */
- gsk_gl_render_job_draw (job,
- x, y,
- corner_sizes[0][0], corner_sizes[0][1]);
+ gsk_ngl_render_job_draw (job,
+ x, y,
+ corner_sizes[0][0], corner_sizes[0][1]);
if (corner_sizes[1][0] > 0 && corner_sizes[1][1] > 0) /* Top right */
- gsk_gl_render_job_draw (job,
- x + w - corner_sizes[1][0], y,
- corner_sizes[1][0], corner_sizes[1][1]);
+ gsk_ngl_render_job_draw (job,
+ x + w - corner_sizes[1][0], y,
+ corner_sizes[1][0], corner_sizes[1][1]);
if (corner_sizes[2][0] > 0 && corner_sizes[2][1] > 0) /* Bottom right */
- gsk_gl_render_job_draw (job,
- x + w - corner_sizes[2][0], y + h - corner_sizes[2][1],
- corner_sizes[2][0], corner_sizes[2][1]);
+ gsk_ngl_render_job_draw (job,
+ x + w - corner_sizes[2][0], y + h - corner_sizes[2][1],
+ corner_sizes[2][0], corner_sizes[2][1]);
if (corner_sizes[3][0] > 0 && corner_sizes[3][1] > 0) /* Bottom left */
- gsk_gl_render_job_draw (job,
- x, y + h - corner_sizes[3][1],
- corner_sizes[3][0], corner_sizes[3][1]);
+ gsk_ngl_render_job_draw (job,
+ x, y + h - corner_sizes[3][1],
+ corner_sizes[3][0], corner_sizes[3][1]);
/* Edges... */;
if (edge_sizes[0] > 0) /* Top */
- gsk_gl_render_job_draw (job,
- x + corner_sizes[0][0], y,
- w - corner_sizes[0][0] - corner_sizes[1][0], edge_sizes[0]);
+ gsk_ngl_render_job_draw (job,
+ x + corner_sizes[0][0], y,
+ w - corner_sizes[0][0] - corner_sizes[1][0], edge_sizes[0]);
if (edge_sizes[1] > 0) /* Right */
- gsk_gl_render_job_draw (job,
- x + w - edge_sizes[1], y + corner_sizes[1][1],
- edge_sizes[1], h - corner_sizes[1][1] - corner_sizes[2][1]);
+ gsk_ngl_render_job_draw (job,
+ x + w - edge_sizes[1], y + corner_sizes[1][1],
+ edge_sizes[1], h - corner_sizes[1][1] - corner_sizes[2][1]);
if (edge_sizes[2] > 0) /* Bottom */
- gsk_gl_render_job_draw (job,
- x + corner_sizes[3][0], y + h - edge_sizes[2],
- w - corner_sizes[3][0] - corner_sizes[2][0], edge_sizes[2]);
+ gsk_ngl_render_job_draw (job,
+ x + corner_sizes[3][0], y + h - edge_sizes[2],
+ w - corner_sizes[3][0] - corner_sizes[2][0], edge_sizes[2]);
if (edge_sizes[3] > 0) /* Left */
- gsk_gl_render_job_draw (job,
- x, y + corner_sizes[0][1],
- edge_sizes[3], h - corner_sizes[0][1] - corner_sizes[3][1]);
+ gsk_ngl_render_job_draw (job,
+ x, y + corner_sizes[0][1],
+ edge_sizes[3], h - corner_sizes[0][1] - corner_sizes[3][1]);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_end_draw (job);
}
static inline void
-gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_blurred_outset_shadow_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
static const GdkRGBA white = { 1, 1, 1, 1 };
@@ -2122,7 +2122,7 @@ gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob *job,
float dy = gsk_outset_shadow_node_get_dy (node);
GskRoundedRect scaled_outline;
GskRoundedRect transformed_outline;
- GskGLRenderOffscreen offscreen = {0};
+ GskNglRenderOffscreen offscreen = {0};
int texture_width, texture_height;
int blurred_texture_id;
int cached_tid;
@@ -2167,20 +2167,20 @@ gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob *job,
scaled_outline.corner[i].height *= scale_y;
}
- cached_tid = gsk_gl_shadow_library_lookup (job->driver->shadows, &scaled_outline, blur_radius);
+ cached_tid = gsk_ngl_shadow_library_lookup (job->driver->shadows, &scaled_outline, blur_radius);
if (cached_tid == 0)
{
GdkGLContext *context = job->command_queue->context;
- GskGLRenderTarget *render_target;
+ GskNglRenderTarget *render_target;
graphene_matrix_t prev_projection;
graphene_rect_t prev_viewport;
guint prev_fbo;
- gsk_next_driver_create_render_target (job->driver,
- texture_width, texture_height,
- GL_NEAREST, GL_NEAREST,
- &render_target);
+ gsk_ngl_driver_create_render_target (job->driver,
+ texture_width, texture_height,
+ GL_NEAREST, GL_NEAREST,
+ &render_target);
if (gdk_gl_context_has_debug (context))
{
@@ -2197,32 +2197,32 @@ gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob *job,
}
/* Change state for offscreen */
- gsk_gl_render_job_set_projection_for_size (job, texture_width, texture_height, &prev_projection);
- gsk_gl_render_job_set_viewport_for_size (job, texture_width, texture_height, &prev_viewport);
- gsk_gl_render_job_set_modelview (job, NULL);
- gsk_gl_render_job_push_clip (job, &scaled_outline);
+ gsk_ngl_render_job_set_projection_for_size (job, texture_width, texture_height, &prev_projection);
+ gsk_ngl_render_job_set_viewport_for_size (job, texture_width, texture_height, &prev_viewport);
+ gsk_ngl_render_job_set_modelview (job, NULL);
+ gsk_ngl_render_job_push_clip (job, &scaled_outline);
/* Bind render target and clear it */
- prev_fbo = gsk_gl_command_queue_bind_framebuffer (job->command_queue, render_target->framebuffer_id);
- gsk_gl_command_queue_clear (job->command_queue, 0, &job->viewport);
+ prev_fbo = gsk_ngl_command_queue_bind_framebuffer (job->command_queue, render_target->framebuffer_id);
+ gsk_ngl_command_queue_clear (job->command_queue, 0, &job->viewport);
/* Draw the outline using color program */
- gsk_gl_render_job_begin_draw (job, job->driver->color);
- gsk_gl_program_set_uniform_color (job->driver->color,
- UNIFORM_COLOR_COLOR, 0,
- &white);
- gsk_gl_render_job_draw (job, 0, 0, texture_width, texture_height);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->color);
+ gsk_ngl_program_set_uniform_color (job->driver->color,
+ UNIFORM_COLOR_COLOR, 0,
+ &white);
+ gsk_ngl_render_job_draw (job, 0, 0, texture_width, texture_height);
+ gsk_ngl_render_job_end_draw (job);
/* Reset state from offscreen */
- gsk_gl_render_job_pop_clip (job);
- gsk_gl_render_job_pop_modelview (job);
- gsk_gl_render_job_set_viewport (job, &prev_viewport, NULL);
- gsk_gl_render_job_set_projection (job, &prev_projection);
+ gsk_ngl_render_job_pop_clip (job);
+ gsk_ngl_render_job_pop_modelview (job);
+ gsk_ngl_render_job_set_viewport (job, &prev_viewport, NULL);
+ gsk_ngl_render_job_set_projection (job, &prev_projection);
/* Now blur the outline */
init_full_texture_region (&offscreen);
- offscreen.texture_id = gsk_next_driver_release_render_target (job->driver, render_target, FALSE);
+ offscreen.texture_id = gsk_ngl_driver_release_render_target (job->driver, render_target, FALSE);
blurred_texture_id = blur_offscreen (job,
&offscreen,
texture_width,
@@ -2230,19 +2230,19 @@ gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob *job,
blur_radius * scale_x,
blur_radius * scale_y);
- gsk_gl_shadow_library_insert (job->driver->shadows,
- &scaled_outline,
- blur_radius,
- blurred_texture_id);
+ gsk_ngl_shadow_library_insert (job->driver->shadows,
+ &scaled_outline,
+ blur_radius,
+ blurred_texture_id);
- gsk_gl_command_queue_bind_framebuffer (job->command_queue, prev_fbo);
+ gsk_ngl_command_queue_bind_framebuffer (job->command_queue, prev_fbo);
}
else
{
blurred_texture_id = cached_tid;
}
- gsk_gl_render_job_transform_rounded_rect (job, outline, &transformed_outline);
+ gsk_ngl_render_job_transform_rounded_rect (job, outline, &transformed_outline);
if (!do_slicing)
{
@@ -2253,41 +2253,41 @@ gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob *job,
offscreen.texture_id = blurred_texture_id;
init_full_texture_region (&offscreen);
- gsk_gl_render_job_begin_draw (job, job->driver->outset_shadow);
- gsk_gl_program_set_uniform_color (job->driver->outset_shadow,
- UNIFORM_OUTSET_SHADOW_COLOR, 0,
- color);
- gsk_gl_program_set_uniform_texture (job->driver->outset_shadow,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0,
- blurred_texture_id);
- gsk_gl_program_set_uniform_rounded_rect (job->driver->outset_shadow,
- UNIFORM_OUTSET_SHADOW_OUTLINE_RECT, 0,
- &transformed_outline);
- gsk_gl_render_job_load_vertices_from_offscreen (job,
- &GRAPHENE_RECT_INIT (min_x,
- min_y,
- texture_width / scale_x,
- texture_height / scale_y),
- &offscreen);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->outset_shadow);
+ gsk_ngl_program_set_uniform_color (job->driver->outset_shadow,
+ UNIFORM_OUTSET_SHADOW_COLOR, 0,
+ color);
+ gsk_ngl_program_set_uniform_texture (job->driver->outset_shadow,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0,
+ blurred_texture_id);
+ gsk_ngl_program_set_uniform_rounded_rect (job->driver->outset_shadow,
+ UNIFORM_OUTSET_SHADOW_OUTLINE_RECT, 0,
+ &transformed_outline);
+ gsk_ngl_render_job_load_vertices_from_offscreen (job,
+ &GRAPHENE_RECT_INIT (min_x,
+ min_y,
+ texture_width / scale_x,
+ texture_height / scale_y),
+ &offscreen);
+ gsk_ngl_render_job_end_draw (job);
return;
}
- gsk_gl_render_job_begin_draw (job, job->driver->outset_shadow);
- gsk_gl_program_set_uniform_color (job->driver->outset_shadow,
- UNIFORM_OUTSET_SHADOW_COLOR, 0,
- color);
- gsk_gl_program_set_uniform_texture (job->driver->outset_shadow,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0,
- blurred_texture_id);
- gsk_gl_program_set_uniform_rounded_rect (job->driver->outset_shadow,
- UNIFORM_OUTSET_SHADOW_OUTLINE_RECT, 0,
- &transformed_outline);
+ gsk_ngl_render_job_begin_draw (job, job->driver->outset_shadow);
+ gsk_ngl_program_set_uniform_color (job->driver->outset_shadow,
+ UNIFORM_OUTSET_SHADOW_COLOR, 0,
+ color);
+ gsk_ngl_program_set_uniform_texture (job->driver->outset_shadow,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0,
+ blurred_texture_id);
+ gsk_ngl_program_set_uniform_rounded_rect (job->driver->outset_shadow,
+ UNIFORM_OUTSET_SHADOW_OUTLINE_RECT, 0,
+ &transformed_outline);
{
float min_x = floorf (outline->bounds.origin.x - spread - half_blur_extra + dx);
@@ -2296,11 +2296,11 @@ gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob *job,
half_blur_extra + dx + spread);
float max_y = ceilf (outline->bounds.origin.y + outline->bounds.size.height +
half_blur_extra + dy + spread);
- const GskGLTextureNineSlice *slices;
- GskGLTexture *texture;
+ const GskNglTextureNineSlice *slices;
+ GskNglTexture *texture;
- texture = gsk_next_driver_get_texture_by_id (job->driver, blurred_texture_id);
- slices = gsk_gl_texture_get_nine_slice (texture, &scaled_outline, extra_blur_pixels);
+ texture = gsk_ngl_driver_get_texture_by_id (job->driver, blurred_texture_id);
+ slices = gsk_ngl_texture_get_nine_slice (texture, &scaled_outline, extra_blur_pixels);
offscreen.was_offscreen = TRUE;
@@ -2311,61 +2311,61 @@ gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob *job,
if (nine_slice_is_visible (&slices[NINE_SLICE_TOP_LEFT]))
{
memcpy (&offscreen.area, &slices[NINE_SLICE_TOP_LEFT].area, sizeof offscreen.area);
- gsk_gl_render_job_load_vertices_from_offscreen (job,
- &GRAPHENE_RECT_INIT (min_x, min_y,
-
slices[NINE_SLICE_TOP_LEFT].rect.width / scale_x,
-
slices[NINE_SLICE_TOP_LEFT].rect.height / scale_y),
- &offscreen);
+ gsk_ngl_render_job_load_vertices_from_offscreen (job,
+ &GRAPHENE_RECT_INIT (min_x, min_y,
+
slices[NINE_SLICE_TOP_LEFT].rect.width / scale_x,
+
slices[NINE_SLICE_TOP_LEFT].rect.height / scale_y),
+ &offscreen);
}
/* Top center */
if (nine_slice_is_visible (&slices[NINE_SLICE_TOP_CENTER]))
- {
- memcpy (&offscreen.area, &slices[NINE_SLICE_TOP_CENTER].area, sizeof offscreen.area);
- float width = (max_x - min_x) - (slices[NINE_SLICE_TOP_LEFT].rect.width / scale_x +
- slices[NINE_SLICE_TOP_RIGHT].rect.width / scale_x);
- gsk_gl_render_job_load_vertices_from_offscreen (job,
- &GRAPHENE_RECT_INIT (min_x +
(slices[NINE_SLICE_TOP_LEFT].rect.width / scale_x),
- min_y,
- width,
-
slices[NINE_SLICE_TOP_CENTER].rect.height / scale_y),
- &offscreen);
- }
+ {
+ memcpy (&offscreen.area, &slices[NINE_SLICE_TOP_CENTER].area, sizeof offscreen.area);
+ float width = (max_x - min_x) - (slices[NINE_SLICE_TOP_LEFT].rect.width / scale_x +
+ slices[NINE_SLICE_TOP_RIGHT].rect.width / scale_x);
+ gsk_ngl_render_job_load_vertices_from_offscreen (job,
+ &GRAPHENE_RECT_INIT (min_x +
(slices[NINE_SLICE_TOP_LEFT].rect.width / scale_x),
+ min_y,
+ width,
+
slices[NINE_SLICE_TOP_CENTER].rect.height / scale_y),
+ &offscreen);
+ }
/* Top right */
if (nine_slice_is_visible (&slices[NINE_SLICE_TOP_RIGHT]))
- {
- memcpy (&offscreen.area, &slices[NINE_SLICE_TOP_RIGHT].area, sizeof offscreen.area);
- gsk_gl_render_job_load_vertices_from_offscreen (job,
- &GRAPHENE_RECT_INIT (max_x -
(slices[NINE_SLICE_TOP_RIGHT].rect.width / scale_x),
- min_y,
-
slices[NINE_SLICE_TOP_RIGHT].rect.width / scale_x,
-
slices[NINE_SLICE_TOP_RIGHT].rect.height / scale_y),
- &offscreen);
- }
+ {
+ memcpy (&offscreen.area, &slices[NINE_SLICE_TOP_RIGHT].area, sizeof offscreen.area);
+ gsk_ngl_render_job_load_vertices_from_offscreen (job,
+ &GRAPHENE_RECT_INIT (max_x -
(slices[NINE_SLICE_TOP_RIGHT].rect.width / scale_x),
+ min_y,
+
slices[NINE_SLICE_TOP_RIGHT].rect.width / scale_x,
+
slices[NINE_SLICE_TOP_RIGHT].rect.height / scale_y),
+ &offscreen);
+ }
/* Bottom right */
if (nine_slice_is_visible (&slices[NINE_SLICE_BOTTOM_RIGHT]))
- {
- memcpy (&offscreen.area, &slices[NINE_SLICE_BOTTOM_RIGHT].area, sizeof offscreen.area);
- gsk_gl_render_job_load_vertices_from_offscreen (job,
- &GRAPHENE_RECT_INIT (max_x -
(slices[NINE_SLICE_BOTTOM_RIGHT].rect.width / scale_x),
- max_y -
(slices[NINE_SLICE_BOTTOM_RIGHT].rect.height / scale_y),
-
slices[NINE_SLICE_BOTTOM_RIGHT].rect.width / scale_x,
-
slices[NINE_SLICE_BOTTOM_RIGHT].rect.height / scale_y),
- &offscreen);
- }
+ {
+ memcpy (&offscreen.area, &slices[NINE_SLICE_BOTTOM_RIGHT].area, sizeof offscreen.area);
+ gsk_ngl_render_job_load_vertices_from_offscreen (job,
+ &GRAPHENE_RECT_INIT (max_x -
(slices[NINE_SLICE_BOTTOM_RIGHT].rect.width / scale_x),
+ max_y -
(slices[NINE_SLICE_BOTTOM_RIGHT].rect.height / scale_y),
+
slices[NINE_SLICE_BOTTOM_RIGHT].rect.width / scale_x,
+
slices[NINE_SLICE_BOTTOM_RIGHT].rect.height / scale_y),
+ &offscreen);
+ }
/* Bottom left */
if (nine_slice_is_visible (&slices[NINE_SLICE_BOTTOM_LEFT]))
{
memcpy (&offscreen.area, &slices[NINE_SLICE_BOTTOM_LEFT].area, sizeof offscreen.area);
- gsk_gl_render_job_load_vertices_from_offscreen (job,
- &GRAPHENE_RECT_INIT (min_x,
- max_y -
(slices[NINE_SLICE_BOTTOM_LEFT].rect.height / scale_y),
-
slices[NINE_SLICE_BOTTOM_LEFT].rect.width / scale_x,
-
slices[NINE_SLICE_BOTTOM_LEFT].rect.height / scale_y),
- &offscreen);
+ gsk_ngl_render_job_load_vertices_from_offscreen (job,
+ &GRAPHENE_RECT_INIT (min_x,
+ max_y -
(slices[NINE_SLICE_BOTTOM_LEFT].rect.height / scale_y),
+
slices[NINE_SLICE_BOTTOM_LEFT].rect.width / scale_x,
+
slices[NINE_SLICE_BOTTOM_LEFT].rect.height / scale_y),
+ &offscreen);
}
/* Left side */
@@ -2374,12 +2374,12 @@ gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob *job,
memcpy (&offscreen.area, &slices[NINE_SLICE_LEFT_CENTER].area, sizeof offscreen.area);
float height = (max_y - min_y) - (slices[NINE_SLICE_TOP_LEFT].rect.height / scale_y +
slices[NINE_SLICE_BOTTOM_LEFT].rect.height / scale_y);
- gsk_gl_render_job_load_vertices_from_offscreen (job,
- &GRAPHENE_RECT_INIT (min_x,
- min_y +
(slices[NINE_SLICE_TOP_LEFT].rect.height / scale_y),
-
slices[NINE_SLICE_LEFT_CENTER].rect.width / scale_x,
- height),
- &offscreen);
+ gsk_ngl_render_job_load_vertices_from_offscreen (job,
+ &GRAPHENE_RECT_INIT (min_x,
+ min_y +
(slices[NINE_SLICE_TOP_LEFT].rect.height / scale_y),
+
slices[NINE_SLICE_LEFT_CENTER].rect.width / scale_x,
+ height),
+ &offscreen);
}
/* Right side */
@@ -2388,12 +2388,12 @@ gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob *job,
memcpy (&offscreen.area, &slices[NINE_SLICE_RIGHT_CENTER].area, sizeof offscreen.area);
float height = (max_y - min_y) - (slices[NINE_SLICE_TOP_RIGHT].rect.height / scale_y +
slices[NINE_SLICE_BOTTOM_RIGHT].rect.height / scale_y);
- gsk_gl_render_job_load_vertices_from_offscreen (job,
- &GRAPHENE_RECT_INIT (max_x -
(slices[NINE_SLICE_RIGHT_CENTER].rect.width / scale_x),
- min_y +
(slices[NINE_SLICE_TOP_LEFT].rect.height / scale_y),
-
slices[NINE_SLICE_RIGHT_CENTER].rect.width / scale_x,
- height),
- &offscreen);
+ gsk_ngl_render_job_load_vertices_from_offscreen (job,
+ &GRAPHENE_RECT_INIT (max_x -
(slices[NINE_SLICE_RIGHT_CENTER].rect.width / scale_x),
+ min_y +
(slices[NINE_SLICE_TOP_LEFT].rect.height / scale_y),
+
slices[NINE_SLICE_RIGHT_CENTER].rect.width / scale_x,
+ height),
+ &offscreen);
}
/* Bottom side */
@@ -2402,12 +2402,12 @@ gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob *job,
memcpy (&offscreen.area, &slices[NINE_SLICE_BOTTOM_CENTER].area, sizeof offscreen.area);
float width = (max_x - min_x) - (slices[NINE_SLICE_BOTTOM_LEFT].rect.width / scale_x +
slices[NINE_SLICE_BOTTOM_RIGHT].rect.width / scale_x);
- gsk_gl_render_job_load_vertices_from_offscreen (job,
- &GRAPHENE_RECT_INIT (min_x +
(slices[NINE_SLICE_BOTTOM_LEFT].rect.width / scale_x),
- max_y -
(slices[NINE_SLICE_BOTTOM_CENTER].rect.height / scale_y),
- width,
-
slices[NINE_SLICE_BOTTOM_CENTER].rect.height / scale_y),
- &offscreen);
+ gsk_ngl_render_job_load_vertices_from_offscreen (job,
+ &GRAPHENE_RECT_INIT (min_x +
(slices[NINE_SLICE_BOTTOM_LEFT].rect.width / scale_x),
+ max_y -
(slices[NINE_SLICE_BOTTOM_CENTER].rect.height / scale_y),
+ width,
+
slices[NINE_SLICE_BOTTOM_CENTER].rect.height / scale_y),
+ &offscreen);
}
/* Middle */
@@ -2418,15 +2418,15 @@ gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob *job,
slices[NINE_SLICE_RIGHT_CENTER].rect.width / scale_x);
float height = (max_y - min_y) - (slices[NINE_SLICE_TOP_CENTER].rect.height / scale_y +
slices[NINE_SLICE_BOTTOM_CENTER].rect.height / scale_y);
- gsk_gl_render_job_load_vertices_from_offscreen (job,
- &GRAPHENE_RECT_INIT (min_x +
(slices[NINE_SLICE_LEFT_CENTER].rect.width / scale_x),
- min_y +
(slices[NINE_SLICE_TOP_CENTER].rect.height / scale_y),
- width, height),
- &offscreen);
+ gsk_ngl_render_job_load_vertices_from_offscreen (job,
+ &GRAPHENE_RECT_INIT (min_x +
(slices[NINE_SLICE_LEFT_CENTER].rect.width / scale_x),
+ min_y +
(slices[NINE_SLICE_TOP_CENTER].rect.height / scale_y),
+ width, height),
+ &offscreen);
}
}
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_end_draw (job);
}
static inline gboolean G_GNUC_PURE
@@ -2445,14 +2445,14 @@ equal_texture_nodes (const GskRenderNode *node1,
}
static inline void
-gsk_gl_render_job_visit_cross_fade_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_cross_fade_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
const GskRenderNode *start_node = gsk_cross_fade_node_get_start_child (node);
const GskRenderNode *end_node = gsk_cross_fade_node_get_end_child (node);
float progress = gsk_cross_fade_node_get_progress (node);
- GskGLRenderOffscreen offscreen_start = {0};
- GskGLRenderOffscreen offscreen_end = {0};
+ GskNglRenderOffscreen offscreen_start = {0};
+ GskNglRenderOffscreen offscreen_end = {0};
g_assert (progress > 0.0);
g_assert (progress < 1.0);
@@ -2465,45 +2465,45 @@ gsk_gl_render_job_visit_cross_fade_node (GskGLRenderJob *job,
offscreen_end.reset_clip = TRUE;
offscreen_end.bounds = &node->bounds;
- if (!gsk_gl_render_job_visit_node_with_offscreen (job, start_node, &offscreen_start))
+ if (!gsk_ngl_render_job_visit_node_with_offscreen (job, start_node, &offscreen_start))
{
- gsk_gl_render_job_visit_node (job, end_node);
+ gsk_ngl_render_job_visit_node (job, end_node);
return;
}
g_assert (offscreen_start.texture_id);
- if (!gsk_gl_render_job_visit_node_with_offscreen (job, end_node, &offscreen_end))
+ if (!gsk_ngl_render_job_visit_node_with_offscreen (job, end_node, &offscreen_end))
{
- float prev_alpha = gsk_gl_render_job_set_alpha (job, job->alpha * progress);
- gsk_gl_render_job_visit_node (job, start_node);
- gsk_gl_render_job_set_alpha (job, prev_alpha);
+ float prev_alpha = gsk_ngl_render_job_set_alpha (job, job->alpha * progress);
+ gsk_ngl_render_job_visit_node (job, start_node);
+ gsk_ngl_render_job_set_alpha (job, prev_alpha);
return;
}
g_assert (offscreen_end.texture_id);
- gsk_gl_render_job_begin_draw (job, job->driver->cross_fade);
- gsk_gl_program_set_uniform_texture (job->driver->cross_fade,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0,
- offscreen_start.texture_id);
- gsk_gl_program_set_uniform_texture (job->driver->cross_fade,
- UNIFORM_CROSS_FADE_SOURCE2, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE1,
- offscreen_end.texture_id);
- gsk_gl_program_set_uniform1f (job->driver->cross_fade,
- UNIFORM_CROSS_FADE_PROGRESS, 0,
- progress);
- gsk_gl_render_job_load_vertices_from_offscreen (job, &node->bounds, &offscreen_end);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->cross_fade);
+ gsk_ngl_program_set_uniform_texture (job->driver->cross_fade,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0,
+ offscreen_start.texture_id);
+ gsk_ngl_program_set_uniform_texture (job->driver->cross_fade,
+ UNIFORM_CROSS_FADE_SOURCE2, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE1,
+ offscreen_end.texture_id);
+ gsk_ngl_program_set_uniform1f (job->driver->cross_fade,
+ UNIFORM_CROSS_FADE_PROGRESS, 0,
+ progress);
+ gsk_ngl_render_job_load_vertices_from_offscreen (job, &node->bounds, &offscreen_end);
+ gsk_ngl_render_job_end_draw (job);
}
static inline void
-gsk_gl_render_job_visit_opacity_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_opacity_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
const GskRenderNode *child = gsk_opacity_node_get_child (node);
float opacity = gsk_opacity_node_get_opacity (node);
@@ -2511,11 +2511,11 @@ gsk_gl_render_job_visit_opacity_node (GskGLRenderJob *job,
if (!ALPHA_IS_CLEAR (new_alpha))
{
- float prev_alpha = gsk_gl_render_job_set_alpha (job, new_alpha);
+ float prev_alpha = gsk_ngl_render_job_set_alpha (job, new_alpha);
if (gsk_render_node_get_node_type (child) == GSK_CONTAINER_NODE)
{
- GskGLRenderOffscreen offscreen = {0};
+ GskNglRenderOffscreen offscreen = {0};
offscreen.bounds = &child->bounds;
offscreen.force_offscreen = TRUE;
@@ -2524,34 +2524,34 @@ gsk_gl_render_job_visit_opacity_node (GskGLRenderJob *job,
/* The semantics of an opacity node mandate that when, e.g., two
* color nodes overlap, there may not be any blending between them.
*/
- if (!gsk_gl_render_job_visit_node_with_offscreen (job, child, &offscreen))
+ if (!gsk_ngl_render_job_visit_node_with_offscreen (job, child, &offscreen))
return;
g_assert (offscreen.texture_id);
- gsk_gl_render_job_begin_draw (job, job->driver->blit);
- gsk_gl_program_set_uniform_texture (job->driver->blit,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0,
- offscreen.texture_id);
- gsk_gl_render_job_load_vertices_from_offscreen (job, &node->bounds, &offscreen);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->blit);
+ gsk_ngl_program_set_uniform_texture (job->driver->blit,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0,
+ offscreen.texture_id);
+ gsk_ngl_render_job_load_vertices_from_offscreen (job, &node->bounds, &offscreen);
+ gsk_ngl_render_job_end_draw (job);
}
else
{
- gsk_gl_render_job_visit_node (job, child);
+ gsk_ngl_render_job_visit_node (job, child);
}
- gsk_gl_render_job_set_alpha (job, prev_alpha);
+ gsk_ngl_render_job_set_alpha (job, prev_alpha);
}
}
static inline void
-gsk_gl_render_job_visit_text_node (GskGLRenderJob *job,
- const GskRenderNode *node,
- const GdkRGBA *color,
- gboolean force_color)
+gsk_ngl_render_job_visit_text_node (GskNglRenderJob *job,
+ const GskRenderNode *node,
+ const GdkRGBA *color,
+ gboolean force_color)
{
const PangoFont *font = gsk_text_node_get_font (node);
const PangoGlyphInfo *glyphs = gsk_text_node_get_glyphs (node, NULL);
@@ -2560,13 +2560,13 @@ gsk_gl_render_job_visit_text_node (GskGLRenderJob *job,
guint num_glyphs = gsk_text_node_get_num_glyphs (node);
float x = offset->x + job->offset_x;
float y = offset->y + job->offset_y;
- GskGLGlyphLibrary *library = job->driver->glyphs;
- GskGLCommandBatch *batch;
- GskGLProgram *program;
+ GskNglGlyphLibrary *library = job->driver->glyphs;
+ GskNglCommandBatch *batch;
+ GskNglProgram *program;
int x_position = 0;
- GskGLGlyphKey lookup;
+ GskNglGlyphKey lookup;
guint last_texture = 0;
- GskGLDrawVertex *vertices;
+ GskNglDrawVertex *vertices;
guint used = 0;
if (num_glyphs == 0)
@@ -2580,22 +2580,22 @@ gsk_gl_render_job_visit_text_node (GskGLRenderJob *job,
else
{
program = job->driver->coloring;
- gsk_gl_program_set_uniform_color (program, UNIFORM_COLORING_COLOR, 0, color);
+ gsk_ngl_program_set_uniform_color (program, UNIFORM_COLORING_COLOR, 0, color);
}
lookup.font = (PangoFont *)font;
lookup.scale = (guint) (text_scale * 1024);
- gsk_gl_render_job_begin_draw (job, program);
- batch = gsk_gl_command_queue_get_batch (job->command_queue);
- vertices = gsk_gl_command_queue_add_n_vertices (job->command_queue, num_glyphs);
+ gsk_ngl_render_job_begin_draw (job, program);
+ batch = gsk_ngl_command_queue_get_batch (job->command_queue);
+ vertices = gsk_ngl_command_queue_add_n_vertices (job->command_queue, num_glyphs);
/* We use one quad per character */
for (guint i = 0; i < num_glyphs; i++)
{
const PangoGlyphInfo *gi = &glyphs[i];
- const GskGLGlyphValue *glyph;
- guint base = used * GSK_GL_N_VERTICES;
+ const GskNglGlyphValue *glyph;
+ guint base = used * GSK_NGL_N_VERTICES;
float glyph_x, glyph_y, glyph_x2, glyph_y2;
float tx, ty, tx2, ty2;
float cx;
@@ -2608,12 +2608,12 @@ gsk_gl_render_job_visit_text_node (GskGLRenderJob *job,
cx = (float)(x_position + gi->geometry.x_offset) / PANGO_SCALE;
cy = (float)(gi->geometry.y_offset) / PANGO_SCALE;
- gsk_gl_glyph_key_set_glyph_and_shift (&lookup, gi->glyph, x + cx, y + cy);
+ gsk_ngl_glyph_key_set_glyph_and_shift (&lookup, gi->glyph, x + cx, y + cy);
- if (!gsk_gl_glyph_library_lookup_or_add (library, &lookup, &glyph))
+ if (!gsk_ngl_glyph_library_lookup_or_add (library, &lookup, &glyph))
goto next;
- texture_id = GSK_GL_TEXTURE_ATLAS_ENTRY_TEXTURE (glyph);
+ texture_id = GSK_NGL_TEXTURE_ATLAS_ENTRY_TEXTURE (glyph);
if G_UNLIKELY (last_texture != texture_id)
{
@@ -2628,16 +2628,16 @@ gsk_gl_render_job_visit_text_node (GskGLRenderJob *job,
* of the new batch as otherwise it will point at the end of our
* vbo array.
*/
- gsk_gl_render_job_split_draw (job);
- batch = gsk_gl_command_queue_get_batch (job->command_queue);
+ gsk_ngl_render_job_split_draw (job);
+ batch = gsk_ngl_command_queue_get_batch (job->command_queue);
batch->draw.vbo_offset = vbo_offset;
}
- gsk_gl_program_set_uniform_texture (program,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0,
- texture_id);
+ gsk_ngl_program_set_uniform_texture (program,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0,
+ texture_id);
last_texture = texture_id;
}
@@ -2681,7 +2681,7 @@ gsk_gl_render_job_visit_text_node (GskGLRenderJob *job,
vertices[base+5].uv[0] = tx2;
vertices[base+5].uv[1] = ty;
- batch->draw.vbo_count += GSK_GL_N_VERTICES;
+ batch->draw.vbo_count += GSK_NGL_N_VERTICES;
used++;
next:
@@ -2689,14 +2689,14 @@ next:
}
if (used != num_glyphs)
- gsk_gl_command_queue_retract_n_vertices (job->command_queue, num_glyphs - used);
+ gsk_ngl_command_queue_retract_n_vertices (job->command_queue, num_glyphs - used);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_end_draw (job);
}
static inline void
-gsk_gl_render_job_visit_shadow_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_shadow_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
const gsize n_shadows = gsk_shadow_node_get_n_shadows (node);
const GskRenderNode *original_child = gsk_shadow_node_get_child (node);
@@ -2713,15 +2713,15 @@ gsk_gl_render_job_visit_shadow_node (GskGLRenderJob *job,
const GskShadow *shadow = gsk_shadow_node_get_shadow (node, i);
const float dx = shadow->dx;
const float dy = shadow->dy;
- GskGLRenderOffscreen offscreen = {0};
+ GskNglRenderOffscreen offscreen = {0};
graphene_rect_t bounds;
if (shadow->radius == 0 &&
gsk_render_node_get_node_type (shadow_child) == GSK_TEXT_NODE)
{
- gsk_gl_render_job_offset (job, dx, dy);
- gsk_gl_render_job_visit_text_node (job, shadow_child, &shadow->color, TRUE);
- gsk_gl_render_job_offset (job, -dx, -dy);
+ gsk_ngl_render_job_offset (job, dx, dy);
+ gsk_ngl_render_job_visit_text_node (job, shadow_child, &shadow->color, TRUE);
+ gsk_ngl_render_job_offset (job, -dx, -dy);
continue;
}
@@ -2764,38 +2764,38 @@ gsk_gl_render_job_visit_shadow_node (GskGLRenderJob *job,
offscreen.reset_clip = TRUE;
offscreen.do_not_cache = TRUE;
- if (!gsk_gl_render_job_visit_node_with_offscreen (job, shadow_child, &offscreen))
+ if (!gsk_ngl_render_job_visit_node_with_offscreen (job, shadow_child, &offscreen))
g_assert_not_reached ();
bounds = shadow_child->bounds;
}
- gsk_gl_render_job_offset (job, dx, dy);
- gsk_gl_render_job_begin_draw (job, job->driver->coloring);
- gsk_gl_program_set_uniform_texture (job->driver->coloring,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0,
- offscreen.texture_id);
- gsk_gl_program_set_uniform_color (job->driver->coloring,
- UNIFORM_COLORING_COLOR, 0,
- &shadow->color);
- gsk_gl_render_job_load_vertices_from_offscreen (job, &bounds, &offscreen);
- gsk_gl_render_job_end_draw (job);
- gsk_gl_render_job_offset (job, -dx, -dy);
+ gsk_ngl_render_job_offset (job, dx, dy);
+ gsk_ngl_render_job_begin_draw (job, job->driver->coloring);
+ gsk_ngl_program_set_uniform_texture (job->driver->coloring,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0,
+ offscreen.texture_id);
+ gsk_ngl_program_set_uniform_color (job->driver->coloring,
+ UNIFORM_COLORING_COLOR, 0,
+ &shadow->color);
+ gsk_ngl_render_job_load_vertices_from_offscreen (job, &bounds, &offscreen);
+ gsk_ngl_render_job_end_draw (job);
+ gsk_ngl_render_job_offset (job, -dx, -dy);
}
/* Now draw the child normally */
- gsk_gl_render_job_visit_node (job, original_child);
+ gsk_ngl_render_job_visit_node (job, original_child);
}
static inline void
-gsk_gl_render_job_visit_blur_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_blur_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
const GskRenderNode *child = gsk_blur_node_get_child (node);
float blur_radius = gsk_blur_node_get_radius (node);
- GskGLRenderOffscreen offscreen = {0};
+ GskNglRenderOffscreen offscreen = {0};
GskTextureKey key;
gboolean cache_texture;
float min_x;
@@ -2814,7 +2814,7 @@ gsk_gl_render_job_visit_blur_node (GskGLRenderJob *job,
key.scale_y = job->scale_y;
key.filter = GL_NEAREST;
- offscreen.texture_id = gsk_next_driver_lookup_texture (job->driver, &key);
+ offscreen.texture_id = gsk_ngl_driver_lookup_texture (job->driver, &key);
cache_texture = offscreen.texture_id == 0;
blur_node (job,
@@ -2826,26 +2826,26 @@ gsk_gl_render_job_visit_blur_node (GskGLRenderJob *job,
g_assert (offscreen.texture_id != 0);
if (cache_texture)
- gsk_next_driver_cache_texture (job->driver, &key, offscreen.texture_id);
+ gsk_ngl_driver_cache_texture (job->driver, &key, offscreen.texture_id);
- gsk_gl_render_job_begin_draw (job, job->driver->blit);
- gsk_gl_program_set_uniform_texture (job->driver->blit,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0,
- offscreen.texture_id);
- gsk_gl_render_job_draw_coords (job, min_x, min_y, max_x, max_y);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->blit);
+ gsk_ngl_program_set_uniform_texture (job->driver->blit,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0,
+ offscreen.texture_id);
+ gsk_ngl_render_job_draw_coords (job, min_x, min_y, max_x, max_y);
+ gsk_ngl_render_job_end_draw (job);
}
static inline void
-gsk_gl_render_job_visit_blend_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_blend_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
const GskRenderNode *top_child = gsk_blend_node_get_top_child (node);
const GskRenderNode *bottom_child = gsk_blend_node_get_bottom_child (node);
- GskGLRenderOffscreen top_offscreen = {0};
- GskGLRenderOffscreen bottom_offscreen = {0};
+ GskNglRenderOffscreen top_offscreen = {0};
+ GskNglRenderOffscreen bottom_offscreen = {0};
top_offscreen.bounds = &node->bounds;
top_offscreen.force_offscreen = TRUE;
@@ -2857,53 +2857,53 @@ gsk_gl_render_job_visit_blend_node (GskGLRenderJob *job,
/* TODO: We create 2 textures here as big as the blend node, but both the
* start and the end node might be a lot smaller than that. */
- if (!gsk_gl_render_job_visit_node_with_offscreen (job, bottom_child, &bottom_offscreen))
+ if (!gsk_ngl_render_job_visit_node_with_offscreen (job, bottom_child, &bottom_offscreen))
{
- gsk_gl_render_job_visit_node (job, top_child);
+ gsk_ngl_render_job_visit_node (job, top_child);
return;
}
g_assert (bottom_offscreen.was_offscreen);
- if (!gsk_gl_render_job_visit_node_with_offscreen (job, top_child, &top_offscreen))
+ if (!gsk_ngl_render_job_visit_node_with_offscreen (job, top_child, &top_offscreen))
{
- gsk_gl_render_job_begin_draw (job, job->driver->blit);
- gsk_gl_program_set_uniform_texture (job->driver->blit,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0,
- bottom_offscreen.texture_id);
- gsk_gl_render_job_load_vertices_from_offscreen (job, &node->bounds, &bottom_offscreen);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->blit);
+ gsk_ngl_program_set_uniform_texture (job->driver->blit,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0,
+ bottom_offscreen.texture_id);
+ gsk_ngl_render_job_load_vertices_from_offscreen (job, &node->bounds, &bottom_offscreen);
+ gsk_ngl_render_job_end_draw (job);
return;
}
g_assert (top_offscreen.was_offscreen);
- gsk_gl_render_job_begin_draw (job, job->driver->blend);
- gsk_gl_program_set_uniform_texture (job->driver->blend,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0,
- bottom_offscreen.texture_id);
- gsk_gl_program_set_uniform_texture (job->driver->blend,
- UNIFORM_BLEND_SOURCE2, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE1,
- top_offscreen.texture_id);
- gsk_gl_program_set_uniform1i (job->driver->blend,
- UNIFORM_BLEND_MODE, 0,
- gsk_blend_node_get_blend_mode (node));
- gsk_gl_render_job_draw_offscreen_rect (job, &node->bounds);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->blend);
+ gsk_ngl_program_set_uniform_texture (job->driver->blend,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0,
+ bottom_offscreen.texture_id);
+ gsk_ngl_program_set_uniform_texture (job->driver->blend,
+ UNIFORM_BLEND_SOURCE2, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE1,
+ top_offscreen.texture_id);
+ gsk_ngl_program_set_uniform1i (job->driver->blend,
+ UNIFORM_BLEND_MODE, 0,
+ gsk_blend_node_get_blend_mode (node));
+ gsk_ngl_render_job_draw_offscreen_rect (job, &node->bounds);
+ gsk_ngl_render_job_end_draw (job);
}
static inline void
-gsk_gl_render_job_visit_color_matrix_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_color_matrix_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
const GskRenderNode *child = gsk_color_matrix_node_get_child (node);
- GskGLRenderOffscreen offscreen = {0};
+ GskNglRenderOffscreen offscreen = {0};
float offset[4];
if (node_is_invisible (child))
@@ -2912,55 +2912,55 @@ gsk_gl_render_job_visit_color_matrix_node (GskGLRenderJob *job,
offscreen.bounds = &node->bounds;
offscreen.reset_clip = TRUE;
- if (!gsk_gl_render_job_visit_node_with_offscreen (job, child, &offscreen))
+ if (!gsk_ngl_render_job_visit_node_with_offscreen (job, child, &offscreen))
g_assert_not_reached ();
g_assert (offscreen.texture_id > 0);
graphene_vec4_to_float (gsk_color_matrix_node_get_color_offset (node), offset);
- gsk_gl_render_job_begin_draw (job, job->driver->color_matrix);
- gsk_gl_program_set_uniform_texture (job->driver->color_matrix,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0,
- offscreen.texture_id);
- gsk_gl_program_set_uniform_matrix (job->driver->color_matrix,
- UNIFORM_COLOR_MATRIX_COLOR_MATRIX, 0,
- gsk_color_matrix_node_get_color_matrix (node));
- gsk_gl_program_set_uniform4fv (job->driver->color_matrix,
- UNIFORM_COLOR_MATRIX_COLOR_OFFSET, 0,
- 1,
- offset);
- gsk_gl_render_job_load_vertices_from_offscreen (job, &node->bounds, &offscreen);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->color_matrix);
+ gsk_ngl_program_set_uniform_texture (job->driver->color_matrix,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0,
+ offscreen.texture_id);
+ gsk_ngl_program_set_uniform_matrix (job->driver->color_matrix,
+ UNIFORM_COLOR_MATRIX_COLOR_MATRIX, 0,
+ gsk_color_matrix_node_get_color_matrix (node));
+ gsk_ngl_program_set_uniform4fv (job->driver->color_matrix,
+ UNIFORM_COLOR_MATRIX_COLOR_OFFSET, 0,
+ 1,
+ offset);
+ gsk_ngl_render_job_load_vertices_from_offscreen (job, &node->bounds, &offscreen);
+ gsk_ngl_render_job_end_draw (job);
}
static inline void
-gsk_gl_render_job_visit_gl_shader_node_fallback (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_gl_shader_node_fallback (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
static const GdkRGBA pink = { 255 / 255., 105 / 255., 180 / 255., 1.0 };
- gsk_gl_render_job_begin_draw (job, job->driver->color);
- gsk_gl_program_set_uniform_color (job->driver->color,
- UNIFORM_COLOR_COLOR, 0,
- &pink);
- gsk_gl_render_job_draw_rect (job, &node->bounds);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->color);
+ gsk_ngl_program_set_uniform_color (job->driver->color,
+ UNIFORM_COLOR_COLOR, 0,
+ &pink);
+ gsk_ngl_render_job_draw_rect (job, &node->bounds);
+ gsk_ngl_render_job_end_draw (job);
}
static inline void
-gsk_gl_render_job_visit_gl_shader_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_gl_shader_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
GError *error = NULL;
GskGLShader *shader;
- GskGLProgram *program;
+ GskNglProgram *program;
int n_children;
shader = gsk_gl_shader_node_get_shader (node);
- program = gsk_next_driver_lookup_shader (job->driver, shader, &error);
+ program = gsk_ngl_driver_lookup_shader (job->driver, shader, &error);
n_children = gsk_gl_shader_node_get_n_children (node);
if G_UNLIKELY (program == NULL)
@@ -2970,12 +2970,12 @@ gsk_gl_render_job_visit_gl_shader_node (GskGLRenderJob *job,
g_object_set_data (G_OBJECT (shader), "gsk-did-warn", GUINT_TO_POINTER (1));
g_warning ("Failed to compile gl shader: %s", error->message);
}
- gsk_gl_render_job_visit_gl_shader_node_fallback (job, node);
+ gsk_ngl_render_job_visit_gl_shader_node_fallback (job, node);
g_clear_error (&error);
}
else
{
- GskGLRenderOffscreen offscreens[4] = {{0}};
+ GskNglRenderOffscreen offscreens[4] = {{0}};
const GskGLUniform *uniforms;
const guint8 *base;
GBytes *args;
@@ -2991,7 +2991,7 @@ gsk_gl_render_job_visit_gl_shader_node (GskGLRenderJob *job,
offscreens[i].force_offscreen = TRUE;
offscreens[i].reset_clip = TRUE;
- if (!gsk_gl_render_job_visit_node_with_offscreen (job, child, &offscreens[i]))
+ if (!gsk_ngl_render_job_visit_node_with_offscreen (job, child, &offscreens[i]))
return;
}
@@ -2999,17 +2999,17 @@ gsk_gl_render_job_visit_gl_shader_node (GskGLRenderJob *job,
base = g_bytes_get_data (args, NULL);
uniforms = gsk_gl_shader_get_uniforms (shader, &n_uniforms);
- gsk_gl_render_job_begin_draw (job, program);
+ gsk_ngl_render_job_begin_draw (job, program);
for (guint i = 0; i < n_children; i++)
- gsk_gl_program_set_uniform_texture (program,
- UNIFORM_CUSTOM_TEXTURE1 + i, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0 + i,
- offscreens[i].texture_id);
- gsk_gl_program_set_uniform2f (program,
- UNIFORM_CUSTOM_SIZE, 0,
- node->bounds.size.width,
- node->bounds.size.height);
+ gsk_ngl_program_set_uniform_texture (program,
+ UNIFORM_CUSTOM_TEXTURE1 + i, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0 + i,
+ offscreens[i].texture_id);
+ gsk_ngl_program_set_uniform2f (program,
+ UNIFORM_CUSTOM_SIZE, 0,
+ node->bounds.size.width,
+ node->bounds.size.height);
for (guint i = 0; i < n_uniforms; i++)
{
const GskGLUniform *u = &uniforms[i];
@@ -3025,75 +3025,75 @@ gsk_gl_render_job_visit_gl_shader_node (GskGLRenderJob *job,
case GSK_GL_UNIFORM_TYPE_NONE:
break;
case GSK_GL_UNIFORM_TYPE_FLOAT:
- gsk_gl_uniform_state_set1fv (job->command_queue->uniforms,
- program->program_info,
- program->args_locations[i],
- 0, 1, (const float *)data);
+ gsk_ngl_uniform_state_set1fv (job->command_queue->uniforms,
+ program->program_info,
+ program->args_locations[i],
+ 0, 1, (const float *)data);
break;
case GSK_GL_UNIFORM_TYPE_INT:
- gsk_gl_uniform_state_set1i (job->command_queue->uniforms,
- program->program_info,
- program->args_locations[i],
- 0, *(const gint32 *)data);
+ gsk_ngl_uniform_state_set1i (job->command_queue->uniforms,
+ program->program_info,
+ program->args_locations[i],
+ 0, *(const gint32 *)data);
break;
case GSK_GL_UNIFORM_TYPE_UINT:
case GSK_GL_UNIFORM_TYPE_BOOL:
- gsk_gl_uniform_state_set1ui (job->command_queue->uniforms,
- program->program_info,
- program->args_locations[i],
- 0, *(const guint32 *)data);
+ gsk_ngl_uniform_state_set1ui (job->command_queue->uniforms,
+ program->program_info,
+ program->args_locations[i],
+ 0, *(const guint32 *)data);
break;
case GSK_GL_UNIFORM_TYPE_VEC2:
- gsk_gl_uniform_state_set2fv (job->command_queue->uniforms,
- program->program_info,
- program->args_locations[i],
- 0, 1, (const float *)data);
+ gsk_ngl_uniform_state_set2fv (job->command_queue->uniforms,
+ program->program_info,
+ program->args_locations[i],
+ 0, 1, (const float *)data);
break;
case GSK_GL_UNIFORM_TYPE_VEC3:
- gsk_gl_uniform_state_set3fv (job->command_queue->uniforms,
- program->program_info,
- program->args_locations[i],
- 0, 1, (const float *)data);
+ gsk_ngl_uniform_state_set3fv (job->command_queue->uniforms,
+ program->program_info,
+ program->args_locations[i],
+ 0, 1, (const float *)data);
break;
case GSK_GL_UNIFORM_TYPE_VEC4:
- gsk_gl_uniform_state_set4fv (job->command_queue->uniforms,
- program->program_info,
- program->args_locations[i],
- 0, 1, (const float *)data);
+ gsk_ngl_uniform_state_set4fv (job->command_queue->uniforms,
+ program->program_info,
+ program->args_locations[i],
+ 0, 1, (const float *)data);
break;
}
}
- gsk_gl_render_job_draw_offscreen_rect (job, &node->bounds);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_draw_offscreen_rect (job, &node->bounds);
+ gsk_ngl_render_job_end_draw (job);
}
}
static void
-gsk_gl_render_job_upload_texture (GskGLRenderJob *job,
- GdkTexture *texture,
- GskGLRenderOffscreen *offscreen)
+gsk_ngl_render_job_upload_texture (GskNglRenderJob *job,
+ GdkTexture *texture,
+ GskNglRenderOffscreen *offscreen)
{
- if (gsk_gl_texture_library_can_cache (GSK_GL_TEXTURE_LIBRARY (job->driver->icons),
+ if (gsk_ngl_texture_library_can_cache (GSK_NGL_TEXTURE_LIBRARY (job->driver->icons),
texture->width,
texture->height) &&
!GDK_IS_GL_TEXTURE (texture))
{
- const GskGLIconData *icon_data;
+ const GskNglIconData *icon_data;
- gsk_gl_icon_library_lookup_or_add (job->driver->icons, texture, &icon_data);
- offscreen->texture_id = GSK_GL_TEXTURE_ATLAS_ENTRY_TEXTURE (icon_data);
+ gsk_ngl_icon_library_lookup_or_add (job->driver->icons, texture, &icon_data);
+ offscreen->texture_id = GSK_NGL_TEXTURE_ATLAS_ENTRY_TEXTURE (icon_data);
memcpy (&offscreen->area, &icon_data->entry.area, sizeof offscreen->area);
}
else
{
- offscreen->texture_id = gsk_next_driver_load_texture (job->driver, texture, GL_LINEAR, GL_LINEAR);
+ offscreen->texture_id = gsk_ngl_driver_load_texture (job->driver, texture, GL_LINEAR, GL_LINEAR);
init_full_texture_region (offscreen);
}
}
static inline void
-gsk_gl_render_job_visit_texture_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_texture_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
GdkTexture *texture = gsk_texture_node_get_texture (node);
int max_texture_size = job->command_queue->max_texture_size;
@@ -3101,21 +3101,21 @@ gsk_gl_render_job_visit_texture_node (GskGLRenderJob *job,
if G_LIKELY (texture->width <= max_texture_size &&
texture->height <= max_texture_size)
{
- GskGLRenderOffscreen offscreen = {0};
+ GskNglRenderOffscreen offscreen = {0};
- gsk_gl_render_job_upload_texture (job, texture, &offscreen);
+ gsk_ngl_render_job_upload_texture (job, texture, &offscreen);
g_assert (offscreen.texture_id);
g_assert (offscreen.was_offscreen == FALSE);
- gsk_gl_render_job_begin_draw (job, job->driver->blit);
- gsk_gl_program_set_uniform_texture (job->driver->blit,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0,
- offscreen.texture_id);
- gsk_gl_render_job_load_vertices_from_offscreen (job, &node->bounds, &offscreen);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->blit);
+ gsk_ngl_program_set_uniform_texture (job->driver->blit,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0,
+ offscreen.texture_id);
+ gsk_ngl_render_job_load_vertices_from_offscreen (job, &node->bounds, &offscreen);
+ gsk_ngl_render_job_end_draw (job);
}
else
{
@@ -3125,20 +3125,20 @@ gsk_gl_render_job_visit_texture_node (GskGLRenderJob *job,
float max_y = min_y + node->bounds.size.height;
float scale_x = (max_x - min_x) / texture->width;
float scale_y = (max_y - min_y) / texture->height;
- GskGLTextureSlice *slices = NULL;
+ GskNglTextureSlice *slices = NULL;
guint n_slices = 0;
- gsk_next_driver_slice_texture (job->driver, texture, &slices, &n_slices);
+ gsk_ngl_driver_slice_texture (job->driver, texture, &slices, &n_slices);
g_assert (slices != NULL);
g_assert (n_slices > 0);
- gsk_gl_render_job_begin_draw (job, job->driver->blit);
+ gsk_ngl_render_job_begin_draw (job, job->driver->blit);
for (guint i = 0; i < n_slices; i ++)
{
- GskGLDrawVertex *vertices;
- const GskGLTextureSlice *slice = &slices[i];
+ GskNglDrawVertex *vertices;
+ const GskNglTextureSlice *slice = &slices[i];
float x1, x2, y1, y2;
x1 = min_x + (scale_x * slice->rect.x);
@@ -3147,13 +3147,13 @@ gsk_gl_render_job_visit_texture_node (GskGLRenderJob *job,
y2 = y1 + (slice->rect.height * scale_y);
if (i > 0)
- gsk_gl_render_job_split_draw (job);
- gsk_gl_program_set_uniform_texture (job->driver->blit,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0,
- slice->texture_id);
- vertices = gsk_gl_command_queue_add_vertices (job->command_queue);
+ gsk_ngl_render_job_split_draw (job);
+ gsk_ngl_program_set_uniform_texture (job->driver->blit,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0,
+ slice->texture_id);
+ vertices = gsk_ngl_command_queue_add_vertices (job->command_queue);
vertices[0].position[0] = x1;
vertices[0].position[1] = y1;
@@ -3186,17 +3186,17 @@ gsk_gl_render_job_visit_texture_node (GskGLRenderJob *job,
vertices[5].uv[1] = 0;
}
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_end_draw (job);
}
}
static inline void
-gsk_gl_render_job_visit_repeat_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_repeat_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
const GskRenderNode *child = gsk_repeat_node_get_child (node);
const graphene_rect_t *child_bounds = gsk_repeat_node_get_child_bounds (node);
- GskGLRenderOffscreen offscreen = {0};
+ GskNglRenderOffscreen offscreen = {0};
if (node_is_invisible (child))
return;
@@ -3204,7 +3204,7 @@ gsk_gl_render_job_visit_repeat_node (GskGLRenderJob *job,
if (!graphene_rect_equal (child_bounds, &child->bounds))
{
/* TODO: implement these repeat nodes. */
- gsk_gl_render_job_visit_as_fallback (job, node);
+ gsk_ngl_render_job_visit_as_fallback (job, node);
return;
}
@@ -3213,88 +3213,88 @@ gsk_gl_render_job_visit_repeat_node (GskGLRenderJob *job,
* of the child texture... */
if (rect_contains_rect (child_bounds, &node->bounds))
{
- gsk_gl_render_job_visit_clipped_child (job, child, &node->bounds);
+ gsk_ngl_render_job_visit_clipped_child (job, child, &node->bounds);
return;
}
offscreen.bounds = &child->bounds;
offscreen.reset_clip = TRUE;
- if (!gsk_gl_render_job_visit_node_with_offscreen (job, child, &offscreen))
+ if (!gsk_ngl_render_job_visit_node_with_offscreen (job, child, &offscreen))
g_assert_not_reached ();
- gsk_gl_render_job_begin_draw (job, job->driver->repeat);
- gsk_gl_program_set_uniform_texture (job->driver->repeat,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0,
- offscreen.texture_id);
- gsk_gl_program_set_uniform4f (job->driver->repeat,
- UNIFORM_REPEAT_CHILD_BOUNDS, 0,
- (node->bounds.origin.x - child_bounds->origin.x) / child_bounds->size.width,
- (node->bounds.origin.y - child_bounds->origin.y) / child_bounds->size.height,
- node->bounds.size.width / child_bounds->size.width,
- node->bounds.size.height / child_bounds->size.height);
- gsk_gl_program_set_uniform4f (job->driver->repeat,
- UNIFORM_REPEAT_TEXTURE_RECT, 0,
- offscreen.area.x,
- offscreen.was_offscreen ? offscreen.area.y2 : offscreen.area.y,
- offscreen.area.x2,
- offscreen.was_offscreen ? offscreen.area.y : offscreen.area.y2);
- gsk_gl_render_job_load_vertices_from_offscreen (job, &node->bounds, &offscreen);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_begin_draw (job, job->driver->repeat);
+ gsk_ngl_program_set_uniform_texture (job->driver->repeat,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0,
+ offscreen.texture_id);
+ gsk_ngl_program_set_uniform4f (job->driver->repeat,
+ UNIFORM_REPEAT_CHILD_BOUNDS, 0,
+ (node->bounds.origin.x - child_bounds->origin.x) / child_bounds->size.width,
+ (node->bounds.origin.y - child_bounds->origin.y) /
child_bounds->size.height,
+ node->bounds.size.width / child_bounds->size.width,
+ node->bounds.size.height / child_bounds->size.height);
+ gsk_ngl_program_set_uniform4f (job->driver->repeat,
+ UNIFORM_REPEAT_TEXTURE_RECT, 0,
+ offscreen.area.x,
+ offscreen.was_offscreen ? offscreen.area.y2 : offscreen.area.y,
+ offscreen.area.x2,
+ offscreen.was_offscreen ? offscreen.area.y : offscreen.area.y2);
+ gsk_ngl_render_job_load_vertices_from_offscreen (job, &node->bounds, &offscreen);
+ gsk_ngl_render_job_end_draw (job);
}
static void
-gsk_gl_render_job_visit_node (GskGLRenderJob *job,
- const GskRenderNode *node)
+gsk_ngl_render_job_visit_node (GskNglRenderJob *job,
+ const GskRenderNode *node)
{
g_assert (job != NULL);
g_assert (node != NULL);
- g_assert (GSK_IS_NEXT_DRIVER (job->driver));
- g_assert (GSK_IS_GL_COMMAND_QUEUE (job->command_queue));
+ g_assert (GSK_IS_NGL_DRIVER (job->driver));
+ g_assert (GSK_IS_NGL_COMMAND_QUEUE (job->command_queue));
if (node_is_invisible (node) ||
- !gsk_gl_render_job_node_overlaps_clip (job, node))
+ !gsk_ngl_render_job_node_overlaps_clip (job, node))
return;
switch (gsk_render_node_get_node_type (node))
{
case GSK_BLEND_NODE:
- gsk_gl_render_job_visit_blend_node (job, node);
+ gsk_ngl_render_job_visit_blend_node (job, node);
break;
case GSK_BLUR_NODE:
if (gsk_blur_node_get_radius (node) > 0)
- gsk_gl_render_job_visit_blur_node (job, node);
+ gsk_ngl_render_job_visit_blur_node (job, node);
else
- gsk_gl_render_job_visit_node (job, gsk_blur_node_get_child (node));
+ gsk_ngl_render_job_visit_node (job, gsk_blur_node_get_child (node));
break;
case GSK_BORDER_NODE:
if (gsk_border_node_get_uniform (node))
- gsk_gl_render_job_visit_uniform_border_node (job, node);
+ gsk_ngl_render_job_visit_uniform_border_node (job, node);
else
- gsk_gl_render_job_visit_border_node (job, node);
+ gsk_ngl_render_job_visit_border_node (job, node);
break;
case GSK_CLIP_NODE:
- gsk_gl_render_job_visit_clip_node (job, node);
+ gsk_ngl_render_job_visit_clip_node (job, node);
break;
case GSK_COLOR_NODE:
- gsk_gl_render_job_visit_color_node (job, node);
+ gsk_ngl_render_job_visit_color_node (job, node);
break;
case GSK_COLOR_MATRIX_NODE:
- gsk_gl_render_job_visit_color_matrix_node (job, node);
+ gsk_ngl_render_job_visit_color_matrix_node (job, node);
break;
case GSK_CONIC_GRADIENT_NODE:
if (gsk_conic_gradient_node_get_n_color_stops (node) < MAX_GRADIENT_STOPS)
- gsk_gl_render_job_visit_conic_gradient_node (job, node);
+ gsk_ngl_render_job_visit_conic_gradient_node (job, node);
else
- gsk_gl_render_job_visit_as_fallback (job, node);
+ gsk_ngl_render_job_visit_as_fallback (job, node);
break;
case GSK_CONTAINER_NODE:
@@ -3304,7 +3304,7 @@ gsk_gl_render_job_visit_node (GskGLRenderJob *job,
for (guint i = 0; i < n_children; i++)
{
const GskRenderNode *child = gsk_container_node_get_child (node, i);
- gsk_gl_render_job_visit_node (job, child);
+ gsk_ngl_render_job_visit_node (job, child);
}
}
break;
@@ -3316,83 +3316,83 @@ gsk_gl_render_job_visit_node (GskGLRenderJob *job,
float progress = gsk_cross_fade_node_get_progress (node);
if (progress <= 0.0f)
- gsk_gl_render_job_visit_node (job, gsk_cross_fade_node_get_start_child (node));
+ gsk_ngl_render_job_visit_node (job, gsk_cross_fade_node_get_start_child (node));
else if (progress >= 1.0f || equal_texture_nodes (start_node, end_node))
- gsk_gl_render_job_visit_node (job, gsk_cross_fade_node_get_end_child (node));
+ gsk_ngl_render_job_visit_node (job, gsk_cross_fade_node_get_end_child (node));
else
- gsk_gl_render_job_visit_cross_fade_node (job, node);
+ gsk_ngl_render_job_visit_cross_fade_node (job, node);
}
break;
case GSK_DEBUG_NODE:
/* Debug nodes are ignored because draws get reordered anyway */
- gsk_gl_render_job_visit_node (job, gsk_debug_node_get_child (node));
+ gsk_ngl_render_job_visit_node (job, gsk_debug_node_get_child (node));
break;
case GSK_GL_SHADER_NODE:
- gsk_gl_render_job_visit_gl_shader_node (job, node);
+ gsk_ngl_render_job_visit_gl_shader_node (job, node);
break;
case GSK_INSET_SHADOW_NODE:
if (gsk_inset_shadow_node_get_blur_radius (node) > 0)
- gsk_gl_render_job_visit_blurred_inset_shadow_node (job, node);
+ gsk_ngl_render_job_visit_blurred_inset_shadow_node (job, node);
else
- gsk_gl_render_job_visit_unblurred_inset_shadow_node (job, node);
+ gsk_ngl_render_job_visit_unblurred_inset_shadow_node (job, node);
break;
case GSK_LINEAR_GRADIENT_NODE:
case GSK_REPEATING_LINEAR_GRADIENT_NODE:
if (gsk_linear_gradient_node_get_n_color_stops (node) < MAX_GRADIENT_STOPS)
- gsk_gl_render_job_visit_linear_gradient_node (job, node);
+ gsk_ngl_render_job_visit_linear_gradient_node (job, node);
else
- gsk_gl_render_job_visit_as_fallback (job, node);
+ gsk_ngl_render_job_visit_as_fallback (job, node);
break;
case GSK_OPACITY_NODE:
- gsk_gl_render_job_visit_opacity_node (job, node);
+ gsk_ngl_render_job_visit_opacity_node (job, node);
break;
case GSK_OUTSET_SHADOW_NODE:
if (gsk_outset_shadow_node_get_blur_radius (node) > 0)
- gsk_gl_render_job_visit_blurred_outset_shadow_node (job, node);
+ gsk_ngl_render_job_visit_blurred_outset_shadow_node (job, node);
else
- gsk_gl_render_job_visit_unblurred_outset_shadow_node (job, node);
+ gsk_ngl_render_job_visit_unblurred_outset_shadow_node (job, node);
break;
case GSK_RADIAL_GRADIENT_NODE:
case GSK_REPEATING_RADIAL_GRADIENT_NODE:
- gsk_gl_render_job_visit_radial_gradient_node (job, node);
+ gsk_ngl_render_job_visit_radial_gradient_node (job, node);
break;
case GSK_REPEAT_NODE:
- gsk_gl_render_job_visit_repeat_node (job, node);
+ gsk_ngl_render_job_visit_repeat_node (job, node);
break;
case GSK_ROUNDED_CLIP_NODE:
- gsk_gl_render_job_visit_rounded_clip_node (job, node);
+ gsk_ngl_render_job_visit_rounded_clip_node (job, node);
break;
case GSK_SHADOW_NODE:
- gsk_gl_render_job_visit_shadow_node (job, node);
+ gsk_ngl_render_job_visit_shadow_node (job, node);
break;
case GSK_TEXT_NODE:
- gsk_gl_render_job_visit_text_node (job,
- node,
- gsk_text_node_get_color (node),
- FALSE);
+ gsk_ngl_render_job_visit_text_node (job,
+ node,
+ gsk_text_node_get_color (node),
+ FALSE);
break;
case GSK_TEXTURE_NODE:
- gsk_gl_render_job_visit_texture_node (job, node);
+ gsk_ngl_render_job_visit_texture_node (job, node);
break;
case GSK_TRANSFORM_NODE:
- gsk_gl_render_job_visit_transform_node (job, node);
+ gsk_ngl_render_job_visit_transform_node (job, node);
break;
case GSK_CAIRO_NODE:
- gsk_gl_render_job_visit_as_fallback (job, node);
+ gsk_ngl_render_job_visit_as_fallback (job, node);
break;
case GSK_NOT_A_RENDER_NODE:
@@ -3403,9 +3403,9 @@ gsk_gl_render_job_visit_node (GskGLRenderJob *job,
}
static gboolean
-gsk_gl_render_job_visit_node_with_offscreen (GskGLRenderJob *job,
- const GskRenderNode *node,
- GskGLRenderOffscreen *offscreen)
+gsk_ngl_render_job_visit_node_with_offscreen (GskNglRenderJob *job,
+ const GskRenderNode *node,
+ GskNglRenderOffscreen *offscreen)
{
GskTextureKey key;
guint cached_id;
@@ -3430,7 +3430,7 @@ gsk_gl_render_job_visit_node_with_offscreen (GskGLRenderJob *job,
offscreen->force_offscreen == FALSE)
{
GdkTexture *texture = gsk_texture_node_get_texture (node);
- gsk_gl_render_job_upload_texture (job, texture, offscreen);
+ gsk_ngl_render_job_upload_texture (job, texture, offscreen);
g_assert (offscreen->was_offscreen == FALSE);
return TRUE;
}
@@ -3445,7 +3445,7 @@ gsk_gl_render_job_visit_node_with_offscreen (GskGLRenderJob *job,
key.scale_y = job->scale_y;
key.filter = filter;
- cached_id = gsk_next_driver_lookup_texture (job->driver, &key);
+ cached_id = gsk_ngl_driver_lookup_texture (job->driver, &key);
if (cached_id != 0)
{
@@ -3485,7 +3485,7 @@ gsk_gl_render_job_visit_node_with_offscreen (GskGLRenderJob *job,
}
}
- GskGLRenderTarget *render_target;
+ GskNglRenderTarget *render_target;
graphene_matrix_t prev_projection;
graphene_rect_t prev_viewport;
graphene_rect_t viewport;
@@ -3494,7 +3494,7 @@ gsk_gl_render_job_visit_node_with_offscreen (GskGLRenderJob *job,
float prev_alpha;
guint prev_fbo;
- if (!gsk_next_driver_create_render_target (job->driver,
+ if (!gsk_ngl_driver_create_render_target (job->driver,
scaled_width, scaled_height,
filter, filter,
&render_target))
@@ -3516,55 +3516,55 @@ gsk_gl_render_job_visit_node_with_offscreen (GskGLRenderJob *job,
render_target->framebuffer_id);
}
- gsk_gl_render_job_transform_bounds (job, offscreen->bounds, &viewport);
+ gsk_ngl_render_job_transform_bounds (job, offscreen->bounds, &viewport);
/* Code above will scale the size with the scale we use in the render ops,
* but for the viewport size, we need our own size limited by the texture size */
viewport.size.width = scaled_width;
viewport.size.height = scaled_height;
- gsk_gl_render_job_set_viewport (job, &viewport, &prev_viewport);
- gsk_gl_render_job_set_projection_from_rect (job, &job->viewport, &prev_projection);
- gsk_gl_render_job_set_modelview (job, gsk_transform_scale (NULL, scale_x, scale_y));
- prev_alpha = gsk_gl_render_job_set_alpha (job, 1.0f);
+ gsk_ngl_render_job_set_viewport (job, &viewport, &prev_viewport);
+ gsk_ngl_render_job_set_projection_from_rect (job, &job->viewport, &prev_projection);
+ gsk_ngl_render_job_set_modelview (job, gsk_transform_scale (NULL, scale_x, scale_y));
+ prev_alpha = gsk_ngl_render_job_set_alpha (job, 1.0f);
job->offset_x = offset_x;
job->offset_y = offset_y;
- prev_fbo = gsk_gl_command_queue_bind_framebuffer (job->command_queue, render_target->framebuffer_id);
- gsk_gl_command_queue_clear (job->command_queue, 0, &job->viewport);
+ prev_fbo = gsk_ngl_command_queue_bind_framebuffer (job->command_queue, render_target->framebuffer_id);
+ gsk_ngl_command_queue_clear (job->command_queue, 0, &job->viewport);
if (offscreen->reset_clip)
- gsk_gl_render_job_push_clip (job, &GSK_ROUNDED_RECT_INIT_FROM_RECT (job->viewport));
+ gsk_ngl_render_job_push_clip (job, &GSK_ROUNDED_RECT_INIT_FROM_RECT (job->viewport));
- gsk_gl_render_job_visit_node (job, node);
+ gsk_ngl_render_job_visit_node (job, node);
if (offscreen->reset_clip)
- gsk_gl_render_job_pop_clip (job);
+ gsk_ngl_render_job_pop_clip (job);
- gsk_gl_render_job_pop_modelview (job);
- gsk_gl_render_job_set_viewport (job, &prev_viewport, NULL);
- gsk_gl_render_job_set_projection (job, &prev_projection);
- gsk_gl_render_job_set_alpha (job, prev_alpha);
- gsk_gl_command_queue_bind_framebuffer (job->command_queue, prev_fbo);
+ gsk_ngl_render_job_pop_modelview (job);
+ gsk_ngl_render_job_set_viewport (job, &prev_viewport, NULL);
+ gsk_ngl_render_job_set_projection (job, &prev_projection);
+ gsk_ngl_render_job_set_alpha (job, prev_alpha);
+ gsk_ngl_command_queue_bind_framebuffer (job->command_queue, prev_fbo);
job->offset_x = offset_x;
job->offset_y = offset_y;
offscreen->was_offscreen = TRUE;
- offscreen->texture_id = gsk_next_driver_release_render_target (job->driver,
- render_target,
- FALSE);
+ offscreen->texture_id = gsk_ngl_driver_release_render_target (job->driver,
+ render_target,
+ FALSE);
init_full_texture_region (offscreen);
if (!offscreen->do_not_cache)
- gsk_next_driver_cache_texture (job->driver, &key, offscreen->texture_id);
+ gsk_ngl_driver_cache_texture (job->driver, &key, offscreen->texture_id);
return TRUE;
}
void
-gsk_gl_render_job_render_flipped (GskGLRenderJob *job,
- GskRenderNode *root)
+gsk_ngl_render_job_render_flipped (GskNglRenderJob *job,
+ GskRenderNode *root)
{
graphene_matrix_t proj;
guint framebuffer_id;
@@ -3573,7 +3573,7 @@ gsk_gl_render_job_render_flipped (GskGLRenderJob *job,
g_return_if_fail (job != NULL);
g_return_if_fail (root != NULL);
- g_return_if_fail (GSK_IS_NEXT_DRIVER (job->driver));
+ g_return_if_fail (GSK_IS_NGL_DRIVER (job->driver));
surface_height = job->viewport.size.height;
@@ -3586,7 +3586,7 @@ gsk_gl_render_job_render_flipped (GskGLRenderJob *job,
ORTHO_FAR_PLANE);
graphene_matrix_scale (&proj, 1, -1, 1);
- if (!gsk_gl_command_queue_create_render_target (job->command_queue,
+ if (!gsk_ngl_command_queue_create_render_target (job->command_queue,
MAX (1, job->viewport.size.width),
MAX (1, job->viewport.size.height),
GL_NEAREST, GL_NEAREST,
@@ -3594,29 +3594,29 @@ gsk_gl_render_job_render_flipped (GskGLRenderJob *job,
return;
/* Setup drawing to our offscreen texture/framebuffer which is flipped */
- gsk_gl_command_queue_bind_framebuffer (job->command_queue, framebuffer_id);
- gsk_gl_command_queue_clear (job->command_queue, 0, &job->viewport);
+ gsk_ngl_command_queue_bind_framebuffer (job->command_queue, framebuffer_id);
+ gsk_ngl_command_queue_clear (job->command_queue, 0, &job->viewport);
/* Visit all nodes creating batches */
gdk_gl_context_push_debug_group (job->command_queue->context, "Building command queue");
- gsk_gl_render_job_visit_node (job, root);
+ gsk_ngl_render_job_visit_node (job, root);
gdk_gl_context_pop_debug_group (job->command_queue->context);
/* Now draw to our real destination, but flipped */
- gsk_gl_render_job_set_alpha (job, 1.0f);
- gsk_gl_command_queue_bind_framebuffer (job->command_queue, job->framebuffer);
- gsk_gl_command_queue_clear (job->command_queue, 0, &job->viewport);
- gsk_gl_render_job_begin_draw (job, job->driver->blit);
- gsk_gl_program_set_uniform_texture (job->driver->blit,
- UNIFORM_SHARED_SOURCE, 0,
- GL_TEXTURE_2D,
- GL_TEXTURE0,
- texture_id);
- gsk_gl_render_job_draw_rect (job, &job->viewport);
- gsk_gl_render_job_end_draw (job);
+ gsk_ngl_render_job_set_alpha (job, 1.0f);
+ gsk_ngl_command_queue_bind_framebuffer (job->command_queue, job->framebuffer);
+ gsk_ngl_command_queue_clear (job->command_queue, 0, &job->viewport);
+ gsk_ngl_render_job_begin_draw (job, job->driver->blit);
+ gsk_ngl_program_set_uniform_texture (job->driver->blit,
+ UNIFORM_SHARED_SOURCE, 0,
+ GL_TEXTURE_2D,
+ GL_TEXTURE0,
+ texture_id);
+ gsk_ngl_render_job_draw_rect (job, &job->viewport);
+ gsk_ngl_render_job_end_draw (job);
gdk_gl_context_push_debug_group (job->command_queue->context, "Executing command queue");
- gsk_gl_command_queue_execute (job->command_queue, surface_height, 1, NULL);
+ gsk_ngl_command_queue_execute (job->command_queue, surface_height, 1, NULL);
gdk_gl_context_pop_debug_group (job->command_queue->context);
glDeleteFramebuffers (1, &framebuffer_id);
@@ -3624,8 +3624,8 @@ gsk_gl_render_job_render_flipped (GskGLRenderJob *job,
}
void
-gsk_gl_render_job_render (GskGLRenderJob *job,
- GskRenderNode *root)
+gsk_ngl_render_job_render (GskNglRenderJob *job,
+ GskRenderNode *root)
{
G_GNUC_UNUSED gint64 start_time;
guint scale_factor;
@@ -3633,21 +3633,21 @@ gsk_gl_render_job_render (GskGLRenderJob *job,
g_return_if_fail (job != NULL);
g_return_if_fail (root != NULL);
- g_return_if_fail (GSK_IS_NEXT_DRIVER (job->driver));
+ g_return_if_fail (GSK_IS_NGL_DRIVER (job->driver));
scale_factor = MAX (job->scale_x, job->scale_y);
surface_height = job->viewport.size.height;
- gsk_gl_command_queue_make_current (job->command_queue);
+ gsk_ngl_command_queue_make_current (job->command_queue);
/* Build the command queue using the shared GL context for all renderers
* on the same display.
*/
start_time = GDK_PROFILER_CURRENT_TIME;
gdk_gl_context_push_debug_group (job->command_queue->context, "Building command queue");
- gsk_gl_command_queue_bind_framebuffer (job->command_queue, job->framebuffer);
- gsk_gl_command_queue_clear (job->command_queue, 0, &job->viewport);
- gsk_gl_render_job_visit_node (job, root);
+ gsk_ngl_command_queue_bind_framebuffer (job->command_queue, job->framebuffer);
+ gsk_ngl_command_queue_clear (job->command_queue, 0, &job->viewport);
+ gsk_ngl_render_job_visit_node (job, root);
gdk_gl_context_pop_debug_group (job->command_queue->context);
gdk_profiler_add_mark (start_time, GDK_PROFILER_CURRENT_TIME-start_time, "Build GL command queue", "");
@@ -3655,7 +3655,7 @@ gsk_gl_render_job_render (GskGLRenderJob *job,
/* At this point the atlases have uploaded content while we processed
* nodes but have not necessarily been used by the commands in the queue.
*/
- gsk_next_driver_save_atlases_to_png (job->driver, NULL);
+ gsk_ngl_driver_save_atlases_to_png (job->driver, NULL);
#endif
/* But now for executing the command queue, we want to use the context
@@ -3663,42 +3663,42 @@ gsk_gl_render_job_render (GskGLRenderJob *job,
* is bound to that context.
*/
start_time = GDK_PROFILER_CURRENT_TIME;
- gsk_gl_command_queue_make_current (job->command_queue);
+ gsk_ngl_command_queue_make_current (job->command_queue);
gdk_gl_context_push_debug_group (job->command_queue->context, "Executing command queue");
- gsk_gl_command_queue_execute (job->command_queue, surface_height, scale_factor, job->region);
+ gsk_ngl_command_queue_execute (job->command_queue, surface_height, scale_factor, job->region);
gdk_gl_context_pop_debug_group (job->command_queue->context);
gdk_profiler_add_mark (start_time, GDK_PROFILER_CURRENT_TIME-start_time, "Execute GL command queue", "");
}
void
-gsk_gl_render_job_set_debug_fallback (GskGLRenderJob *job,
- gboolean debug_fallback)
+gsk_ngl_render_job_set_debug_fallback (GskNglRenderJob *job,
+ gboolean debug_fallback)
{
g_return_if_fail (job != NULL);
job->debug_fallback = !!debug_fallback;
}
-GskGLRenderJob *
-gsk_gl_render_job_new (GskNextDriver *driver,
- const graphene_rect_t *viewport,
- float scale_factor,
- const cairo_region_t *region,
- guint framebuffer)
+GskNglRenderJob *
+gsk_ngl_render_job_new (GskNglDriver *driver,
+ const graphene_rect_t *viewport,
+ float scale_factor,
+ const cairo_region_t *region,
+ guint framebuffer)
{
const graphene_rect_t *clip_rect = viewport;
graphene_rect_t transformed_extents;
- GskGLRenderJob *job;
+ GskNglRenderJob *job;
- g_return_val_if_fail (GSK_IS_NEXT_DRIVER (driver), NULL);
+ g_return_val_if_fail (GSK_IS_NGL_DRIVER (driver), NULL);
g_return_val_if_fail (viewport != NULL, NULL);
g_return_val_if_fail (scale_factor > 0, NULL);
- job = g_slice_new0 (GskGLRenderJob);
+ job = g_slice_new0 (GskNglRenderJob);
job->driver = g_object_ref (driver);
job->command_queue = job->driver->command_queue;
- job->clip = g_array_sized_new (FALSE, FALSE, sizeof (GskGLRenderClip), 16);
- job->modelview = g_array_sized_new (FALSE, FALSE, sizeof (GskGLRenderModelview), 16);
+ job->clip = g_array_sized_new (FALSE, FALSE, sizeof (GskNglRenderClip), 16);
+ job->modelview = g_array_sized_new (FALSE, FALSE, sizeof (GskNglRenderModelview), 16);
job->framebuffer = framebuffer;
job->offset_x = 0;
job->offset_y = 0;
@@ -3706,9 +3706,9 @@ gsk_gl_render_job_new (GskNextDriver *driver,
job->scale_y = scale_factor;
job->viewport = *viewport;
- gsk_gl_render_job_set_alpha (job, 1.0);
- gsk_gl_render_job_set_projection_from_rect (job, viewport, NULL);
- gsk_gl_render_job_set_modelview (job, gsk_transform_scale (NULL, scale_factor, scale_factor));
+ gsk_ngl_render_job_set_alpha (job, 1.0);
+ gsk_ngl_render_job_set_projection_from_rect (job, viewport, NULL);
+ gsk_ngl_render_job_set_modelview (job, gsk_transform_scale (NULL, scale_factor, scale_factor));
/* Setup our initial clip. If region is NULL then we are drawing the
* whole viewport. Otherwise, we need to convert the region to a
@@ -3720,34 +3720,34 @@ gsk_gl_render_job_new (GskNextDriver *driver,
cairo_rectangle_int_t extents;
cairo_region_get_extents (region, &extents);
- gsk_gl_render_job_transform_bounds (job,
- &GRAPHENE_RECT_INIT (extents.x,
- extents.y,
- extents.width,
- extents.height),
- &transformed_extents);
+ gsk_ngl_render_job_transform_bounds (job,
+ &GRAPHENE_RECT_INIT (extents.x,
+ extents.y,
+ extents.width,
+ extents.height),
+ &transformed_extents);
clip_rect = &transformed_extents;
job->region = cairo_region_create_rectangle (&extents);
}
- gsk_gl_render_job_push_clip (job,
- &GSK_ROUNDED_RECT_INIT (clip_rect->origin.x,
- clip_rect->origin.y,
- clip_rect->size.width,
- clip_rect->size.height));
+ gsk_ngl_render_job_push_clip (job,
+ &GSK_ROUNDED_RECT_INIT (clip_rect->origin.x,
+ clip_rect->origin.y,
+ clip_rect->size.width,
+ clip_rect->size.height));
return job;
}
void
-gsk_gl_render_job_free (GskGLRenderJob *job)
+gsk_ngl_render_job_free (GskNglRenderJob *job)
{
job->current_modelview = NULL;
job->current_clip = NULL;
while (job->modelview->len > 0)
{
- GskGLRenderModelview *modelview = &g_array_index (job->modelview, GskGLRenderModelview,
job->modelview->len-1);
+ GskNglRenderModelview *modelview = &g_array_index (job->modelview, GskNglRenderModelview,
job->modelview->len-1);
g_clear_pointer (&modelview->transform, gsk_transform_unref);
job->modelview->len--;
}
@@ -3756,5 +3756,5 @@ gsk_gl_render_job_free (GskGLRenderJob *job)
g_clear_pointer (&job->region, cairo_region_destroy);
g_clear_pointer (&job->modelview, g_array_unref);
g_clear_pointer (&job->clip, g_array_unref);
- g_slice_free (GskGLRenderJob, job);
+ g_slice_free (GskNglRenderJob, job);
}
diff --git a/gsk/ngl/gsknglrenderjobprivate.h b/gsk/ngl/gsknglrenderjobprivate.h
new file mode 100644
index 0000000000..ba3f3e49b7
--- /dev/null
+++ b/gsk/ngl/gsknglrenderjobprivate.h
@@ -0,0 +1,39 @@
+/* gsknglrenderjobprivate.h
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ */
+
+#ifndef __GSK_NGL_RENDER_JOB_H__
+#define __GSK_NGL_RENDER_JOB_H__
+
+#include "gskngltypesprivate.h"
+
+GskNglRenderJob *gsk_ngl_render_job_new (GskNglDriver *driver,
+ const graphene_rect_t *viewport,
+ float scale_factor,
+ const cairo_region_t *region,
+ guint framebuffer);
+void gsk_ngl_render_job_free (GskNglRenderJob *job);
+void gsk_ngl_render_job_render (GskNglRenderJob *job,
+ GskRenderNode *root);
+void gsk_ngl_render_job_render_flipped (GskNglRenderJob *job,
+ GskRenderNode *root);
+void gsk_ngl_render_job_set_debug_fallback (GskNglRenderJob *job,
+ gboolean debug_fallback);
+
+#endif /* __GSK_NGL_RENDER_JOB_H__ */
diff --git a/gsk/next/gskglshadowlibrary.c b/gsk/ngl/gsknglshadowlibrary.c
similarity index 62%
rename from gsk/next/gskglshadowlibrary.c
rename to gsk/ngl/gsknglshadowlibrary.c
index 24a9481fc2..bcf524c8b7 100644
--- a/gsk/next/gskglshadowlibrary.c
+++ b/gsk/ngl/gsknglshadowlibrary.c
@@ -1,4 +1,4 @@
-/* gskglshadowlibrary.c
+/* gsknglshadowlibrary.c
*
* Copyright 2020 Christian Hergert <chergert redhat com>
*
@@ -22,15 +22,15 @@
#include <string.h>
-#include "gskgldriverprivate.h"
-#include "gskglshadowlibraryprivate.h"
+#include "gskngldriverprivate.h"
+#include "gsknglshadowlibraryprivate.h"
#define MAX_UNUSED_FRAMES (16 * 5)
-struct _GskGLShadowLibrary
+struct _GskNglShadowLibrary
{
GObject parent_instance;
- GskNextDriver *driver;
+ GskNglDriver *driver;
GArray *shadows;
};
@@ -42,7 +42,7 @@ typedef struct _Shadow
gint64 last_used_in_frame;
} Shadow;
-G_DEFINE_TYPE (GskGLShadowLibrary, gsk_gl_shadow_library, G_TYPE_OBJECT)
+G_DEFINE_TYPE (GskNglShadowLibrary, gsk_ngl_shadow_library, G_TYPE_OBJECT)
enum {
PROP_0,
@@ -52,10 +52,10 @@ enum {
static GParamSpec *properties [N_PROPS];
-GskGLShadowLibrary *
-gsk_gl_shadow_library_new (GskNextDriver *driver)
+GskNglShadowLibrary *
+gsk_ngl_shadow_library_new (GskNglDriver *driver)
{
- g_return_val_if_fail (GSK_IS_NEXT_DRIVER (driver), NULL);
+ g_return_val_if_fail (GSK_IS_NGL_DRIVER (driver), NULL);
return g_object_new (GSK_TYPE_GL_SHADOW_LIBRARY,
"driver", driver,
@@ -63,29 +63,29 @@ gsk_gl_shadow_library_new (GskNextDriver *driver)
}
static void
-gsk_gl_shadow_library_dispose (GObject *object)
+gsk_ngl_shadow_library_dispose (GObject *object)
{
- GskGLShadowLibrary *self = (GskGLShadowLibrary *)object;
+ GskNglShadowLibrary *self = (GskNglShadowLibrary *)object;
for (guint i = 0; i < self->shadows->len; i++)
{
const Shadow *shadow = &g_array_index (self->shadows, Shadow, i);
- gsk_next_driver_release_texture_by_id (self->driver, shadow->texture_id);
+ gsk_ngl_driver_release_texture_by_id (self->driver, shadow->texture_id);
}
g_clear_pointer (&self->shadows, g_array_unref);
g_clear_object (&self->driver);
- G_OBJECT_CLASS (gsk_gl_shadow_library_parent_class)->dispose (object);
+ G_OBJECT_CLASS (gsk_ngl_shadow_library_parent_class)->dispose (object);
}
static void
-gsk_gl_shadow_library_get_property (GObject *object,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec)
+gsk_ngl_shadow_library_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
{
- GskGLShadowLibrary *self = GSK_GL_SHADOW_LIBRARY (object);
+ GskNglShadowLibrary *self = GSK_NGL_SHADOW_LIBRARY (object);
switch (prop_id)
{
@@ -99,12 +99,12 @@ gsk_gl_shadow_library_get_property (GObject *object,
}
static void
-gsk_gl_shadow_library_set_property (GObject *object,
- guint prop_id,
- const GValue *value,
- GParamSpec *pspec)
+gsk_ngl_shadow_library_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
{
- GskGLShadowLibrary *self = GSK_GL_SHADOW_LIBRARY (object);
+ GskNglShadowLibrary *self = GSK_NGL_SHADOW_LIBRARY (object);
switch (prop_id)
{
@@ -118,43 +118,43 @@ gsk_gl_shadow_library_set_property (GObject *object,
}
static void
-gsk_gl_shadow_library_class_init (GskGLShadowLibraryClass *klass)
+gsk_ngl_shadow_library_class_init (GskNglShadowLibraryClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
- object_class->dispose = gsk_gl_shadow_library_dispose;
- object_class->get_property = gsk_gl_shadow_library_get_property;
- object_class->set_property = gsk_gl_shadow_library_set_property;
+ object_class->dispose = gsk_ngl_shadow_library_dispose;
+ object_class->get_property = gsk_ngl_shadow_library_get_property;
+ object_class->set_property = gsk_ngl_shadow_library_set_property;
properties [PROP_DRIVER] =
g_param_spec_object ("driver",
"Driver",
"Driver",
- GSK_TYPE_NEXT_DRIVER,
+ GSK_TYPE_NGL_DRIVER,
(G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
g_object_class_install_properties (object_class, N_PROPS, properties);
}
static void
-gsk_gl_shadow_library_init (GskGLShadowLibrary *self)
+gsk_ngl_shadow_library_init (GskNglShadowLibrary *self)
{
self->shadows = g_array_new (FALSE, FALSE, sizeof (Shadow));
}
void
-gsk_gl_shadow_library_insert (GskGLShadowLibrary *self,
- const GskRoundedRect *outline,
- float blur_radius,
- guint texture_id)
+gsk_ngl_shadow_library_insert (GskNglShadowLibrary *self,
+ const GskRoundedRect *outline,
+ float blur_radius,
+ guint texture_id)
{
Shadow *shadow;
- g_assert (GSK_IS_GL_SHADOW_LIBRARY (self));
+ g_assert (GSK_IS_NGL_SHADOW_LIBRARY (self));
g_assert (outline != NULL);
g_assert (texture_id != 0);
- gsk_next_driver_mark_texture_permanent (self->driver, texture_id);
+ gsk_ngl_driver_mark_texture_permanent (self->driver, texture_id);
g_array_set_size (self->shadows, self->shadows->len + 1);
@@ -166,13 +166,13 @@ gsk_gl_shadow_library_insert (GskGLShadowLibrary *self,
}
guint
-gsk_gl_shadow_library_lookup (GskGLShadowLibrary *self,
- const GskRoundedRect *outline,
- float blur_radius)
+gsk_ngl_shadow_library_lookup (GskNglShadowLibrary *self,
+ const GskRoundedRect *outline,
+ float blur_radius)
{
Shadow *ret = NULL;
- g_assert (GSK_IS_GL_SHADOW_LIBRARY (self));
+ g_assert (GSK_IS_NGL_SHADOW_LIBRARY (self));
g_assert (outline != NULL);
/* Ensure GskRoundedRect is 12 packed floats without padding
@@ -203,13 +203,13 @@ gsk_gl_shadow_library_lookup (GskGLShadowLibrary *self,
}
void
-gsk_gl_shadow_library_begin_frame (GskGLShadowLibrary *self)
+gsk_ngl_shadow_library_begin_frame (GskNglShadowLibrary *self)
{
gint64 watermark;
int i;
int p;
- g_return_if_fail (GSK_IS_GL_SHADOW_LIBRARY (self));
+ g_return_if_fail (GSK_IS_NGL_SHADOW_LIBRARY (self));
watermark = self->driver->current_frame_id - MAX_UNUSED_FRAMES;
@@ -219,7 +219,7 @@ gsk_gl_shadow_library_begin_frame (GskGLShadowLibrary *self)
if (shadow->last_used_in_frame < watermark)
{
- gsk_next_driver_release_texture_by_id (self->driver, shadow->texture_id);
+ gsk_ngl_driver_release_texture_by_id (self->driver, shadow->texture_id);
g_array_remove_index_fast (self->shadows, i);
p--;
i--;
diff --git a/gsk/ngl/gsknglshadowlibraryprivate.h b/gsk/ngl/gsknglshadowlibraryprivate.h
new file mode 100644
index 0000000000..3c534663dc
--- /dev/null
+++ b/gsk/ngl/gsknglshadowlibraryprivate.h
@@ -0,0 +1,44 @@
+/* gsknglshadowlibraryprivate.h
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ */
+
+#ifndef __GSK_NGL_SHADOW_LIBRARY_PRIVATE_H__
+#define __GSK_NGL_SHADOW_LIBRARY_PRIVATE_H__
+
+#include "gskngltexturelibraryprivate.h"
+
+G_BEGIN_DECLS
+
+#define GSK_TYPE_GL_SHADOW_LIBRARY (gsk_ngl_shadow_library_get_type())
+
+G_DECLARE_FINAL_TYPE (GskNglShadowLibrary, gsk_ngl_shadow_library, GSK, NGL_SHADOW_LIBRARY, GObject)
+
+GskNglShadowLibrary *gsk_ngl_shadow_library_new (GskNglDriver *driver);
+void gsk_ngl_shadow_library_begin_frame (GskNglShadowLibrary *self);
+guint gsk_ngl_shadow_library_lookup (GskNglShadowLibrary *self,
+ const GskRoundedRect *outline,
+ float blur_radius);
+void gsk_ngl_shadow_library_insert (GskNglShadowLibrary *self,
+ const GskRoundedRect *outline,
+ float blur_radius,
+ guint texture_id);
+
+G_END_DECLS
+
+#endif /* __GSK_NGL_SHADOW_LIBRARY_PRIVATE_H__ */
diff --git a/gsk/ngl/gskngltexturelibrary.c b/gsk/ngl/gskngltexturelibrary.c
new file mode 100644
index 0000000000..dc9303f373
--- /dev/null
+++ b/gsk/ngl/gskngltexturelibrary.c
@@ -0,0 +1,315 @@
+/* gskngltexturelibrary.c
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ */
+
+#include "config.h"
+
+#include "gsknglcommandqueueprivate.h"
+#include "gskngldriverprivate.h"
+#include "gskngltexturelibraryprivate.h"
+
+G_DEFINE_ABSTRACT_TYPE (GskNglTextureLibrary, gsk_ngl_texture_library, G_TYPE_OBJECT)
+
+enum {
+ PROP_0,
+ PROP_DRIVER,
+ N_PROPS
+};
+
+static GParamSpec *properties [N_PROPS];
+
+static void
+gsk_ngl_texture_library_constructed (GObject *object)
+{
+ G_OBJECT_CLASS (gsk_ngl_texture_library_parent_class)->constructed (object);
+
+ g_assert (GSK_NGL_TEXTURE_LIBRARY (object)->hash_table != NULL);
+}
+
+static void
+gsk_ngl_texture_library_dispose (GObject *object)
+{
+ GskNglTextureLibrary *self = (GskNglTextureLibrary *)object;
+
+ g_clear_object (&self->driver);
+
+ G_OBJECT_CLASS (gsk_ngl_texture_library_parent_class)->dispose (object);
+}
+
+static void
+gsk_ngl_texture_library_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GskNglTextureLibrary *self = GSK_NGL_TEXTURE_LIBRARY (object);
+
+ switch (prop_id)
+ {
+ case PROP_DRIVER:
+ g_value_set_object (value, self->driver);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+gsk_ngl_texture_library_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GskNglTextureLibrary *self = GSK_NGL_TEXTURE_LIBRARY (object);
+
+ switch (prop_id)
+ {
+ case PROP_DRIVER:
+ self->driver = g_value_dup_object (value);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ }
+}
+
+static void
+gsk_ngl_texture_library_class_init (GskNglTextureLibraryClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->constructed = gsk_ngl_texture_library_constructed;
+ object_class->dispose = gsk_ngl_texture_library_dispose;
+ object_class->get_property = gsk_ngl_texture_library_get_property;
+ object_class->set_property = gsk_ngl_texture_library_set_property;
+
+ properties [PROP_DRIVER] =
+ g_param_spec_object ("driver",
+ "Driver",
+ "Driver",
+ GSK_TYPE_NGL_DRIVER,
+ (G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_properties (object_class, N_PROPS, properties);
+}
+
+static void
+gsk_ngl_texture_library_init (GskNglTextureLibrary *self)
+{
+}
+
+void
+gsk_ngl_texture_library_set_funcs (GskNglTextureLibrary *self,
+ GHashFunc hash_func,
+ GEqualFunc equal_func,
+ GDestroyNotify key_destroy,
+ GDestroyNotify value_destroy)
+{
+ g_return_if_fail (GSK_IS_NGL_TEXTURE_LIBRARY (self));
+ g_return_if_fail (self->hash_table == NULL);
+
+ self->hash_table = g_hash_table_new_full (hash_func, equal_func,
+ key_destroy, value_destroy);
+}
+
+void
+gsk_ngl_texture_library_begin_frame (GskNglTextureLibrary *self)
+{
+ g_return_if_fail (GSK_IS_NGL_TEXTURE_LIBRARY (self));
+
+ if (GSK_NGL_TEXTURE_LIBRARY_GET_CLASS (self)->begin_frame)
+ GSK_NGL_TEXTURE_LIBRARY_GET_CLASS (self)->begin_frame (self);
+}
+
+void
+gsk_ngl_texture_library_end_frame (GskNglTextureLibrary *self)
+{
+ g_return_if_fail (GSK_IS_NGL_TEXTURE_LIBRARY (self));
+
+ if (GSK_NGL_TEXTURE_LIBRARY_GET_CLASS (self)->end_frame)
+ GSK_NGL_TEXTURE_LIBRARY_GET_CLASS (self)->end_frame (self);
+}
+
+static GskNglTexture *
+gsk_ngl_texture_library_pack_one (GskNglTextureLibrary *self,
+ guint width,
+ guint height)
+{
+ GskNglTexture *texture;
+
+ g_assert (GSK_IS_NGL_TEXTURE_LIBRARY (self));
+
+ if (width > self->driver->command_queue->max_texture_size ||
+ height > self->driver->command_queue->max_texture_size)
+ {
+ g_warning ("Clipping requested texture of size %ux%u to maximum allowable size %u.",
+ width, height, self->driver->command_queue->max_texture_size);
+ width = MIN (width, self->driver->command_queue->max_texture_size);
+ height = MIN (height, self->driver->command_queue->max_texture_size);
+ }
+
+ texture = gsk_ngl_driver_create_texture (self->driver, width, height, GL_LINEAR, GL_LINEAR);
+ texture->permanent = TRUE;
+
+ return texture;
+}
+
+static inline gboolean
+gsk_ngl_texture_atlas_pack (GskNglTextureAtlas *self,
+ int width,
+ int height,
+ int *out_x,
+ int *out_y)
+{
+ stbrp_rect rect;
+
+ rect.w = width;
+ rect.h = height;
+
+ stbrp_pack_rects (&self->context, &rect, 1);
+
+ if (rect.was_packed)
+ {
+ *out_x = rect.x;
+ *out_y = rect.y;
+ }
+
+ return rect.was_packed;
+}
+
+static void
+gsk_ngl_texture_atlases_pack (GskNglDriver *driver,
+ int width,
+ int height,
+ GskNglTextureAtlas **out_atlas,
+ int *out_x,
+ int *out_y)
+{
+ GskNglTextureAtlas *atlas = NULL;
+ int x, y;
+
+ for (guint i = 0; i < driver->atlases->len; i++)
+ {
+ atlas = g_ptr_array_index (driver->atlases, i);
+
+ if (gsk_ngl_texture_atlas_pack (atlas, width, height, &x, &y))
+ break;
+
+ atlas = NULL;
+ }
+
+ if (atlas == NULL)
+ {
+ /* No atlas has enough space, so create a new one... */
+ atlas = gsk_ngl_driver_create_atlas (driver);
+
+ /* Pack it onto that one, which surely has enough space... */
+ if (!gsk_ngl_texture_atlas_pack (atlas, width, height, &x, &y))
+ g_assert_not_reached ();
+ }
+
+ *out_atlas = atlas;
+ *out_x = x;
+ *out_y = y;
+}
+
+gpointer
+gsk_ngl_texture_library_pack (GskNglTextureLibrary *self,
+ gpointer key,
+ gsize valuelen,
+ guint width,
+ guint height,
+ int padding,
+ guint *out_packed_x,
+ guint *out_packed_y)
+{
+ GskNglTextureAtlasEntry *entry;
+ GskNglTextureAtlas *atlas = NULL;
+
+ g_assert (GSK_IS_NGL_TEXTURE_LIBRARY (self));
+ g_assert (key != NULL);
+ g_assert (valuelen > sizeof (GskNglTextureAtlasEntry));
+ g_assert (out_packed_x != NULL);
+ g_assert (out_packed_y != NULL);
+
+ entry = g_slice_alloc0 (valuelen);
+ entry->n_pixels = width * height;
+ entry->accessed = TRUE;
+
+ /* If our size is invisible then we just want an entry in the
+ * cache for faster lookups, but do not actually spend any texture
+ * allocations on this entry.
+ */
+ if (width <= 0 && height <= 0)
+ {
+ entry->is_atlased = FALSE;
+ entry->texture = NULL;
+ entry->area.x = 0.0f;
+ entry->area.y = 0.0f;
+ entry->area.x2 = 0.0f;
+ entry->area.y2 = 0.0f;
+
+ *out_packed_x = 0;
+ *out_packed_y = 0;
+ }
+ else if (width <= self->max_entry_size && height <= self->max_entry_size)
+ {
+ int packed_x;
+ int packed_y;
+
+ gsk_ngl_texture_atlases_pack (self->driver,
+ padding + width + padding,
+ padding + height + padding,
+ &atlas,
+ &packed_x,
+ &packed_y);
+
+ entry->atlas = atlas;
+ entry->is_atlased = TRUE;
+ entry->area.x = (float)(packed_x + padding) / atlas->width;
+ entry->area.y = (float)(packed_y + padding) / atlas->height;
+ entry->area.x2 = entry->area.x + (float)width / atlas->width;
+ entry->area.y2 = entry->area.y + (float)height / atlas->height;
+
+ *out_packed_x = packed_x;
+ *out_packed_y = packed_y;
+ }
+ else
+ {
+ GskNglTexture *texture = gsk_ngl_texture_library_pack_one (self,
+ padding + width + padding,
+ padding + height + padding);
+
+ entry->texture = texture;
+ entry->is_atlased = FALSE;
+ entry->accessed = TRUE;
+ entry->area.x = 0.0f;
+ entry->area.y = 0.0f;
+ entry->area.x2 = 1.0f;
+ entry->area.y2 = 1.0f;
+
+ *out_packed_x = padding;
+ *out_packed_y = padding;
+ }
+
+ g_hash_table_insert (self->hash_table, key, entry);
+
+ return entry;
+}
diff --git a/gsk/ngl/gskngltexturelibraryprivate.h b/gsk/ngl/gskngltexturelibraryprivate.h
new file mode 100644
index 0000000000..56c3d604cc
--- /dev/null
+++ b/gsk/ngl/gskngltexturelibraryprivate.h
@@ -0,0 +1,202 @@
+/* gskngltexturelibraryprivate.h
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * This file is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or (at your option)
+ * any later version.
+ *
+ * This file is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ */
+
+#ifndef __GSK_NGL_TEXTURE_LIBRARY_PRIVATE_H__
+#define __GSK_NGL_TEXTURE_LIBRARY_PRIVATE_H__
+
+#include "gskngltypesprivate.h"
+#include "gskngltexturepoolprivate.h"
+
+#include "../gl/stb_rect_pack.h"
+
+G_BEGIN_DECLS
+
+#define GSK_TYPE_GL_TEXTURE_LIBRARY (gsk_ngl_texture_library_get_type ())
+#define GSK_NGL_TEXTURE_LIBRARY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj),
GSK_TYPE_GL_TEXTURE_LIBRARY, GskNglTextureLibrary))
+#define GSK_IS_NGL_TEXTURE_LIBRARY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj),
GSK_TYPE_GL_TEXTURE_LIBRARY))
+#define GSK_NGL_TEXTURE_LIBRARY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass),
GSK_TYPE_GL_TEXTURE_LIBRARY, GskNglTextureLibraryClass))
+#define GSK_IS_NGL_TEXTURE_LIBRARY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),
GSK_TYPE_GL_TEXTURE_LIBRARY))
+#define GSK_NGL_TEXTURE_LIBRARY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),
GSK_TYPE_GL_TEXTURE_LIBRARY, GskNglTextureLibraryClass))
+
+typedef struct _GskNglTextureAtlas
+{
+ struct stbrp_context context;
+ struct stbrp_node *nodes;
+
+ int width;
+ int height;
+
+ guint texture_id;
+
+ /* Pixels of rects that have been used at some point,
+ * But are now unused.
+ */
+ int unused_pixels;
+
+ void *user_data;
+} GskNglTextureAtlas;
+
+typedef struct _GskNglTextureAtlasEntry
+{
+ /* A backreference to either the atlas or texture containing
+ * the contents of the atlas entry. For larger items, no atlas
+ * is used and instead a direct texture.
+ */
+ union {
+ GskNglTextureAtlas *atlas;
+ GskNglTexture *texture;
+ };
+
+ /* The area within the atlas translated to 0..1 bounds */
+ struct {
+ float x;
+ float y;
+ float x2;
+ float y2;
+ } area;
+
+ /* Number of pixels in the entry, used to calculate usage
+ * of an atlas while processing.
+ */
+ guint n_pixels : 29;
+
+ /* If entry has marked pixels as used in the atlas this frame */
+ guint used : 1;
+
+ /* If entry was accessed this frame */
+ guint accessed : 1;
+
+ /* When true, backref is an atlas, otherwise texture */
+ guint is_atlased : 1;
+
+ /* Suffix data that is per-library specific. gpointer used to
+ * guarantee the alignment for the entries using this.
+ */
+ gpointer data[0];
+} GskNglTextureAtlasEntry;
+
+typedef struct _GskNglTextureLibrary
+{
+ GObject parent_instance;
+ GskNglDriver *driver;
+ GHashTable *hash_table;
+ guint max_entry_size;
+} GskNglTextureLibrary;
+
+typedef struct _GskNglTextureLibraryClass
+{
+ GObjectClass parent_class;
+
+ void (*begin_frame) (GskNglTextureLibrary *library);
+ void (*end_frame) (GskNglTextureLibrary *library);
+} GskNglTextureLibraryClass;
+
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (GskNglTextureLibrary, g_object_unref)
+
+GType gsk_ngl_texture_library_get_type (void) G_GNUC_CONST;
+void gsk_ngl_texture_library_set_funcs (GskNglTextureLibrary *self,
+ GHashFunc hash_func,
+ GEqualFunc equal_func,
+ GDestroyNotify key_destroy,
+ GDestroyNotify value_destroy);
+void gsk_ngl_texture_library_begin_frame (GskNglTextureLibrary *self);
+void gsk_ngl_texture_library_end_frame (GskNglTextureLibrary *self);
+gpointer gsk_ngl_texture_library_pack (GskNglTextureLibrary *self,
+ gpointer key,
+ gsize valuelen,
+ guint width,
+ guint height,
+ int padding,
+ guint *out_packed_x,
+ guint *out_packed_y);
+
+static inline void
+gsk_ngl_texture_atlas_mark_unused (GskNglTextureAtlas *self,
+ int n_pixels)
+{
+ self->unused_pixels += n_pixels;
+}
+
+static inline void
+gsk_ngl_texture_atlas_mark_used (GskNglTextureAtlas *self,
+ int n_pixels)
+{
+ self->unused_pixels -= n_pixels;
+}
+
+static inline gboolean
+gsk_ngl_texture_library_lookup (GskNglTextureLibrary *self,
+ gconstpointer key,
+ GskNglTextureAtlasEntry **out_entry)
+{
+ GskNglTextureAtlasEntry *entry = g_hash_table_lookup (self->hash_table, key);
+
+ if G_LIKELY (entry != NULL && entry->accessed && entry->used)
+ {
+ *out_entry = entry;
+ return TRUE;
+ }
+
+ if (entry != NULL)
+ {
+ if (!entry->used && entry->is_atlased)
+ {
+ g_assert (entry->atlas != NULL);
+ gsk_ngl_texture_atlas_mark_used (entry->atlas, entry->n_pixels);
+ entry->used = TRUE;
+ }
+
+ entry->accessed = TRUE;
+ *out_entry = entry;
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static inline guint
+GSK_NGL_TEXTURE_ATLAS_ENTRY_TEXTURE (gconstpointer d)
+{
+ const GskNglTextureAtlasEntry *e = d;
+
+ return e->is_atlased ? e->atlas->texture_id
+ : e->texture ? e->texture->texture_id : 0;
+}
+
+static inline double
+gsk_ngl_texture_atlas_get_unused_ratio (const GskNglTextureAtlas *self)
+{
+ if (self->unused_pixels > 0)
+ return (double)(self->unused_pixels) / (double)(self->width * self->height);
+ return 0.0;
+}
+
+static inline gboolean
+gsk_ngl_texture_library_can_cache (GskNglTextureLibrary *self,
+ int width,
+ int height)
+{
+ g_assert (self->max_entry_size > 0);
+ return width <= self->max_entry_size && height <= self->max_entry_size;
+}
+
+G_END_DECLS
+
+#endif /* __GSK_NGL_TEXTURE_LIBRARY_PRIVATE_H__ */
diff --git a/gsk/next/gskgltexturepool.c b/gsk/ngl/gskngltexturepool.c
similarity index 72%
rename from gsk/next/gskgltexturepool.c
rename to gsk/ngl/gskngltexturepool.c
index e81c04632a..707ae37455 100644
--- a/gsk/next/gskgltexturepool.c
+++ b/gsk/ngl/gskngltexturepool.c
@@ -1,4 +1,4 @@
-/* gskgltexturepool.c
+/* gskngltexturepool.c
*
* Copyright 2020 Christian Hergert <chergert redhat com>
*
@@ -22,11 +22,11 @@
#include <gdk/gdktextureprivate.h>
-#include "gskgltexturepoolprivate.h"
+#include "gskngltexturepoolprivate.h"
#include "ninesliceprivate.h"
void
-gsk_gl_texture_free (GskGLTexture *texture)
+gsk_ngl_texture_free (GskNglTexture *texture)
{
if (texture != NULL)
{
@@ -51,18 +51,18 @@ gsk_gl_texture_free (GskGLTexture *texture)
g_clear_pointer (&texture->slices, g_free);
g_clear_pointer (&texture->nine_slice, g_free);
- g_slice_free (GskGLTexture, texture);
+ g_slice_free (GskNglTexture, texture);
}
}
void
-gsk_gl_texture_pool_init (GskGLTexturePool *self)
+gsk_ngl_texture_pool_init (GskNglTexturePool *self)
{
g_queue_init (&self->queue);
}
void
-gsk_gl_texture_pool_clear (GskGLTexturePool *self)
+gsk_ngl_texture_pool_clear (GskNglTexturePool *self)
{
guint *free_me = NULL;
guint *texture_ids;
@@ -75,14 +75,14 @@ gsk_gl_texture_pool_clear (GskGLTexturePool *self)
while (self->queue.length > 0)
{
- GskGLTexture *head = g_queue_peek_head (&self->queue);
+ GskNglTexture *head = g_queue_peek_head (&self->queue);
g_queue_unlink (&self->queue, &head->link);
texture_ids[i++] = head->texture_id;
head->texture_id = 0;
- gsk_gl_texture_free (head);
+ gsk_ngl_texture_free (head);
}
g_assert (self->queue.length == 0);
@@ -94,11 +94,9 @@ gsk_gl_texture_pool_clear (GskGLTexturePool *self)
}
void
-gsk_gl_texture_pool_put (GskGLTexturePool *self,
- GskGLTexture *texture)
+gsk_ngl_texture_pool_put (GskNglTexturePool *self,
+ GskNglTexture *texture)
{
- GList *sibling;
-
g_assert (self != NULL);
g_assert (texture != NULL);
g_assert (texture->user == NULL);
@@ -107,23 +105,23 @@ gsk_gl_texture_pool_put (GskGLTexturePool *self,
g_assert (texture->link.data == texture);
if (texture->permanent)
- gsk_gl_texture_free (texture);
+ gsk_ngl_texture_free (texture);
else
g_queue_push_tail_link (&self->queue, &texture->link);
}
-GskGLTexture *
-gsk_gl_texture_pool_get (GskGLTexturePool *self,
- int width,
- int height,
- int min_filter,
- int mag_filter)
+GskNglTexture *
+gsk_ngl_texture_pool_get (GskNglTexturePool *self,
+ int width,
+ int height,
+ int min_filter,
+ int mag_filter)
{
- GskGLTexture *texture;
+ GskNglTexture *texture;
g_assert (self != NULL);
- texture = g_slice_new0 (GskGLTexture);
+ texture = g_slice_new0 (GskNglTexture);
texture->link.data = texture;
texture->min_filter = min_filter;
texture->mag_filter = mag_filter;
@@ -147,17 +145,17 @@ gsk_gl_texture_pool_get (GskGLTexturePool *self,
return texture;
}
-GskGLTexture *
-gsk_gl_texture_new (guint texture_id,
- int width,
- int height,
- int min_filter,
- int mag_filter,
- gint64 frame_id)
+GskNglTexture *
+gsk_ngl_texture_new (guint texture_id,
+ int width,
+ int height,
+ int min_filter,
+ int mag_filter,
+ gint64 frame_id)
{
- GskGLTexture *texture;
+ GskNglTexture *texture;
- texture = g_slice_new0 (GskGLTexture);
+ texture = g_slice_new0 (GskNglTexture);
texture->texture_id = texture_id;
texture->link.data = texture;
texture->min_filter = min_filter;
@@ -169,17 +167,17 @@ gsk_gl_texture_new (guint texture_id,
return texture;
}
-const GskGLTextureNineSlice *
-gsk_gl_texture_get_nine_slice (GskGLTexture *texture,
- const GskRoundedRect *outline,
- float extra_pixels)
+const GskNglTextureNineSlice *
+gsk_ngl_texture_get_nine_slice (GskNglTexture *texture,
+ const GskRoundedRect *outline,
+ float extra_pixels)
{
g_assert (texture != NULL);
g_assert (outline != NULL);
if G_UNLIKELY (texture->nine_slice == NULL)
{
- texture->nine_slice = g_new0 (GskGLTextureNineSlice, 9);
+ texture->nine_slice = g_new0 (GskNglTextureNineSlice, 9);
nine_slice_rounded_rect (texture->nine_slice, outline);
nine_slice_grow (texture->nine_slice, extra_pixels);
diff --git a/gsk/ngl/gskngltexturepoolprivate.h b/gsk/ngl/gskngltexturepoolprivate.h
new file mode 100644
index 0000000000..8b39ec5440
--- /dev/null
+++ b/gsk/ngl/gskngltexturepoolprivate.h
@@ -0,0 +1,102 @@
+/* gskngltexturepoolprivate.h
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * This file is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or (at your option)
+ * any later version.
+ *
+ * This file is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ */
+
+#ifndef _GSK_NGL_TEXTURE_POOL_PRIVATE_H__
+#define _GSK_NGL_TEXTURE_POOL_PRIVATE_H__
+
+#include "gskngltypesprivate.h"
+
+G_BEGIN_DECLS
+
+typedef struct _GskNglTexturePool
+{
+ GQueue queue;
+} GskNglTexturePool;
+
+struct _GskNglTextureSlice
+{
+ cairo_rectangle_int_t rect;
+ guint texture_id;
+};
+
+struct _GskNglTextureNineSlice
+{
+ cairo_rectangle_int_t rect;
+ struct {
+ float x;
+ float y;
+ float x2;
+ float y2;
+ } area;
+};
+
+struct _GskNglTexture
+{
+ /* Used to insert into queue */
+ GList link;
+
+ /* Identifier of the frame that created it */
+ gint64 last_used_in_frame;
+
+ /* Backpointer to texture (can be cleared asynchronously) */
+ GdkTexture *user;
+
+ /* Only used by sliced textures */
+ GskNglTextureSlice *slices;
+ guint n_slices;
+
+ /* Only used by nine-slice textures */
+ GskNglTextureNineSlice *nine_slice;
+
+ /* The actual GL texture identifier in some shared context */
+ guint texture_id;
+
+ int width;
+ int height;
+ int min_filter;
+ int mag_filter;
+
+ /* Set when used by an atlas so we don't drop the texture */
+ guint permanent : 1;
+};
+
+void gsk_ngl_texture_pool_init (GskNglTexturePool *self);
+void gsk_ngl_texture_pool_clear (GskNglTexturePool *self);
+GskNglTexture *gsk_ngl_texture_pool_get (GskNglTexturePool *self,
+ int width,
+ int height,
+ int min_filter,
+ int mag_filter);
+void gsk_ngl_texture_pool_put (GskNglTexturePool *self,
+ GskNglTexture *texture);
+GskNglTexture *gsk_ngl_texture_new (guint texture_id,
+ int width,
+ int height,
+ int min_filter,
+ int mag_filter,
+ gint64 frame_id);
+const GskNglTextureNineSlice *gsk_ngl_texture_get_nine_slice (GskNglTexture *texture,
+ const GskRoundedRect *outline,
+ float extra_pixels);
+void gsk_ngl_texture_free (GskNglTexture *texture);
+
+G_END_DECLS
+
+#endif /* _GSK_NGL_TEXTURE_POOL_PRIVATE_H__ */
diff --git a/gsk/ngl/gskngltypesprivate.h b/gsk/ngl/gskngltypesprivate.h
new file mode 100644
index 0000000000..aba6f2f4c9
--- /dev/null
+++ b/gsk/ngl/gskngltypesprivate.h
@@ -0,0 +1,62 @@
+/* gskngltypesprivate.h
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ */
+
+#ifndef __GSK_NGL_TYPES_PRIVATE_H__
+#define __GSK_NGL_TYPES_PRIVATE_H__
+
+#include <epoxy/gl.h>
+#include <graphene.h>
+#include <gdk/gdk.h>
+#include <gsk/gsk.h>
+
+G_BEGIN_DECLS
+
+#define GSK_NGL_N_VERTICES 6
+
+typedef struct _GskNglAttachmentState GskNglAttachmentState;
+typedef struct _GskNglBuffer GskNglBuffer;
+typedef struct _GskNglCommandQueue GskNglCommandQueue;
+typedef struct _GskNglCompiler GskNglCompiler;
+typedef struct _GskNglDrawVertex GskNglDrawVertex;
+typedef struct _GskNglRenderTarget GskNglRenderTarget;
+typedef struct _GskNglGlyphLibrary GskNglGlyphLibrary;
+typedef struct _GskNglIconLibrary GskNglIconLibrary;
+typedef struct _GskNglProgram GskNglProgram;
+typedef struct _GskNglRenderJob GskNglRenderJob;
+typedef struct _GskNglShadowLibrary GskNglShadowLibrary;
+typedef struct _GskNglTexture GskNglTexture;
+typedef struct _GskNglTextureSlice GskNglTextureSlice;
+typedef struct _GskNglTextureAtlas GskNglTextureAtlas;
+typedef struct _GskNglTextureLibrary GskNglTextureLibrary;
+typedef struct _GskNglTextureNineSlice GskNglTextureNineSlice;
+typedef struct _GskNglUniformInfo GskNglUniformInfo;
+typedef struct _GskNglUniformProgram GskNglUniformProgram;
+typedef struct _GskNglUniformState GskNglUniformState;
+typedef struct _GskNglDriver GskNglDriver;
+
+struct _GskNglDrawVertex
+{
+ float position[2];
+ float uv[2];
+};
+
+G_END_DECLS
+
+#endif /* __GSK_NGL_TYPES_PRIVATE_H__ */
diff --git a/gsk/next/gskgluniformstate.c b/gsk/ngl/gskngluniformstate.c
similarity index 72%
rename from gsk/next/gskgluniformstate.c
rename to gsk/ngl/gskngluniformstate.c
index fae38f91bd..9b896e7d1a 100644
--- a/gsk/next/gskgluniformstate.c
+++ b/gsk/ngl/gskngluniformstate.c
@@ -1,4 +1,4 @@
-/* gskgluniformstate.c
+/* gskngluniformstate.c
*
* Copyright 2020 Christian Hergert <chergert redhat com>
*
@@ -23,7 +23,7 @@
#include <gsk/gskroundedrectprivate.h>
#include <string.h>
-#include "gskgluniformstateprivate.h"
+#include "gskngluniformstateprivate.h"
static const guint8 uniform_sizes[] = {
0,
@@ -54,12 +54,12 @@ static const guint8 uniform_sizes[] = {
0,
};
-GskGLUniformState *
-gsk_gl_uniform_state_new (void)
+GskNglUniformState *
+gsk_ngl_uniform_state_new (void)
{
- GskGLUniformState *state;
+ GskNglUniformState *state;
- state = g_atomic_rc_box_new0 (GskGLUniformState);
+ state = g_atomic_rc_box_new0 (GskNglUniformState);
state->programs = g_hash_table_new_full (NULL, NULL, NULL, g_free);
state->values_len = 4096;
state->values_pos = 0;
@@ -68,41 +68,41 @@ gsk_gl_uniform_state_new (void)
return g_steal_pointer (&state);
}
-GskGLUniformState *
-gsk_gl_uniform_state_ref (GskGLUniformState *state)
+GskNglUniformState *
+gsk_ngl_uniform_state_ref (GskNglUniformState *state)
{
return g_atomic_rc_box_acquire (state);
}
static void
-gsk_gl_uniform_state_finalize (gpointer data)
+gsk_ngl_uniform_state_finalize (gpointer data)
{
- GskGLUniformState *state = data;
+ GskNglUniformState *state = data;
g_clear_pointer (&state->programs, g_hash_table_unref);
g_clear_pointer (&state->values_buf, g_free);
}
void
-gsk_gl_uniform_state_unref (GskGLUniformState *state)
+gsk_ngl_uniform_state_unref (GskNglUniformState *state)
{
- g_atomic_rc_box_release_full (state, gsk_gl_uniform_state_finalize);
+ g_atomic_rc_box_release_full (state, gsk_ngl_uniform_state_finalize);
}
gpointer
-gsk_gl_uniform_state_init_value (GskGLUniformState *state,
- GskGLUniformProgram *program,
- GskGLUniformFormat format,
- guint array_count,
- guint location,
- GskGLUniformInfoElement **infoptr)
+gsk_ngl_uniform_state_init_value (GskNglUniformState *state,
+ GskNglUniformProgram *program,
+ GskNglUniformFormat format,
+ guint array_count,
+ guint location,
+ GskNglUniformInfoElement **infoptr)
{
- GskGLUniformInfoElement *info;
+ GskNglUniformInfoElement *info;
guint offset;
g_assert (state != NULL);
g_assert (array_count < 32);
- g_assert ((int)format >= 0 && format < GSK_GL_UNIFORM_FORMAT_LAST);
+ g_assert ((int)format >= 0 && format < GSK_NGL_UNIFORM_FORMAT_LAST);
g_assert (format > 0);
g_assert (program != NULL);
g_assert (program->sparse != NULL);
@@ -121,7 +121,7 @@ gsk_gl_uniform_state_init_value (GskGLUniformState *state,
if G_LIKELY (array_count <= info->info.array_count)
{
*infoptr = info;
- return GSK_GL_UNIFORM_VALUE (state->values_buf, info->info.offset);
+ return GSK_NGL_UNIFORM_VALUE (state->values_buf, info->info.offset);
}
/* We found the uniform, but there is not enough space for the
@@ -151,12 +151,12 @@ gsk_gl_uniform_state_init_value (GskGLUniformState *state,
setup_info:
- gsk_gl_uniform_state_realloc (state,
- uniform_sizes[format] * MAX (1, array_count),
- &offset);
+ gsk_ngl_uniform_state_realloc (state,
+ uniform_sizes[format] * MAX (1, array_count),
+ &offset);
/* we have 21 bits for offset */
- g_assert (offset < (1 << GSK_GL_UNIFORM_OFFSET_BITS));
+ g_assert (offset < (1 << GSK_NGL_UNIFORM_OFFSET_BITS));
/* We could once again be setting up this info if the array size grew.
* So make sure that we have space in our space array for the value.
@@ -173,14 +173,14 @@ setup_info:
*infoptr = info;
- return GSK_GL_UNIFORM_VALUE (state->values_buf, info->info.offset);
+ return GSK_NGL_UNIFORM_VALUE (state->values_buf, info->info.offset);
}
void
-gsk_gl_uniform_state_end_frame (GskGLUniformState *state)
+gsk_ngl_uniform_state_end_frame (GskNglUniformState *state)
{
GHashTableIter iter;
- GskGLUniformProgram *program;
+ GskNglUniformProgram *program;
guint allocator = 0;
g_return_if_fail (state != NULL);
@@ -197,7 +197,7 @@ gsk_gl_uniform_state_end_frame (GskGLUniformState *state)
for (guint j = 0; j < program->n_sparse; j++)
{
guint location = program->sparse[j];
- GskGLUniformInfoElement *info = &program->uniforms[location];
+ GskNglUniformInfoElement *info = &program->uniforms[location];
guint size;
g_assert (info->info.format > 0);
@@ -206,7 +206,7 @@ gsk_gl_uniform_state_end_frame (GskGLUniformState *state)
size = uniform_sizes[info->info.format] * MAX (1, info->info.array_count);
/* Adjust alignment for value */
- allocator += gsk_gl_uniform_state_align (allocator, size);
+ allocator += gsk_ngl_uniform_state_align (allocator, size);
/* Offset is in slots of 4 bytes */
info->info.offset = allocator / 4;
@@ -224,20 +224,20 @@ gsk_gl_uniform_state_end_frame (GskGLUniformState *state)
}
gsize
-gsk_gl_uniform_format_size (GskGLUniformFormat format)
+gsk_ngl_uniform_format_size (GskNglUniformFormat format)
{
g_assert (format > 0);
- g_assert (format < GSK_GL_UNIFORM_FORMAT_LAST);
+ g_assert (format < GSK_NGL_UNIFORM_FORMAT_LAST);
return uniform_sizes[format];
}
-GskGLUniformProgram *
-gsk_gl_uniform_state_get_program (GskGLUniformState *state,
- guint program,
- guint n_uniforms)
+GskNglUniformProgram *
+gsk_ngl_uniform_state_get_program (GskNglUniformState *state,
+ guint program,
+ guint n_uniforms)
{
- GskGLUniformProgram *ret;
+ GskNglUniformProgram *ret;
g_return_val_if_fail (state != NULL, NULL);
g_return_val_if_fail (program > 0, NULL);
@@ -247,12 +247,12 @@ gsk_gl_uniform_state_get_program (GskGLUniformState *state,
if (ret == NULL)
{
- gsize uniform_size = n_uniforms * sizeof (GskGLUniformInfoElement);
+ gsize uniform_size = n_uniforms * sizeof (GskNglUniformInfoElement);
gsize sparse_size = n_uniforms * sizeof (guint);
- gsize size = sizeof (GskGLUniformProgram) + uniform_size + sparse_size;
+ gsize size = sizeof (GskNglUniformProgram) + uniform_size + sparse_size;
/* Must be multiple of 4 for space pointer to align */
- G_STATIC_ASSERT (sizeof (GskGLUniformInfoElement) == 8);
+ G_STATIC_ASSERT (sizeof (GskNglUniformInfoElement) == 8);
ret = g_malloc0 (size);
ret->program_id = program;
diff --git a/gsk/ngl/gskngluniformstateprivate.h b/gsk/ngl/gskngluniformstateprivate.h
new file mode 100644
index 0000000000..1385f93dac
--- /dev/null
+++ b/gsk/ngl/gskngluniformstateprivate.h
@@ -0,0 +1,685 @@
+/* gskngluniformstateprivate.h
+ *
+ * Copyright 2020 Christian Hergert <chergert redhat com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ */
+
+#ifndef GSK_NGL_UNIFORM_STATE_PRIVATE_H
+#define GSK_NGL_UNIFORM_STATE_PRIVATE_H
+
+#include "gskngltypesprivate.h"
+
+G_BEGIN_DECLS
+
+typedef struct { float v0; } Uniform1f;
+typedef struct { float v0; float v1; } Uniform2f;
+typedef struct { float v0; float v1; float v2; } Uniform3f;
+typedef struct { float v0; float v1; float v2; float v3; } Uniform4f;
+
+typedef struct { int v0; } Uniform1i;
+typedef struct { int v0; int v1; } Uniform2i;
+typedef struct { int v0; int v1; int v2; } Uniform3i;
+typedef struct { int v0; int v1; int v2; int v3; } Uniform4i;
+
+typedef struct { guint v0; } Uniform1ui;
+
+#define GSK_NGL_UNIFORM_ARRAY_BITS 5
+#define GSK_NGL_UNIFORM_FORMAT_BITS 5
+#define GSK_NGL_UNIFORM_OFFSET_BITS 21
+
+typedef struct _GskNglUniformInfo
+{
+ guint initial : 1;
+ guint format : GSK_NGL_UNIFORM_FORMAT_BITS;
+ guint array_count : GSK_NGL_UNIFORM_ARRAY_BITS;
+ guint offset : GSK_NGL_UNIFORM_OFFSET_BITS;
+} GskNglUniformInfo;
+
+G_STATIC_ASSERT (sizeof (GskNglUniformInfo) == 4);
+
+typedef struct _GskNglUniformInfoElement
+{
+ GskNglUniformInfo info;
+ guint stamp;
+} GskNglUniformInfoElement;
+
+G_STATIC_ASSERT (sizeof (GskNglUniformInfoElement) == 8);
+
+typedef struct _GskNglUniformProgram
+{
+ guint program_id;
+ guint n_uniforms : 12;
+ guint has_attachments : 1;
+
+ /* To avoid walking our 1:1 array of location->uniform slots, we have
+ * a sparse index that allows us to skip the empty zones.
+ */
+ guint *sparse;
+ guint n_sparse;
+
+ /* Uniforms are provided inline at the end of structure to avoid
+ * an extra dereference.
+ */
+ GskNglUniformInfoElement uniforms[0];
+} GskNglUniformProgram;
+
+typedef struct _GskNglUniformState
+{
+ GHashTable *programs;
+ guint8 *values_buf;
+ guint values_pos;
+ guint values_len;
+} GskNglUniformState;
+
+/**
+ * GskNglUniformStateCallback:
+ * @info: a pointer to the information about the uniform
+ * @location: the location of the uniform within the GPU program.
+ * @user_data: closure data for the callback
+ *
+ * This callback can be used to snapshot state of a program which
+ * is useful when batching commands so that the state may be compared
+ * with future evocations of the program.
+ */
+typedef void (*GskNglUniformStateCallback) (const GskNglUniformInfo *info,
+ guint location,
+ gpointer user_data);
+
+typedef enum _GskNglUniformKind
+{
+ GSK_NGL_UNIFORM_FORMAT_1F = 1,
+ GSK_NGL_UNIFORM_FORMAT_2F,
+ GSK_NGL_UNIFORM_FORMAT_3F,
+ GSK_NGL_UNIFORM_FORMAT_4F,
+
+ GSK_NGL_UNIFORM_FORMAT_1FV,
+ GSK_NGL_UNIFORM_FORMAT_2FV,
+ GSK_NGL_UNIFORM_FORMAT_3FV,
+ GSK_NGL_UNIFORM_FORMAT_4FV,
+
+ GSK_NGL_UNIFORM_FORMAT_1I,
+ GSK_NGL_UNIFORM_FORMAT_2I,
+ GSK_NGL_UNIFORM_FORMAT_3I,
+ GSK_NGL_UNIFORM_FORMAT_4I,
+
+ GSK_NGL_UNIFORM_FORMAT_1UI,
+
+ GSK_NGL_UNIFORM_FORMAT_TEXTURE,
+
+ GSK_NGL_UNIFORM_FORMAT_MATRIX,
+ GSK_NGL_UNIFORM_FORMAT_ROUNDED_RECT,
+ GSK_NGL_UNIFORM_FORMAT_COLOR,
+
+ GSK_NGL_UNIFORM_FORMAT_LAST
+} GskNglUniformFormat;
+
+G_STATIC_ASSERT (GSK_NGL_UNIFORM_FORMAT_LAST < (1 << GSK_NGL_UNIFORM_FORMAT_BITS));
+
+GskNglUniformState *gsk_ngl_uniform_state_new (void);
+GskNglUniformState *gsk_ngl_uniform_state_ref (GskNglUniformState *state);
+void gsk_ngl_uniform_state_unref (GskNglUniformState *state);
+GskNglUniformProgram *gsk_ngl_uniform_state_get_program (GskNglUniformState *state,
+ guint program,
+ guint n_uniforms);
+void gsk_ngl_uniform_state_end_frame (GskNglUniformState *state);
+gsize gsk_ngl_uniform_format_size (GskNglUniformFormat format);
+gpointer gsk_ngl_uniform_state_init_value (GskNglUniformState *state,
+ GskNglUniformProgram *program,
+ GskNglUniformFormat format,
+ guint array_count,
+ guint location,
+ GskNglUniformInfoElement **infoptr);
+
+#define GSK_NGL_UNIFORM_VALUE(base, offset) ((gpointer)((base) + ((offset) * 4)))
+#define gsk_ngl_uniform_state_get_uniform_data(state,offset) GSK_NGL_UNIFORM_VALUE((state)->values_buf,
offset)
+#define gsk_ngl_uniform_state_snapshot(state, program_info, callback, user_data) \
+ G_STMT_START { \
+ for (guint z = 0; z < program_info->n_sparse; z++) \
+ { \
+ guint location = program_info->sparse[z]; \
+ GskNglUniformInfoElement *info = &program_info->uniforms[location]; \
+ \
+ g_assert (location < GL_MAX_UNIFORM_LOCATIONS); \
+ g_assert (location < program_info->n_uniforms); \
+ \
+ if (info->info.format > 0) \
+ callback (&info->info, location, user_data); \
+ } \
+ } G_STMT_END
+
+static inline gpointer
+gsk_ngl_uniform_state_get_value (GskNglUniformState *state,
+ GskNglUniformProgram *program,
+ GskNglUniformFormat format,
+ guint array_count,
+ guint location,
+ guint stamp,
+ GskNglUniformInfoElement **infoptr)
+{
+ GskNglUniformInfoElement *info;
+
+ if (location == (guint)-1)
+ return NULL;
+
+ /* If the stamp is the same, then we can ignore the request
+ * and short-circuit as early as possible. This requires the
+ * caller to increment their private stamp when they change
+ * internal state.
+ *
+ * This is generally used for the shared uniforms like projection,
+ * modelview, clip, etc to avoid so many comparisons which cost
+ * considerable CPU.
+ */
+ info = &program->uniforms[location];
+ if (stamp != 0 && stamp == info->stamp)
+ return NULL;
+
+ if G_LIKELY (format == info->info.format && array_count <= info->info.array_count)
+ {
+ *infoptr = info;
+ return GSK_NGL_UNIFORM_VALUE (state->values_buf, info->info.offset);
+ }
+
+ return gsk_ngl_uniform_state_init_value (state, program, format, array_count, location, infoptr);
+}
+
+static inline guint
+gsk_ngl_uniform_state_align (guint current_pos,
+ guint size)
+{
+ guint align = size > 8 ? 16 : (size > 4 ? 8 : 4);
+ guint masked = current_pos & (align - 1);
+
+ g_assert (size > 0);
+ g_assert (align == 4 || align == 8 || align == 16);
+ g_assert (masked < align);
+
+ return align - masked;
+}
+
+static inline gpointer
+gsk_ngl_uniform_state_realloc (GskNglUniformState *state,
+ guint size,
+ guint *offset)
+{
+ guint padding = gsk_ngl_uniform_state_align (state->values_pos, size);
+
+ if G_UNLIKELY (state->values_len - padding - size < state->values_pos)
+ {
+ state->values_len *= 2;
+ state->values_buf = g_realloc (state->values_buf, state->values_len);
+ }
+
+ /* offsets are in slots of 4 to use fewer bits */
+ g_assert ((state->values_pos + padding) % 4 == 0);
+ *offset = (state->values_pos + padding) / 4;
+ state->values_pos += padding + size;
+
+ return GSK_NGL_UNIFORM_VALUE (state->values_buf, *offset);
+}
+
+#define GSK_NGL_UNIFORM_STATE_REPLACE(info, u, type, count) \
+ G_STMT_START { \
+ if ((info)->info.initial && count == (info)->info.array_count) \
+ { \
+ u = GSK_NGL_UNIFORM_VALUE (state->values_buf, (info)->info.offset); \
+ } \
+ else \
+ { \
+ guint offset; \
+ u = gsk_ngl_uniform_state_realloc (state, sizeof(type) * MAX (1, count), &offset); \
+ g_assert (offset < (1 << GSK_NGL_UNIFORM_OFFSET_BITS)); \
+ (info)->info.offset = offset; \
+ /* We might have increased array length */ \
+ (info)->info.array_count = count; \
+ } \
+ } G_STMT_END
+
+static inline void
+gsk_ngl_uniform_info_changed (GskNglUniformInfoElement *info,
+ guint location,
+ guint stamp)
+{
+ info->stamp = stamp;
+ info->info.initial = FALSE;
+}
+
+static inline void
+gsk_ngl_uniform_state_set1f (GskNglUniformState *state,
+ GskNglUniformProgram *program,
+ guint location,
+ guint stamp,
+ float value0)
+{
+ Uniform1f *u;
+ GskNglUniformInfoElement *info;
+
+ g_assert (state != NULL);
+ g_assert (program != 0);
+
+ if ((u = gsk_ngl_uniform_state_get_value (state, program, GSK_NGL_UNIFORM_FORMAT_1F, 1, location, stamp,
&info)))
+ {
+ GSK_NGL_UNIFORM_STATE_REPLACE (info, u, Uniform1f , 1);
+ u->v0 = value0;
+ gsk_ngl_uniform_info_changed (info, location, stamp);
+ }
+}
+
+static inline void
+gsk_ngl_uniform_state_set2f (GskNglUniformState *state,
+ GskNglUniformProgram *program,
+ guint location,
+ guint stamp,
+ float value0,
+ float value1)
+{
+ Uniform2f *u;
+ GskNglUniformInfoElement *info;
+
+ g_assert (state != NULL);
+ g_assert (program != NULL);
+
+ if ((u = gsk_ngl_uniform_state_get_value (state, program, GSK_NGL_UNIFORM_FORMAT_2F, 1, location, stamp,
&info)))
+ {
+ GSK_NGL_UNIFORM_STATE_REPLACE (info, u, Uniform2f, 1);
+ u->v0 = value0;
+ u->v1 = value1;
+ gsk_ngl_uniform_info_changed (info, location, stamp);
+ }
+}
+
+static inline void
+gsk_ngl_uniform_state_set3f (GskNglUniformState *state,
+ GskNglUniformProgram *program,
+ guint location,
+ guint stamp,
+ float value0,
+ float value1,
+ float value2)
+{
+ Uniform3f *u;
+ GskNglUniformInfoElement *info;
+
+ g_assert (state != NULL);
+ g_assert (program != NULL);
+
+ if ((u = gsk_ngl_uniform_state_get_value (state, program, GSK_NGL_UNIFORM_FORMAT_3F, 1, location, stamp,
&info)))
+ {
+ GSK_NGL_UNIFORM_STATE_REPLACE (info, u, Uniform3f, 1);
+ u->v0 = value0;
+ u->v1 = value1;
+ u->v2 = value2;
+ gsk_ngl_uniform_info_changed (info, location, stamp);
+ }
+}
+
+static inline void
+gsk_ngl_uniform_state_set4f (GskNglUniformState *state,
+ GskNglUniformProgram *program,
+ guint location,
+ guint stamp,
+ float value0,
+ float value1,
+ float value2,
+ float value3)
+{
+ Uniform4f *u;
+ GskNglUniformInfoElement *info;
+
+ g_assert (state != NULL);
+ g_assert (program != NULL);
+
+ if ((u = gsk_ngl_uniform_state_get_value (state, program, GSK_NGL_UNIFORM_FORMAT_4F, 1, location, stamp,
&info)))
+ {
+ GSK_NGL_UNIFORM_STATE_REPLACE (info, u, Uniform4f, 1);
+ u->v0 = value0;
+ u->v1 = value1;
+ u->v2 = value2;
+ u->v3 = value3;
+ gsk_ngl_uniform_info_changed (info, location, stamp);
+ }
+}
+
+static inline void
+gsk_ngl_uniform_state_set1ui (GskNglUniformState *state,
+ GskNglUniformProgram *program,
+ guint location,
+ guint stamp,
+ guint value0)
+{
+ Uniform1ui *u;
+ GskNglUniformInfoElement *info;
+
+ g_assert (state != NULL);
+ g_assert (program != NULL);
+
+ if ((u = gsk_ngl_uniform_state_get_value (state, program, GSK_NGL_UNIFORM_FORMAT_1UI, 1, location, stamp,
&info)))
+ {
+ GSK_NGL_UNIFORM_STATE_REPLACE (info, u, Uniform1ui, 1);
+ u->v0 = value0;
+ gsk_ngl_uniform_info_changed (info, location, stamp);
+ }
+}
+
+static inline void
+gsk_ngl_uniform_state_set1i (GskNglUniformState *state,
+ GskNglUniformProgram *program,
+ guint location,
+ guint stamp,
+ int value0)
+{
+ Uniform1i *u;
+ GskNglUniformInfoElement *info;
+
+ g_assert (state != NULL);
+ g_assert (program != NULL);
+
+ if ((u = gsk_ngl_uniform_state_get_value (state, program, GSK_NGL_UNIFORM_FORMAT_1I, 1, location, stamp,
&info)))
+ {
+ GSK_NGL_UNIFORM_STATE_REPLACE (info, u, Uniform1i, 1);
+ u->v0 = value0;
+ gsk_ngl_uniform_info_changed (info, location, stamp);
+ }
+}
+
+static inline void
+gsk_ngl_uniform_state_set2i (GskNglUniformState *state,
+ GskNglUniformProgram *program,
+ guint location,
+ guint stamp,
+ int value0,
+ int value1)
+{
+ Uniform2i *u;
+ GskNglUniformInfoElement *info;
+
+ g_assert (state != NULL);
+ g_assert (program != NULL);
+
+ if ((u = gsk_ngl_uniform_state_get_value (state, program, GSK_NGL_UNIFORM_FORMAT_2I, 1, location, stamp,
&info)))
+ {
+ GSK_NGL_UNIFORM_STATE_REPLACE (info, u, Uniform2i, 1);
+ u->v0 = value0;
+ u->v1 = value1;
+ gsk_ngl_uniform_info_changed (info, location, stamp);
+ }
+}
+
+static inline void
+gsk_ngl_uniform_state_set3i (GskNglUniformState *state,
+ GskNglUniformProgram *program,
+ guint location,
+ guint stamp,
+ int value0,
+ int value1,
+ int value2)
+{
+ Uniform3i *u;
+ GskNglUniformInfoElement *info;
+
+ g_assert (state != NULL);
+ g_assert (program != NULL);
+
+ if ((u = gsk_ngl_uniform_state_get_value (state, program, GSK_NGL_UNIFORM_FORMAT_3I, 1, location, stamp,
&info)))
+ {
+ GSK_NGL_UNIFORM_STATE_REPLACE (info, u, Uniform3i, 1);
+ u->v0 = value0;
+ u->v1 = value1;
+ u->v2 = value2;
+ gsk_ngl_uniform_info_changed (info, location, stamp);
+ }
+}
+
+static inline void
+gsk_ngl_uniform_state_set4i (GskNglUniformState *state,
+ GskNglUniformProgram *program,
+ guint location,
+ guint stamp,
+ int value0,
+ int value1,
+ int value2,
+ int value3)
+{
+ Uniform4i *u;
+ GskNglUniformInfoElement *info;
+
+ g_assert (state != NULL);
+ g_assert (program != NULL);
+
+ if ((u = gsk_ngl_uniform_state_get_value (state, program, GSK_NGL_UNIFORM_FORMAT_4I, 1, location, stamp,
&info)))
+ {
+ GSK_NGL_UNIFORM_STATE_REPLACE (info, u, Uniform4i, 1);
+ u->v0 = value0;
+ u->v1 = value1;
+ u->v2 = value2;
+ u->v3 = value3;
+ gsk_ngl_uniform_info_changed (info, location, stamp);
+ }
+}
+
+static inline void
+gsk_ngl_uniform_state_set_rounded_rect (GskNglUniformState *state,
+ GskNglUniformProgram *program,
+ guint location,
+ guint stamp,
+ const GskRoundedRect *rounded_rect)
+{
+ GskRoundedRect *u;
+ GskNglUniformInfoElement *info;
+
+ g_assert (state != NULL);
+ g_assert (program != NULL);
+ g_assert (rounded_rect != NULL);
+
+ if ((u = gsk_ngl_uniform_state_get_value (state, program, GSK_NGL_UNIFORM_FORMAT_ROUNDED_RECT, 1,
location, stamp, &info)))
+ {
+ GSK_NGL_UNIFORM_STATE_REPLACE (info, u, GskRoundedRect, 1);
+ memcpy (u, rounded_rect, sizeof *rounded_rect);
+ gsk_ngl_uniform_info_changed (info, location, stamp);
+ }
+}
+
+static inline void
+gsk_ngl_uniform_state_set_matrix (GskNglUniformState *state,
+ GskNglUniformProgram *program,
+ guint location,
+ guint stamp,
+ const graphene_matrix_t *matrix)
+{
+ graphene_matrix_t *u;
+ GskNglUniformInfoElement *info;
+
+ g_assert (state != NULL);
+ g_assert (program != NULL);
+ g_assert (matrix != NULL);
+
+ if ((u = gsk_ngl_uniform_state_get_value (state, program, GSK_NGL_UNIFORM_FORMAT_MATRIX, 1, location,
stamp, &info)))
+ {
+ GSK_NGL_UNIFORM_STATE_REPLACE (info, u, graphene_matrix_t, 1);
+ memcpy (u, matrix, sizeof *matrix);
+ gsk_ngl_uniform_info_changed (info, location, stamp);
+ }
+}
+
+/**
+ * gsk_ngl_uniform_state_set_texture:
+ * @state: a #GskNglUniformState
+ * @program: the program id
+ * @location: the location of the texture
+ * @texture_slot: a texturing slot such as GL_TEXTURE0
+ *
+ * Sets the uniform expecting a texture to @texture_slot. This API
+ * expects a texture slot such as GL_TEXTURE0 to reduce chances of
+ * miss-use by the caller.
+ *
+ * The value stored to the uniform is in the form of 0 for GL_TEXTURE0,
+ * 1 for GL_TEXTURE1, and so on.
+ */
+static inline void
+gsk_ngl_uniform_state_set_texture (GskNglUniformState *state,
+ GskNglUniformProgram *program,
+ guint location,
+ guint stamp,
+ guint texture_slot)
+{
+ GskNglUniformInfoElement *info;
+ guint *u;
+
+ g_assert (texture_slot >= GL_TEXTURE0);
+ g_assert (texture_slot < GL_TEXTURE16);
+
+ texture_slot -= GL_TEXTURE0;
+
+ if ((u = gsk_ngl_uniform_state_get_value (state, program, GSK_NGL_UNIFORM_FORMAT_TEXTURE, 1, location,
stamp, &info)))
+ {
+ GSK_NGL_UNIFORM_STATE_REPLACE (info, u, guint, 1);
+ *u = texture_slot;
+ gsk_ngl_uniform_info_changed (info, location, stamp);
+ }
+}
+
+/**
+ * gsk_ngl_uniform_state_set_color:
+ * @state: a #GskNglUniformState
+ * @program: a program id > 0
+ * @location: the uniform location
+ * @color: a color to set or %NULL for transparent
+ *
+ * Sets a uniform to the color described by @color. This is a convenience
+ * function to allow callers to avoid having to translate colors to floats
+ * in other portions of the renderer.
+ */
+static inline void
+gsk_ngl_uniform_state_set_color (GskNglUniformState *state,
+ GskNglUniformProgram *program,
+ guint location,
+ guint stamp,
+ const GdkRGBA *color)
+{
+ static const GdkRGBA transparent = {0};
+ GskNglUniformInfoElement *info;
+ GdkRGBA *u;
+
+ g_assert (state != NULL);
+ g_assert (program != NULL);
+
+ if ((u = gsk_ngl_uniform_state_get_value (state, program, GSK_NGL_UNIFORM_FORMAT_COLOR, 1, location,
stamp, &info)))
+ {
+ if (color == NULL)
+ color = &transparent;
+
+ GSK_NGL_UNIFORM_STATE_REPLACE (info, u, GdkRGBA, 1);
+ memcpy (u, color, sizeof *color);
+ gsk_ngl_uniform_info_changed (info, location, stamp);
+ }
+}
+
+static inline void
+gsk_ngl_uniform_state_set1fv (GskNglUniformState *state,
+ GskNglUniformProgram *program,
+ guint location,
+ guint stamp,
+ guint count,
+ const float *value)
+{
+ Uniform1f *u;
+ GskNglUniformInfoElement *info;
+
+ g_assert (state != NULL);
+ g_assert (program != NULL);
+ g_assert (count > 0);
+
+ if ((u = gsk_ngl_uniform_state_get_value (state, program, GSK_NGL_UNIFORM_FORMAT_1FV, count, location,
stamp, &info)))
+ {
+ GSK_NGL_UNIFORM_STATE_REPLACE (info, u, Uniform1f, count);
+ memcpy (u, value, sizeof (Uniform1f) * count);
+ gsk_ngl_uniform_info_changed (info, location, stamp);
+ }
+}
+
+static inline void
+gsk_ngl_uniform_state_set2fv (GskNglUniformState *state,
+ GskNglUniformProgram *program,
+ guint location,
+ guint stamp,
+ guint count,
+ const float *value)
+{
+ Uniform2f *u;
+ GskNglUniformInfoElement *info;
+
+ g_assert (state != NULL);
+ g_assert (program != NULL);
+ g_assert (count > 0);
+
+ if ((u = gsk_ngl_uniform_state_get_value (state, program, GSK_NGL_UNIFORM_FORMAT_2FV, count, location,
stamp, &info)))
+ {
+ GSK_NGL_UNIFORM_STATE_REPLACE (info, u, Uniform2f, count);
+ memcpy (u, value, sizeof (Uniform2f) * count);
+ gsk_ngl_uniform_info_changed (info, location, stamp);
+ }
+}
+
+static inline void
+gsk_ngl_uniform_state_set3fv (GskNglUniformState *state,
+ GskNglUniformProgram *program,
+ guint location,
+ guint stamp,
+ guint count,
+ const float *value)
+{
+ Uniform3f *u;
+ GskNglUniformInfoElement *info;
+
+ g_assert (state != NULL);
+ g_assert (program != NULL);
+ g_assert (count > 0);
+
+ if ((u = gsk_ngl_uniform_state_get_value (state, program, GSK_NGL_UNIFORM_FORMAT_3FV, count, location,
stamp, &info)))
+ {
+ GSK_NGL_UNIFORM_STATE_REPLACE (info, u, Uniform3f, count);
+ memcpy (u, value, sizeof (Uniform3f) * count);
+ gsk_ngl_uniform_info_changed (info, location, stamp);
+ }
+}
+
+static inline void
+gsk_ngl_uniform_state_set4fv (GskNglUniformState *state,
+ GskNglUniformProgram *program,
+ guint location,
+ guint stamp,
+ guint count,
+ const float *value)
+{
+ Uniform4f *u;
+ GskNglUniformInfoElement *info;
+
+ g_assert (state != NULL);
+ g_assert (program != NULL);
+ g_assert (count > 0);
+
+ if ((u = gsk_ngl_uniform_state_get_value (state, program, GSK_NGL_UNIFORM_FORMAT_4FV, count, location,
stamp, &info)))
+ {
+ GSK_NGL_UNIFORM_STATE_REPLACE (info, u, Uniform4f, count);
+ memcpy (u, value, sizeof (Uniform4f) * count);
+ gsk_ngl_uniform_info_changed (info, location, stamp);
+ }
+}
+
+G_END_DECLS
+
+#endif /* GSK_NGL_UNIFORM_STATE_PRIVATE_H */
diff --git a/gsk/next/inlinearray.h b/gsk/ngl/inlinearray.h
similarity index 100%
rename from gsk/next/inlinearray.h
rename to gsk/ngl/inlinearray.h
diff --git a/gsk/next/ninesliceprivate.h b/gsk/ngl/ninesliceprivate.h
similarity index 93%
rename from gsk/next/ninesliceprivate.h
rename to gsk/ngl/ninesliceprivate.h
index 46677b437f..fe787acc1d 100644
--- a/gsk/next/ninesliceprivate.h
+++ b/gsk/ngl/ninesliceprivate.h
@@ -22,7 +22,7 @@
#ifndef __NINE_SLICE_PRIVATE_H__
#define __NINE_SLICE_PRIVATE_H__
-#include "gskgltexturepoolprivate.h"
+#include "gskngltexturepoolprivate.h"
#if 0
# define DEBUG_NINE_SLICE
@@ -43,14 +43,14 @@ enum {
};
static inline bool G_GNUC_PURE
-nine_slice_is_visible (const GskGLTextureNineSlice *slice)
+nine_slice_is_visible (const GskNglTextureNineSlice *slice)
{
return slice->rect.width > 0 && slice->rect.height > 0;
}
static inline void
-nine_slice_rounded_rect (GskGLTextureNineSlice *slices,
- const GskRoundedRect *rect)
+nine_slice_rounded_rect (GskNglTextureNineSlice *slices,
+ const GskRoundedRect *rect)
{
const graphene_point_t *origin = &rect->bounds.origin;
const graphene_size_t *size = &rect->bounds.size;
@@ -130,16 +130,16 @@ nine_slice_rounded_rect (GskGLTextureNineSlice *slices,
}
static inline void
-nine_slice_to_texture_coords (GskGLTextureNineSlice *slices,
- int texture_width,
- int texture_height)
+nine_slice_to_texture_coords (GskNglTextureNineSlice *slices,
+ int texture_width,
+ int texture_height)
{
float fw = texture_width;
float fh = texture_height;
for (guint i = 0; i < 9; i++)
{
- GskGLTextureNineSlice *slice = &slices[i];
+ GskNglTextureNineSlice *slice = &slices[i];
slice->area.x = slice->rect.x / fw;
slice->area.y = 1.0 - ((slice->rect.y + slice->rect.height) / fh);
@@ -158,8 +158,8 @@ nine_slice_to_texture_coords (GskGLTextureNineSlice *slices,
}
static inline void
-nine_slice_grow (GskGLTextureNineSlice *slices,
- int amount)
+nine_slice_grow (GskNglTextureNineSlice *slices,
+ int amount)
{
if (amount == 0)
return;
diff --git a/gtk/gtktestutils.c b/gtk/gtktestutils.c
index 64d4e5a4a1..35dcff797c 100644
--- a/gtk/gtktestutils.c
+++ b/gtk/gtktestutils.c
@@ -41,7 +41,7 @@
#define GTK_COMPILATION
#include <gsk/gl/gskglrenderer.h>
-#include <gsk/next/gskglrenderer.h>
+#include <gsk/ngl/gsknglrenderer.h>
#ifdef GDK_WINDOWING_BROADWAY
#include <gsk/broadway/gskbroadwayrenderer.h>
diff --git a/gtk/inspector/general.c b/gtk/inspector/general.c
index 7e410b6c36..451300bb5a 100644
--- a/gtk/inspector/general.c
+++ b/gtk/inspector/general.c
@@ -147,8 +147,8 @@ init_version (GtkInspectorGeneral *gen)
renderer = "Vulkan";
else if (strcmp (G_OBJECT_TYPE_NAME (gsk_renderer), "GskGLRenderer") == 0)
renderer = "GL";
- else if (strcmp (G_OBJECT_TYPE_NAME (gsk_renderer), "GskNextRenderer") == 0)
- renderer = "GL (Next)";
+ else if (strcmp (G_OBJECT_TYPE_NAME (gsk_renderer), "GskNgltRenderer") == 0)
+ renderer = "NGL";
else if (strcmp (G_OBJECT_TYPE_NAME (gsk_renderer), "GskCairoRenderer") == 0)
renderer = "Cairo";
else
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
