Lerking/gtk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

gpu: Remove buffer handling

Browse Source 
We don't use buffers atm, and if we want to bring them back later, we
can just look at reverting this commit.

And it's in the way while refactoring.
This commit is contained in:
Benjamin Otte
2024-07-19 20:45:56 +02:00
parent dc9f0869b1
commit 1331a10e88
10 changed files with 11 additions and 444 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
gsk/gpu/gskgldescriptors.c
View File

@@ -2,7 +2,6 @@
#include "gskgldescriptorsprivate.h"
#include "gskglbufferprivate.h"
#include "gskglimageprivate.h"
struct _GskGLDescriptors
@@ -55,23 +54,6 @@ gsk_gl_descriptors_add_image (GskGpuDescriptors *desc,
}
}
static gboolean
gsk_gl_descriptors_add_buffer (GskGpuDescriptors *desc,
GskGpuBuffer *buffer,
guint32 *out_descriptor)
{
gsize used_buffers;
used_buffers = gsk_gpu_descriptors_get_n_buffers (desc);
if (used_buffers >= 11)
return FALSE;
*out_descriptor = used_buffers;
return TRUE;
}
static void
gsk_gl_descriptors_class_init (GskGLDescriptorsClass *klass)
{
@@ -81,7 +63,6 @@ gsk_gl_descriptors_class_init (GskGLDescriptorsClass *klass)
object_class->finalize = gsk_gl_descriptors_finalize;
descriptors_class->add_image = gsk_gl_descriptors_add_image;
descriptors_class->add_buffer = gsk_gl_descriptors_add_buffer;
}
static void
@@ -133,12 +114,4 @@ gsk_gl_descriptors_use (GskGLDescriptors *self)
glBindSampler (i - ext, gsk_gl_device_get_sampler_id (self->device, gsk_gpu_descriptors_get_sampler (desc, i)));
}
}
for (i = 0; i < gsk_gpu_descriptors_get_n_buffers (desc); i++)
{
GskGLBuffer *buffer = GSK_GL_BUFFER (gsk_gpu_descriptors_get_buffer (desc, i));
/* index 0 are the globals, we start at 1 */
gsk_gl_buffer_bind_base (buffer, i + 1);
}
}

83
gsk/gpu/gskgpudescriptors.c
View File

@@ -12,12 +12,6 @@ struct _GskGpuImageEntry
guint32 descriptor;
};
struct _GskGpuBufferEntry
{
GskGpuBuffer *buffer;
guint32 descriptor;
};
static void
gsk_gpu_image_entry_clear (gpointer data)
{
@@ -26,14 +20,6 @@ gsk_gpu_image_entry_clear (gpointer data)
g_object_unref (entry->image);
}
static void
gsk_gpu_buffer_entry_clear (gpointer data)
{
GskGpuBufferEntry *entry = data;
g_object_unref (entry->buffer);
}
#define GDK_ARRAY_NAME gsk_gpu_image_entries
#define GDK_ARRAY_TYPE_NAME GskGpuImageEntries
#define GDK_ARRAY_ELEMENT_TYPE GskGpuImageEntry
@@ -43,21 +29,11 @@ gsk_gpu_buffer_entry_clear (gpointer data)
#define GDK_ARRAY_NO_MEMSET 1
#include "gdk/gdkarrayimpl.c"
#define GDK_ARRAY_NAME gsk_gpu_buffer_entries
#define GDK_ARRAY_TYPE_NAME GskGpuBufferEntries
#define GDK_ARRAY_ELEMENT_TYPE GskGpuBufferEntry
#define GDK_ARRAY_FREE_FUNC gsk_gpu_buffer_entry_clear
#define GDK_ARRAY_BY_VALUE 1
#define GDK_ARRAY_PREALLOC 4
#define GDK_ARRAY_NO_MEMSET 1
#include "gdk/gdkarrayimpl.c"
typedef struct _GskGpuDescriptorsPrivate GskGpuDescriptorsPrivate;
struct _GskGpuDescriptorsPrivate
{
GskGpuImageEntries images;
GskGpuBufferEntries buffers;
};
G_DEFINE_TYPE_WITH_PRIVATE (GskGpuDescriptors, gsk_gpu_descriptors, G_TYPE_OBJECT)
@@ -69,7 +45,6 @@ gsk_gpu_descriptors_finalize (GObject *object)
GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
gsk_gpu_image_entries_clear (&priv->images);
gsk_gpu_buffer_entries_clear (&priv->buffers);
G_OBJECT_CLASS (gsk_gpu_descriptors_parent_class)->finalize (object);
}
@@ -88,7 +63,6 @@ gsk_gpu_descriptors_init (GskGpuDescriptors *self)
GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
gsk_gpu_image_entries_init (&priv->images);
gsk_gpu_buffer_entries_init (&priv->buffers);
}
gsize
@@ -99,25 +73,14 @@ gsk_gpu_descriptors_get_n_images (GskGpuDescriptors *self)
return gsk_gpu_image_entries_get_size (&priv->images);
}
gsize
gsk_gpu_descriptors_get_n_buffers (GskGpuDescriptors *self)
{
GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
return gsk_gpu_buffer_entries_get_size (&priv->buffers);
}
void
gsk_gpu_descriptors_set_size (GskGpuDescriptors *self,
gsize n_images,
gsize n_buffers)
gsize n_images)
{
GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
g_assert (n_images <= gsk_gpu_image_entries_get_size (&priv->images));
gsk_gpu_image_entries_set_size (&priv->images, n_images);
g_assert (n_buffers <= gsk_gpu_buffer_entries_get_size (&priv->buffers));
gsk_gpu_buffer_entries_set_size (&priv->buffers, n_buffers);
}
GskGpuImage *
@@ -158,16 +121,6 @@ gsk_gpu_descriptors_find_image (GskGpuDescriptors *self,
g_return_val_if_reached ((gsize) -1);
}
GskGpuBuffer *
gsk_gpu_descriptors_get_buffer (GskGpuDescriptors *self,
gsize id)
{
GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
const GskGpuBufferEntry *entry = gsk_gpu_buffer_entries_get (&priv->buffers, id);
return entry->buffer;
}
gboolean
gsk_gpu_descriptors_add_image (GskGpuDescriptors *self,
GskGpuImage *image,
@@ -204,37 +157,3 @@ gsk_gpu_descriptors_add_image (GskGpuDescriptors *self,
return TRUE;
}
gboolean
gsk_gpu_descriptors_add_buffer (GskGpuDescriptors *self,
GskGpuBuffer *buffer,
guint32 *out_descriptor)
{
GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
gsize i;
guint32 descriptor;
for (i = 0; i < gsk_gpu_buffer_entries_get_size (&priv->buffers); i++)
{
const GskGpuBufferEntry *entry = gsk_gpu_buffer_entries_get (&priv->buffers, i);
if (entry->buffer == buffer)
{
*out_descriptor = entry->descriptor;
return TRUE;
}
}
if (!GSK_GPU_DESCRIPTORS_GET_CLASS (self)->add_buffer (self, buffer, &descriptor))
return FALSE;
gsk_gpu_buffer_entries_append (&priv->buffers,
&(GskGpuBufferEntry) {
.buffer = g_object_ref (buffer),
.descriptor = descriptor
});
*out_descriptor = descriptor;
return TRUE;
}

12
gsk/gpu/gskgpudescriptorsprivate.h
View File

@@ -26,34 +26,24 @@ struct _GskGpuDescriptorsClass
GskGpuImage *image,
GskGpuSampler sampler,
guint32 *out_id);
gboolean (* add_buffer) (GskGpuDescriptors *self,
GskGpuBuffer *buffer,
guint32 *out_id);
};
GType gsk_gpu_descriptors_get_type (void) G_GNUC_CONST;
gsize gsk_gpu_descriptors_get_n_images (GskGpuDescriptors *self);
gsize gsk_gpu_descriptors_get_n_buffers (GskGpuDescriptors *self);
void gsk_gpu_descriptors_set_size (GskGpuDescriptors *self,
gsize n_images,
gsize n_buffers);
gsize n_images);
GskGpuImage * gsk_gpu_descriptors_get_image (GskGpuDescriptors *self,
gsize id);
GskGpuSampler gsk_gpu_descriptors_get_sampler (GskGpuDescriptors *self,
gsize id);
gsize gsk_gpu_descriptors_find_image (GskGpuDescriptors *self,
guint32 descriptor);
GskGpuBuffer * gsk_gpu_descriptors_get_buffer (GskGpuDescriptors *self,
gsize id);
gboolean gsk_gpu_descriptors_add_image (GskGpuDescriptors *self,
GskGpuImage *image,
GskGpuSampler sampler,
guint32 *out_descriptor);
gboolean gsk_gpu_descriptors_add_buffer (GskGpuDescriptors *self,
GskGpuBuffer *buffer,
guint32 *out_descriptor);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskGpuDescriptors, g_object_unref)

1
gsk/gpu/gskvulkandescriptors.c
View File

@@ -2,7 +2,6 @@
#include "gskvulkandescriptorsprivate.h"
#include "gskvulkanbufferprivate.h"
#include "gskvulkanframeprivate.h"
#include "gskvulkanimageprivate.h"

13
gsk/gpu/gskvulkanframe.c
View File

@@ -242,26 +242,23 @@ gsk_vulkan_frame_prepare_descriptors (GskVulkanFrame *self)
{
GskVulkanDevice *device;
VkDevice vk_device;
gsize i, n_images, n_buffers, n_sets;
gsize i, n_images, n_sets;
device = GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self)));
vk_device = gsk_vulkan_device_get_vk_device (device);
n_images = 0;
n_buffers = 0;
n_sets = 2 * gsk_descriptors_get_size (&self->descriptors);
for (i = 0; i < gsk_descriptors_get_size (&self->descriptors); i++)
{
gsize n_desc_images, n_desc_buffers;
gsize n_desc_images;
GskVulkanRealDescriptors *desc = gsk_descriptors_get (&self->descriptors, i);
gsk_vulkan_real_descriptors_prepare (desc, &n_desc_images, &n_desc_buffers);
gsk_vulkan_real_descriptors_prepare (desc, &n_desc_images);
n_images += n_desc_images;
n_buffers += n_desc_buffers;
}
if (n_sets > self->pool_n_sets ||
n_images > self->pool_n_images ||
n_buffers > self->pool_n_buffers)
n_images > self->pool_n_images)
{
if (self->vk_descriptor_pool != VK_NULL_HANDLE)
{
@@ -274,8 +271,6 @@ gsk_vulkan_frame_prepare_descriptors (GskVulkanFrame *self)
self->pool_n_sets = 4 << g_bit_nth_msf (n_sets - 1, -1);
if (n_images > self->pool_n_images)
self->pool_n_images = 2 << g_bit_nth_msf (n_images - 1, -1);
if (n_buffers > self->pool_n_buffers)
self->pool_n_buffers = 4 << g_bit_nth_msf (n_buffers - 1, -1);
}
if (self->vk_descriptor_pool == VK_NULL_HANDLE)

78
gsk/gpu/gskvulkanrealdescriptors.c
View File

@@ -3,7 +3,6 @@
#include "gskvulkanrealdescriptorsprivate.h"
#include "gskgpucacheprivate.h"
#include "gskvulkanbufferprivate.h"
#include "gskvulkanframeprivate.h"
#include "gskvulkanimageprivate.h"
@@ -15,14 +14,6 @@
#define GDK_ARRAY_NO_MEMSET 1
#include "gdk/gdkarrayimpl.c"
#define GDK_ARRAY_NAME gsk_descriptor_buffer_infos
#define GDK_ARRAY_TYPE_NAME GskDescriptorBufferInfos
#define GDK_ARRAY_ELEMENT_TYPE VkDescriptorBufferInfo
#define GDK_ARRAY_BY_VALUE 1
#define GDK_ARRAY_PREALLOC 32
#define GDK_ARRAY_NO_MEMSET 1
#include "gdk/gdkarrayimpl.c"
#define GDK_ARRAY_NAME gsk_samplers
#define GDK_ARRAY_TYPE_NAME GskSamplers
#define GDK_ARRAY_ELEMENT_TYPE VkSampler
@@ -41,7 +32,6 @@ struct _GskVulkanRealDescriptors
GskSamplers immutable_samplers;
GskDescriptorImageInfos descriptor_immutable_images;
GskDescriptorImageInfos descriptor_images;
GskDescriptorBufferInfos descriptor_buffers;
VkDescriptorSet descriptor_sets[GSK_VULKAN_N_DESCRIPTOR_SETS];
};
@@ -131,29 +121,6 @@ gsk_vulkan_real_descriptors_add_image (GskGpuDescriptors *desc,
return TRUE;
}
static gboolean
gsk_vulkan_real_descriptors_add_buffer (GskGpuDescriptors *desc,
GskGpuBuffer *buffer,
guint32 *out_descriptor)
{
GskVulkanRealDescriptors *self = GSK_VULKAN_REAL_DESCRIPTORS (desc);
GskVulkanDevice *device = GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame)));
if (gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers) >=
gsk_vulkan_device_get_max_buffers (device))
return FALSE;
*out_descriptor = gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers);
gsk_descriptor_buffer_infos_append (&self->descriptor_buffers,
&(VkDescriptorBufferInfo) {
.buffer = gsk_vulkan_buffer_get_vk_buffer (GSK_VULKAN_BUFFER (buffer)),
.offset = 0,
.range = VK_WHOLE_SIZE
});
return TRUE;
}
static void
gsk_vulkan_real_descriptors_finalize (GObject *object)
{
@@ -162,7 +129,6 @@ gsk_vulkan_real_descriptors_finalize (GObject *object)
gsk_samplers_clear (&self->immutable_samplers);
gsk_descriptor_image_infos_clear (&self->descriptor_immutable_images);
gsk_descriptor_image_infos_clear (&self->descriptor_images);
gsk_descriptor_buffer_infos_clear (&self->descriptor_buffers);
gsk_vulkan_device_release_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame))),
self->pipeline_layout);
@@ -180,7 +146,6 @@ gsk_vulkan_real_descriptors_class_init (GskVulkanRealDescriptorsClass *klass)
object_class->finalize = gsk_vulkan_real_descriptors_finalize;
descriptors_class->add_image = gsk_vulkan_real_descriptors_add_image;
descriptors_class->add_buffer = gsk_vulkan_real_descriptors_add_buffer;
vulkan_descriptors_class->get_pipeline_layout = gsk_vulkan_real_descriptors_get_pipeline_layout;
vulkan_descriptors_class->bind = gsk_vulkan_real_descriptors_bind;
@@ -192,7 +157,6 @@ gsk_vulkan_real_descriptors_init (GskVulkanRealDescriptors *self)
gsk_samplers_init (&self->immutable_samplers);
gsk_descriptor_image_infos_init (&self->descriptor_immutable_images);
gsk_descriptor_image_infos_init (&self->descriptor_images);
gsk_descriptor_buffer_infos_init (&self->descriptor_buffers);
}
GskVulkanRealDescriptors *
@@ -215,8 +179,7 @@ gsk_vulkan_real_descriptors_is_full (GskVulkanRealDescriptors *self)
return gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images) >= gsk_vulkan_device_get_max_immutable_samplers (device) ||
gsk_descriptor_image_infos_get_size (&self->descriptor_images) +
MAX (1, gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images) * 3) >=
gsk_vulkan_device_get_max_samplers (device) ||
gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers) >= gsk_vulkan_device_get_max_buffers (device);
gsk_vulkan_device_get_max_samplers (device);
}
static void
@@ -261,42 +224,21 @@ gsk_vulkan_real_descriptors_fill_sets (GskVulkanRealDescriptors *self)
{
gsk_descriptor_image_infos_append (&self->descriptor_images, gsk_descriptor_image_infos_get (&self->descriptor_images, 0));
}
if (gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers) == 0)
{
/* If there's no storage buffer yet, just make one */
GskGpuBuffer *buffer;
gsize ignored_offset;
guint32 ignored;
buffer = gsk_gpu_frame_write_storage_buffer (GSK_GPU_FRAME (self->frame), NULL, 0, &ignored_offset);
if (!gsk_gpu_descriptors_add_buffer (GSK_GPU_DESCRIPTORS (self),
buffer,
&ignored))
{
g_assert_not_reached ();
}
}
while (n_buffers > gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers))
{
gsk_descriptor_buffer_infos_append (&self->descriptor_buffers, gsk_descriptor_buffer_infos_get (&self->descriptor_buffers, 0));
}
}
void
gsk_vulkan_real_descriptors_prepare (GskVulkanRealDescriptors *self,
gsize *n_images,
gsize *n_buffers)
gsize *n_images)
{
self->pipeline_layout = gsk_vulkan_device_acquire_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame))),
gsk_samplers_get_data (&self->immutable_samplers),
gsk_samplers_get_size (&self->immutable_samplers),
gsk_descriptor_image_infos_get_size (&self->descriptor_images),
gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers));
0);
gsk_vulkan_real_descriptors_fill_sets (self);
*n_images = MAX (1, gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images)) +
gsk_descriptor_image_infos_get_size (&self->descriptor_images);
*n_buffers = gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers);
}
void
@@ -327,7 +269,7 @@ gsk_vulkan_real_descriptors_update_sets (GskVulkanRealDescriptors *self,
.descriptorSetCount = GSK_VULKAN_N_DESCRIPTOR_SETS,
.pDescriptorCounts = (uint32_t[GSK_VULKAN_N_DESCRIPTOR_SETS]) {
gsk_descriptor_image_infos_get_size (&self->descriptor_images),
gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers)
0,
}
}
},
@@ -358,18 +300,6 @@ gsk_vulkan_real_descriptors_update_sets (GskVulkanRealDescriptors *self,
.pImageInfo = gsk_descriptor_image_infos_get_data (&self->descriptor_images)
};
}
if (gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers) > 0)
{
write_descriptor_sets[n_descriptor_sets++] = (VkWriteDescriptorSet) {
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
.dstSet = self->descriptor_sets[GSK_VULKAN_BUFFER_SET_LAYOUT],
.dstBinding = 0,
.dstArrayElement = 0,
.descriptorCount = gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers),
.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
.pBufferInfo = gsk_descriptor_buffer_infos_get_data (&self->descriptor_buffers)
};
}
vkUpdateDescriptorSets (vk_device,
n_descriptor_sets,

3
gsk/gpu/gskvulkanrealdescriptorsprivate.h
View File

@@ -14,8 +14,7 @@ GskVulkanRealDescriptors * gsk_vulkan_real_descriptors_new
gboolean gsk_vulkan_real_descriptors_is_full (GskVulkanRealDescriptors *self);
void gsk_vulkan_real_descriptors_prepare (GskVulkanRealDescriptors *self,
gsize *n_images,
gsize *n_buffers);
gsize *n_images);
void gsk_vulkan_real_descriptors_update_sets (GskVulkanRealDescriptors *self,
VkDescriptorPool vk_descriptor_pool);

13
gsk/gpu/gskvulkansubdescriptors.c
View File

@@ -49,18 +49,6 @@ gsk_vulkan_sub_descriptors_add_image (GskGpuDescriptors *desc,
out_descriptor);
}
static gboolean
gsk_vulkan_sub_descriptors_add_buffer (GskGpuDescriptors *desc,
GskGpuBuffer *buffer,
guint32 *out_descriptor)
{
GskVulkanSubDescriptors *self = GSK_VULKAN_SUB_DESCRIPTORS (desc);
return gsk_gpu_descriptors_add_buffer (GSK_GPU_DESCRIPTORS (self->parent),
buffer,
out_descriptor);
}
static void
gsk_vulkan_sub_descriptors_finalize (GObject *object)
{
@@ -81,7 +69,6 @@ gsk_vulkan_sub_descriptors_class_init (GskVulkanSubDescriptorsClass *klass)
object_class->finalize = gsk_vulkan_sub_descriptors_finalize;
descriptors_class->add_image = gsk_vulkan_sub_descriptors_add_image;
descriptors_class->add_buffer = gsk_vulkan_sub_descriptors_add_buffer;
vulkan_descriptors_class->get_pipeline_layout = gsk_vulkan_sub_descriptors_get_pipeline_layout;
vulkan_descriptors_class->bind = gsk_vulkan_sub_descriptors_bind;

53
gsk/gpu/shaders/common-gl.glsl
View File

@@ -17,16 +17,6 @@ uniform PushConstants
#define GSK_GLOBAL_CLIP_RECT push.clip[0]
#define GSK_GLOBAL_SCALE push.scale
#if __VERSION__ < 420 || (defined(GSK_GLES) && __VERSION__ < 310)
layout(std140)
#else
layout(std140, binding = 1)
#endif
uniform Floats
{
vec4 really_just_floats[1024];
} floats[11];
#if N_EXTERNAL_TEXTURES > 0
uniform samplerExternalOES external_textures[N_EXTERNAL_TEXTURES];
#endif
@@ -48,49 +38,6 @@ uniform sampler2D textures[N_TEXTURES];
#define PASS(_loc) in
#define PASS_FLAT(_loc) flat in
float
gsk_get_float (int id)
{
int float_id = id & 0x3FFFFF;
int array_id = (id >> 22) & 0xFF;
switch (array_id)
{
case 0:
return floats[0].really_just_floats[float_id >> 2][float_id & 3];
case 1:
return floats[1].really_just_floats[float_id >> 2][float_id & 3];
case 2:
return floats[2].really_just_floats[float_id >> 2][float_id & 3];
case 3:
return floats[3].really_just_floats[float_id >> 2][float_id & 3];
case 4:
return floats[4].really_just_floats[float_id >> 2][float_id & 3];
case 5:
return floats[5].really_just_floats[float_id >> 2][float_id & 3];
case 6:
return floats[6].really_just_floats[float_id >> 2][float_id & 3];
case 7:
return floats[7].really_just_floats[float_id >> 2][float_id & 3];
case 8:
return floats[8].really_just_floats[float_id >> 2][float_id & 3];
case 9:
return floats[9].really_just_floats[float_id >> 2][float_id & 3];
case 10:
return floats[10].really_just_floats[float_id >> 2][float_id & 3];
default:
return 0.0;
}
}
float
gsk_get_float (uint id)
{
return gsk_get_float (int (id));
}
#define gsk_get_int(id) (floatBitsToInt(gsk_get_float(id)))
#define gsk_get_uint(id) (floatBitsToUint(gsk_get_float(id)))
#if __VERSION__ < 400 || defined(GSK_GLES)
vec4

172
gsk/gpu/shaders/common-vulkan.glsl
View File

@@ -37,9 +37,6 @@ layout(constant_id=5) const uint GSK_VARIATION = 0;
layout(set = 0, binding = 0) uniform sampler2D immutable_textures[GSK_N_IMMUTABLE_SAMPLERS];
layout(set = 0, binding = 1) uniform sampler2D textures[GSK_N_SAMPLERS];
layout(set = 1, binding = 0) readonly buffer FloatBuffers {
float floats[];
} buffers[GSK_N_BUFFERS];
layout(location = 0) out vec4 out_color;
@@ -1025,175 +1022,6 @@ gsk_texel_fetch (uint id,
return vec4 (1.0, 0.0, 0.8, 1.0);
}
#ifdef HAVE_VULKAN_1_2
#define gsk_get_buffer(id) buffers[nonuniformEXT (id)]
#define gsk_get_float(id) gsk_get_buffer(id >> 22).floats[id & 0x3FFFFF]
#else
float
gsk_get_float (uint id)
{
uint buffer_id = id >> 22;
uint float_id = id & 0x3FFFFF;
if (buffer_id < 16)
{
if (buffer_id < 8)
{
if (buffer_id < 4)
{
if (buffer_id < 2)
{
if (buffer_id < 1)
return buffers[0].floats[float_id];
else if (GSK_N_BUFFERS > 1)
return buffers[1].floats[float_id];
}
else if (GSK_N_BUFFERS > 2)
{
if (buffer_id < 3)
return buffers[2].floats[float_id];
else if (GSK_N_BUFFERS > 3)
return buffers[3].floats[float_id];
}
}
else if (GSK_N_BUFFERS > 4)
{
if (buffer_id < 6)
{
if (buffer_id < 5)
return buffers[4].floats[float_id];
else if (GSK_N_BUFFERS > 5)
return buffers[5].floats[float_id];
}
else if (GSK_N_BUFFERS > 6)
{
if (buffer_id < 7)
return buffers[6].floats[float_id];
else if (GSK_N_BUFFERS > 7)
return buffers[7].floats[float_id];
}
}
}
else if (GSK_N_BUFFERS > 8)
{
if (buffer_id < 12)
{
if (buffer_id < 10)
{
if (buffer_id < 9)
return buffers[8].floats[float_id];
else if (GSK_N_BUFFERS > 9)
return buffers[9].floats[float_id];
}
else if (GSK_N_BUFFERS > 10)
{
if (buffer_id < 11)
return buffers[10].floats[float_id];
else if (GSK_N_BUFFERS > 11)
return buffers[11].floats[float_id];
}
}
else if (GSK_N_BUFFERS > 12)
{
if (buffer_id < 14)
{
if (buffer_id < 13)
return buffers[12].floats[float_id];
else if (GSK_N_BUFFERS > 13)
return buffers[13].floats[float_id];
}
else if (GSK_N_BUFFERS > 14)
{
if (buffer_id < 15)
return buffers[14].floats[float_id];
else if (GSK_N_BUFFERS > 15)
return buffers[15].floats[float_id];
}
}
}
}
else if (GSK_N_BUFFERS > 16)
{
if (buffer_id < 24)
{
if (buffer_id < 20)
{
if (buffer_id < 18)
{
if (buffer_id < 17)
return buffers[16].floats[float_id];
else if (GSK_N_BUFFERS > 17)
return buffers[17].floats[float_id];
}
else if (GSK_N_BUFFERS > 18)
{
if (buffer_id < 19)
return buffers[18].floats[float_id];
else if (GSK_N_BUFFERS > 19)
return buffers[19].floats[float_id];
}
}
else if (GSK_N_BUFFERS > 20)
{
if (buffer_id < 22)
{
if (buffer_id < 21)
return buffers[20].floats[float_id];
else if (GSK_N_BUFFERS > 21)
return buffers[21].floats[float_id];
}
else if (GSK_N_BUFFERS > 22)
{
if (buffer_id < 23)
return buffers[22].floats[float_id];
else if (GSK_N_BUFFERS > 23)
return buffers[23].floats[float_id];
}
}
}
else if (GSK_N_BUFFERS > 24)
{
if (buffer_id < 28)
{
if (buffer_id < 26)
{
if (buffer_id < 25)
return buffers[24].floats[float_id];
else if (GSK_N_BUFFERS > 25)
return buffers[25].floats[float_id];
}
else if (GSK_N_BUFFERS > 26)
{
if (buffer_id < 27)
return buffers[26].floats[float_id];
else if (GSK_N_BUFFERS > 27)
return buffers[27].floats[float_id];
}
}
else if (GSK_N_BUFFERS > 28)
{
if (buffer_id < 30)
{
if (buffer_id < 29)
return buffers[28].floats[float_id];
else if (GSK_N_BUFFERS > 29)
return buffers[29].floats[float_id];
}
else if (GSK_N_BUFFERS > 30)
{
if (buffer_id < 31)
return buffers[30].floats[float_id];
else if (GSK_N_BUFFERS > 31)
return buffers[31].floats[float_id];
}
}
}
}
return 0.0;
}
#endif
#define gsk_get_int(id) (floatBitsToInt(gsk_get_float(id)))
#define gsk_get_uint(id) (floatBitsToUint(gsk_get_float(id)))
void
gsk_set_output_color (vec4 color)
{