From 6859aef001082de2bb5129e318ddfa9a343b92a0 Mon Sep 17 00:00:00 2001 From: Kovid Goyal Date: Tue, 3 Nov 2026 10:32:26 +0530 Subject: [PATCH] Declare texture and uniform block binding slots in the shaders Every texture and uniform block in kitty's shaders now declares its binding slot with [[vk::binding(N)]], from a single documented table, SHADER_BINDING_SLOTS, which the shader build verifies. Slots are unique across shaders and kinds of resource, as Vulkan requires, and so that resources bound once and used by many programs, such as the sprite textures, are never displaced by another program's bindings. The slots are passed to the C code in the program metadata, which no longer hard codes texture units or uniform buffer binding points, and no longer sets sampler uniforms or calls glUniformBlockBinding() equivalents. Instead the driver receives the slots when a pipeline is created. The OpenGL driver applies them to the linked program since OpenGL 3 has no layout(binding) qualifiers; targets where the slots are part of the compiled code can ignore them. --- gpu/api.h | 41 ++++++-- gpu/opengl/driver.c | 49 +++++++-- kitty/gpu.c | 33 ++++-- kitty/gpu.h | 21 ++-- kitty/shaders.c | 144 ++++++++++++++------------- kitty/shaders/background.slang | 5 +- kitty/shaders/bgimage.slang | 3 +- kitty/shaders/blit.slang | 3 +- kitty/shaders/border.slang | 4 +- kitty/shaders/cell.slang | 4 +- kitty/shaders/custom/pipeline.slang | 12 ++- kitty/shaders/graphics.slang | 3 +- kitty/shaders/indexed_graphics.slang | 3 +- kitty/shaders/screenshot.slang | 3 +- kitty/shaders/slang.py | 45 ++++++++- 15 files changed, 254 insertions(+), 119 deletions(-) diff --git a/gpu/api.h b/gpu/api.h index c8977ce1e..08dfa2cfe 100644 --- a/gpu/api.h +++ b/gpu/api.h @@ -235,6 +235,22 @@ typedef struct GPUUniformBlockInfo { // Some targets, such as GLSL for OpenGL, look up parameters by the identifier // used in the compiled code, which can differ from the Slang name. For those // the mapping is supplied when creating the pipeline. +// The binding slot of a texture or uniform block of a pipeline, from the +// reflection data. Textures and uniform buffers are bound to these slots with +// bind_texture() and bind_uniform_buffer(). Targets where the slots are not +// part of the compiled code, such as GLSL for OpenGL 3, apply them when the +// pipeline is created. +typedef enum { + GPU_BINDING_TEXTURE = 1, + GPU_BINDING_UNIFORM_BLOCK, +} GPUBindingKind; + +typedef struct GPUBinding { + GPUBindingKind kind; + const char *name; // name of the texture, or of the type of the uniform block, in the Slang source + uint32_t slot; +} GPUBinding; + typedef struct GPUNativeName { const char *name; // the name of a parameter, vertex input or uniform block type in the Slang source const char *native_name; // the corresponding identifier in the compiled code @@ -298,8 +314,8 @@ typedef struct GPUDriverAPI { // width * height pixels of the specified layout with rows aligned to 4 bytes. bool (*texture_read)(void *driver, gpu_texture_t texture, GPUPixelLayout layout, void *dst, size_t dst_size); void (*texture_get_desc)(void *driver, gpu_texture_t texture, GPUTextureDesc *ans); - // Bind a texture to a texture unit, for sampling by the current pipeline - void (*bind_texture)(void *driver, uint32_t unit, gpu_texture_t texture); + // Bind a texture to a slot, for sampling by pipelines, see GPUBinding + void (*bind_texture)(void *driver, uint32_t slot, gpu_texture_t texture); // }}} // Buffers {{{ @@ -314,17 +330,24 @@ typedef struct GPUDriverAPI { void *(*buffer_map)(void *driver, gpu_buffer_t buffer, GPUMapMode mode, size_t offset, size_t size); void (*buffer_unmap)(void *driver, gpu_buffer_t buffer); void (*buffer_copy)(void *driver, gpu_buffer_t src, size_t src_offset, gpu_buffer_t dst, size_t dst_offset, size_t size); - // Make a uniform buffer available to uniform blocks associated with binding_point - void (*bind_uniform_buffer)(void *driver, uint32_t binding_point, gpu_buffer_t buffer); + // Bind a uniform buffer to a slot, for use by pipelines, see GPUBinding + void (*bind_uniform_buffer)(void *driver, uint32_t slot, gpu_buffer_t buffer); // }}} // Pipelines {{{ // Create a pipeline from shader sources compiled for the shader target of - // the driver. native_names maps Slang names to identifiers in the compiled - // code, see GPUNativeName, and may be empty for targets that do not need - // it. On failure last_error() contains the compiler output. + // the driver. bindings are the binding slots of its textures and uniform + // blocks, see GPUBinding. native_names maps Slang names to identifiers in + // the compiled code, see GPUNativeName, and may be empty for targets that + // do not need it. On failure last_error() contains the compiler output. gpu_pipeline_t (*pipeline_create)( - void *driver, const GPUShaderSource *sources, size_t num_sources, const GPUNativeName *native_names, size_t num_native_names); + void *driver, + const GPUShaderSource *sources, + size_t num_sources, + const GPUBinding *bindings, + size_t num_bindings, + const GPUNativeName *native_names, + size_t num_native_names); void (*pipeline_destroy)(void *driver, gpu_pipeline_t pipeline); // Make a pipeline current, GPU_NULL_HANDLE for none void (*use_pipeline)(void *driver, gpu_pipeline_t pipeline); @@ -336,8 +359,6 @@ typedef struct GPUDriverAPI { // name is the name of the type of the uniform block. The size reported // by the driver is used to verify the layout from the reflection data. bool (*pipeline_uniform_block)(void *driver, gpu_pipeline_t pipeline, const char *name, GPUUniformBlockInfo *ans); - // Associate a uniform block of the pipeline with a binding point, see bind_uniform_buffer() - void (*pipeline_bind_uniform_block)(void *driver, gpu_pipeline_t pipeline, uint32_t block_index, uint32_t binding_point); // The location of the named vertex input, -1 if it is not used int32_t (*pipeline_attribute_location)(void *driver, gpu_pipeline_t pipeline, const char *name); // Set the value of a loose uniform of the current pipeline. components is diff --git a/gpu/opengl/driver.c b/gpu/opengl/driver.c index eadf51399..157f8221c 100644 --- a/gpu/opengl/driver.c +++ b/gpu/opengl/driver.c @@ -542,8 +542,8 @@ texture_get_desc(void *driver UNUSED, gpu_texture_t texture, GPUTextureDesc *ans } static void -bind_texture(void *driver UNUSED, uint32_t unit, gpu_texture_t texture) { - glActiveTexture(GL_TEXTURE0 + unit); +bind_texture(void *driver UNUSED, uint32_t slot, gpu_texture_t texture) { + glActiveTexture(GL_TEXTURE0 + slot); const Texture *t = AS_TEXTURE(texture); if (t) glBindTexture(t->target, t->id); else glBindTexture(GL_TEXTURE_2D, 0); @@ -622,8 +622,8 @@ buffer_copy(void *driver UNUSED, gpu_buffer_t src, size_t src_offset, gpu_buffer } static void -bind_uniform_buffer(void *driver UNUSED, uint32_t binding_point, gpu_buffer_t buffer) { - glBindBufferBase(GL_UNIFORM_BUFFER, binding_point, AS_BUFFER(buffer)->id); +bind_uniform_buffer(void *driver UNUSED, uint32_t slot, gpu_buffer_t buffer) { + glBindBufferBase(GL_UNIFORM_BUFFER, slot, AS_BUFFER(buffer)->id); } // }}} @@ -726,8 +726,40 @@ native_name(const Pipeline *p, const char *name) { return name; } +// OpenGL 3 has no layout(binding) qualifiers, so the binding slots are applied +// to the linked program +static void +apply_bindings(const Pipeline *p, const GPUBinding *bindings, size_t num_bindings) { + GLint previous_program = 0; + glGetIntegerv(GL_CURRENT_PROGRAM, &previous_program); + glUseProgram(p->id); + for (size_t i = 0; i < num_bindings; i++) { + const GPUBinding *b = bindings + i; + const char *name = native_name(p, b->name); + switch (b->kind) { + case GPU_BINDING_TEXTURE: { + // Unused samplers are optimized away by the GLSL compiler + GLint loc = glGetUniformLocation(p->id, name); + if (loc >= 0) glUniform1i(loc, (GLint)b->slot); + } break; + case GPU_BINDING_UNIFORM_BLOCK: { + GLuint index = glGetUniformBlockIndex(p->id, name); + if (index != GL_INVALID_INDEX) glUniformBlockBinding(p->id, index, b->slot); + } break; + } + } + glUseProgram((GLuint)previous_program); +} + static gpu_pipeline_t -pipeline_create(void *driver, const GPUShaderSource *sources, size_t num_sources, const GPUNativeName *native_names, size_t num_native_names) { +pipeline_create( + void *driver, + const GPUShaderSource *sources, + size_t num_sources, + const GPUBinding *bindings, + size_t num_bindings, + const GPUNativeName *native_names, + size_t num_native_names) { Driver *d = driver; Pipeline *p = calloc(1, sizeof(Pipeline)); if (!p) { @@ -763,6 +795,7 @@ pipeline_create(void *driver, const GPUShaderSource *sources, size_t num_sources pipeline_destroy(d, AS_HANDLE(p)); return GPU_NULL_HANDLE; } + apply_bindings(p, bindings, num_bindings); return AS_HANDLE(p); } @@ -800,11 +833,6 @@ pipeline_uniform_block(void *driver, gpu_pipeline_t pipeline, const char *name, return true; } -static void -pipeline_bind_uniform_block(void *driver UNUSED, gpu_pipeline_t pipeline, uint32_t block_index, uint32_t binding_point) { - glUniformBlockBinding(AS_PIPELINE(pipeline)->id, block_index, binding_point); -} - static int32_t pipeline_attribute_location(void *driver UNUSED, gpu_pipeline_t pipeline, const char *name) { const Pipeline *p = AS_PIPELINE(pipeline); @@ -1270,7 +1298,6 @@ kitty_gpu_driver_load(uint32_t api_version, const GPUDriverInitParams *params, G F(use_pipeline), F(pipeline_uniform_slot), F(pipeline_uniform_block), - F(pipeline_bind_uniform_block), F(pipeline_attribute_location), F(set_uniform_floats), F(set_uniform_ints), diff --git a/kitty/gpu.c b/kitty/gpu.c index 90ffcdacd..e917198d4 100644 --- a/kitty/gpu.c +++ b/kitty/gpu.c @@ -232,7 +232,7 @@ save_texture_as_png(gpu_texture_t texture, const char *filename) { // }}} // Programs {{{ -typedef enum { PROGRAM_UNIFORM, PROGRAM_ATTRIBUTE, PROGRAM_BLOCK, PROGRAM_ARRAY } ProgramMetadataKind; +typedef enum { PROGRAM_UNIFORM, PROGRAM_ATTRIBUTE, PROGRAM_BLOCK, PROGRAM_ARRAY, PROGRAM_TEXTURE } ProgramMetadataKind; typedef struct ProgramMetadataEntry { ProgramMetadataKind kind; bool missing_location_logged; @@ -355,14 +355,23 @@ set_program_layout(int program, PyObject *metadata) { insert_program_metadata(program, name, e); } + PyObject *textures = metadata_item(metadata, "textures", &PyDict_Type); + if (!textures) return false; + pos = 0; + while (PyDict_Next(textures, &pos, &key, &val)) { + ProgramMetadataEntry e = {.kind = PROGRAM_TEXTURE, .location = (int32_t)PyLong_AsLong(val)}; + if (PyErr_Occurred()) return false; + insert_program_metadata(program, PyUnicode_AsUTF8(key), e); + } + PyObject *blocks = metadata_item(metadata, "blocks", &PyDict_Type); if (!blocks) return false; pos = 0; while (PyDict_Next(blocks, &pos, &key, &val)) { const char *block_name = PyUnicode_AsUTF8(key); if (!block_name) return false; - int32_t size; - if (!metadata_uint(val, "size", &size)) return false; + int32_t size, slot; + if (!metadata_uint(val, "size", &size) || !metadata_uint(val, "slot", &slot)) return false; GPUUniformBlockInfo info; if (!gpu_pipeline_uniform_block(pipeline, block_name, &info)) { PyErr_Format(PyExc_ValueError, "The GPU program: %d has no uniform block: %s with error: %s", program, block_name, gpu_last_error()); @@ -380,7 +389,7 @@ set_program_layout(int program, PyObject *metadata) { size); return false; } - ProgramMetadataEntry be = {.kind = PROGRAM_BLOCK, .block = {.index = (int32_t)info.index, .size = size}}; + ProgramMetadataEntry be = {.kind = PROGRAM_BLOCK, .block = {.index = (int32_t)info.index, .size = size, .slot = (uint32_t)slot}}; insert_program_metadata(program, block_name, be); PyObject *arrays = metadata_item(val, "arrays", &PyDict_Type); @@ -436,10 +445,18 @@ program_uniform_array(int program, const char *name) { } // }}} -void -bind_program_uniform_block(int program, const char *name, uint32_t binding_point) { - UniformBlock b = program_uniform_block(program, name); - gpu_pipeline_bind_uniform_block(programs[program], (uint32_t)b.index, binding_point); +uint32_t +program_texture_slot(int program, const char *name) { + return (uint32_t)program_metadata_entry(program, name, PROGRAM_TEXTURE)->location; +} + +bool +try_program_texture_slot(int program, const char *name, uint32_t *slot) { + if (!program_layouts_initialized[program]) return false; + program_metadata_map_itr itr = vt_get(program_layouts + program, name); + if (vt_is_end(itr) || itr.data->val.kind != PROGRAM_TEXTURE) return false; + *slot = (uint32_t)itr.data->val.location; + return true; } void diff --git a/kitty/gpu.h b/kitty/gpu.h index 92d5ea4e7..6564d4d63 100644 --- a/kitty/gpu.h +++ b/kitty/gpu.h @@ -190,8 +190,14 @@ gpu_bind_uniform_buffer(uint32_t binding_point, gpu_buffer_t buffer) { } static inline gpu_pipeline_t -gpu_pipeline_create(const GPUShaderSource *sources, size_t num_sources, const GPUNativeName *native_names, size_t num_native_names) { - return A.pipeline_create(D, sources, num_sources, native_names, num_native_names); +gpu_pipeline_create( + const GPUShaderSource *sources, + size_t num_sources, + const GPUBinding *bindings, + size_t num_bindings, + const GPUNativeName *native_names, + size_t num_native_names) { + return A.pipeline_create(D, sources, num_sources, bindings, num_bindings, native_names, num_native_names); } static inline void @@ -214,11 +220,6 @@ gpu_pipeline_uniform_block(gpu_pipeline_t pipeline, const char *name, GPUUniform return A.pipeline_uniform_block(D, pipeline, name, ans); } -static inline void -gpu_pipeline_bind_uniform_block(gpu_pipeline_t pipeline, uint32_t block_index, uint32_t binding_point) { - A.pipeline_bind_uniform_block(D, pipeline, block_index, binding_point); -} - static inline int32_t gpu_pipeline_attribute_location(gpu_pipeline_t pipeline, const char *name) { return A.pipeline_attribute_location(D, pipeline, name); @@ -396,6 +397,7 @@ void save_texture_as_png(gpu_texture_t texture, const char *filename); // Programs {{{ typedef struct UniformBlock { int32_t size, index; + uint32_t slot; // the binding slot, see bind_uniform_buffer() } UniformBlock; typedef struct ArrayInformation { @@ -418,7 +420,10 @@ int32_t try_program_uniform_location(int program, const char *name); int32_t program_attribute_location(int program, const char *name); UniformBlock program_uniform_block(int program, const char *name); ArrayInformation program_uniform_array(int program, const char *name); -void bind_program_uniform_block(int program, const char *name, uint32_t binding_point); +// The binding slot of the named texture of the program, see bind_texture() +uint32_t program_texture_slot(int program, const char *name); +// As above, returns false if the program has no such texture +bool try_program_texture_slot(int program, const char *name, uint32_t *slot); void bind_program(int program); void unbind_program(void); // }}} diff --git a/kitty/shaders.c b/kitty/shaders.c index e8bf5db07..b2d36920e 100644 --- a/kitty/shaders.c +++ b/kitty/shaders.c @@ -43,7 +43,8 @@ enum { NUM_PROGRAMS }; static_assert(NUM_PROGRAMS <= MAX_GPU_PROGRAMS, "Too many GPU programs"); -enum { SPRITE_MAP_UNIT, GRAPHICS_UNIT, SPRITE_DECORATIONS_MAP_UNIT, CUSTOM_END_TEXTURE_A_UNIT, CUSTOM_END_TEXTURE_B_UNIT, CUSTOM_END_TEXTURE_PERSIST_UNIT }; +// The binding slots of textures and uniform blocks come from the program +// metadata, see SHADER_BINDING_SLOTS in shaders/slang.py typedef struct UIRenderData { unsigned screen_width, screen_height, cell_width, cell_height, screen_left, screen_top, full_framebuffer_width, full_framebuffer_height; @@ -228,8 +229,13 @@ realloc_sprite_texture(FONTS_DATA_HANDLE fg) { static void bind_sprite_map(const SpriteMap *sprite_map) { - gpu_bind_texture(SPRITE_DECORATIONS_MAP_UNIT, sprite_map->decorations_map.texture_id); - gpu_bind_texture(SPRITE_MAP_UNIT, sprite_map->texture_id); + // The sprite textures are bound once and used by all the cell programs, + // which share the same layout. They have binding slots distinct from those + // of every other program, so drawing images in between does not displace them. + uint32_t slot; + // The cell programs are compiled only once the first OS window is created + if (try_program_texture_slot(CELL_PROGRAM, "sprite_decorations_map", &slot)) gpu_bind_texture(slot, sprite_map->decorations_map.texture_id); + if (try_program_texture_slot(CELL_PROGRAM, "sprites", &slot)) gpu_bind_texture(slot, sprite_map->texture_id); } static void @@ -354,7 +360,6 @@ draw_rounded_rect( // Cell {{{ -enum { CELL_RENDER_DATA_BINDING_POINT = 0, COLOR_TABLE_BINDING_POINT = 1, BORDER_COLORS_BINDING_POINT = 2, CUSTOM_END_DATA_BINDING_POINT = 3 }; enum { BORDER_COLORS_GLOBAL_BUFFER }; // VAOs used only to hold buffers for UBOs that are shared amongst programs/windows, // their vertex attribute/array facilities are unused. @@ -446,13 +451,6 @@ upload_gamma_lut(void) { static void init_cell_program(void) { - for (int i = CELL_PROGRAM; i < CELL_PROGRAM_SENTINEL; i++) { - UniformBlock crd = program_uniform_block(i, "CellRenderData"); - gpu_pipeline_bind_uniform_block(program_pipeline(i), (uint32_t)crd.index, CELL_RENDER_DATA_BINDING_POINT); - UniformBlock ct = program_uniform_block(i, "ColorTable"); - gpu_pipeline_bind_uniform_block(program_pipeline(i), (uint32_t)ct.index, COLOR_TABLE_BINDING_POINT); - } - // Sanity check to ensure the attribute location binding worked #define C(p, name, expected) \ { \ @@ -467,16 +465,7 @@ init_cell_program(void) { } #undef C UniformBlock border_colors = program_uniform_block(BORDERS_PROGRAM, "Colors"); - gpu_pipeline_bind_uniform_block(program_pipeline(BORDERS_PROGRAM), (uint32_t)border_colors.index, BORDER_COLORS_BINDING_POINT); - // The padding program shares the cell background computation and so uses the - // same uniform blocks bound to the same binding points as the cell programs. - { - UniformBlock crd = program_uniform_block(PADDING_PROGRAM, "CellRenderData"); - gpu_pipeline_bind_uniform_block(program_pipeline(PADDING_PROGRAM), (uint32_t)crd.index, CELL_RENDER_DATA_BINDING_POINT); - UniformBlock ct = program_uniform_block(PADDING_PROGRAM, "ColorTable"); - gpu_pipeline_bind_uniform_block(program_pipeline(PADDING_PROGRAM), (uint32_t)ct.index, COLOR_TABLE_BINDING_POINT); - } #define C(name, expected) \ { \ int aloc = attrib_location(PADDING_PROGRAM, #name); \ @@ -486,10 +475,11 @@ init_cell_program(void) { C(sprite_idx, 1); C(is_selected, 2); #undef C - // Indexed color images get their colors from the color table of the window they are in - for (int i = GRAPHICS_INDEXED_PROGRAM; i <= GRAPHICS_INDEXED_UNSCALED_PROGRAM; i++) { - UniformBlock ct = program_uniform_block(i, "ColorTable"); - gpu_pipeline_bind_uniform_block(program_pipeline(i), (uint32_t)ct.index, COLOR_TABLE_BINDING_POINT); + // The sprite textures are bound once for all cell programs, see bind_sprite_map() + for (int i = CELL_PROGRAM + 1; i < CELL_PROGRAM_SENTINEL; i++) { + uint32_t a, b; + if (try_program_texture_slot(i, "sprites", &a) && (!try_program_texture_slot(CELL_PROGRAM, "sprites", &b) || a != b)) + fatal("The cell programs use different binding slots for the sprites texture"); } if (shader_globals_vao_idx == -1) { @@ -645,16 +635,6 @@ init_custom_programs(void) { custom_shaders.count++; if (i == CUSTOM_END_PROGRAM) { bind_program(i); - gpu_uniform1i(program_uniform_location(i, "backbuffer"), GRAPHICS_UNIT); -#define set_optional_sampler(name, unit) \ - { \ - int32_t loc = try_program_uniform_location(i, name); \ - if (loc >= 0) gpu_uniform1i(loc, unit); \ - } - set_optional_sampler("a", CUSTOM_END_TEXTURE_A_UNIT); - set_optional_sampler("b", CUSTOM_END_TEXTURE_B_UNIT); - set_optional_sampler("persist", CUSTOM_END_TEXTURE_PERSIST_UNIT); -#undef set_optional_sampler int32_t group_loc = try_program_uniform_location(i, "group"); if (group_loc >= 0) gpu_uniform1i(group_loc, 0); else if (custom_shaders.end.num_groups > 1) { @@ -667,7 +647,6 @@ init_custom_programs(void) { custom_shaders.end.num_groups); } UniformBlock ubd = program_uniform_block(i, "KittyCustomShaderData"); - gpu_pipeline_bind_uniform_block(program_pipeline(i), (uint32_t)ubd.index, CUSTOM_END_DATA_BINDING_POINT); if (custom_end_vao_idx == -1) { custom_end_vao_idx = create_vao(); add_buffer_to_vao(custom_end_vao_idx, GPU_BUFFER_UNIFORM); @@ -940,7 +919,7 @@ custom_shader_needs_render(const ShaderAnimState *before, const ShaderAnimState void bind_shader_globals_to_current_context(void) { if (shader_globals_vao_idx == -1) return; - bind_vao_uniform_buffer(shader_globals_vao_idx, BORDER_COLORS_GLOBAL_BUFFER, BORDER_COLORS_BINDING_POINT); + bind_vao_uniform_buffer(shader_globals_vao_idx, BORDER_COLORS_GLOBAL_BUFFER, program_uniform_block(BORDERS_PROGRAM, "Colors").slot); } #define CELL_BUFFERS enum { cell_data_buffer, selection_buffer, uniform_buffer, color_table_buffer, padding_cell_data_buffer, padding_selection_buffer }; @@ -1315,9 +1294,10 @@ draw_graphics(int program, ImageRenderData *data, uint32_t start, uint32_t count int32_t dest_rect_loc = program_uniform_location(program, "dest_rect"); const bool is_indexed = program == GRAPHICS_INDEXED_PROGRAM || program == GRAPHICS_INDEXED_UNSCALED_PROGRAM; const int32_t has_alpha_loc = is_indexed ? program_uniform_location(program, "has_alpha") : -1; + const uint32_t image_slot = program_texture_slot(program, "image"); for (uint32_t i = 0; i < count;) { ImageRenderData *group = data + start + i; - gpu_bind_texture(GRAPHICS_UNIT, group->texture_id); + gpu_bind_texture(image_slot, group->texture_id); if (has_alpha_loc > -1) gpu_uniform1ui(has_alpha_loc, group->indexed_px_sz == 2); if (group->group_count == 0) { i++; @@ -1381,10 +1361,6 @@ set_cell_uniforms(bool force) { if (!constants_set || force) { float text_contrast = 1.0f + OPT(text_contrast) * 0.01f; float text_gamma_adjustment = OPT(text_gamma_adjustment) < 0.01f ? 1.0f : 1.0f / OPT(text_gamma_adjustment); - for (int i = GRAPHICS_PROGRAM; i <= GRAPHICS_INDEXED_UNSCALED_PROGRAM; i++) { - bind_program(i); - gpu_uniform1i(program_uniform_location(i, "image"), GRAPHICS_UNIT); - } // These are set for every cell program, but the background program draws no // text and so does not have them. #define set_optional(setter, name, value) \ @@ -1394,16 +1370,10 @@ set_cell_uniforms(bool force) { } for (int i = CELL_PROGRAM; i < CELL_PROGRAM_SENTINEL; i++) { bind_program(i); - set_optional(gpu_uniform1i, "sprites", SPRITE_MAP_UNIT); - set_optional(gpu_uniform1i, "sprite_decorations_map", SPRITE_DECORATIONS_MAP_UNIT); set_optional(gpu_uniform1f, "text_contrast", text_contrast); set_optional(gpu_uniform1f, "text_gamma_adjustment", text_gamma_adjustment); } #undef set_optional - bind_program(BLIT_PROGRAM); - gpu_uniform1i(program_uniform_location(BLIT_PROGRAM, "image"), GRAPHICS_UNIT); - bind_program(SCREENSHOT_PROGRAM); - gpu_uniform1i(program_uniform_location(SCREENSHOT_PROGRAM, "image"), GRAPHICS_UNIT); constants_set = true; } } @@ -1728,7 +1698,6 @@ draw_window_number(const UIRenderData *ui) { bind_program(GRAPHICS_ALPHA_MASK_PROGRAM); ImageRenderData *ird = load_alpha_mask_texture(lr.width_px, lr.height_px, lr.canvas); gpu_data_for_image(ird, -1, 1, 1, -1); - gpu_uniform1i(program_uniform_location(GRAPHICS_ALPHA_MASK_PROGRAM, "image"), GRAPHICS_UNIT); color_type digit_color = colorprofile_to_color_with_fallback( ui->screen->color_profile, ui->screen->color_profile->overridden.highlight_bg, @@ -2098,8 +2067,8 @@ static void call_cell_program(int program, const UIRenderData *ui, ssize_t vao_idx, bool for_final_output, unsigned draw_bg_bitfield) { bind_program(program); CELL_BUFFERS; - bind_vao_uniform_buffer(vao_idx, uniform_buffer, CELL_RENDER_DATA_BINDING_POINT); - bind_vao_uniform_buffer(vao_idx, color_table_buffer, COLOR_TABLE_BINDING_POINT); + bind_vao_uniform_buffer(vao_idx, uniform_buffer, program_uniform_block(program, "CellRenderData").slot); + bind_vao_uniform_buffer(vao_idx, color_table_buffer, program_uniform_block(program, "ColorTable").slot); gpu_uniform1ui(program_uniform_location(program, "draw_bg_bitfield"), draw_bg_bitfield); if (for_final_output) gpu_set_srgb_output(true); draw_quad(!for_final_output, render_lines_for_screen(ui->screen) * ui->screen->columns); @@ -2191,8 +2160,8 @@ draw_window_padding(const UIRenderData *ui, unsigned int cl, unsigned int ct, un bind_program(PADDING_PROGRAM); bind_vertex_array(vao_idx); CELL_BUFFERS; - bind_vao_uniform_buffer(vao_idx, uniform_buffer, CELL_RENDER_DATA_BINDING_POINT); - bind_vao_uniform_buffer(vao_idx, color_table_buffer, COLOR_TABLE_BINDING_POINT); + bind_vao_uniform_buffer(vao_idx, uniform_buffer, program_uniform_block(PADDING_PROGRAM, "CellRenderData").slot); + bind_vao_uniform_buffer(vao_idx, color_table_buffer, program_uniform_block(PADDING_PROGRAM, "ColorTable").slot); if (for_final_output) gpu_set_srgb_output(true); // Point instanced attributes at the padding-specific buffers once for both draws. @@ -2344,7 +2313,7 @@ draw_image_layer(const UIRenderData *ui, ssize_t vao_idx, uint32_t start, uint32 } CELL_BUFFERS; // The color table may not be bound yet, for example, when the window has a background image - bind_vao_uniform_buffer(vao_idx, color_table_buffer, COLOR_TABLE_BINDING_POINT); + bind_vao_uniform_buffer(vao_idx, color_table_buffer, program_uniform_block(GRAPHICS_INDEXED_PROGRAM, "ColorTable").slot); const ImageRenderData *data = ui->grd.images; for (uint32_t run_start = start, end = start + count; run_start < end;) { const int program = program_for_image(data + run_start); @@ -2665,9 +2634,8 @@ draw_bg_image(OSWindow *os_window, Tab *tab) { gpu_uniform4f(program_uniform_location(BGIMAGE_PROGRAM, "sizes"), vwidth, vheight, iwidth, iheight); gpu_uniform1f(program_uniform_location(BGIMAGE_PROGRAM, "tiled"), tiled); gpu_uniform4f(program_uniform_location(BGIMAGE_PROGRAM, "positions"), left, top, right, bottom); - gpu_uniform1i(program_uniform_location(BGIMAGE_PROGRAM, "image"), GRAPHICS_UNIT); color_vec4(program_uniform_location(BGIMAGE_PROGRAM, "background"), s.bgcolor, s.opacity); - gpu_bind_texture(GRAPHICS_UNIT, bg->texture_id); + gpu_bind_texture(program_texture_slot(BGIMAGE_PROGRAM, "image"), bg->texture_id); draw_quad(false, 0); unbind_program(); } @@ -2685,7 +2653,6 @@ draw_centered_alpha_mask(size_t screen_width, size_t screen_height, size_t width ImageRenderData *data = load_alpha_mask_texture(width, height, canvas); gpu_data_for_centered_image(data, screen_width, screen_height, width, height); bind_program(GRAPHICS_ALPHA_MASK_PROGRAM); - gpu_uniform1i(program_uniform_location(GRAPHICS_ALPHA_MASK_PROGRAM, "image"), GRAPHICS_UNIT); color_vec3(program_uniform_location(GRAPHICS_ALPHA_MASK_PROGRAM, "amask_fg"), OPT(foreground)); color_vec4_premult(program_uniform_location(GRAPHICS_ALPHA_MASK_PROGRAM, "amask_bg_premult"), OPT(background), background_opacity); draw_graphics(GRAPHICS_ALPHA_MASK_PROGRAM, data, 0, 1, 1.0); @@ -2903,8 +2870,11 @@ update_pointer_map(OSWindow *os_window, int32_t group_loc) { if (!pointer_map_target.framebuffer_id) setup_texture_as_render_target(POINTER_MAP_SIZE, POINTER_MAP_SIZE, &pointer_map_target.texture_id, &pointer_map_target.framebuffer_id); // The pointer map does not sample any textures, but every sampler must be bound to a valid one - static const int units[] = {GRAPHICS_UNIT, CUSTOM_END_TEXTURE_A_UNIT, CUSTOM_END_TEXTURE_B_UNIT, CUSTOM_END_TEXTURE_PERSIST_UNIT}; - for (size_t i = 0; i < arraysz(units); i++) { gpu_bind_texture(units[i], global_state.layers_render_texture.texture_id); } + static const char *const names[] = {"backbuffer", "a", "b", "persist"}; + for (size_t i = 0; i < arraysz(names); i++) { + uint32_t slot; + if (try_program_texture_slot(CUSTOM_END_PROGRAM, names[i], &slot)) gpu_bind_texture(slot, global_state.layers_render_texture.texture_id); + } bind_framebuffer_for_output(pointer_map_target.framebuffer_id); gpu_set_viewport(0, 0, POINTER_MAP_SIZE, POINTER_MAP_SIZE); gpu_uniform1i(group_loc, -1); @@ -3170,7 +3140,7 @@ run_custom_end_shader(OSWindow *os_window, float sx, float sy, monotonic_t now) } } unmap_vao_buffer(custom_end_vao_idx, 0); - bind_vao_uniform_buffer(custom_end_vao_idx, 0, CUSTOM_END_DATA_BINDING_POINT); + bind_vao_uniform_buffer(custom_end_vao_idx, 0, program_uniform_block(CUSTOM_END_PROGRAM, "KittyCustomShaderData").slot); // A custom shader need not reference any of these, in which case the driver // drops them and glUniform*() on the resulting -1 location is a no-op. @@ -3196,12 +3166,13 @@ run_custom_end_shader(OSWindow *os_window, float sx, float sy, monotonic_t now) os_window->indirect_output.fbo_b_id, os_window->persist_fbo_id, }; - static const int named_tex_units[4] = { - GRAPHICS_UNIT, // DEFAULT maps to backbuffer slot - CUSTOM_END_TEXTURE_A_UNIT, - CUSTOM_END_TEXTURE_B_UNIT, - CUSTOM_END_TEXTURE_PERSIST_UNIT, - }; + // The binding slots of the named textures, indexed by NamedTexture enum + // value, false in has_named_tex_slot when the program does not use the texture + static const char *const named_tex_names[4] = {"backbuffer", "a", "b", "persist"}; + uint32_t named_tex_slots[4] = {0}; + bool has_named_tex_slot[4]; + for (size_t i = 0; i < arraysz(named_tex_names); i++) + has_named_tex_slot[i] = try_program_texture_slot(CUSTOM_END_PROGRAM, named_tex_names[i], named_tex_slots + i); // Pre-scan to find the last group that will actually run this frame. // That group gets convert_to_srgb=true so its draw call replaces the @@ -3231,7 +3202,7 @@ run_custom_end_shader(OSWindow *os_window, float sx, float sy, monotonic_t now) backbuffer_is_main ? global_state.layers_render_texture.texture_id : global_state.layers_render_texture.extra_texture_id; // Bind backbuffer to the backbuffer texture unit - gpu_bind_texture(GRAPHICS_UNIT, backbuffer); + if (has_named_tex_slot[CUSTOM_SHADER_TEXTURE_DEFAULT]) gpu_bind_texture(named_tex_slots[CUSTOM_SHADER_TEXTURE_DEFAULT], backbuffer); // Bind each named texture to its own unit. // If the texture is the output for this group, or is not declared in the @@ -3245,7 +3216,7 @@ run_custom_end_shader(OSWindow *os_window, float sx, float sy, monotonic_t now) } else { tex = backbuffer; // not present — fall back to backbuffer } - gpu_bind_texture(named_tex_units[t], tex); + if (has_named_tex_slot[t]) gpu_bind_texture(named_tex_slots[t], tex); } // Set the output framebuffer @@ -3317,7 +3288,7 @@ stop_os_window_rendering(OSWindow *os_window, Tab *tab, Window *active_window, m set_framebuffer_to_use_for_output(0); bind_framebuffer_for_output(0); bind_program(BLIT_PROGRAM); - gpu_bind_texture(GRAPHICS_UNIT, global_state.layers_render_texture.texture_id); + gpu_bind_texture(program_texture_slot(BLIT_PROGRAM, "image"), global_state.layers_render_texture.texture_id); gpu_uniform4f(program_uniform_location(BLIT_PROGRAM, "src_rect"), 0, sy, sx, 0); gpu_uniform4f(program_uniform_location(BLIT_PROGRAM, "dest_rect"), -1, 1, 1, -1); restore_viewport(); @@ -3413,7 +3384,7 @@ take_screenshot_of_rectangular_region(OSWindow *os_window, Region region, unsign gpu_uniform2f(program_uniform_location(SCREENSHOT_PROGRAM, "src_size"), (float)vw, (float)vh); // Bind the source texture - gpu_bind_texture(GRAPHICS_UNIT, src_texture); + gpu_bind_texture(program_texture_slot(SCREENSHOT_PROGRAM, "image"), src_texture); // Draw the scaled quad draw_quad(false, 0); @@ -3697,6 +3668,39 @@ compile_program(PyObject UNUSED *self, PyObject *args) { num_names++; } } + // The binding slots of textures and uniform blocks + PyObject *textures = PyDict_GetItemString(metadata, "textures"), *blocks = PyDict_GetItemString(metadata, "blocks"); + if (!textures || !PyDict_Check(textures) || !blocks || !PyDict_Check(blocks)) { + PyErr_SetString(PyExc_KeyError, "The shader program metadata has no textures or blocks dict"); + return NULL; + } + RAII_ALLOC(GPUBinding, bindings, calloc(MAX(1, PyDict_GET_SIZE(textures) + PyDict_GET_SIZE(blocks)), sizeof(GPUBinding))); + if (!bindings) return PyErr_NoMemory(); + size_t num_bindings = 0; + { + PyObject *key, *val; + Py_ssize_t pos = 0; + while (PyDict_Next(textures, &pos, &key, &val)) { + GPUBinding *b = bindings + num_bindings++; + b->kind = GPU_BINDING_TEXTURE; + if (!(b->name = PyUnicode_AsUTF8(key))) return NULL; + b->slot = (uint32_t)PyLong_AsUnsignedLong(val); + if (PyErr_Occurred()) return NULL; + } + pos = 0; + while (PyDict_Next(blocks, &pos, &key, &val)) { + GPUBinding *b = bindings + num_bindings++; + b->kind = GPU_BINDING_UNIFORM_BLOCK; + if (!(b->name = PyUnicode_AsUTF8(key))) return NULL; + PyObject *slot = PyDict_Check(val) ? PyDict_GetItemString(val, "slot") : NULL; + if (!slot) { + PyErr_Format(PyExc_KeyError, "The uniform block %s in the shader program metadata has no slot", b->name); + return NULL; + } + b->slot = (uint32_t)PyLong_AsUnsignedLong(slot); + if (PyErr_Occurred()) return NULL; + } + } RAII_PyObject(vertex_source, join_shader_sources(vertex_shaders)); if (!vertex_source) return NULL; RAII_PyObject(fragment_source, join_shader_sources(fragment_shaders)); @@ -3710,7 +3714,7 @@ compile_program(PyObject UNUSED *self, PyObject *args) { {.stage = GPU_SHADER_VERTEX, .language = language, .code = vcode, .size = (size_t)vsz}, {.stage = GPU_SHADER_FRAGMENT, .language = language, .code = fcode, .size = (size_t)fsz}, }; - gpu_pipeline_t pipeline = gpu_pipeline_create(sources, arraysz(sources), names, num_names); + gpu_pipeline_t pipeline = gpu_pipeline_create(sources, arraysz(sources), bindings, num_bindings, names, num_names); if (!pipeline) { PyErr_SetString(PyExc_ValueError, gpu_last_error()); return NULL; diff --git a/kitty/shaders/background.slang b/kitty/shaders/background.slang index e9f73572a..633c439e6 100644 --- a/kitty/shaders/background.slang +++ b/kitty/shaders/background.slang @@ -42,7 +42,8 @@ public struct CellRenderData { }; // Uniform Blocks (adjust binding slots as needed for your pipeline layout) -public ConstantBuffer crd; +[[vk::binding(6)]] +public ConstantBuffer crd; // binding slots: see SHADER_BINDING_SLOTS in slang.py // The SGR color table, then the mark background and foreground colors and // finally the special colors used by indexed color images. @@ -51,6 +52,7 @@ public struct ColorTable { uint color_table[INDEXED_IMAGE_SPECIAL_COLORS_OFFSET + NUM_INDEXED_IMAGE_SPECIAL_COLORS]; }; +[[vk::binding(7)]] public ConstantBuffer ctb; #define color_table ctb.color_table @@ -61,6 +63,7 @@ public struct GammaLUT { float gamma_lut[256]; }; +[[vk::binding(8)]] public ConstantBuffer glt; #define gamma_lut glt.gamma_lut // diff --git a/kitty/shaders/bgimage.slang b/kitty/shaders/bgimage.slang index c7890c314..8c6373287 100644 --- a/kitty/shaders/bgimage.slang +++ b/kitty/shaders/bgimage.slang @@ -59,7 +59,8 @@ vertex_main(uint vertex_id: SV_VertexID, uniform float tiled, uniform float4 siz } // Global Texture Bindings -uniform Sampler2D image; +[[vk::binding(1)]] +uniform Sampler2D image; // binding slots: see SHADER_BINDING_SLOTS in slang.py // Main Fragment Shader Entry Point [shader("fragment")] diff --git a/kitty/shaders/blit.slang b/kitty/shaders/blit.slang index 7155c19d6..bfd9061d9 100644 --- a/kitty/shaders/blit.slang +++ b/kitty/shaders/blit.slang @@ -20,7 +20,8 @@ vertex_main(uint vertex_id: SV_VertexID, uniform float4 src_rect, uniform float4 return { ans.texcoord, float4(ans.position[0], ans.position[1], 0.0, 1.0) }; } -uniform Sampler2D image; +[[vk::binding(1)]] +uniform Sampler2D image; // binding slots: see SHADER_BINDING_SLOTS in slang.py [shader("fragment")] float4 diff --git a/kitty/shaders/border.slang b/kitty/shaders/border.slang index 73a17a216..db368574c 100644 --- a/kitty/shaders/border.slang +++ b/kitty/shaders/border.slang @@ -20,12 +20,14 @@ import utils; struct GammaLUT { uniform float gamma_lut[256]; }; -ConstantBuffer glt; +[[vk::binding(8)]] +ConstantBuffer glt; // binding slots: see SHADER_BINDING_SLOTS in slang.py #define gamma_lut glt.gamma_lut struct Colors { uniform uint colors[9]; }; +[[vk::binding(9)]] ConstantBuffer clrs; #define colors clrs.colors diff --git a/kitty/shaders/cell.slang b/kitty/shaders/cell.slang index 9877ebbef..1f8cea6ae 100644 --- a/kitty/shaders/cell.slang +++ b/kitty/shaders/cell.slang @@ -23,7 +23,8 @@ static const bool ONLY_BACKGROUND = RENDER_MODE == 1; // LUT as well as most color utility functions live in the background module so // that they can be shared with the padding shader. -uniform Sampler2D sprite_decorations_map; +[[vk::binding(2)]] +uniform Sampler2D sprite_decorations_map; // binding slots: see SHADER_BINDING_SLOTS in slang.py static const uint SPRITE_INDEX_MASK = 0x7fffffff; static const uint SPRITE_COLORED_MASK = 0x80000000; @@ -217,6 +218,7 @@ vertex_main( return vo; } +[[vk::binding(0)]] uniform Sampler2DArray sprites; // Scaling factor for the extra text-alpha adjustment for luminance-difference. static const float text_gamma_scaling = 0.5; diff --git a/kitty/shaders/custom/pipeline.slang b/kitty/shaders/custom/pipeline.slang index 3ed29b8d9..0dc63617c 100644 --- a/kitty/shaders/custom/pipeline.slang +++ b/kitty/shaders/custom/pipeline.slang @@ -29,7 +29,8 @@ get_coords_for_blit(uint vertex_id, float4 src_rect, float4 dest_rect) { } -public ConstantBuffer csd; +[[vk::binding(10)]] +public ConstantBuffer csd; // binding slots: see SHADER_BINDING_SLOTS in slang.py public float4 @@ -59,7 +60,14 @@ linear2srgb(float3 x) { // vector return lerp(lower, upper, step(float3(0.0031308f), x)); } -uniform Sampler2D backbuffer, a, b, persist; +[[vk::binding(1)]] +uniform Sampler2D backbuffer; +[[vk::binding(3)]] +uniform Sampler2D a; +[[vk::binding(4)]] +uniform Sampler2D b; +[[vk::binding(5)]] +uniform Sampler2D persist; // The size of the pointer map grid, POINTER_MAP_SIZE is defined by kitty from state.h when compiling static const float pointer_map_size = POINTER_MAP_SIZE; diff --git a/kitty/shaders/graphics.slang b/kitty/shaders/graphics.slang index eed8719b9..b2ca7c2aa 100644 --- a/kitty/shaders/graphics.slang +++ b/kitty/shaders/graphics.slang @@ -23,7 +23,8 @@ vertex_main(uint vertex_id: SV_VertexID, uniform float4 src_rect, uniform float4 return { ans.texcoord, float4(ans.position[0], ans.position[1], 0.0, 1.0) }; } -uniform Sampler2D image; +[[vk::binding(1)]] +uniform Sampler2D image; // binding slots: see SHADER_BINDING_SLOTS in slang.py [shader("fragment")] float4 diff --git a/kitty/shaders/indexed_graphics.slang b/kitty/shaders/indexed_graphics.slang index 5afccbdc3..5794806f8 100644 --- a/kitty/shaders/indexed_graphics.slang +++ b/kitty/shaders/indexed_graphics.slang @@ -28,7 +28,8 @@ vertex_main(uint vertex_id: SV_VertexID, uniform float4 src_rect, uniform float4 // The red channel is the palette index and, when has_alpha is non-zero, the // green channel is the straight alpha. -uniform Sampler2D image; +[[vk::binding(1)]] +uniform Sampler2D image; // binding slots: see SHADER_BINDING_SLOTS in slang.py float4 premult_color_at(int2 pos, uint has_alpha) { diff --git a/kitty/shaders/screenshot.slang b/kitty/shaders/screenshot.slang index 289c6b8e7..61c0462f0 100644 --- a/kitty/shaders/screenshot.slang +++ b/kitty/shaders/screenshot.slang @@ -18,7 +18,8 @@ vertex_main(uint vertex_id: SV_VertexID, uniform float4 src_rect, uniform float4 return { ans.texcoord, float4(ans.position[0], ans.position[1], 0.0, 1.0) }; } -uniform Sampler2D image; +[[vk::binding(1)]] +uniform Sampler2D image; // binding slots: see SHADER_BINDING_SLOTS in slang.py float3 safe_unpremult_to_linear(float4 s) { diff --git a/kitty/shaders/slang.py b/kitty/shaders/slang.py index 29ddb258e..f3aed2b0d 100644 --- a/kitty/shaders/slang.py +++ b/kitty/shaders/slang.py @@ -1317,6 +1317,44 @@ def shader_name_from_path(path: str) -> str: return '.'.join(parts[:2]) +# The binding slots of every texture and uniform block in kitty's shaders, +# declared in the shaders with [[vk::binding(N)]]. Slots are unique across all +# shaders and kinds of resource, which is required by Vulkan where textures and +# uniform blocks share a single namespace of bindings. Unique slots also mean +# that resources bound once and used by many programs, such as the sprite +# textures, which are bound once per frame while drawing both cells and +# images, are never displaced by binding the resources of another program. +# The C code never hard codes slots, it gets them from the program metadata, so +# drivers for targets that assign slots differently, such as Metal, work too. +SHADER_BINDING_SLOTS = MappingProxyType( + { + # textures + 'sprites': 0, + 'image': 1, + 'backbuffer': 1, # the custom shader equivalent of image, both are bound before every draw + 'sprite_decorations_map': 2, + 'a': 3, + 'b': 4, + 'persist': 5, + # uniform blocks, identified by the name of their type + 'CellRenderData': 6, + 'ColorTable': 7, + 'GammaLUT': 8, + 'Colors': 9, + 'KittyCustomShaderData': 10, + } +) + + +def check_binding_slot(name: str, slot: int) -> int: + expected = SHADER_BINDING_SLOTS.get(name) + if expected is None: + raise ValueError(f'The shader resource {name} has no binding slot in SHADER_BINDING_SLOTS') + if slot != expected: + raise ValueError(f'The shader resource {name} uses binding slot {slot} instead of {expected}, declare it with [[vk::binding({expected})]]') + return slot + + def program_metadata(target: ShaderTarget, reflections: Sequence[dict[str, Any]], native: GLSLMetadata) -> dict[str, Any]: """ The metadata about a program passed to the C code. It is generated from the @@ -1327,6 +1365,7 @@ def program_metadata(target: ShaderTarget, reflections: Sequence[dict[str, Any]] """ inputs: dict[str, int] = {} uniforms: set[str] = set() + textures: dict[str, int] = {} blocks: dict[str, dict[str, Any]] = {} params: dict[str, dict[str, dict[str, int]]] = {} # Uniform blocks that are emitted as uniform blocks rather than as loose uniforms by the target @@ -1339,17 +1378,18 @@ def program_metadata(target: ShaderTarget, reflections: Sequence[dict[str, Any]] evl = t['elementVarLayout'] et = evl['type'] tname = et['name'] + slot = check_binding_slot(tname, p['binding']['index']) if tname in real_blocks: arrays = {} for f in et['fields']: ft = f['type'] if ft['kind'] == 'array': arrays[f['name']] = {'offset': f['binding']['offset'], 'stride': ft['uniformStride'], 'count': ft['elementCount']} - blocks[tname] = {'size': evl['binding']['size'], 'arrays': arrays} + blocks[tname] = {'size': evl['binding']['size'], 'arrays': arrays, 'slot': slot} else: uniforms.update(f['name'] for f in et['fields']) case 'resource': - uniforms.add(p['name']) + textures[p['name']] = check_binding_slot(p['name'], p['binding']['index']) case _: raise ValueError(f'Unsupported shader parameter: {p["name"]} of kind: {t["kind"]}') for ep in refl['entryPoints']: @@ -1372,6 +1412,7 @@ def program_metadata(target: ShaderTarget, reflections: Sequence[dict[str, Any]] 'target': target.id, 'inputs': inputs, 'uniforms': sorted(uniforms), + 'textures': textures, 'blocks': blocks, 'params': params, 'native_names': native_names,