AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
eb3423312f
gtk2/gsk/ngl/gskngldriver.c
Matthias Clasen 2d266d107b gsk: Clean up docs syntax 
Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-22 17:25:26 -04:00

1342 lines
46 KiB
C
Raw Blame History

/* gskngldriver.c
*
* Copyright 2017 Timm Bäder <mail@baedert.org>
* Copyright 2018 Matthias Clasen <mclasen@redhat.com>
* Copyright 2018 Alexander Larsson <alexl@redhat.com>
* 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 <gdk/gdkglcontextprivate.h>
#include <gdk/gdktextureprivate.h>
#include <gsk/gskdebugprivate.h>
#include <gsk/gskglshaderprivate.h>
#include <gsk/gskrendererprivate.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
#define MAX_OLD_RATIO 0.5
typedef struct _GskNglTextureState
{
GdkGLContext *context;
GLuint texture_id;
} GskNglTextureState;
G_DEFINE_TYPE (GskNglDriver, gsk_ngl_driver, G_TYPE_OBJECT)
static guint
texture_key_hash (gconstpointer v)
{
const GskTextureKey *k = (const GskTextureKey *)v;
/* Optimize for 0..3 where 0 is the scaled out case. Usually
* we'll be squarely on 1 or 2 for standard vs HiDPI. When rendering
* to a texture scaled out like in node-editor, we might be < 1.
*/
guint scale_x = floorf (k->scale_x);
guint scale_y = floorf (k->scale_y);
return GPOINTER_TO_SIZE (k->pointer) ^
((scale_x << 8) |
(scale_y << 6) |
(k->filter << 1) |
k->pointer_is_child);
}
static gboolean
texture_key_equal (gconstpointer v1,
gconstpointer v2)
{
const GskTextureKey *k1 = (const GskTextureKey *)v1;
const GskTextureKey *k2 = (const GskTextureKey *)v2;
return k1->pointer == k2->pointer &&
k1->scale_x == k2->scale_x &&
k1->scale_y == k2->scale_y &&
k1->filter == k2->filter &&
k1->pointer_is_child == k2->pointer_is_child &&
(!k1->pointer_is_child || memcmp (&k1->parent_rect, &k2->parent_rect, sizeof k1->parent_rect) == 0);
}
static void
remove_texture_key_for_id (GskNglDriver *self,
guint texture_id)
{
GskTextureKey *key;
g_assert (GSK_IS_NGL_DRIVER (self));
g_assert (texture_id > 0);
/* g_hash_table_remove() will cause @key to be freed */
if (g_hash_table_steal_extended (self->texture_id_to_key,
GUINT_TO_POINTER (texture_id),
NULL,
(gpointer *)&key))
g_hash_table_remove (self->key_to_texture_id, key);
}
static void
gsk_ngl_texture_destroyed (gpointer data)
{
((GskNglTexture *)data)->user = NULL;
}
static guint
gsk_ngl_driver_collect_unused_textures (GskNglDriver *self,
gint64 watermark)
{
GHashTableIter iter;
gpointer k, v;
guint old_size;
guint collected;
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))
{
GskNglTexture *t = v;
if (t->user || t->permanent)
continue;
if (t->last_used_in_frame <= watermark)
{
g_hash_table_iter_steal (&iter);
g_assert (t->link.prev == NULL);
g_assert (t->link.next == NULL);
g_assert (t->link.data == t);
/* Steal this texture and put it back into the pool */
remove_texture_key_for_id (self, t->texture_id);
gsk_ngl_texture_pool_put (&self->texture_pool, t);
}
}
collected = old_size - g_hash_table_size (self->textures);
return collected;
}
static void
gsk_ngl_texture_atlas_free (GskNglTextureAtlas *atlas)
{
if (atlas->texture_id != 0)
{
glDeleteTextures (1, &atlas->texture_id);
atlas->texture_id = 0;
}
g_clear_pointer (&atlas->nodes, g_free);
g_slice_free (GskNglTextureAtlas, atlas);
}
GskNglTextureAtlas *
gsk_ngl_driver_create_atlas (GskNglDriver *self)
{
GskNglTextureAtlas *atlas;
g_return_val_if_fail (GSK_IS_NGL_DRIVER (self), NULL);
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_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,
"Texture atlas %d",
atlas->texture_id);
g_ptr_array_add (self->atlases, atlas);
return atlas;
}
static void
remove_program (gpointer data)
{
GskNglProgram *program = data;
g_assert (!program || GSK_IS_NGL_PROGRAM (program));
if (program != NULL)
{
gsk_ngl_program_delete (program);
g_object_unref (program);
}
}
static void
gsk_ngl_driver_shader_weak_cb (gpointer data,
GObject *where_object_was)
{
GskNglDriver *self = data;
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_ngl_driver_dispose (GObject *object)
{
GskNglDriver *self = (GskNglDriver *)object;
g_assert (GSK_IS_NGL_DRIVER (self));
g_assert (self->in_frame == FALSE);
#define GSK_NGL_NO_UNIFORMS
#define GSK_NGL_ADD_UNIFORM(pos, KEY, name)
#define GSK_NGL_DEFINE_PROGRAM(name, resource, uniforms) \
GSK_NGL_DELETE_PROGRAM(name); \
GSK_NGL_DELETE_PROGRAM(name ## _no_clip); \
GSK_NGL_DELETE_PROGRAM(name ## _rect_clip);
#define GSK_NGL_DELETE_PROGRAM(name) \
G_STMT_START { \
if (self->name) \
gsk_ngl_program_delete (self->name); \
g_clear_object (&self->name); \
} G_STMT_END;
# include "gsknglprograms.defs"
#undef GSK_NGL_NO_UNIFORMS
#undef GSK_NGL_ADD_UNIFORM
#undef GSK_NGL_DEFINE_PROGRAM
if (self->shader_cache != NULL)
{
GHashTableIter iter;
gpointer k, v;
g_hash_table_iter_init (&iter, self->shader_cache);
while (g_hash_table_iter_next (&iter, &k, &v))
{
GskGLShader *shader = k;
g_object_weak_unref (G_OBJECT (shader),
gsk_ngl_driver_shader_weak_cb,
self);
g_hash_table_iter_remove (&iter);
}
g_clear_pointer (&self->shader_cache, g_hash_table_unref);
}
if (self->command_queue != NULL)
{
gsk_ngl_command_queue_make_current (self->command_queue);
gsk_ngl_driver_collect_unused_textures (self, 0);
g_clear_object (&self->command_queue);
}
if (self->autorelease_framebuffers->len > 0)
{
glDeleteFramebuffers (self->autorelease_framebuffers->len,
(GLuint *)(gpointer)self->autorelease_framebuffers->data);
self->autorelease_framebuffers->len = 0;
}
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);
g_assert (!self->key_to_texture_id|| g_hash_table_size (self->key_to_texture_id) == 0);
g_clear_object (&self->glyphs);
g_clear_object (&self->icons);
g_clear_object (&self->shadows);
g_clear_pointer (&self->atlases, g_ptr_array_unref);
g_clear_pointer (&self->autorelease_framebuffers, g_array_unref);
g_clear_pointer (&self->key_to_texture_id, g_hash_table_unref);
g_clear_pointer (&self->textures, g_hash_table_unref);
g_clear_pointer (&self->key_to_texture_id, g_hash_table_unref);
g_clear_pointer (&self->texture_id_to_key, g_hash_table_unref);
g_clear_pointer (&self->render_targets, g_ptr_array_unref);
g_clear_pointer (&self->shader_cache, g_hash_table_unref);
g_clear_object (&self->command_queue);
g_clear_object (&self->shared_command_queue);
G_OBJECT_CLASS (gsk_ngl_driver_parent_class)->dispose (object);
}
static void
gsk_ngl_driver_class_init (GskNglDriverClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->dispose = gsk_ngl_driver_dispose;
}
static void
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_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_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_ngl_texture_atlas_free);
}
static gboolean
gsk_ngl_driver_load_programs (GskNglDriver *self,
GError **error)
{
GskNglCompiler *compiler;
gboolean ret = FALSE;
g_assert (GSK_IS_NGL_DRIVER (self));
g_assert (GSK_IS_NGL_COMMAND_QUEUE (self->command_queue));
compiler = gsk_ngl_compiler_new (self, self->debug);
/* Setup preambles that are shared by all shaders */
gsk_ngl_compiler_set_preamble_from_resource (compiler,
GSK_NGL_COMPILER_ALL,
"/org/gtk/libgsk/ngl/preamble.glsl");
gsk_ngl_compiler_set_preamble_from_resource (compiler,
GSK_NGL_COMPILER_VERTEX,
"/org/gtk/libgsk/ngl/preamble.vs.glsl");
gsk_ngl_compiler_set_preamble_from_resource (compiler,
GSK_NGL_COMPILER_FRAGMENT,
"/org/gtk/libgsk/ngl/preamble.fs.glsl");
/* Setup attributes that are provided via VBO */
gsk_ngl_compiler_bind_attribute (compiler, "aPosition", 0);
gsk_ngl_compiler_bind_attribute (compiler, "aUv", 1);
gsk_ngl_compiler_bind_attribute (compiler, "aColor", 2);
gsk_ngl_compiler_bind_attribute (compiler, "aColor2", 3);
/* Use XMacros to register all of our programs and their 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) \
gsk_ngl_compiler_set_source_from_resource (compiler, GSK_NGL_COMPILER_ALL, resource); \
GSK_NGL_COMPILE_PROGRAM(name ## _no_clip, uniforms, "#define NO_CLIP 1\n"); \
GSK_NGL_COMPILE_PROGRAM(name ## _rect_clip, uniforms, "#define RECT_CLIP 1\n"); \
GSK_NGL_COMPILE_PROGRAM(name, uniforms, "");
#define GSK_NGL_COMPILE_PROGRAM(name, uniforms, clip) \
G_STMT_START { \
GskNglProgram *program; \
gboolean have_alpha; \
gboolean have_source; \
\
if (!(program = gsk_ngl_compiler_compile (compiler, #name, clip, error))) \
goto failure; \
\
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_ngl_program_uniforms_added (program, have_source); \
if (have_alpha) \
gsk_ngl_program_set_uniform1f (program, UNIFORM_SHARED_ALPHA, 0, 1.0f); \
\
*(GskNglProgram **)(((guint8 *)self) + G_STRUCT_OFFSET (GskNglDriver, name)) = \
g_steal_pointer (&program); \
} G_STMT_END;
# include "gsknglprograms.defs"
#undef GSK_NGL_DEFINE_PROGRAM_CLIP
#undef GSK_NGL_DEFINE_PROGRAM
#undef GSK_NGL_ADD_UNIFORM
ret = TRUE;
failure:
g_clear_object (&compiler);
return ret;
}
/**
* 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_ngl_driver_autorelease_framebuffer (GskNglDriver *self,
guint framebuffer_id)
{
g_assert (GSK_IS_NGL_DRIVER (self));
g_array_append_val (self->autorelease_framebuffers, framebuffer_id);
}
static GskNglDriver *
gsk_ngl_driver_new (GskNglCommandQueue *command_queue,
gboolean debug_shaders,
GError **error)
{
GskNglDriver *self;
GdkGLContext *context;
g_return_val_if_fail (GSK_IS_NGL_COMMAND_QUEUE (command_queue), NULL);
context = gsk_ngl_command_queue_get_context (command_queue);
gdk_gl_context_make_current (context);
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_ngl_driver_load_programs (self, error))
{
g_object_unref (self);
return NULL;
}
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_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
*
* 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 `GskNglDriver` if successful; otherwise %NULL and
* @error is set.
*/
GskNglDriver *
gsk_ngl_driver_from_shared_context (GdkGLContext *context,
gboolean debug_shaders,
GError **error)
{
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_NGL_DRIVER")))
return g_object_ref (driver);
gdk_gl_context_make_current (context);
/* Initially we create a command queue using the shared context. However,
* as frames are processed this will be replaced with the command queue
* for a given renderer. But since the programs are compiled into the
* shared context, all other contexts sharing with it will have access
* to those programs.
*/
command_queue = gsk_ngl_command_queue_new (context, NULL);
if (!(driver = gsk_ngl_driver_new (command_queue, debug_shaders, error)))
goto failure;
g_object_set_data_full (G_OBJECT (context),
"GSK_NGL_DRIVER",
g_object_ref (driver),
g_object_unref);
failure:
g_clear_object (&command_queue);
return g_steal_pointer (&driver);
}
static GPtrArray *
gsk_ngl_driver_compact_atlases (GskNglDriver *self)
{
GPtrArray *removed = NULL;
g_assert (GSK_IS_NGL_DRIVER (self));
for (guint i = self->atlases->len; i > 0; i--)
{
GskNglTextureAtlas *atlas = g_ptr_array_index (self->atlases, i - 1);
if (gsk_ngl_texture_atlas_get_unused_ratio (atlas) > MAX_OLD_RATIO)
{
GSK_NOTE (GLYPH_CACHE,
g_message ("Dropping atlas %d (%g.2%% old)", i,
100.0 * gsk_ngl_texture_atlas_get_unused_ratio (atlas)));
if (removed == NULL)
removed = g_ptr_array_new_with_free_func ((GDestroyNotify)gsk_ngl_texture_atlas_free);
g_ptr_array_add (removed, g_ptr_array_steal_index (self->atlases, i - 1));
}
}
GSK_NOTE (GLYPH_CACHE, {
static guint timestamp;
if (timestamp++ % 60 == 0)
g_message ("%d atlases", self->atlases->len);
});
return removed;
}
/**
* gsk_ngl_driver_begin_frame:
* @self: a `GskNglDriver`
* @command_queue: A `GskNglCommandQueue` from the renderer
*
* Begin a new frame.
*
* Texture atlases, pools, and other resources will be prepared to draw the
* next frame. The command queue should be one that was created for the
* target context to be drawn into (the context of the renderer's surface).
*/
void
gsk_ngl_driver_begin_frame (GskNglDriver *self,
GskNglCommandQueue *command_queue)
{
gint64 last_frame_id;
GPtrArray *removed;
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;
self->in_frame = TRUE;
self->current_frame_id++;
g_set_object (&self->command_queue, command_queue);
gsk_ngl_command_queue_begin_frame (self->command_queue);
/* Compact atlases with too many freed pixels */
removed = gsk_ngl_driver_compact_atlases (self);
/* Mark unused pixel regions of the atlases */
gsk_ngl_texture_library_begin_frame (GSK_NGL_TEXTURE_LIBRARY (self->icons),
self->current_frame_id,
removed);
gsk_ngl_texture_library_begin_frame (GSK_NGL_TEXTURE_LIBRARY (self->glyphs),
self->current_frame_id,
removed);
/* Cleanup old shadows */
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_ngl_driver_collect_unused_textures (self, last_frame_id - 1);
/* Now free atlas textures */
g_clear_pointer (&removed, g_ptr_array_unref);
}
/**
* 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_ngl_driver_end_frame (GskNglDriver *self)
{
g_return_if_fail (GSK_IS_NGL_DRIVER (self));
g_return_if_fail (self->in_frame == TRUE);
gsk_ngl_command_queue_make_current (self->command_queue);
gsk_ngl_command_queue_end_frame (self->command_queue);
self->in_frame = FALSE;
}
/**
* gsk_ngl_driver_after_frame:
* @self: a `GskNglDriver`
*
* This function does post-frame cleanup operations.
*
* To reduce the chances of blocking on the driver it is performed
* after the frame has swapped buffers.
*/
void
gsk_ngl_driver_after_frame (GskNglDriver *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
* self->autorelease_framebuffers) so we can release the FBOs immediately
* afterwards.
*/
while (self->render_targets->len > 0)
{
GskNglRenderTarget *render_target = g_ptr_array_index (self->render_targets, self->render_targets->len - 1);
gsk_ngl_driver_autorelease_framebuffer (self, render_target->framebuffer_id);
glDeleteTextures (1, &render_target->texture_id);
g_slice_free (GskNglRenderTarget, render_target);
self->render_targets->len--;
}
/* Now that we have collected render targets, release all the FBOs */
if (self->autorelease_framebuffers->len > 0)
{
glDeleteFramebuffers (self->autorelease_framebuffers->len,
(GLuint *)(gpointer)self->autorelease_framebuffers->data);
self->autorelease_framebuffers->len = 0;
}
/* Release any cached textures we used during the frame */
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
* from external systems such as GDK).
*/
g_set_object (&self->command_queue, self->shared_command_queue);
}
GdkGLContext *
gsk_ngl_driver_get_context (GskNglDriver *self)
{
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_ngl_command_queue_get_context (self->command_queue);
}
/**
* 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_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_ngl_driver_cache_texture (GskNglDriver *self,
const GskTextureKey *key,
guint texture_id)
{
GskTextureKey *k;
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)));
k = g_memdup (key, sizeof *key);
g_hash_table_insert (self->key_to_texture_id, k, GUINT_TO_POINTER (texture_id));
g_hash_table_insert (self->texture_id_to_key, GUINT_TO_POINTER (texture_id), k);
}
/**
* gsk_ngl_driver_load_texture:
* @self: a `GdkTexture`
* @texture: a `GdkTexture`
* @min_filter: GL_NEAREST or GL_LINEAR
* @mag_filter: GL_NEAREST or GL_LINEAR
*
* Loads a `GdkTexture` by uploading the contents to the GPU when
* necessary. If @texture is a `GdkGLTexture`, it can be used without
* uploading contents to the GPU.
*
* If the texture has already been uploaded and not yet released
* from cache, this function returns that texture id without further
* work.
*
* If the texture has not been used for a number of frames, it will
* be removed from cache.
*
* There is no need to release the resulting texture identifier after
* using it. It will be released automatically.
*
* Returns: a texture identifier
*/
guint
gsk_ngl_driver_load_texture (GskNglDriver *self,
GdkTexture *texture,
int min_filter,
int mag_filter)
{
GdkGLContext *context;
GdkTexture *downloaded_texture = NULL;
GdkTexture *source_texture;
GskNglTexture *t;
guint texture_id;
int height;
int width;
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_NGL_COMMAND_QUEUE (self->command_queue), 0);
context = self->command_queue->context;
if (GDK_IS_GL_TEXTURE (texture))
{
GdkGLContext *texture_context = gdk_gl_texture_get_context ((GdkGLTexture *)texture);
GdkGLContext *shared_context = gdk_gl_context_get_shared_context (context);
if (texture_context == context ||
(shared_context != NULL &&
shared_context == gdk_gl_context_get_shared_context (texture_context)))
{
/* A GL texture from the same GL context is a simple task... */
return gdk_gl_texture_get_id ((GdkGLTexture *)texture);
}
else
{
cairo_surface_t *surface;
/* In this case, we have to temporarily make the texture's
* context the current one, download its data into our context
* and then create a texture from it. */
if (texture_context != NULL)
gdk_gl_context_make_current (texture_context);
surface = gdk_texture_download_surface (texture);
downloaded_texture = gdk_texture_new_for_surface (surface);
cairo_surface_destroy (surface);
gdk_gl_context_make_current (context);
source_texture = downloaded_texture;
}
}
else
{
if ((t = gdk_texture_get_render_data (texture, self)))
{
if (t->min_filter == min_filter && t->mag_filter == mag_filter)
return t->texture_id;
}
source_texture = texture;
}
width = gdk_texture_get_width (texture);
height = gdk_texture_get_height (texture);
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_ngl_texture_destroyed))
t->user = texture;
gdk_gl_context_label_object_printf (context, GL_TEXTURE, t->texture_id,
"GdkTexture<%p> %d", texture, t->texture_id);
g_clear_object (&downloaded_texture);
return texture_id;
}
/**
* 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
* @mag_filter: GL_NEAREST or GL_FILTER
*
* Creates a new texture immediately that can be used by the caller
* to upload data, map to a framebuffer, or other uses which may
* modify the texture immediately.
*
* 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 `GskNglTexture` which can be returned to the pool with
* gsk_ngl_driver_release_texture().
*/
GskNglTexture *
gsk_ngl_driver_create_texture (GskNglDriver *self,
float width,
float height,
int min_filter,
int mag_filter)
{
GskNglTexture *texture;
g_return_val_if_fail (GSK_IS_NGL_DRIVER (self), NULL);
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);
texture->last_used_in_frame = self->current_frame_id;
return texture;
}
/**
* 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
* usage on the GPU.
*
* When the frame has completed, pooled textures will be released
* to free additional VRAM back to the system.
*/
void
gsk_ngl_driver_release_texture (GskNglDriver *self,
GskNglTexture *texture)
{
guint texture_id;
g_assert (GSK_IS_NGL_DRIVER (self));
g_assert (texture != NULL);
texture_id = texture->texture_id;
if (texture_id > 0)
remove_texture_key_for_id (self, texture_id);
g_hash_table_steal (self->textures, GUINT_TO_POINTER (texture_id));
gsk_ngl_texture_pool_put (&self->texture_pool, texture);
}
/**
* 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
* @mag_filter: the mag filter to use for the texture
* @out_render_target: (out): a location for the render target
*
* Creates a new render target which contains a framebuffer and a texture
* bound to that framebuffer of the size @width x @height and using the
* appropriate filters.
*
* 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.
*
* Returns: %TRUE if successful; otherwise %FALSE and @out_fbo_id and
* @out_texture_id are undefined.
*/
gboolean
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_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
if (self->render_targets->len > 0)
{
for (guint i = self->render_targets->len; i > 0; i--)
{
GskNglRenderTarget *render_target = g_ptr_array_index (self->render_targets, i-1);
if (render_target->width == width &&
render_target->height == height &&
render_target->min_filter == min_filter &&
render_target->mag_filter == mag_filter)
{
*out_render_target = g_ptr_array_steal_index_fast (self->render_targets, i-1);
return TRUE;
}
}
}
#endif
if (gsk_ngl_command_queue_create_render_target (self->command_queue,
width, height,
min_filter, mag_filter,
&framebuffer_id, &texture_id))
{
GskNglRenderTarget *render_target;
render_target = g_slice_new0 (GskNglRenderTarget);
render_target->min_filter = min_filter;
render_target->mag_filter = mag_filter;
render_target->width = width;
render_target->height = height;
render_target->framebuffer_id = framebuffer_id;
render_target->texture_id = texture_id;
*out_render_target = render_target;
return TRUE;
}
*out_render_target = NULL;
return FALSE;
}
/**
* 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
* be made to cache the render target so that future creations of render
* targets are performed faster.
*
* If @release_texture is %FALSE, the backing texture id is returned and
* the framebuffer is released. Otherwise, both the texture and framebuffer
* are released or cached until the end of the frame.
*
* This may be called when building the render job as the texture or
* framebuffer will not be removed immediately.
*
* Returns: a texture id if @release_texture is %FALSE, otherwise zero.
*/
guint
gsk_ngl_driver_release_render_target (GskNglDriver *self,
GskNglRenderTarget *render_target,
gboolean release_texture)
{
guint texture_id;
g_return_val_if_fail (GSK_IS_NGL_DRIVER (self), 0);
g_return_val_if_fail (render_target != NULL, 0);
if (release_texture)
{
texture_id = 0;
g_ptr_array_add (self->render_targets, render_target);
}
else
{
GskNglTexture *texture;
texture_id = render_target->texture_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_ngl_driver_autorelease_framebuffer (self, render_target->framebuffer_id);
g_slice_free (GskNglRenderTarget, render_target);
}
return texture_id;
}
/**
* gsk_ngl_driver_lookup_shader:
* @self: a `GskNglDriver`
* @shader: the shader to lookup or load
* @error: a location for a `GError`
*
* Attepts to load @shader from the shader cache.
*
* If it has not been loaded, then it will compile the shader on demand.
*
* Returns: (nullable) (transfer none): a `GskGLShader`
*/
GskNglProgram *
gsk_ngl_driver_lookup_shader (GskNglDriver *self,
GskGLShader *shader,
GError **error)
{
GskNglProgram *program;
g_return_val_if_fail (self != NULL, NULL);
g_return_val_if_fail (shader != NULL, NULL);
program = g_hash_table_lookup (self->shader_cache, shader);
if (program == NULL)
{
const GskGLUniform *uniforms;
GskNglCompiler *compiler;
GBytes *suffix;
int n_required_textures;
int n_uniforms;
uniforms = gsk_gl_shader_get_uniforms (shader, &n_uniforms);
if (n_uniforms > GSK_NGL_PROGRAM_MAX_CUSTOM_ARGS)
{
g_set_error (error,
GDK_GL_ERROR,
GDK_GL_ERROR_UNSUPPORTED_FORMAT,
"Tried to use %d uniforms, while only %d is supported",
n_uniforms,
GSK_NGL_PROGRAM_MAX_CUSTOM_ARGS);
return NULL;
}
n_required_textures = gsk_gl_shader_get_n_textures (shader);
if (n_required_textures > GSK_NGL_PROGRAM_MAX_CUSTOM_TEXTURES)
{
g_set_error (error,
GDK_GL_ERROR,
GDK_GL_ERROR_UNSUPPORTED_FORMAT,
"Tried to use %d textures, while only %d is supported",
n_required_textures,
GSK_NGL_PROGRAM_MAX_CUSTOM_TEXTURES);
return NULL;
}
compiler = gsk_ngl_compiler_new (self, FALSE);
suffix = gsk_gl_shader_get_source (shader);
gsk_ngl_compiler_set_preamble_from_resource (compiler,
GSK_NGL_COMPILER_ALL,
"/org/gtk/libgsk/ngl/preamble.glsl");
gsk_ngl_compiler_set_preamble_from_resource (compiler,
GSK_NGL_COMPILER_VERTEX,
"/org/gtk/libgsk/ngl/preamble.vs.glsl");
gsk_ngl_compiler_set_preamble_from_resource (compiler,
GSK_NGL_COMPILER_FRAGMENT,
"/org/gtk/libgsk/ngl/preamble.fs.glsl");
gsk_ngl_compiler_set_source_from_resource (compiler,
GSK_NGL_COMPILER_ALL,
"/org/gtk/libgsk/ngl/custom.glsl");
gsk_ngl_compiler_set_suffix (compiler, GSK_NGL_COMPILER_FRAGMENT, suffix);
/* Setup attributes that are provided via VBO */
gsk_ngl_compiler_bind_attribute (compiler, "aPosition", 0);
gsk_ngl_compiler_bind_attribute (compiler, "aUv", 1);
gsk_ngl_compiler_bind_attribute (compiler, "aColor", 2);
gsk_ngl_compiler_bind_attribute (compiler, "aColor2", 3);
if ((program = gsk_ngl_compiler_compile (compiler, NULL, "", error)))
{
gboolean have_alpha;
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);
/* Custom arguments (max is 8) */
for (guint i = 0; i < n_uniforms; i++)
gsk_ngl_program_add_uniform (program, uniforms[i].name, UNIFORM_CUSTOM_ARG0+i);
gsk_ngl_program_uniforms_added (program, TRUE);
if (have_alpha)
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_ngl_driver_shader_weak_cb,
self);
}
g_object_unref (compiler);
}
return program;
}
#ifdef G_ENABLE_DEBUG
static void
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);
cairo_surface_t *s;
glBindTexture (GL_TEXTURE_2D, atlas->texture_id);
glGetTexImage (GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
s = cairo_image_surface_create_for_data (data, CAIRO_FORMAT_ARGB32, atlas->width, atlas->height, stride);
cairo_surface_write_to_png (s, filename);
cairo_surface_destroy (s);
g_free (data);
}
void
gsk_ngl_driver_save_atlases_to_png (GskNglDriver *self,
const char *directory)
{
g_return_if_fail (GSK_IS_NGL_DRIVER (self));
if (directory == NULL)
directory = ".";
for (guint i = 0; i < self->atlases->len; 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,
(int)self->current_frame_id,
atlas->texture_id);
write_atlas_to_png (atlas, filename);
g_free (filename);
}
}
#endif
GskNglCommandQueue *
gsk_ngl_driver_create_command_queue (GskNglDriver *self,
GdkGLContext *context)
{
g_return_val_if_fail (GSK_IS_NGL_DRIVER (self), NULL);
g_return_val_if_fail (GDK_IS_GL_CONTEXT (context), NULL);
return gsk_ngl_command_queue_new (context, self->shared_command_queue->uniforms);
}
void
gsk_ngl_driver_add_texture_slices (GskNglDriver *self,
GdkTexture *texture,
GskNglTextureSlice **out_slices,
guint *out_n_slices)
{
int max_texture_size;
GskNglTextureSlice *slices;
GskNglTexture *t;
guint n_slices;
guint cols;
guint rows;
int tex_width;
int tex_height;
int x = 0, y = 0;
g_assert (GSK_IS_NGL_DRIVER (self));
g_assert (GDK_IS_TEXTURE (texture));
g_assert (out_slices != NULL);
g_assert (out_n_slices != NULL);
/* XXX: Too much? */
max_texture_size = self->command_queue->max_texture_size / 4;
tex_width = texture->width;
tex_height = texture->height;
cols = (texture->width / max_texture_size) + 1;
rows = (texture->height / max_texture_size) + 1;
if ((t = gdk_texture_get_render_data (texture, self)))
{
*out_slices = t->slices;
*out_n_slices = t->n_slices;
return;
}
n_slices = cols * rows;
slices = g_new0 (GskNglTextureSlice, n_slices);
for (guint col = 0; col < cols; col ++)
{
int slice_width = MIN (max_texture_size, texture->width - x);
for (guint row = 0; row < rows; row ++)
{
int slice_height = MIN (max_texture_size, texture->height - y);
int slice_index = (col * rows) + row;
guint texture_id;
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;
slices[slice_index].rect.width = slice_width;
slices[slice_index].rect.height = slice_height;
slices[slice_index].texture_id = texture_id;
y += slice_height;
}
y = 0;
x += slice_width;
}
/* Allocate one Texture for the entire thing. */
t = gsk_ngl_texture_new (0,
tex_width, tex_height,
GL_NEAREST, GL_NEAREST,
self->current_frame_id);
/* 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_ngl_texture_free);
t->slices = *out_slices = slices;
t->n_slices = *out_n_slices = n_slices;
}
GskNglTexture *
gsk_ngl_driver_mark_texture_permanent (GskNglDriver *self,
guint texture_id)
{
GskNglTexture *t;
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))))
t->permanent = TRUE;
return t;
}
void
gsk_ngl_driver_release_texture_by_id (GskNglDriver *self,
guint texture_id)
{
GskNglTexture *texture;
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_ngl_driver_release_texture (self, texture);
}
static void
create_texture_from_texture_destroy (gpointer data)
{
GskNglTextureState *state = data;
g_assert (state != NULL);
g_assert (GDK_IS_GL_CONTEXT (state->context));
gdk_gl_context_make_current (state->context);
glDeleteTextures (1, &state->texture_id);
g_clear_object (&state->context);
g_slice_free (GskNglTextureState, state);
}
GdkTexture *
gsk_ngl_driver_create_gdk_texture (GskNglDriver *self,
guint texture_id)
{
GskNglTextureState *state;
GskNglTexture *texture;
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);
g_return_val_if_fail (!g_hash_table_contains (self->texture_id_to_key, GUINT_TO_POINTER (texture_id)), NULL);
/* We must be tracking this texture_id already to use it */
if (!(texture = g_hash_table_lookup (self->textures, GUINT_TO_POINTER (texture_id))))
g_return_val_if_reached (NULL);
state = g_slice_new0 (GskNglTextureState);
state->texture_id = texture_id;
state->context = g_object_ref (self->command_queue->context);
g_hash_table_steal (self->textures, GUINT_TO_POINTER (texture_id));
return gdk_gl_texture_new (self->command_queue->context,
texture_id,
texture->width,
texture->height,
create_texture_from_texture_destroy,
state);
}
Reference in New Issue View Git Blame Copy Permalink