AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2025-01-15 06:40:08 +00:00
Code Issues Projects Releases Wiki Activity
719ff9eca9
gtk/gsk/gpu/shaders/common-vulkan.glsl

235 lines
7.8 KiB
Plaintext
Raw Normal View History

gpu: Require Vulkan 1.2 shaders for dynamic indexing Shader compilers struggle with compiling code that indexes texture arrays by indexes, so keep the fallback shaders simple and don't do that there. There's not much of a performance difference anyway between those two methods.
2023-11-06 01:50:25 +00:00
#ifdef HAVE_VULKAN_1_2
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
#extension GL_EXT_nonuniform_qualifier : enable
gpu: Handle missing support nor nonuniform texture accesses We compile custom shaders for Vulkan 1.0 that don't require the extension. We also ensure that our accesses are uniform by only executing one shader at a time.
2023-11-03 06:01:52 +00:00
#endif
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
#include "enums.glsl"
layout(push_constant) uniform PushConstants {
mat4 mvp;
gpu: Turn globals into macros This way, we can be more flexible in refactoring how we handle globals (guess what we're gonna do next).
2023-10-05 01:17:51 +00:00
mat3x4 clip;
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
vec2 scale;
} push;
layout(constant_id=0) const uint GSK_SHADER_CLIP = GSK_GPU_SHADER_CLIP_NONE;
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
layout(constant_id=1) const uint GSK_N_IMMUTABLE_SAMPLERS = 8;
layout(constant_id=2) const uint GSK_N_SAMPLERS = 16;
layout(constant_id=3) const uint GSK_N_BUFFERS = 16;
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
gpu: Turn globals into macros This way, we can be more flexible in refactoring how we handle globals (guess what we're gonna do next).
2023-10-05 01:17:51 +00:00
#define GSK_GLOBAL_MVP push.mvp
#define GSK_GLOBAL_CLIP push.clip
#define GSK_GLOBAL_CLIP_RECT push.clip[0]
#define GSK_GLOBAL_SCALE push.scale
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
#define GSK_VERTEX_INDEX gl_VertexIndex
#ifdef GSK_VERTEX_SHADER
#define IN(_loc) layout(location = _loc) in
#define PASS(_loc) layout(location = _loc) out
#define PASS_FLAT(_loc) layout(location = _loc) flat out
#endif
#ifdef GSK_FRAGMENT_SHADER
#define PASS(_loc) layout(location = _loc) in
#define PASS_FLAT(_loc) layout(location = _loc) flat in
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
layout(set = 0, binding = 0) uniform sampler2D immutable_textures[GSK_N_IMMUTABLE_SAMPLERS];
layout(set = 0, binding = 1) uniform sampler2D textures[GSK_N_SAMPLERS];
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
layout(set = 1, binding = 0) readonly buffer FloatBuffers {
float floats[];
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
} buffers[GSK_N_BUFFERS];
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
layout(location = 0) out vec4 out_color;
gpu: Hook up immutable samplers to shaders Define an array with a compile-time-constant variable size for the immutable samplers. A bunch of work is necessary to ensure that at least one element is in the sampler array, because the GLSL code sampler2D immutable_textures[0]; is invalid.
2023-10-19 06:00:37 +00:00
vec4
gsk_texture (uint id,
vec2 pos)
{
if ((id & 1) != 0)
gpu: Work around Ycbcr not working with dynamically uniform indices There's a well hidden line in the spec that says in https://registry.khronos.org/vulkan/specs/1.3/html/chap15.html#interfaces-resources-descset If the combined image sampler enables sampler Y′CBCR conversion, it **must** be indexed only by constant integral expressions when aggregated into arrays in shader code, irrespective of the shaderSampledImageArrayDynamicIndexing feature. So we'll use the same trick that we use for old GL here and do an if dance that gives us dynamically uniform expressions.
2023-10-21 19:09:40 +00:00
{
id >>= 1;
if (id == 0)
return texture (immutable_textures[0], pos);
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else if (GSK_N_IMMUTABLE_SAMPLERS > 1 && id == 1)
gpu: Work around Ycbcr not working with dynamically uniform indices There's a well hidden line in the spec that says in https://registry.khronos.org/vulkan/specs/1.3/html/chap15.html#interfaces-resources-descset If the combined image sampler enables sampler Y′CBCR conversion, it **must** be indexed only by constant integral expressions when aggregated into arrays in shader code, irrespective of the shaderSampledImageArrayDynamicIndexing feature. So we'll use the same trick that we use for old GL here and do an if dance that gives us dynamically uniform expressions.
2023-10-21 19:09:40 +00:00
return texture (immutable_textures[1], pos);
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else if (GSK_N_IMMUTABLE_SAMPLERS > 2 && id == 2)
gpu: Work around Ycbcr not working with dynamically uniform indices There's a well hidden line in the spec that says in https://registry.khronos.org/vulkan/specs/1.3/html/chap15.html#interfaces-resources-descset If the combined image sampler enables sampler Y′CBCR conversion, it **must** be indexed only by constant integral expressions when aggregated into arrays in shader code, irrespective of the shaderSampledImageArrayDynamicIndexing feature. So we'll use the same trick that we use for old GL here and do an if dance that gives us dynamically uniform expressions.
2023-10-21 19:09:40 +00:00
return texture (immutable_textures[2], pos);
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else if (GSK_N_IMMUTABLE_SAMPLERS > 3 && id == 3)
gpu: Work around Ycbcr not working with dynamically uniform indices There's a well hidden line in the spec that says in https://registry.khronos.org/vulkan/specs/1.3/html/chap15.html#interfaces-resources-descset If the combined image sampler enables sampler Y′CBCR conversion, it **must** be indexed only by constant integral expressions when aggregated into arrays in shader code, irrespective of the shaderSampledImageArrayDynamicIndexing feature. So we'll use the same trick that we use for old GL here and do an if dance that gives us dynamically uniform expressions.
2023-10-21 19:09:40 +00:00
return texture (immutable_textures[3], pos);
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else if (GSK_N_IMMUTABLE_SAMPLERS > 4 && id == 4)
gpu: Work around Ycbcr not working with dynamically uniform indices There's a well hidden line in the spec that says in https://registry.khronos.org/vulkan/specs/1.3/html/chap15.html#interfaces-resources-descset If the combined image sampler enables sampler Y′CBCR conversion, it **must** be indexed only by constant integral expressions when aggregated into arrays in shader code, irrespective of the shaderSampledImageArrayDynamicIndexing feature. So we'll use the same trick that we use for old GL here and do an if dance that gives us dynamically uniform expressions.
2023-10-21 19:09:40 +00:00
return texture (immutable_textures[4], pos);
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else if (GSK_N_IMMUTABLE_SAMPLERS > 5 && id == 5)
gpu: Work around Ycbcr not working with dynamically uniform indices There's a well hidden line in the spec that says in https://registry.khronos.org/vulkan/specs/1.3/html/chap15.html#interfaces-resources-descset If the combined image sampler enables sampler Y′CBCR conversion, it **must** be indexed only by constant integral expressions when aggregated into arrays in shader code, irrespective of the shaderSampledImageArrayDynamicIndexing feature. So we'll use the same trick that we use for old GL here and do an if dance that gives us dynamically uniform expressions.
2023-10-21 19:09:40 +00:00
return texture (immutable_textures[5], pos);
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else if (GSK_N_IMMUTABLE_SAMPLERS > 6 && id == 6)
gpu: Work around Ycbcr not working with dynamically uniform indices There's a well hidden line in the spec that says in https://registry.khronos.org/vulkan/specs/1.3/html/chap15.html#interfaces-resources-descset If the combined image sampler enables sampler Y′CBCR conversion, it **must** be indexed only by constant integral expressions when aggregated into arrays in shader code, irrespective of the shaderSampledImageArrayDynamicIndexing feature. So we'll use the same trick that we use for old GL here and do an if dance that gives us dynamically uniform expressions.
2023-10-21 19:09:40 +00:00
return texture (immutable_textures[6], pos);
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else if (GSK_N_IMMUTABLE_SAMPLERS > 7 && id == 7)
gpu: Work around Ycbcr not working with dynamically uniform indices There's a well hidden line in the spec that says in https://registry.khronos.org/vulkan/specs/1.3/html/chap15.html#interfaces-resources-descset If the combined image sampler enables sampler Y′CBCR conversion, it **must** be indexed only by constant integral expressions when aggregated into arrays in shader code, irrespective of the shaderSampledImageArrayDynamicIndexing feature. So we'll use the same trick that we use for old GL here and do an if dance that gives us dynamically uniform expressions.
2023-10-21 19:09:40 +00:00
return texture (immutable_textures[7], pos);
}
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else
{
id >>= 1;
gpu: Require Vulkan 1.2 shaders for dynamic indexing Shader compilers struggle with compiling code that indexes texture arrays by indexes, so keep the fallback shaders simple and don't do that there. There's not much of a performance difference anyway between those two methods.
2023-11-06 01:50:25 +00:00
#ifdef HAVE_VULKAN_1_2
gpu: Handle missing support nor nonuniform texture accesses We compile custom shaders for Vulkan 1.0 that don't require the extension. We also ensure that our accesses are uniform by only executing one shader at a time.
2023-11-03 06:01:52 +00:00
return texture (textures[nonuniformEXT (id)], pos);
#else
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
if (id == 0)
return texture (textures[0], pos);
else if (GSK_N_SAMPLERS > 1 && id == 1)
return texture (textures[1], pos);
else if (GSK_N_SAMPLERS > 2 && id == 2)
return texture (textures[2], pos);
else if (GSK_N_SAMPLERS > 3 && id == 3)
return texture (textures[3], pos);
else if (GSK_N_SAMPLERS > 4 && id == 4)
return texture (textures[4], pos);
else if (GSK_N_SAMPLERS > 5 && id == 5)
return texture (textures[5], pos);
else if (GSK_N_SAMPLERS > 6 && id == 6)
return texture (textures[6], pos);
else if (GSK_N_SAMPLERS > 7 && id == 7)
return texture (textures[7], pos);
gpu: Handle missing support nor nonuniform texture accesses We compile custom shaders for Vulkan 1.0 that don't require the extension. We also ensure that our accesses are uniform by only executing one shader at a time.
2023-11-03 06:01:52 +00:00
#endif
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
}
gpu: Handle missing support nor nonuniform texture accesses We compile custom shaders for Vulkan 1.0 that don't require the extension. We also ensure that our accesses are uniform by only executing one shader at a time.
2023-11-03 06:01:52 +00:00
return vec4 (1.0, 0.0, 0.8, 1.0);
gpu: Hook up immutable samplers to shaders Define an array with a compile-time-constant variable size for the immutable samplers. A bunch of work is necessary to ensure that at least one element is in the sampler array, because the GLSL code sampler2D immutable_textures[0]; is invalid.
2023-10-19 06:00:37 +00:00
}
gpu: Add straight alpha support Add a GSK_GPU_IMAGE_STRAIGHT_ALPHA and use it for images that have straight alpha. Make sure those images get passed through a premultiplying pass with the new straight alpha shader. Also remove the old Postprocess flags from the Vulkan image that were a leftover from copying that code from the old Vulkan renderer.
2023-10-31 18:21:59 +00:00
ivec2
gsk_texture_size (uint id,
int lod)
{
if ((id & 1) != 0)
{
id >>= 1;
if (id == 0)
return textureSize (immutable_textures[0], lod);
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else if (GSK_N_IMMUTABLE_SAMPLERS > 1 && id == 1)
gpu: Add straight alpha support Add a GSK_GPU_IMAGE_STRAIGHT_ALPHA and use it for images that have straight alpha. Make sure those images get passed through a premultiplying pass with the new straight alpha shader. Also remove the old Postprocess flags from the Vulkan image that were a leftover from copying that code from the old Vulkan renderer.
2023-10-31 18:21:59 +00:00
return textureSize (immutable_textures[1], lod);
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else if (GSK_N_IMMUTABLE_SAMPLERS > 2 && id == 2)
gpu: Add straight alpha support Add a GSK_GPU_IMAGE_STRAIGHT_ALPHA and use it for images that have straight alpha. Make sure those images get passed through a premultiplying pass with the new straight alpha shader. Also remove the old Postprocess flags from the Vulkan image that were a leftover from copying that code from the old Vulkan renderer.
2023-10-31 18:21:59 +00:00
return textureSize (immutable_textures[2], lod);
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else if (GSK_N_IMMUTABLE_SAMPLERS > 3 && id == 3)
gpu: Add straight alpha support Add a GSK_GPU_IMAGE_STRAIGHT_ALPHA and use it for images that have straight alpha. Make sure those images get passed through a premultiplying pass with the new straight alpha shader. Also remove the old Postprocess flags from the Vulkan image that were a leftover from copying that code from the old Vulkan renderer.
2023-10-31 18:21:59 +00:00
return textureSize (immutable_textures[3], lod);
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else if (GSK_N_IMMUTABLE_SAMPLERS > 4 && id == 4)
gpu: Add straight alpha support Add a GSK_GPU_IMAGE_STRAIGHT_ALPHA and use it for images that have straight alpha. Make sure those images get passed through a premultiplying pass with the new straight alpha shader. Also remove the old Postprocess flags from the Vulkan image that were a leftover from copying that code from the old Vulkan renderer.
2023-10-31 18:21:59 +00:00
return textureSize (immutable_textures[4], lod);
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else if (GSK_N_IMMUTABLE_SAMPLERS > 5 && id == 5)
gpu: Add straight alpha support Add a GSK_GPU_IMAGE_STRAIGHT_ALPHA and use it for images that have straight alpha. Make sure those images get passed through a premultiplying pass with the new straight alpha shader. Also remove the old Postprocess flags from the Vulkan image that were a leftover from copying that code from the old Vulkan renderer.
2023-10-31 18:21:59 +00:00
return textureSize (immutable_textures[5], lod);
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else if (GSK_N_IMMUTABLE_SAMPLERS > 6 && id == 6)
gpu: Add straight alpha support Add a GSK_GPU_IMAGE_STRAIGHT_ALPHA and use it for images that have straight alpha. Make sure those images get passed through a premultiplying pass with the new straight alpha shader. Also remove the old Postprocess flags from the Vulkan image that were a leftover from copying that code from the old Vulkan renderer.
2023-10-31 18:21:59 +00:00
return textureSize (immutable_textures[6], lod);
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else if (GSK_N_IMMUTABLE_SAMPLERS > 7 && id == 7)
gpu: Add straight alpha support Add a GSK_GPU_IMAGE_STRAIGHT_ALPHA and use it for images that have straight alpha. Make sure those images get passed through a premultiplying pass with the new straight alpha shader. Also remove the old Postprocess flags from the Vulkan image that were a leftover from copying that code from the old Vulkan renderer.
2023-10-31 18:21:59 +00:00
return textureSize (immutable_textures[7], lod);
}
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else
{
id >>= 1;
gpu: Require Vulkan 1.2 shaders for dynamic indexing Shader compilers struggle with compiling code that indexes texture arrays by indexes, so keep the fallback shaders simple and don't do that there. There's not much of a performance difference anyway between those two methods.
2023-11-06 01:50:25 +00:00
#ifdef HAVE_VULKAN_1_2
gpu: Handle missing support nor nonuniform texture accesses We compile custom shaders for Vulkan 1.0 that don't require the extension. We also ensure that our accesses are uniform by only executing one shader at a time.
2023-11-03 06:01:52 +00:00
return textureSize (textures[nonuniformEXT (id)], lod);
#else
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
if (id == 0)
return textureSize (textures[0], lod);
else if (GSK_N_SAMPLERS > 1 && id == 1)
return textureSize (textures[1], lod);
else if (GSK_N_SAMPLERS > 2 && id == 2)
return textureSize (textures[2], lod);
else if (GSK_N_SAMPLERS > 3 && id == 3)
return textureSize (textures[3], lod);
else if (GSK_N_SAMPLERS > 4 && id == 4)
return textureSize (textures[4], lod);
else if (GSK_N_SAMPLERS > 5 && id == 5)
return textureSize (textures[5], lod);
else if (GSK_N_SAMPLERS > 6 && id == 6)
return textureSize (textures[6], lod);
else if (GSK_N_SAMPLERS > 7 && id == 7)
return textureSize (textures[7], lod);
gpu: Handle missing support nor nonuniform texture accesses We compile custom shaders for Vulkan 1.0 that don't require the extension. We also ensure that our accesses are uniform by only executing one shader at a time.
2023-11-03 06:01:52 +00:00
#endif
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
}
gpu: Handle missing support nor nonuniform texture accesses We compile custom shaders for Vulkan 1.0 that don't require the extension. We also ensure that our accesses are uniform by only executing one shader at a time.
2023-11-03 06:01:52 +00:00
return ivec2 (1, 1);
gpu: Add straight alpha support Add a GSK_GPU_IMAGE_STRAIGHT_ALPHA and use it for images that have straight alpha. Make sure those images get passed through a premultiplying pass with the new straight alpha shader. Also remove the old Postprocess flags from the Vulkan image that were a leftover from copying that code from the old Vulkan renderer.
2023-10-31 18:21:59 +00:00
}
vec4
gsk_texel_fetch (uint id,
ivec2 pos,
int lod)
{
if ((id & 1) != 0)
{
id >>= 1;
if (id == 0)
return texelFetch (immutable_textures[0], pos, lod);
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else if (GSK_N_IMMUTABLE_SAMPLERS > 1 && id == 1)
gpu: Add straight alpha support Add a GSK_GPU_IMAGE_STRAIGHT_ALPHA and use it for images that have straight alpha. Make sure those images get passed through a premultiplying pass with the new straight alpha shader. Also remove the old Postprocess flags from the Vulkan image that were a leftover from copying that code from the old Vulkan renderer.
2023-10-31 18:21:59 +00:00
return texelFetch (immutable_textures[1], pos, lod);
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else if (GSK_N_IMMUTABLE_SAMPLERS > 2 && id == 2)
gpu: Add straight alpha support Add a GSK_GPU_IMAGE_STRAIGHT_ALPHA and use it for images that have straight alpha. Make sure those images get passed through a premultiplying pass with the new straight alpha shader. Also remove the old Postprocess flags from the Vulkan image that were a leftover from copying that code from the old Vulkan renderer.
2023-10-31 18:21:59 +00:00
return texelFetch (immutable_textures[2], pos, lod);
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else if (GSK_N_IMMUTABLE_SAMPLERS > 3 && id == 3)
gpu: Add straight alpha support Add a GSK_GPU_IMAGE_STRAIGHT_ALPHA and use it for images that have straight alpha. Make sure those images get passed through a premultiplying pass with the new straight alpha shader. Also remove the old Postprocess flags from the Vulkan image that were a leftover from copying that code from the old Vulkan renderer.
2023-10-31 18:21:59 +00:00
return texelFetch (immutable_textures[3], pos, lod);
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else if (GSK_N_IMMUTABLE_SAMPLERS > 4 && id == 4)
gpu: Add straight alpha support Add a GSK_GPU_IMAGE_STRAIGHT_ALPHA and use it for images that have straight alpha. Make sure those images get passed through a premultiplying pass with the new straight alpha shader. Also remove the old Postprocess flags from the Vulkan image that were a leftover from copying that code from the old Vulkan renderer.
2023-10-31 18:21:59 +00:00
return texelFetch (immutable_textures[4], pos, lod);
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else if (GSK_N_IMMUTABLE_SAMPLERS > 5 && id == 5)
gpu: Add straight alpha support Add a GSK_GPU_IMAGE_STRAIGHT_ALPHA and use it for images that have straight alpha. Make sure those images get passed through a premultiplying pass with the new straight alpha shader. Also remove the old Postprocess flags from the Vulkan image that were a leftover from copying that code from the old Vulkan renderer.
2023-10-31 18:21:59 +00:00
return texelFetch (immutable_textures[5], pos, lod);
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else if (GSK_N_IMMUTABLE_SAMPLERS > 6 && id == 6)
gpu: Add straight alpha support Add a GSK_GPU_IMAGE_STRAIGHT_ALPHA and use it for images that have straight alpha. Make sure those images get passed through a premultiplying pass with the new straight alpha shader. Also remove the old Postprocess flags from the Vulkan image that were a leftover from copying that code from the old Vulkan renderer.
2023-10-31 18:21:59 +00:00
return texelFetch (immutable_textures[6], pos, lod);
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else if (GSK_N_IMMUTABLE_SAMPLERS > 7 && id == 7)
gpu: Add straight alpha support Add a GSK_GPU_IMAGE_STRAIGHT_ALPHA and use it for images that have straight alpha. Make sure those images get passed through a premultiplying pass with the new straight alpha shader. Also remove the old Postprocess flags from the Vulkan image that were a leftover from copying that code from the old Vulkan renderer.
2023-10-31 18:21:59 +00:00
return texelFetch (immutable_textures[7], pos, lod);
}
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
else
{
id >>= 1;
gpu: Require Vulkan 1.2 shaders for dynamic indexing Shader compilers struggle with compiling code that indexes texture arrays by indexes, so keep the fallback shaders simple and don't do that there. There's not much of a performance difference anyway between those two methods.
2023-11-06 01:50:25 +00:00
#ifdef HAVE_VULKAN_1_2
gpu: Handle missing support nor nonuniform texture accesses We compile custom shaders for Vulkan 1.0 that don't require the extension. We also ensure that our accesses are uniform by only executing one shader at a time.
2023-11-03 06:01:52 +00:00
return texelFetch (textures[nonuniformEXT (id)], pos, lod);
#else
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
if (id == 0)
return texelFetch (textures[0], pos, lod);
else if (GSK_N_SAMPLERS > 1 && id == 1)
return texelFetch (textures[1], pos, lod);
else if (GSK_N_SAMPLERS > 2 && id == 2)
return texelFetch (textures[2], pos, lod);
else if (GSK_N_SAMPLERS > 3 && id == 3)
return texelFetch (textures[3], pos, lod);
else if (GSK_N_SAMPLERS > 4 && id == 4)
return texelFetch (textures[4], pos, lod);
else if (GSK_N_SAMPLERS > 5 && id == 5)
return texelFetch (textures[5], pos, lod);
else if (GSK_N_SAMPLERS > 6 && id == 6)
return texelFetch (textures[6], pos, lod);
else if (GSK_N_SAMPLERS > 7 && id == 7)
return texelFetch (textures[7], pos, lod);
gpu: Handle missing support nor nonuniform texture accesses We compile custom shaders for Vulkan 1.0 that don't require the extension. We also ensure that our accesses are uniform by only executing one shader at a time.
2023-11-03 06:01:52 +00:00
#endif
gpu: Update shader code for different buffer/sampler sizes Use specialization constants for that.
2023-11-03 01:30:12 +00:00
}
gpu: Handle missing support nor nonuniform texture accesses We compile custom shaders for Vulkan 1.0 that don't require the extension. We also ensure that our accesses are uniform by only executing one shader at a time.
2023-11-03 06:01:52 +00:00
return vec4 (1.0, 0.0, 0.8, 1.0);
gpu: Add straight alpha support Add a GSK_GPU_IMAGE_STRAIGHT_ALPHA and use it for images that have straight alpha. Make sure those images get passed through a premultiplying pass with the new straight alpha shader. Also remove the old Postprocess flags from the Vulkan image that were a leftover from copying that code from the old Vulkan renderer.
2023-10-31 18:21:59 +00:00
}
gpu: Require Vulkan 1.2 shaders for dynamic indexing Shader compilers struggle with compiling code that indexes texture arrays by indexes, so keep the fallback shaders simple and don't do that there. There's not much of a performance difference anyway between those two methods.
2023-11-06 01:50:25 +00:00
#ifdef HAVE_VULKAN_1_2
gpu: Add float array to shaders and add an ubershader ... and use it for a naive color node implementation using both so I can test it actually works.
2023-08-30 19:57:41 +00:00
#define gsk_get_buffer(id) buffers[nonuniformEXT (id)]
gpu: Require Vulkan 1.2 shaders for dynamic indexing Shader compilers struggle with compiling code that indexes texture arrays by indexes, so keep the fallback shaders simple and don't do that there. There's not much of a performance difference anyway between those two methods.
2023-11-06 01:50:25 +00:00
#define gsk_get_float(id) gsk_get_buffer(id >> 22).floats[id & 0x3FFFFF]
gpu: Handle missing support nor nonuniform texture accesses We compile custom shaders for Vulkan 1.0 that don't require the extension. We also ensure that our accesses are uniform by only executing one shader at a time.
2023-11-03 06:01:52 +00:00
#else
gpu: Require Vulkan 1.2 shaders for dynamic indexing Shader compilers struggle with compiling code that indexes texture arrays by indexes, so keep the fallback shaders simple and don't do that there. There's not much of a performance difference anyway between those two methods.
2023-11-06 01:50:25 +00:00
float
gsk_get_float (uint id)
{
uint buffer_id = id >> 22;
uint float_id = id & 0x3FFFFF;
if (buffer_id == 0)
return buffers[0].floats[float_id];
else if (GSK_N_BUFFERS > 1 && buffer_id == 1)
return buffers[1].floats[float_id];
else if (GSK_N_BUFFERS > 2 && buffer_id == 2)
return buffers[2].floats[float_id];
else if (GSK_N_BUFFERS > 3 && buffer_id == 3)
return buffers[3].floats[float_id];
else if (GSK_N_BUFFERS > 4 && buffer_id == 4)
return buffers[4].floats[float_id];
else if (GSK_N_BUFFERS > 5 && buffer_id == 5)
return buffers[5].floats[float_id];
else if (GSK_N_BUFFERS > 6 && buffer_id == 6)
return buffers[6].floats[float_id];
else if (GSK_N_BUFFERS > 7 && buffer_id == 7)
return buffers[7].floats[float_id];
}
gpu: Handle missing support nor nonuniform texture accesses We compile custom shaders for Vulkan 1.0 that don't require the extension. We also ensure that our accesses are uniform by only executing one shader at a time.
2023-11-03 06:01:52 +00:00
#endif
gpu: Add float array to shaders and add an ubershader ... and use it for a naive color node implementation using both so I can test it actually works.
2023-08-30 19:57:41 +00:00
#define gsk_get_int(id) (floatBitsToInt(gsk_get_float(id)))
#define gsk_get_uint(id) (floatBitsToUint(gsk_get_float(id)))
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
void
gsk_set_output_color (vec4 color)
{
out_color = color;
}
#endif
Reference in New Issue Copy Permalink