AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
6129daf29b
gtk2/gsk/gskvulkanrenderpass.c

361 lines
11 KiB
C
Raw Normal View History

vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
#include "config.h"
#include "gskvulkanrenderpassprivate.h"
#include "gskvulkanimageprivate.h"
#include "gskrendernodeprivate.h"
#include "gskrenderer.h"
vulkan: Implement texture caching And with this change, the GPU looks bored again.
2016-12-09 06:23:04 +00:00
#include "gskvulkanrendererprivate.h"
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
typedef struct _GskVulkanRenderOp GskVulkanRenderOp;
typedef enum {
vulkan: Add more node operations Add SURFACE and TEXTURE operations. This way, we actually render more than one node every frame because not everything is a fallback node anymore that gets composited with its children into a cairo surface.
2016-12-09 04:59:19 +00:00
GSK_VULKAN_OP_FALLBACK,
GSK_VULKAN_OP_SURFACE,
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
GSK_VULKAN_OP_TEXTURE,
GSK_VULKAN_OP_BIND_MVP
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
} GskVulkanOpType;
struct _GskVulkanRenderOp
{
GskVulkanOpType type;
GskRenderNode *node; /* node that's the source of this op */
GskVulkanImage *source; /* source image to render */
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
graphene_matrix_t mvp; /* new mvp to set */
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
gsize vertex_offset; /* offset into vertex buffer */
gsize vertex_count; /* number of vertices */
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
gsize descriptor_set_index; /* index into descriptor sets array for the right descriptor set to bind */
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
};
struct _GskVulkanRenderPass
{
GdkVulkanContext *vulkan;
GArray *render_ops;
};
GskVulkanRenderPass *
gsk_vulkan_render_pass_new (GdkVulkanContext *context)
{
GskVulkanRenderPass *self;
self = g_slice_new0 (GskVulkanRenderPass);
self->vulkan = g_object_ref (context);
self->render_ops = g_array_new (FALSE, FALSE, sizeof (GskVulkanRenderOp));
return self;
}
void
gsk_vulkan_render_pass_free (GskVulkanRenderPass *self)
{
g_array_unref (self->render_ops);
g_object_unref (self->vulkan);
g_slice_free (GskVulkanRenderPass, self);
}
void
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
gsk_vulkan_render_pass_add_node (GskVulkanRenderPass *self,
GskVulkanRender *render,
const graphene_matrix_t *mvp,
GskRenderNode *node)
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
{
GskVulkanRenderOp op = {
.type = GSK_VULKAN_OP_FALLBACK,
.node = node
};
vulkan: Add more node operations Add SURFACE and TEXTURE operations. This way, we actually render more than one node every frame because not everything is a fallback node anymore that gets composited with its children into a cairo surface.
2016-12-09 04:59:19 +00:00
if (gsk_render_node_get_opacity (node) < 1.0)
goto fallback;
gsk: Remove gsk_render_node_is_surface/texture() Use gsk_render_node_get_node_type() instead.
2016-12-11 01:33:58 +00:00
switch (gsk_render_node_get_node_type (node))
vulkan: Add more node operations Add SURFACE and TEXTURE operations. This way, we actually render more than one node every frame because not everything is a fallback node anymore that gets composited with its children into a cairo surface.
2016-12-09 04:59:19 +00:00
{
gsk: Remove gsk_render_node_is_surface/texture() Use gsk_render_node_get_node_type() instead.
2016-12-11 01:33:58 +00:00
case GSK_NOT_A_RENDER_NODE:
default:
g_assert_not_reached ();
break;
case GSK_CAIRO_NODE:
vulkan: Add more node operations Add SURFACE and TEXTURE operations. This way, we actually render more than one node every frame because not everything is a fallback node anymore that gets composited with its children into a cairo surface.
2016-12-09 04:59:19 +00:00
op.type = GSK_VULKAN_OP_SURFACE;
g_array_append_val (self->render_ops, op);
gsk: Remove gsk_render_node_is_surface/texture() Use gsk_render_node_get_node_type() instead.
2016-12-11 01:33:58 +00:00
break;
case GSK_TEXTURE_NODE:
vulkan: Add more node operations Add SURFACE and TEXTURE operations. This way, we actually render more than one node every frame because not everything is a fallback node anymore that gets composited with its children into a cairo surface.
2016-12-09 04:59:19 +00:00
op.type = GSK_VULKAN_OP_TEXTURE;
g_array_append_val (self->render_ops, op);
gsk: Remove gsk_render_node_is_surface/texture() Use gsk_render_node_get_node_type() instead.
2016-12-11 01:33:58 +00:00
break;
case GSK_CONTAINER_NODE:
gsK: Move children handling to GskContainerNode
2016-12-12 18:30:41 +00:00
{
guint i;
for (i = 0; i < gsk_container_node_get_n_children (node); i++)
{
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
gsk_vulkan_render_pass_add_node (self, render, mvp, gsk_container_node_get_child (node, i));
gsK: Move children handling to GskContainerNode
2016-12-12 18:30:41 +00:00
}
}
gsk: Remove gsk_render_node_is_surface/texture() Use gsk_render_node_get_node_type() instead.
2016-12-11 01:33:58 +00:00
break;
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
case GSK_TRANSFORM_NODE:
{
graphene_matrix_t transform;
op.type = GSK_VULKAN_OP_BIND_MVP;
gsk_transform_node_get_transform (node, &transform);
graphene_matrix_multiply (&transform, mvp, &op.mvp);
g_array_append_val (self->render_ops, op);
gsk_vulkan_render_pass_add_node (self, render, &op.mvp, gsk_transform_node_get_child (node));
graphene_matrix_init_from_matrix (&op.mvp, mvp);
g_array_append_val (self->render_ops, op);
}
break;
vulkan: Add more node operations Add SURFACE and TEXTURE operations. This way, we actually render more than one node every frame because not everything is a fallback node anymore that gets composited with its children into a cairo surface.
2016-12-09 04:59:19 +00:00
}
return;
fallback:
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
g_array_append_val (self->render_ops, op);
}
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
void
gsk_vulkan_render_pass_add (GskVulkanRenderPass *self,
GskVulkanRender *render,
const graphene_matrix_t *mvp,
GskRenderNode *node)
{
GskVulkanRenderOp op = {
.type = GSK_VULKAN_OP_BIND_MVP,
.mvp = *mvp
};
g_array_append_val (self->render_ops, op);
gsk_vulkan_render_pass_add_node (self, render, mvp, node);
}
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
static void
vulkan: Make the GskVulkanRender struct private
2016-12-08 16:55:32 +00:00
gsk_vulkan_render_pass_upload_fallback (GskVulkanRenderPass *self,
GskVulkanRenderOp *op,
GskVulkanRender *render,
VkCommandBuffer command_buffer)
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
{
graphene_rect_t bounds;
cairo_surface_t *surface;
cairo_t *cr;
gsk_render_node_get_bounds (op->node, &bounds);
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
ceil (bounds.size.width),
ceil (bounds.size.height));
cr = cairo_create (surface);
cairo_translate (cr, bounds.origin.x, bounds.origin.y);
Call gsk_render_node_draw() instead of creating fallback renderers
2016-12-13 02:15:07 +00:00
gsk_render_node_draw (op->node, cr);
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
cairo_destroy (cr);
vulkan: Make the GskVulkanRender struct private
2016-12-08 16:55:32 +00:00
op->source = gsk_vulkan_image_new_from_data (self->vulkan,
command_buffer,
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
cairo_image_surface_get_data (surface),
cairo_image_surface_get_width (surface),
cairo_image_surface_get_height (surface),
cairo_image_surface_get_stride (surface));
cairo_surface_destroy (surface);
gsk_vulkan_render_add_cleanup_image (render, op->source);
}
void
gsk_vulkan_render_pass_upload (GskVulkanRenderPass *self,
vulkan: Make the GskVulkanRender struct private
2016-12-08 16:55:32 +00:00
GskVulkanRender *render,
VkCommandBuffer command_buffer)
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
{
GskVulkanRenderOp *op;
guint i;
for (i = 0; i < self->render_ops->len; i++)
{
op = &g_array_index (self->render_ops, GskVulkanRenderOp, i);
switch (op->type)
{
case GSK_VULKAN_OP_FALLBACK:
vulkan: Make the GskVulkanRender struct private
2016-12-08 16:55:32 +00:00
gsk_vulkan_render_pass_upload_fallback (self, op, render, command_buffer);
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
break;
vulkan: Add more node operations Add SURFACE and TEXTURE operations. This way, we actually render more than one node every frame because not everything is a fallback node anymore that gets composited with its children into a cairo surface.
2016-12-09 04:59:19 +00:00
case GSK_VULKAN_OP_SURFACE:
{
gsk: Add gsk_cairo_node_new() Split off Cairo drawn content nodes and require you to allocate them using this new function.
2016-12-11 00:23:02 +00:00
cairo_surface_t *surface = gsk_cairo_node_get_surface (op->node);
vulkan: Add more node operations Add SURFACE and TEXTURE operations. This way, we actually render more than one node every frame because not everything is a fallback node anymore that gets composited with its children into a cairo surface.
2016-12-09 04:59:19 +00:00
op->source = gsk_vulkan_image_new_from_data (self->vulkan,
command_buffer,
cairo_image_surface_get_data (surface),
cairo_image_surface_get_width (surface),
cairo_image_surface_get_height (surface),
cairo_image_surface_get_stride (surface));
gsk_vulkan_render_add_cleanup_image (render, op->source);
}
break;
case GSK_VULKAN_OP_TEXTURE:
{
vulkan: Implement texture caching And with this change, the GPU looks bored again.
2016-12-09 06:23:04 +00:00
op->source = gsk_vulkan_renderer_ref_texture_image (GSK_VULKAN_RENDERER (gsk_vulkan_render_get_renderer (render)),
gsk: Add gsk_texture_node_new() Start the transition into the different node types.
2016-12-10 21:52:22 +00:00
gsk_texture_node_get_texture (op->node),
vulkan: Implement texture caching And with this change, the GPU looks bored again.
2016-12-09 06:23:04 +00:00
command_buffer);
vulkan: Add more node operations Add SURFACE and TEXTURE operations. This way, we actually render more than one node every frame because not everything is a fallback node anymore that gets composited with its children into a cairo surface.
2016-12-09 04:59:19 +00:00
gsk_vulkan_render_add_cleanup_image (render, op->source);
}
break;
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
default:
g_assert_not_reached ();
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
case GSK_VULKAN_OP_BIND_MVP:
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
break;
}
}
}
gsize
gsk_vulkan_render_pass_count_vertices (GskVulkanRenderPass *self)
{
return self->render_ops->len * 6;
}
static gsize
gsk_vulkan_render_op_collect_vertices (GskVulkanRenderOp *op,
GskVulkanVertex *vertices)
{
graphene_rect_t bounds;
gsk_render_node_get_bounds (op->node, &bounds);
vertices[0] = (GskVulkanVertex) { bounds.origin.x, bounds.origin.y, 0.0, 0.0 };
vertices[1] = (GskVulkanVertex) { bounds.origin.x + bounds.size.width, bounds.origin.y, 1.0, 0.0 };
vertices[2] = (GskVulkanVertex) { bounds.origin.x, bounds.origin.y + bounds.size.height, 0.0, 1.0 };
vertices[3] = (GskVulkanVertex) { bounds.origin.x, bounds.origin.y + bounds.size.height, 0.0, 1.0 };
vertices[4] = (GskVulkanVertex) { bounds.origin.x + bounds.size.width, bounds.origin.y, 1.0, 0.0 };
vertices[5] = (GskVulkanVertex) { bounds.origin.x + bounds.size.width, bounds.origin.y + bounds.size.height, 1.0, 1.0 };
return 6;
}
gsize
gsk_vulkan_render_pass_collect_vertices (GskVulkanRenderPass *self,
GskVulkanVertex *vertices,
gsize offset,
gsize total)
{
GskVulkanRenderOp *op;
gsize n;
guint i;
n = 0;
for (i = 0; i < self->render_ops->len; i++)
{
op = &g_array_index (self->render_ops, GskVulkanRenderOp, i);
switch (op->type)
{
case GSK_VULKAN_OP_FALLBACK:
vulkan: Add more node operations Add SURFACE and TEXTURE operations. This way, we actually render more than one node every frame because not everything is a fallback node anymore that gets composited with its children into a cairo surface.
2016-12-09 04:59:19 +00:00
case GSK_VULKAN_OP_SURFACE:
case GSK_VULKAN_OP_TEXTURE:
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
op->vertex_offset = offset + n;
op->vertex_count = gsk_vulkan_render_op_collect_vertices (op, vertices + n + offset);
break;
default:
g_assert_not_reached ();
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
case GSK_VULKAN_OP_BIND_MVP:
op->vertex_offset = 0;
op->vertex_count = 0;
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
break;
}
n += op->vertex_count;
g_assert (n + offset <= total);
}
return n;
}
void
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
gsk_vulkan_render_pass_reserve_descriptor_sets (GskVulkanRenderPass *self,
GskVulkanRender *render)
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
{
GskVulkanRenderOp *op;
guint i;
for (i = 0; i < self->render_ops->len; i++)
{
op = &g_array_index (self->render_ops, GskVulkanRenderOp, i);
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
switch (op->type)
{
case GSK_VULKAN_OP_FALLBACK:
vulkan: Add more node operations Add SURFACE and TEXTURE operations. This way, we actually render more than one node every frame because not everything is a fallback node anymore that gets composited with its children into a cairo surface.
2016-12-09 04:59:19 +00:00
case GSK_VULKAN_OP_SURFACE:
case GSK_VULKAN_OP_TEXTURE:
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
op->descriptor_set_index = gsk_vulkan_render_reserve_descriptor_set (render, op->source);
break;
default:
g_assert_not_reached ();
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
case GSK_VULKAN_OP_BIND_MVP:
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
break;
}
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
}
}
void
vulkan: Push the correct matrix when drawing Instead of pushing the root matrix, push the world matrix for the current node. That way, the bounds we emit as vertices are actually properly transformed.
2016-12-09 04:53:04 +00:00
gsk_vulkan_render_pass_draw (GskVulkanRenderPass *self,
GskVulkanRender *render,
GskVulkanPipeline *pipeline,
VkCommandBuffer command_buffer)
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
{
GskVulkanRenderOp *op;
vulkan: Push the correct matrix when drawing Instead of pushing the root matrix, push the world matrix for the current node. That way, the bounds we emit as vertices are actually properly transformed.
2016-12-09 04:53:04 +00:00
float float_matrix[16];
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
guint i;
for (i = 0; i < self->render_ops->len; i++)
{
op = &g_array_index (self->render_ops, GskVulkanRenderOp, i);
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
switch (op->type)
{
case GSK_VULKAN_OP_FALLBACK:
case GSK_VULKAN_OP_SURFACE:
case GSK_VULKAN_OP_TEXTURE:
vkCmdBindDescriptorSets (command_buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
gsk_vulkan_pipeline_get_pipeline_layout (pipeline),
0,
1,
(VkDescriptorSet[1]) {
gsk_vulkan_render_get_descriptor_set (render, op->descriptor_set_index)
},
0,
NULL);
vkCmdDraw (command_buffer,
op->vertex_count, 1,
op->vertex_offset, 0);
break;
case GSK_VULKAN_OP_BIND_MVP:
graphene_matrix_to_float (&op->mvp, float_matrix);
vkCmdPushConstants (command_buffer,
gsk_vulkan_pipeline_get_pipeline_layout (pipeline),
VK_SHADER_STAGE_VERTEX_BIT,
0,
sizeof (float_matrix),
&float_matrix);
break;
default:
g_assert_not_reached ();
break;
}
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
}
}
Reference in New Issue Copy Permalink