griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

GPU: Refactor Qualifier and ImageType

Browse Source 
This allow to use types closer to GLSL in resource
declaration.

These are aliased for clarity in the GPU
module (i.e. `isampler2D` is shortened to `Int2D`).

Rel #137446

Pull Request: https://projects.blender.org/blender/blender/pulls/137954
This commit is contained in:
Clément Foucault
2025-04-24 14:38:13 +02:00
committed by Clément Foucault
parent 3d5eda688d
commit 59df50c326
149 changed files with 1803 additions and 1819 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
intern/opencolorio/ocio_impl_glsl.cc
View File

@@ -213,8 +213,8 @@ static bool createGPUShader(OCIO_GPUShader &shader,
info.define("in", "");
#endif
info.typedef_source("ocio_shader_shared.hh");
info.sampler(TEXTURE_SLOT_IMAGE, ImageType::FLOAT_2D, "image_texture");
info.sampler(TEXTURE_SLOT_OVERLAY, ImageType::FLOAT_2D, "overlay_texture");
info.sampler(TEXTURE_SLOT_IMAGE, ImageType::Float2D, "image_texture");
info.sampler(TEXTURE_SLOT_OVERLAY, ImageType::Float2D, "overlay_texture");
info.uniform_buf(UNIFORMBUF_SLOT_DISPLAY, "OCIO_GPUParameters", "parameters");
info.push_constant(Type::float4x4_t, "ModelViewProjectionMatrix");
info.vertex_in(0, Type::float2_t, "pos");
@@ -233,16 +233,16 @@ static bool createGPUShader(OCIO_GPUShader &shader,
if (use_curve_mapping) {
info.define("USE_CURVE_MAPPING");
info.uniform_buf(UNIFORMBUF_SLOT_CURVEMAP, "OCIO_GPUCurveMappingParameters", "curve_mapping");
info.sampler(TEXTURE_SLOT_CURVE_MAPPING, ImageType::FLOAT_1D, "curve_mapping_texture");
info.sampler(TEXTURE_SLOT_CURVE_MAPPING, ImageType::Float1D, "curve_mapping_texture");
}
/* Set LUT textures. */
int slot = TEXTURE_SLOT_LUTS_OFFSET;
for (OCIO_GPULutTexture &texture : textures.luts) {
const int dimensions = GPU_texture_dimensions(texture.texture);
ImageType type = (dimensions == 1) ? ImageType::FLOAT_1D :
(dimensions == 2) ? ImageType::FLOAT_2D :
ImageType::FLOAT_3D;
ImageType type = (dimensions == 1) ? ImageType::Float1D :
(dimensions == 2) ? ImageType::Float2D :
ImageType::Float3D;
info.sampler(slot++, type, texture.sampler_name.c_str());
}

36
intern/opensubdiv/internal/evaluator/gpu_compute_evaluator.cc
View File

@@ -357,30 +357,30 @@ static GPUShader *compile_eval_stencil_shader(BufferDescriptor const &srcDesc,
info.define("WORK_GROUP_SIZE", work_group_size);
info.typedef_source("osd_patch_basis.glsl");
info.storage_buf(
SHADER_SRC_VERTEX_BUFFER_BUF_SLOT, Qualifier::READ, "float", "srcVertexBuffer[]");
SHADER_SRC_VERTEX_BUFFER_BUF_SLOT, Qualifier::read, "float", "srcVertexBuffer[]");
info.storage_buf(
SHADER_DST_VERTEX_BUFFER_BUF_SLOT, Qualifier::WRITE, "float", "dstVertexBuffer[]");
SHADER_DST_VERTEX_BUFFER_BUF_SLOT, Qualifier::write, "float", "dstVertexBuffer[]");
info.push_constant(Type::int_t, "srcOffset");
info.push_constant(Type::int_t, "dstOffset");
bool deriv1 = (duDesc.length > 0 || dvDesc.length > 0);
if (deriv1) {
info.define("OPENSUBDIV_GLSL_COMPUTE_USE_1ST_DERIVATIVES");
info.storage_buf(SHADER_DU_BUFFER_BUF_SLOT, Qualifier::READ_WRITE, "float", "duBuffer[]");
info.storage_buf(SHADER_DV_BUFFER_BUF_SLOT, Qualifier::READ_WRITE, "float", "dvBuffer[]");
info.storage_buf(SHADER_DU_BUFFER_BUF_SLOT, Qualifier::read_write, "float", "duBuffer[]");
info.storage_buf(SHADER_DV_BUFFER_BUF_SLOT, Qualifier::read_write, "float", "dvBuffer[]");
info.push_constant(Type::int3_t, "duDesc");
info.push_constant(Type::int3_t, "dvDesc");
}
info.storage_buf(SHADER_SIZES_BUF_SLOT, Qualifier::READ, "int", "sizes_buf[]");
info.storage_buf(SHADER_OFFSETS_BUF_SLOT, Qualifier::READ, "int", "offsets_buf[]");
info.storage_buf(SHADER_INDICES_BUF_SLOT, Qualifier::READ, "int", "indices_buf[]");
info.storage_buf(SHADER_WEIGHTS_BUF_SLOT, Qualifier::READ, "float", "weights_buf[]");
info.storage_buf(SHADER_SIZES_BUF_SLOT, Qualifier::read, "int", "sizes_buf[]");
info.storage_buf(SHADER_OFFSETS_BUF_SLOT, Qualifier::read, "int", "offsets_buf[]");
info.storage_buf(SHADER_INDICES_BUF_SLOT, Qualifier::read, "int", "indices_buf[]");
info.storage_buf(SHADER_WEIGHTS_BUF_SLOT, Qualifier::read, "float", "weights_buf[]");
if (deriv1) {
info.storage_buf(
SHADER_DU_WEIGHTS_BUF_SLOT, Qualifier::READ_WRITE, "float", "du_weights_buf[]");
SHADER_DU_WEIGHTS_BUF_SLOT, Qualifier::read_write, "float", "du_weights_buf[]");
info.storage_buf(
SHADER_DV_WEIGHTS_BUF_SLOT, Qualifier::READ_WRITE, "float", "dv_weights_buf[]");
SHADER_DV_WEIGHTS_BUF_SLOT, Qualifier::read_write, "float", "dv_weights_buf[]");
}
info.push_constant(Type::int_t, "batchStart");
info.push_constant(Type::int_t, "batchEnd");
@@ -459,29 +459,29 @@ static GPUShader *compile_eval_patches_shader(BufferDescriptor const &srcDesc,
info.define("WORK_GROUP_SIZE", work_group_size);
info.typedef_source("osd_patch_basis.glsl");
info.storage_buf(
SHADER_SRC_VERTEX_BUFFER_BUF_SLOT, Qualifier::READ, "float", "srcVertexBuffer[]");
SHADER_SRC_VERTEX_BUFFER_BUF_SLOT, Qualifier::read, "float", "srcVertexBuffer[]");
info.storage_buf(
SHADER_DST_VERTEX_BUFFER_BUF_SLOT, Qualifier::WRITE, "float", "dstVertexBuffer[]");
SHADER_DST_VERTEX_BUFFER_BUF_SLOT, Qualifier::write, "float", "dstVertexBuffer[]");
info.push_constant(Type::int_t, "srcOffset");
info.push_constant(Type::int_t, "dstOffset");
bool deriv1 = (duDesc.length > 0 || dvDesc.length > 0);
if (deriv1) {
info.define("OPENSUBDIV_GLSL_COMPUTE_USE_1ST_DERIVATIVES");
info.storage_buf(SHADER_DU_BUFFER_BUF_SLOT, Qualifier::READ_WRITE, "float", "duBuffer[]");
info.storage_buf(SHADER_DV_BUFFER_BUF_SLOT, Qualifier::READ_WRITE, "float", "dvBuffer[]");
info.storage_buf(SHADER_DU_BUFFER_BUF_SLOT, Qualifier::read_write, "float", "duBuffer[]");
info.storage_buf(SHADER_DV_BUFFER_BUF_SLOT, Qualifier::read_write, "float", "dvBuffer[]");
info.push_constant(Type::int3_t, "duDesc");
info.push_constant(Type::int3_t, "dvDesc");
}
info.storage_buf(
SHADER_PATCH_ARRAY_BUFFER_BUF_SLOT, Qualifier::READ, "OsdPatchArray", "patchArrayBuffer[]");
SHADER_PATCH_ARRAY_BUFFER_BUF_SLOT, Qualifier::read, "OsdPatchArray", "patchArrayBuffer[]");
info.storage_buf(
SHADER_PATCH_COORDS_BUF_SLOT, Qualifier::READ, "OsdPatchCoord", "patchCoords[]");
SHADER_PATCH_COORDS_BUF_SLOT, Qualifier::read, "OsdPatchCoord", "patchCoords[]");
info.storage_buf(
SHADER_PATCH_INDEX_BUFFER_BUF_SLOT, Qualifier::READ, "int", "patchIndexBuffer[]");
SHADER_PATCH_INDEX_BUFFER_BUF_SLOT, Qualifier::read, "int", "patchIndexBuffer[]");
info.storage_buf(
SHADER_PATCH_PARAM_BUFFER_BUF_SLOT, Qualifier::READ, "OsdPatchParam", "patchParamBuffer[]");
SHADER_PATCH_PARAM_BUFFER_BUF_SLOT, Qualifier::read, "OsdPatchParam", "patchParamBuffer[]");
info.compute_source("osd_eval_patches_comp.glsl");
GPUShader *shader = GPU_shader_create_from_info(

12
source/blender/compositor/cached_resources/intern/ocio_color_space_conversion_shader.cc
View File

@@ -242,12 +242,12 @@ class GPUShaderCreator : public OCIO::GpuShaderCreator {
{
texture = GPU_texture_create_1d(
texture_name, width, 1, texture_format, GPU_TEXTURE_USAGE_SHADER_READ, values);
shader_create_info_.sampler(textures_.size() + 1, ImageType::FLOAT_1D, resource_name);
shader_create_info_.sampler(textures_.size() + 1, ImageType::Float1D, resource_name);
}
else {
texture = GPU_texture_create_2d(
texture_name, width, height, 1, texture_format, GPU_TEXTURE_USAGE_SHADER_READ, values);
shader_create_info_.sampler(textures_.size() + 1, ImageType::FLOAT_2D, resource_name);
shader_create_info_.sampler(textures_.size() + 1, ImageType::Float2D, resource_name);
}
GPU_texture_filter_mode(texture, interpolation != OCIO::INTERP_NEAREST);
@@ -268,7 +268,7 @@ class GPUShaderCreator : public OCIO::GpuShaderCreator {
/* Don't use the name argument directly since ShaderCreateInfo only stores references to
* resource names, instead, use the name that is stored in resource_names_. */
const std::string &resource_name = *resource_names_[resource_names_.size() - 1];
shader_create_info_.sampler(textures_.size() + 1, ImageType::FLOAT_3D, resource_name);
shader_create_info_.sampler(textures_.size() + 1, ImageType::Float3D, resource_name);
GPUTexture *texture = GPU_texture_create_3d(texture_name,
size,
@@ -306,11 +306,11 @@ class GPUShaderCreator : public OCIO::GpuShaderCreator {
GpuShaderCreator::finalize();
shader_create_info_.local_group_size(16, 16);
shader_create_info_.sampler(0, ImageType::FLOAT_2D, input_sampler_name());
shader_create_info_.sampler(0, ImageType::Float2D, input_sampler_name());
shader_create_info_.image(0,
Result::gpu_texture_format(ResultType::Color, precision_),
Qualifier::WRITE,
ImageType::FLOAT_2D,
Qualifier::write,
ImageReadWriteType::Float2D,
output_image_name());
shader_create_info_.compute_source("gpu_shader_compositor_ocio_processor.glsl");
shader_create_info_.compute_source_generated += shader_code_;

10
source/blender/compositor/intern/shader_operation.cc
View File

@@ -571,15 +571,15 @@ static ImageType gpu_image_type_from_result_type(const ResultType type)
case ResultType::Float3:
case ResultType::Color:
case ResultType::Float4:
return ImageType::FLOAT_2D;
return ImageType::Float2D;
case ResultType::Int:
case ResultType::Int2:
case ResultType::Bool:
return ImageType::INT_2D;
return ImageType::Int2D;
}
BLI_assert_unreachable();
return ImageType::FLOAT_2D;
return ImageType::Float2D;
}
void ShaderOperation::generate_code_for_outputs(ShaderCreateInfo &shader_create_info)
@@ -639,8 +639,8 @@ void ShaderOperation::generate_code_for_outputs(ShaderCreateInfo &shader_create_
/* Add a write-only image for this output where its values will be written. */
shader_create_info.image(output_index,
result.get_gpu_texture_format(),
Qualifier::WRITE,
gpu_image_type_from_result_type(result.type()),
Qualifier::write,
ImageReadWriteType(gpu_image_type_from_result_type(result.type())),
output_identifier,
Frequency::PASS);
output_index++;

4
source/blender/compositor/shaders/infos/compositor_alpha_crop_info.hh
View File

@@ -8,8 +8,8 @@ GPU_SHADER_CREATE_INFO(compositor_alpha_crop)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(int2, lower_bound)
PUSH_CONSTANT(int2, upper_bound)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_alpha_crop.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

6
source/blender/compositor/shaders/infos/compositor_bilateral_blur_info.hh
View File

@@ -8,9 +8,9 @@ GPU_SHADER_CREATE_INFO(compositor_bilateral_blur)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(int, radius)
PUSH_CONSTANT(float, threshold)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, determinator_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, determinator_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_bilateral_blur.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

8
source/blender/compositor/shaders/infos/compositor_bokeh_blur_info.hh
View File

@@ -8,10 +8,10 @@ GPU_SHADER_CREATE_INFO(compositor_bokeh_blur)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(int, radius)
PUSH_CONSTANT(bool, extend_bounds)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, weights_tx)
SAMPLER(2, FLOAT_2D, mask_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, weights_tx)
SAMPLER(2, sampler2D, mask_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_bokeh_blur.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

10
source/blender/compositor/shaders/infos/compositor_bokeh_blur_variable_size_info.hh
View File

@@ -8,11 +8,11 @@ GPU_SHADER_CREATE_INFO(compositor_bokeh_blur_variable_size)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float, base_size)
PUSH_CONSTANT(int, search_radius)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, weights_tx)
SAMPLER(2, FLOAT_2D, size_tx)
SAMPLER(3, FLOAT_2D, mask_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, weights_tx)
SAMPLER(2, sampler2D, size_tx)
SAMPLER(3, sampler2D, mask_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_bokeh_blur_variable_size.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

2
source/blender/compositor/shaders/infos/compositor_bokeh_image_info.hh
View File

@@ -11,7 +11,7 @@ PUSH_CONSTANT(float, rotation)
PUSH_CONSTANT(float, roundness)
PUSH_CONSTANT(float, catadioptric)
PUSH_CONSTANT(float, lens_shift)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_bokeh_image.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

6
source/blender/compositor/shaders/infos/compositor_box_mask_info.hh
View File

@@ -11,9 +11,9 @@ PUSH_CONSTANT(float2, location)
PUSH_CONSTANT(float2, size)
PUSH_CONSTANT(float, cos_angle)
PUSH_CONSTANT(float, sin_angle)
SAMPLER(0, FLOAT_2D, base_mask_tx)
SAMPLER(1, FLOAT_2D, mask_value_tx)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_mask_img)
SAMPLER(0, sampler2D, base_mask_tx)
SAMPLER(1, sampler2D, mask_value_tx)
IMAGE(0, GPU_R16F, write, image2D, output_mask_img)
COMPUTE_SOURCE("compositor_box_mask.glsl")
GPU_SHADER_CREATE_END()

4
source/blender/compositor/shaders/infos/compositor_compute_preview_info.hh
View File

@@ -6,8 +6,8 @@
GPU_SHADER_CREATE_INFO(compositor_compute_preview)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, preview_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, preview_img)
COMPUTE_SOURCE("compositor_compute_preview.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

118
source/blender/compositor/shaders/infos/compositor_convert_info.hh
View File

@@ -12,12 +12,12 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float_shared)
ADDITIONAL_INFO(compositor_convert_shared)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(0, sampler2D, input_tx)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_int_shared)
ADDITIONAL_INFO(compositor_convert_shared)
SAMPLER(0, INT_2D, input_tx)
SAMPLER(0, isampler2D, input_tx)
GPU_SHADER_CREATE_END()
/* --------------------------------------------------------------------
@@ -26,49 +26,49 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float_to_int)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_R16I, WRITE, INT_2D, output_img)
IMAGE(0, GPU_R16I, write, iimage2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "ivec4(float_to_int(value.x), ivec3(0))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float_to_int2)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_RG16I, WRITE, INT_2D, output_img)
IMAGE(0, GPU_RG16I, write, iimage2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "ivec4(float_to_int2(value.x), ivec2(0))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float_to_float2)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_RG16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RG16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(float_to_float2(value.x), vec2(0.0f))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float_to_float3)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(float_to_float3(value.x), 0.0f)")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float_to_color)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(float_to_color(value.x))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float_to_float4)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(float_to_float4(value.x))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float_to_bool)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_R8I, WRITE, INT_2D, output_img)
IMAGE(0, GPU_R8I, write, iimage2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "ivec4(float_to_bool(value.x))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -79,49 +79,49 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_int_to_int2)
ADDITIONAL_INFO(compositor_convert_int_shared)
IMAGE(0, GPU_RG16I, WRITE, INT_2D, output_img)
IMAGE(0, GPU_RG16I, write, iimage2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "ivec4(int_to_int2(value.x), ivec2(0))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_int_to_float)
ADDITIONAL_INFO(compositor_convert_int_shared)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_R16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(int_to_float(value.x), vec3(0.0f))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_int_to_float2)
ADDITIONAL_INFO(compositor_convert_int_shared)
IMAGE(0, GPU_RG16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RG16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(int_to_float2(value.x), vec2(0.0f))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_int_to_float3)
ADDITIONAL_INFO(compositor_convert_int_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(int_to_float3(value.x), 0.0f)")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_int_to_color)
ADDITIONAL_INFO(compositor_convert_int_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(int_to_color(value.x))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_int_to_float4)
ADDITIONAL_INFO(compositor_convert_int_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(int_to_float4(value.x))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_int_to_bool)
ADDITIONAL_INFO(compositor_convert_int_shared)
IMAGE(0, GPU_R8I, WRITE, INT_2D, output_img)
IMAGE(0, GPU_R8I, write, iimage2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "ivec4(int_to_bool(value.x))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -132,49 +132,49 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_int2_to_int)
ADDITIONAL_INFO(compositor_convert_int_shared)
IMAGE(0, GPU_R16I, WRITE, INT_2D, output_img)
IMAGE(0, GPU_R16I, write, iimage2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "ivec4(int2_to_int(value.xy), ivec3(0))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_int2_to_float)
ADDITIONAL_INFO(compositor_convert_int_shared)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_R16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(int2_to_float(value.xy), vec3(0.0f))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_int2_to_float2)
ADDITIONAL_INFO(compositor_convert_int_shared)
IMAGE(0, GPU_RG16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RG16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(int2_to_float2(value.xy), vec2(0.0f))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_int2_to_float3)
ADDITIONAL_INFO(compositor_convert_int_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(int2_to_float3(value.xy), 0.0f)")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_int2_to_color)
ADDITIONAL_INFO(compositor_convert_int_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(int2_to_color(value.xy))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_int2_to_float4)
ADDITIONAL_INFO(compositor_convert_int_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(int2_to_float4(value.xy))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_int2_to_bool)
ADDITIONAL_INFO(compositor_convert_int_shared)
IMAGE(0, GPU_R8I, WRITE, INT_2D, output_img)
IMAGE(0, GPU_R8I, write, iimage2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "ivec4(int2_to_bool(value.xy))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -185,49 +185,49 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float2_to_float)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_R16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(float2_to_float(value.xy), vec3(0.0f))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float2_to_int)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_R16I, WRITE, INT_2D, output_img)
IMAGE(0, GPU_R16I, write, iimage2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "ivec4(float2_to_int(value.xy), ivec3(0))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float2_to_int2)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_RG16I, WRITE, INT_2D, output_img)
IMAGE(0, GPU_RG16I, write, iimage2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "ivec4(float2_to_int2(value.xy), ivec2(0))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float2_to_float3)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(float2_to_float3(value.xy), 0.0f)")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float2_to_color)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(float2_to_color(value.xy))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float2_to_float4)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(float2_to_float4(value.xy))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float2_to_bool)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_R8I, WRITE, INT_2D, output_img)
IMAGE(0, GPU_R8I, write, iimage2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "ivec4(float2_to_bool(value.xy))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -238,49 +238,49 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float3_to_float)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_R16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(float3_to_float(value.xyz), vec3(0.0f))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float3_to_int)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_R16I, WRITE, INT_2D, output_img)
IMAGE(0, GPU_R16I, write, iimage2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "ivec4(float3_to_int(value.xyz), ivec3(0))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float3_to_int2)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_RG16I, WRITE, INT_2D, output_img)
IMAGE(0, GPU_RG16I, write, iimage2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "ivec4(float3_to_int2(value.xyz), ivec2(0))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float3_to_float2)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_RG16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RG16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(float3_to_float2(value.xyz), vec2(0.0f))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float3_to_color)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(float3_to_color(value.xyz))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float3_to_float4)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(float3_to_float4(value.xyz))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float3_to_bool)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_R8I, WRITE, INT_2D, output_img)
IMAGE(0, GPU_R8I, write, iimage2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "ivec4(float3_to_bool(value.xyz))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -292,7 +292,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_color_to_float)
ADDITIONAL_INFO(compositor_convert_float_shared)
PUSH_CONSTANT(float3, luminance_coefficients_u)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_R16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)",
"vec4(color_to_float(value, luminance_coefficients_u), vec3(0.0f))")
DO_STATIC_COMPILATION()
@@ -301,7 +301,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_color_to_int)
ADDITIONAL_INFO(compositor_convert_float_shared)
PUSH_CONSTANT(float3, luminance_coefficients_u)
IMAGE(0, GPU_R16I, WRITE, INT_2D, output_img)
IMAGE(0, GPU_R16I, write, iimage2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)",
"ivec4(color_to_int(value, luminance_coefficients_u), ivec3(0))")
DO_STATIC_COMPILATION()
@@ -309,28 +309,28 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_color_to_int2)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_RG16I, WRITE, INT_2D, output_img)
IMAGE(0, GPU_RG16I, write, iimage2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "ivec4(color_to_int2(value), ivec2(0))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_color_to_float2)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_RG16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RG16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(color_to_float2(value), vec2(0.0f))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_color_to_float3)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(color_to_float3(value), 0.0f)")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_color_to_float4)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(color_to_float4(value))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -338,7 +338,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_color_to_bool)
ADDITIONAL_INFO(compositor_convert_float_shared)
PUSH_CONSTANT(float3, luminance_coefficients_u)
IMAGE(0, GPU_R8I, WRITE, INT_2D, output_img)
IMAGE(0, GPU_R8I, write, iimage2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "ivec4(color_to_bool(value, luminance_coefficients_u))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -349,49 +349,49 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float4_to_float)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_R16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(float4_to_float(value), vec3(0.0f))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float4_to_int)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_R16I, WRITE, INT_2D, output_img)
IMAGE(0, GPU_R16I, write, iimage2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "ivec4(float4_to_int(value), ivec3(0))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float4_to_int2)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_RG16I, WRITE, INT_2D, output_img)
IMAGE(0, GPU_RG16I, write, iimage2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "ivec4(float4_to_int2(value), ivec2(0))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float4_to_float2)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_RG16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RG16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(float4_to_float2(value), vec2(0.0f))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float4_to_float3)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(float4_to_float3(value), 0.0f)")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float4_to_color)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(float4_to_color(value))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_float4_to_bool)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_R8I, WRITE, INT_2D, output_img)
IMAGE(0, GPU_R8I, write, iimage2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "ivec4(float4_to_bool(value))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -402,49 +402,49 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_bool_to_float)
ADDITIONAL_INFO(compositor_convert_int_shared)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_R16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(bool_to_float(bool(value.x)), vec3(0.0f))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_bool_to_int)
ADDITIONAL_INFO(compositor_convert_int_shared)
IMAGE(0, GPU_R16I, WRITE, INT_2D, output_img)
IMAGE(0, GPU_R16I, write, iimage2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "ivec4(bool_to_int(bool(value.x)), ivec3(0))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_bool_to_int2)
ADDITIONAL_INFO(compositor_convert_int_shared)
IMAGE(0, GPU_RG16I, WRITE, INT_2D, output_img)
IMAGE(0, GPU_RG16I, write, iimage2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "ivec4(bool_to_int2(bool(value.x)), ivec2(0))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_bool_to_float2)
ADDITIONAL_INFO(compositor_convert_int_shared)
IMAGE(0, GPU_RG16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RG16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(bool_to_float2(bool(value.x)), vec2(0.0f))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_bool_to_float3)
ADDITIONAL_INFO(compositor_convert_int_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(bool_to_float3(bool(value.x)), 0.0f)")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_bool_to_color)
ADDITIONAL_INFO(compositor_convert_int_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(bool_to_color(bool(value.x)))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_bool_to_float4)
ADDITIONAL_INFO(compositor_convert_int_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(bool_to_float4(bool(value.x)))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -455,7 +455,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_convert_color_to_alpha)
ADDITIONAL_INFO(compositor_convert_float_shared)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_R16F, write, image2D, output_img)
DEFINE_VALUE("CONVERT_EXPRESSION(value)", "vec4(value.a)")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

14
source/blender/compositor/shaders/infos/compositor_cryptomatte_info.hh
View File

@@ -9,8 +9,8 @@ using namespace blender::gpu::shader;
GPU_SHADER_CREATE_INFO(compositor_cryptomatte_pick)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(int2, lower_bound)
SAMPLER(0, FLOAT_2D, first_layer_tx)
IMAGE(0, GPU_RGBA32F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, first_layer_tx)
IMAGE(0, GPU_RGBA32F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_cryptomatte_pick.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -20,17 +20,17 @@ LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(int2, lower_bound)
PUSH_CONSTANT(int, identifiers_count)
PUSH_CONSTANT_ARRAY(float, identifiers, 32)
SAMPLER(0, FLOAT_2D, layer_tx)
IMAGE(0, GPU_R16F, READ_WRITE, FLOAT_2D, matte_img)
SAMPLER(0, sampler2D, layer_tx)
IMAGE(0, GPU_R16F, read_write, image2D, matte_img)
COMPUTE_SOURCE("compositor_cryptomatte_matte.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_cryptomatte_image)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, matte_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, matte_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_cryptomatte_image.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

16
source/blender/compositor/shaders/infos/compositor_defocus_info.hh
View File

@@ -8,8 +8,8 @@ GPU_SHADER_CREATE_INFO(compositor_defocus_radius_from_scale)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float, scale)
PUSH_CONSTANT(float, max_radius)
SAMPLER(0, FLOAT_2D, radius_tx)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, radius_img)
SAMPLER(0, sampler2D, radius_tx)
IMAGE(0, GPU_R16F, write, image2D, radius_img)
COMPUTE_SOURCE("compositor_defocus_radius_from_scale.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -21,8 +21,8 @@ PUSH_CONSTANT(float, max_radius)
PUSH_CONSTANT(float, focal_length)
PUSH_CONSTANT(float, pixels_per_meter)
PUSH_CONSTANT(float, distance_to_image_of_focus)
SAMPLER(0, FLOAT_2D, depth_tx)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, radius_img)
SAMPLER(0, sampler2D, depth_tx)
IMAGE(0, GPU_R16F, write, image2D, radius_img)
COMPUTE_SOURCE("compositor_defocus_radius_from_depth.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -30,10 +30,10 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_defocus_blur)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(int, search_radius)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, weights_tx)
SAMPLER(2, FLOAT_2D, radius_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, weights_tx)
SAMPLER(2, sampler2D, radius_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_defocus_blur.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

12
source/blender/compositor/shaders/infos/compositor_deriche_gaussian_blur_info.hh
View File

@@ -11,18 +11,18 @@ PUSH_CONSTANT(float4, non_causal_feedforward_coefficients)
PUSH_CONSTANT(float4, feedback_coefficients)
PUSH_CONSTANT(float, causal_boundary_coefficient)
PUSH_CONSTANT(float, non_causal_boundary_coefficient)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, causal_output_img)
IMAGE(1, GPU_RGBA16F, WRITE, FLOAT_2D, non_causal_output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, causal_output_img)
IMAGE(1, GPU_RGBA16F, write, image2D, non_causal_output_img)
COMPUTE_SOURCE("compositor_deriche_gaussian_blur.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_deriche_gaussian_blur_sum)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, causal_input_tx)
SAMPLER(1, FLOAT_2D, non_causal_input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, causal_input_tx)
SAMPLER(1, sampler2D, non_causal_input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_deriche_gaussian_blur_sum.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

6
source/blender/compositor/shaders/infos/compositor_despeckle_info.hh
View File

@@ -8,9 +8,9 @@ GPU_SHADER_CREATE_INFO(compositor_despeckle)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float, color_threshold)
PUSH_CONSTANT(float, neighbor_threshold)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, factor_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, factor_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_despeckle.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

4
source/blender/compositor/shaders/infos/compositor_directional_blur_info.hh
View File

@@ -12,8 +12,8 @@ PUSH_CONSTANT(float2, translation)
PUSH_CONSTANT(float, rotation_sin)
PUSH_CONSTANT(float, rotation_cos)
PUSH_CONSTANT(float, scale)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_directional_blur.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

10
source/blender/compositor/shaders/infos/compositor_displace_info.hh
View File

@@ -6,11 +6,11 @@
GPU_SHADER_CREATE_INFO(compositor_displace)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, displacement_tx)
SAMPLER(2, FLOAT_2D, x_scale_tx)
SAMPLER(3, FLOAT_2D, y_scale_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, displacement_tx)
SAMPLER(2, sampler2D, x_scale_tx)
SAMPLER(3, sampler2D, y_scale_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_displace.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

18
source/blender/compositor/shaders/infos/compositor_double_edge_mask_info.hh
View File

@@ -8,21 +8,21 @@ GPU_SHADER_CREATE_INFO(compositor_double_edge_mask_compute_boundary)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(bool, include_all_inner_edges)
PUSH_CONSTANT(bool, include_edges_of_image)
SAMPLER(0, FLOAT_2D, inner_mask_tx)
SAMPLER(1, FLOAT_2D, outer_mask_tx)
IMAGE(0, GPU_RG16I, WRITE, INT_2D, inner_boundary_img)
IMAGE(1, GPU_RG16I, WRITE, INT_2D, outer_boundary_img)
SAMPLER(0, sampler2D, inner_mask_tx)
SAMPLER(1, sampler2D, outer_mask_tx)
IMAGE(0, GPU_RG16I, write, iimage2D, inner_boundary_img)
IMAGE(1, GPU_RG16I, write, iimage2D, outer_boundary_img)
COMPUTE_SOURCE("compositor_double_edge_mask_compute_boundary.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_double_edge_mask_compute_gradient)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, inner_mask_tx)
SAMPLER(1, FLOAT_2D, outer_mask_tx)
SAMPLER(2, INT_2D, flooded_inner_boundary_tx)
SAMPLER(3, INT_2D, flooded_outer_boundary_tx)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, inner_mask_tx)
SAMPLER(1, sampler2D, outer_mask_tx)
SAMPLER(2, isampler2D, flooded_inner_boundary_tx)
SAMPLER(3, isampler2D, flooded_outer_boundary_tx)
IMAGE(0, GPU_R16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_double_edge_mask_compute_gradient.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

6
source/blender/compositor/shaders/infos/compositor_edge_filter_info.hh
View File

@@ -7,9 +7,9 @@
GPU_SHADER_CREATE_INFO(compositor_edge_filter)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float4x4, ukernel)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, factor_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, factor_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_edge_filter.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

6
source/blender/compositor/shaders/infos/compositor_ellipse_mask_info.hh
View File

@@ -11,9 +11,9 @@ PUSH_CONSTANT(float2, location)
PUSH_CONSTANT(float2, radius)
PUSH_CONSTANT(float, cos_angle)
PUSH_CONSTANT(float, sin_angle)
SAMPLER(0, FLOAT_2D, base_mask_tx)
SAMPLER(1, FLOAT_2D, mask_value_tx)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_mask_img)
SAMPLER(0, sampler2D, base_mask_tx)
SAMPLER(1, sampler2D, mask_value_tx)
IMAGE(0, GPU_R16F, write, image2D, output_mask_img)
COMPUTE_SOURCE("compositor_ellipse_mask.glsl")
GPU_SHADER_CREATE_END()

6
source/blender/compositor/shaders/infos/compositor_filter_info.hh
View File

@@ -7,9 +7,9 @@
GPU_SHADER_CREATE_INFO(compositor_filter)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float4x4, ukernel)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, factor_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, factor_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_filter.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

4
source/blender/compositor/shaders/infos/compositor_flip_info.hh
View File

@@ -8,8 +8,8 @@ GPU_SHADER_CREATE_INFO(compositor_flip)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(bool, flip_x)
PUSH_CONSTANT(bool, flip_y)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_flip.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

4
source/blender/compositor/shaders/infos/compositor_gamma_correct_info.hh
View File

@@ -6,8 +6,8 @@
GPU_SHADER_CREATE_INFO(compositor_gamma_correct_shared)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_gamma_correct.glsl")
GPU_SHADER_CREATE_END()

56
source/blender/compositor/shaders/infos/compositor_glare_info.hh
View File

@@ -13,8 +13,8 @@ LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float, threshold)
PUSH_CONSTANT(float, highlights_smoothness)
PUSH_CONSTANT(float, max_brightness)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_glare_highlights.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -23,9 +23,9 @@ GPU_SHADER_CREATE_INFO(compositor_glare_mix)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float, saturation)
PUSH_CONSTANT(float3, tint)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, glare_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, glare_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_glare_mix.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -34,16 +34,16 @@ GPU_SHADER_CREATE_INFO(compositor_glare_write_glare_output)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float, saturation)
PUSH_CONSTANT(float3, tint)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_glare_write_glare_output.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_glare_write_highlights_output)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_glare_write_highlights_output.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -54,9 +54,9 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_glare_ghost_base)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, small_ghost_tx)
SAMPLER(1, FLOAT_2D, big_ghost_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, combined_ghost_img)
SAMPLER(0, sampler2D, small_ghost_tx)
SAMPLER(1, sampler2D, big_ghost_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, combined_ghost_img)
COMPUTE_SOURCE("compositor_glare_ghost_base.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -65,8 +65,8 @@ GPU_SHADER_CREATE_INFO(compositor_glare_ghost_accumulate)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float4, scales)
PUSH_CONSTANT_ARRAY(float4, color_modulators, 4)
SAMPLER(0, FLOAT_2D, input_ghost_tx)
IMAGE(0, GPU_RGBA16F, READ_WRITE, FLOAT_2D, accumulated_ghost_img)
SAMPLER(0, sampler2D, input_ghost_tx)
IMAGE(0, GPU_RGBA16F, read_write, image2D, accumulated_ghost_img)
COMPUTE_SOURCE("compositor_glare_ghost_accumulate.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -79,7 +79,7 @@ GPU_SHADER_CREATE_INFO(compositor_glare_simple_star_horizontal_pass)
LOCAL_GROUP_SIZE(16)
PUSH_CONSTANT(int, iterations)
PUSH_CONSTANT(float, fade_factor)
IMAGE(0, GPU_RGBA16F, READ_WRITE, FLOAT_2D, horizontal_img)
IMAGE(0, GPU_RGBA16F, read_write, image2D, horizontal_img)
COMPUTE_SOURCE("compositor_glare_simple_star_horizontal_pass.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -88,8 +88,8 @@ GPU_SHADER_CREATE_INFO(compositor_glare_simple_star_vertical_pass)
LOCAL_GROUP_SIZE(16)
PUSH_CONSTANT(int, iterations)
PUSH_CONSTANT(float, fade_factor)
SAMPLER(0, FLOAT_2D, horizontal_tx)
IMAGE(0, GPU_RGBA16F, READ_WRITE, FLOAT_2D, vertical_img)
SAMPLER(0, sampler2D, horizontal_tx)
IMAGE(0, GPU_RGBA16F, read_write, image2D, vertical_img)
COMPUTE_SOURCE("compositor_glare_simple_star_vertical_pass.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -98,7 +98,7 @@ GPU_SHADER_CREATE_INFO(compositor_glare_simple_star_diagonal_pass)
LOCAL_GROUP_SIZE(16)
PUSH_CONSTANT(int, iterations)
PUSH_CONSTANT(float, fade_factor)
IMAGE(0, GPU_RGBA16F, READ_WRITE, FLOAT_2D, diagonal_img)
IMAGE(0, GPU_RGBA16F, read_write, image2D, diagonal_img)
COMPUTE_SOURCE("compositor_glare_simple_star_diagonal_pass.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -107,8 +107,8 @@ GPU_SHADER_CREATE_INFO(compositor_glare_simple_star_anti_diagonal_pass)
LOCAL_GROUP_SIZE(16)
PUSH_CONSTANT(int, iterations)
PUSH_CONSTANT(float, fade_factor)
SAMPLER(0, FLOAT_2D, diagonal_tx)
IMAGE(0, GPU_RGBA16F, READ_WRITE, FLOAT_2D, anti_diagonal_img)
SAMPLER(0, sampler2D, diagonal_tx)
IMAGE(0, GPU_RGBA16F, read_write, image2D, anti_diagonal_img)
COMPUTE_SOURCE("compositor_glare_simple_star_anti_diagonal_pass.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -122,8 +122,8 @@ LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float, color_modulator)
PUSH_CONSTANT(float3, fade_factors)
PUSH_CONSTANT(float2, streak_vector)
SAMPLER(0, FLOAT_2D, input_streak_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_streak_img)
SAMPLER(0, sampler2D, input_streak_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_streak_img)
COMPUTE_SOURCE("compositor_glare_streaks_filter.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -131,8 +131,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_glare_streaks_accumulate)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float, attenuation_factor)
SAMPLER(0, FLOAT_2D, streak_tx)
IMAGE(0, GPU_RGBA16F, READ_WRITE, FLOAT_2D, accumulated_streaks_img)
SAMPLER(0, sampler2D, streak_tx)
IMAGE(0, GPU_RGBA16F, read_write, image2D, accumulated_streaks_img)
COMPUTE_SOURCE("compositor_glare_streaks_accumulate.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -143,8 +143,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_glare_bloom_downsample_shared)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_glare_bloom_downsample.glsl")
GPU_SHADER_CREATE_END()
@@ -162,8 +162,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_glare_bloom_upsample)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, READ_WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, read_write, image2D, output_img)
COMPUTE_SOURCE("compositor_glare_bloom_upsample.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

4
source/blender/compositor/shaders/infos/compositor_id_mask_info.hh
View File

@@ -7,8 +7,8 @@
GPU_SHADER_CREATE_INFO(compositor_id_mask)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(int, index)
SAMPLER(0, FLOAT_2D, input_mask_tx)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_mask_img)
SAMPLER(0, sampler2D, input_mask_tx)
IMAGE(0, GPU_R16F, write, image2D, output_mask_img)
COMPUTE_SOURCE("compositor_id_mask.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

4
source/blender/compositor/shaders/infos/compositor_image_crop_info.hh
View File

@@ -7,8 +7,8 @@
GPU_SHADER_CREATE_INFO(compositor_image_crop)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(int2, lower_bound)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_image_crop.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

22
source/blender/compositor/shaders/infos/compositor_inpaint_info.hh
View File

@@ -6,8 +6,8 @@
GPU_SHADER_CREATE_INFO(compositor_inpaint_compute_boundary)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RG16I, WRITE, INT_2D, boundary_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RG16I, write, iimage2D, boundary_img)
COMPUTE_SOURCE("compositor_inpaint_compute_boundary.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -15,11 +15,11 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_inpaint_fill_region)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(int, max_distance)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, INT_2D, flooded_boundary_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, filled_region_img)
IMAGE(1, GPU_R16F, WRITE, FLOAT_2D, distance_to_boundary_img)
IMAGE(2, GPU_R16F, WRITE, FLOAT_2D, smoothing_radius_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, isampler2D, flooded_boundary_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, filled_region_img)
IMAGE(1, GPU_R16F, write, image2D, distance_to_boundary_img)
IMAGE(2, GPU_R16F, write, image2D, smoothing_radius_img)
COMPUTE_SOURCE("compositor_inpaint_fill_region.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -27,10 +27,10 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_inpaint_compute_region)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(int, max_distance)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, inpainted_region_tx)
SAMPLER(2, FLOAT_2D, distance_to_boundary_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, inpainted_region_tx)
SAMPLER(2, sampler2D, distance_to_boundary_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_inpaint_compute_region.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

4
source/blender/compositor/shaders/infos/compositor_jump_flooding_info.hh
View File

@@ -7,8 +7,8 @@
GPU_SHADER_CREATE_INFO(compositor_jump_flooding)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(int, step_size)
SAMPLER(0, INT_2D, input_tx)
IMAGE(0, GPU_RG16I, WRITE, INT_2D, output_img)
SAMPLER(0, isampler2D, input_tx)
IMAGE(0, GPU_RG16I, write, iimage2D, output_img)
COMPUTE_SOURCE("compositor_jump_flooding.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

34
source/blender/compositor/shaders/infos/compositor_keying_info.hh
View File

@@ -6,17 +6,17 @@
GPU_SHADER_CREATE_INFO(compositor_keying_extract_chroma)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_keying_extract_chroma.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_keying_replace_chroma)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, new_chroma_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, new_chroma_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_keying_replace_chroma.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -24,9 +24,9 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_keying_compute_matte)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float, key_balance)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, key_tx)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, key_tx)
IMAGE(0, GPU_R16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_keying_compute_matte.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -37,10 +37,10 @@ PUSH_CONSTANT(int, edge_search_radius)
PUSH_CONSTANT(float, edge_tolerance)
PUSH_CONSTANT(float, black_level)
PUSH_CONSTANT(float, white_level)
SAMPLER(0, FLOAT_2D, input_matte_tx)
SAMPLER(1, FLOAT_2D, garbage_matte_tx)
SAMPLER(2, FLOAT_2D, core_matte_tx)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_matte_img)
SAMPLER(0, sampler2D, input_matte_tx)
SAMPLER(1, sampler2D, garbage_matte_tx)
SAMPLER(2, sampler2D, core_matte_tx)
IMAGE(0, GPU_R16F, write, image2D, output_matte_img)
COMPUTE_SOURCE("compositor_keying_tweak_matte.glsl")
GPU_SHADER_CREATE_END()
@@ -52,7 +52,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_keying_tweak_matte_with_edges)
ADDITIONAL_INFO(compositor_keying_tweak_matte_shared)
DEFINE("COMPUTE_EDGES")
IMAGE(1, GPU_R16F, WRITE, FLOAT_2D, output_edges_img)
IMAGE(1, GPU_R16F, write, image2D, output_edges_img)
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -60,10 +60,10 @@ GPU_SHADER_CREATE_INFO(compositor_keying_compute_image)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float, despill_factor)
PUSH_CONSTANT(float, despill_balance)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, matte_tx)
SAMPLER(2, FLOAT_2D, key_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, matte_tx)
SAMPLER(2, sampler2D, key_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_keying_compute_image.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

6
source/blender/compositor/shaders/infos/compositor_keying_screen_info.hh
View File

@@ -8,9 +8,9 @@ GPU_SHADER_CREATE_INFO(compositor_keying_screen)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float, smoothness)
PUSH_CONSTANT(int, number_of_markers)
STORAGE_BUF(0, READ, vec2, marker_positions[])
STORAGE_BUF(1, READ, vec4, marker_colors[])
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
STORAGE_BUF(0, read, vec2, marker_positions[])
STORAGE_BUF(1, read, vec4, marker_colors[])
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_keying_screen.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

24
source/blender/compositor/shaders/infos/compositor_kuwahara_info.hh
View File

@@ -6,13 +6,13 @@
GPU_SHADER_CREATE_INFO(compositor_kuwahara_classic_shared)
LOCAL_GROUP_SIZE(16, 16)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_kuwahara_classic.glsl")
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_kuwahara_classic_convolution_shared)
ADDITIONAL_INFO(compositor_kuwahara_classic_shared)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(0, sampler2D, input_tx)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_kuwahara_classic_convolution_constant_size)
@@ -24,7 +24,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_kuwahara_classic_convolution_variable_size)
ADDITIONAL_INFO(compositor_kuwahara_classic_convolution_shared)
SAMPLER(1, FLOAT_2D, size_tx)
SAMPLER(1, sampler2D, size_tx)
DEFINE("VARIABLE_SIZE")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -32,8 +32,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_kuwahara_classic_summed_area_table_shared)
ADDITIONAL_INFO(compositor_kuwahara_classic_shared)
DEFINE("SUMMED_AREA_TABLE")
SAMPLER(0, FLOAT_2D, table_tx)
SAMPLER(1, FLOAT_2D, squared_table_tx)
SAMPLER(0, sampler2D, table_tx)
SAMPLER(1, sampler2D, squared_table_tx)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_kuwahara_classic_summed_area_table_constant_size)
@@ -45,15 +45,15 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_kuwahara_classic_summed_area_table_variable_size)
ADDITIONAL_INFO(compositor_kuwahara_classic_summed_area_table_shared)
SAMPLER(2, FLOAT_2D, size_tx)
SAMPLER(2, sampler2D, size_tx)
DEFINE("VARIABLE_SIZE")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_kuwahara_anisotropic_compute_structure_tensor)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, structure_tensor_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, structure_tensor_img)
COMPUTE_SOURCE("compositor_kuwahara_anisotropic_compute_structure_tensor.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -62,9 +62,9 @@ GPU_SHADER_CREATE_INFO(compositor_kuwahara_anisotropic_shared)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float, eccentricity)
PUSH_CONSTANT(float, sharpness)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, structure_tensor_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, structure_tensor_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_kuwahara_anisotropic.glsl")
GPU_SHADER_CREATE_END()
@@ -78,6 +78,6 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_kuwahara_anisotropic_variable_size)
ADDITIONAL_INFO(compositor_kuwahara_anisotropic_shared)
DEFINE("VARIABLE_SIZE")
SAMPLER(2, FLOAT_2D, size_tx)
SAMPLER(2, sampler2D, size_tx)
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

6
source/blender/compositor/shaders/infos/compositor_map_uv_info.hh
View File

@@ -6,9 +6,9 @@
GPU_SHADER_CREATE_INFO(compositor_map_uv_shared)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, uv_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, uv_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_map_uv_anisotropic)

4
source/blender/compositor/shaders/infos/compositor_morphological_blur_info.hh
View File

@@ -6,8 +6,8 @@
GPU_SHADER_CREATE_INFO(compositor_morphological_blur_shared)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_R16F, READ_WRITE, FLOAT_2D, blurred_input_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_R16F, read_write, image2D, blurred_input_img)
COMPUTE_SOURCE("compositor_morphological_blur.glsl")
GPU_SHADER_CREATE_END()

8
source/blender/compositor/shaders/infos/compositor_morphological_distance_feather_info.hh
View File

@@ -6,10 +6,10 @@
GPU_SHADER_CREATE_INFO(compositor_morphological_distance_feather_shared)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, weights_tx)
SAMPLER(2, FLOAT_2D, falloffs_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, weights_tx)
SAMPLER(2, sampler2D, falloffs_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_morphological_distance_feather.glsl")
GPU_SHADER_CREATE_END()

4
source/blender/compositor/shaders/infos/compositor_morphological_distance_info.hh
View File

@@ -7,8 +7,8 @@
GPU_SHADER_CREATE_INFO(compositor_morphological_distance_shared)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(int, radius)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_R16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_morphological_distance.glsl")
GPU_SHADER_CREATE_END()

4
source/blender/compositor/shaders/infos/compositor_morphological_distance_threshold_info.hh
View File

@@ -9,8 +9,8 @@ LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(int, radius)
PUSH_CONSTANT(int, distance)
PUSH_CONSTANT(float, inset)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_R16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_morphological_distance_threshold.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

4
source/blender/compositor/shaders/infos/compositor_morphological_step_info.hh
View File

@@ -7,8 +7,8 @@
GPU_SHADER_CREATE_INFO(compositor_morphological_step_shared)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(int, radius)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_R16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_morphological_step.glsl")
GPU_SHADER_CREATE_END()

16
source/blender/compositor/shaders/infos/compositor_motion_blur_info.hh
View File

@@ -7,8 +7,8 @@
GPU_SHADER_CREATE_INFO(compositor_motion_blur_max_velocity_dilate)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float, shutter_speed)
SAMPLER(0, FLOAT_2D, input_tx)
STORAGE_BUF(0, READ_WRITE, uint, tile_indirection_buf[])
SAMPLER(0, sampler2D, input_tx)
STORAGE_BUF(0, read_write, uint, tile_indirection_buf[])
COMPUTE_SOURCE("compositor_motion_blur_max_velocity_dilate.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -17,12 +17,12 @@ GPU_SHADER_CREATE_INFO(compositor_motion_blur)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(int, samples_count)
PUSH_CONSTANT(float, shutter_speed)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, depth_tx)
SAMPLER(2, FLOAT_2D, velocity_tx)
SAMPLER(3, FLOAT_2D, max_velocity_tx)
STORAGE_BUF(0, READ, uint, tile_indirection_buf[])
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, depth_tx)
SAMPLER(2, sampler2D, velocity_tx)
SAMPLER(3, sampler2D, max_velocity_tx)
STORAGE_BUF(0, read, uint, tile_indirection_buf[])
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_motion_blur.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

6
source/blender/compositor/shaders/infos/compositor_movie_distortion_info.hh
View File

@@ -6,9 +6,9 @@
GPU_SHADER_CREATE_INFO(compositor_movie_distortion)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, distortion_grid_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, distortion_grid_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_movie_distortion.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

4
source/blender/compositor/shaders/infos/compositor_normalize_info.hh
View File

@@ -8,8 +8,8 @@ GPU_SHADER_CREATE_INFO(compositor_normalize)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float, minimum)
PUSH_CONSTANT(float, scale)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_R16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_normalize.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

26
source/blender/compositor/shaders/infos/compositor_parallel_reduction_info.hh
View File

@@ -7,7 +7,7 @@
GPU_SHADER_CREATE_INFO(compositor_parallel_reduction_shared)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(bool, is_initial_reduction)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(0, sampler2D, input_tx)
COMPUTE_SOURCE("compositor_parallel_reduction.glsl")
GPU_SHADER_CREATE_END()
@@ -22,7 +22,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_sum_float_shared)
ADDITIONAL_INFO(compositor_sum_shared)
IMAGE(0, GPU_R32F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_R32F, write, image2D, output_img)
DEFINE_VALUE("TYPE", "float")
DEFINE_VALUE("IDENTITY", "0.0f")
DEFINE_VALUE("LOAD(value)", "value.x")
@@ -62,7 +62,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_sum_color)
ADDITIONAL_INFO(compositor_sum_shared)
IMAGE(0, GPU_RGBA32F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA32F, write, image2D, output_img)
DEFINE_VALUE("TYPE", "vec4")
DEFINE_VALUE("IDENTITY", "vec4(0.0f)")
DEFINE_VALUE("INITIALIZE(value)", "value")
@@ -76,7 +76,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_sum_squared_difference_float_shared)
ADDITIONAL_INFO(compositor_parallel_reduction_shared)
IMAGE(0, GPU_R32F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_R32F, write, image2D, output_img)
PUSH_CONSTANT(float, subtrahend)
DEFINE_VALUE("TYPE", "float")
DEFINE_VALUE("IDENTITY", "0.0f")
@@ -115,7 +115,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_maximum_luminance)
ADDITIONAL_INFO(compositor_parallel_reduction_shared)
IMAGE(0, GPU_R32F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_R32F, write, image2D, output_img)
PUSH_CONSTANT(float3, luminance_coefficients)
DEFINE_VALUE("TYPE", "float")
DEFINE_VALUE("IDENTITY", "FLT_MIN")
@@ -127,7 +127,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_maximum_brightness)
ADDITIONAL_INFO(compositor_parallel_reduction_shared)
IMAGE(0, GPU_R32F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_R32F, write, image2D, output_img)
DEFINE_VALUE("TYPE", "float")
DEFINE_VALUE("IDENTITY", "FLT_MIN")
DEFINE_VALUE("INITIALIZE(value)", "reduce_max(value.rgb)")
@@ -138,7 +138,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_maximum_float)
ADDITIONAL_INFO(compositor_parallel_reduction_shared)
IMAGE(0, GPU_R32F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_R32F, write, image2D, output_img)
DEFINE_VALUE("TYPE", "float")
DEFINE_VALUE("IDENTITY", "FLT_MIN")
DEFINE_VALUE("INITIALIZE(value)", "value.x")
@@ -149,7 +149,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_maximum_float_in_range)
ADDITIONAL_INFO(compositor_parallel_reduction_shared)
IMAGE(0, GPU_R32F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_R32F, write, image2D, output_img)
PUSH_CONSTANT(float, lower_bound)
PUSH_CONSTANT(float, upper_bound)
DEFINE_VALUE("TYPE", "float")
@@ -166,7 +166,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_minimum_luminance)
ADDITIONAL_INFO(compositor_parallel_reduction_shared)
IMAGE(0, GPU_R32F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_R32F, write, image2D, output_img)
PUSH_CONSTANT(float3, luminance_coefficients)
DEFINE_VALUE("TYPE", "float")
DEFINE_VALUE("IDENTITY", "FLT_MAX")
@@ -178,7 +178,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_minimum_float)
ADDITIONAL_INFO(compositor_parallel_reduction_shared)
IMAGE(0, GPU_R32F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_R32F, write, image2D, output_img)
DEFINE_VALUE("TYPE", "float")
DEFINE_VALUE("IDENTITY", "FLT_MAX")
DEFINE_VALUE("INITIALIZE(value)", "value.x")
@@ -189,7 +189,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_minimum_float_in_range)
ADDITIONAL_INFO(compositor_parallel_reduction_shared)
IMAGE(0, GPU_R32F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_R32F, write, image2D, output_img)
PUSH_CONSTANT(float, lower_bound)
PUSH_CONSTANT(float, upper_bound)
DEFINE_VALUE("TYPE", "float")
@@ -207,8 +207,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_max_velocity)
LOCAL_GROUP_SIZE(32, 32)
PUSH_CONSTANT(bool, is_initial_reduction)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("TYPE", "vec4")
DEFINE_VALUE("IDENTITY", "vec4(0.0f)")
DEFINE_VALUE("INITIALIZE(value)", "value")

2
source/blender/compositor/shaders/infos/compositor_pixel_coordinates_info.hh
View File

@@ -6,7 +6,7 @@
GPU_SHADER_CREATE_INFO(compositor_pixel_coordinates)
LOCAL_GROUP_SIZE(16, 16)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_pixel_coordinates.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

4
source/blender/compositor/shaders/infos/compositor_pixelate_info.hh
View File

@@ -7,8 +7,8 @@
GPU_SHADER_CREATE_INFO(compositor_pixelate)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(int, pixel_size)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_pixelate.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

16
source/blender/compositor/shaders/infos/compositor_plane_deform_info.hh
View File

@@ -7,7 +7,7 @@
GPU_SHADER_CREATE_INFO(compositor_plane_deform_mask)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float4x4, homography_matrix)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, mask_img)
IMAGE(0, GPU_R16F, write, image2D, mask_img)
COMPUTE_SOURCE("compositor_plane_deform_mask.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -15,9 +15,9 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_plane_deform_shared)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float4x4, homography_matrix)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, mask_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, mask_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_plane_deform)
@@ -44,7 +44,7 @@ GPU_SHADER_CREATE_INFO(compositor_plane_deform_motion_blur_mask)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(int, number_of_motion_blur_samples)
UNIFORM_BUF(0, float4x4, homography_matrices[64])
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, mask_img)
IMAGE(0, GPU_R16F, write, image2D, mask_img)
COMPUTE_SOURCE("compositor_plane_deform_motion_blur_mask.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -53,9 +53,9 @@ GPU_SHADER_CREATE_INFO(compositor_plane_deform_motion_blur)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(int, number_of_motion_blur_samples)
UNIFORM_BUF(0, float4x4, homography_matrices[64])
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, mask_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, mask_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_plane_deform_motion_blur.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

4
source/blender/compositor/shaders/infos/compositor_premultiply_alpha_info.hh
View File

@@ -6,8 +6,8 @@
GPU_SHADER_CREATE_INFO(compositor_premultiply_alpha)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_premultiply_alpha.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

4
source/blender/compositor/shaders/infos/compositor_projector_lens_distortion_info.hh
View File

@@ -7,8 +7,8 @@
GPU_SHADER_CREATE_INFO(compositor_projector_lens_distortion)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float, dispersion)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_projector_lens_distortion.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

8
source/blender/compositor/shaders/infos/compositor_read_input_info.hh
View File

@@ -7,27 +7,27 @@
GPU_SHADER_CREATE_INFO(compositor_read_input_shared)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(int2, lower_bound)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(0, sampler2D, input_tx)
COMPUTE_SOURCE("compositor_read_input.glsl")
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_read_input_float)
ADDITIONAL_INFO(compositor_read_input_shared)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_R16F, write, image2D, output_img)
DEFINE_VALUE("READ_EXPRESSION(input_color)", "vec4(input_color.r, vec3(0.0f))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_read_input_float4)
ADDITIONAL_INFO(compositor_read_input_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DEFINE_VALUE("READ_EXPRESSION(input_color)", "input_color")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_read_input_alpha)
ADDITIONAL_INFO(compositor_read_input_shared)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_R16F, write, image2D, output_img)
DEFINE_VALUE("READ_EXPRESSION(input_color)", "vec4(input_color.a, vec3(0.0f))")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

10
source/blender/compositor/shaders/infos/compositor_realize_on_domain_info.hh
View File

@@ -7,7 +7,7 @@
GPU_SHADER_CREATE_INFO(compositor_realize_on_domain_shared)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float4x4, inverse_transformation)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(0, sampler2D, input_tx)
COMPUTE_SOURCE("compositor_realize_on_domain.glsl")
GPU_SHADER_CREATE_END()
@@ -23,24 +23,24 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_realize_on_domain_float4)
ADDITIONAL_INFO(compositor_realize_on_domain_standard_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, domain_img)
IMAGE(0, GPU_RGBA16F, write, image2D, domain_img)
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_realize_on_domain_float)
ADDITIONAL_INFO(compositor_realize_on_domain_standard_shared)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, domain_img)
IMAGE(0, GPU_R16F, write, image2D, domain_img)
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_realize_on_domain_bicubic_float4)
ADDITIONAL_INFO(compositor_realize_on_domain_bicubic_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, domain_img)
IMAGE(0, GPU_RGBA16F, write, image2D, domain_img)
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_realize_on_domain_bicubic_float)
ADDITIONAL_INFO(compositor_realize_on_domain_bicubic_shared)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, domain_img)
IMAGE(0, GPU_R16F, write, image2D, domain_img)
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

8
source/blender/compositor/shaders/infos/compositor_scale_variable_info.hh
View File

@@ -6,10 +6,10 @@
GPU_SHADER_CREATE_INFO(compositor_scale_variable_shared)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, x_scale_tx)
SAMPLER(2, FLOAT_2D, y_scale_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, x_scale_tx)
SAMPLER(2, sampler2D, y_scale_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_scale_variable.glsl")
GPU_SHADER_CREATE_END()

4
source/blender/compositor/shaders/infos/compositor_screen_lens_distortion_info.hh
View File

@@ -8,8 +8,8 @@ GPU_SHADER_CREATE_INFO(compositor_screen_lens_distortion_shared)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float3, chromatic_distortion)
PUSH_CONSTANT(float, scale)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_screen_lens_distortion.glsl")
GPU_SHADER_CREATE_END()

20
source/blender/compositor/shaders/infos/compositor_smaa_info.hh
View File

@@ -15,8 +15,8 @@ DEFINE_VALUE("SMAA_LOCAL_CONTRAST_ADAPTATION_FACTOR", "smaa_local_contrast_adapt
PUSH_CONSTANT(float3, luminance_coefficients)
PUSH_CONSTANT(float, smaa_threshold)
PUSH_CONSTANT(float, smaa_local_contrast_adaptation_factor)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, edges_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, edges_img)
COMPUTE_SOURCE("compositor_smaa_edge_detection.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -28,10 +28,10 @@ DEFINE_VALUE("SMAA_RT_METRICS",
"vec4(1.0f / vec2(textureSize(edges_tx, 0)), vec2(textureSize(edges_tx, 0)))")
DEFINE_VALUE("SMAA_CORNER_ROUNDING", "smaa_corner_rounding")
PUSH_CONSTANT(int, smaa_corner_rounding)
SAMPLER(0, FLOAT_2D, edges_tx)
SAMPLER(1, FLOAT_2D, area_tx)
SAMPLER(2, FLOAT_2D, search_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, weights_img)
SAMPLER(0, sampler2D, edges_tx)
SAMPLER(1, sampler2D, area_tx)
SAMPLER(2, sampler2D, search_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, weights_img)
COMPUTE_SOURCE("compositor_smaa_blending_weight_calculation.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -41,19 +41,19 @@ LOCAL_GROUP_SIZE(16, 16)
DEFINE("SMAA_GLSL_3")
DEFINE_VALUE("SMAA_RT_METRICS",
"vec4(1.0f / vec2(textureSize(input_tx, 0)), vec2(textureSize(input_tx, 0)))")
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, weights_tx)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, weights_tx)
COMPUTE_SOURCE("compositor_smaa_neighborhood_blending.glsl")
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_smaa_neighborhood_blending_float4)
ADDITIONAL_INFO(compositor_smaa_neighborhood_blending_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_smaa_neighborhood_blending_float)
ADDITIONAL_INFO(compositor_smaa_neighborhood_blending_shared)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_R16F, write, image2D, output_img)
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

6
source/blender/compositor/shaders/infos/compositor_split_info.hh
View File

@@ -7,9 +7,9 @@
GPU_SHADER_CREATE_INFO(compositor_split_shared)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float, split_ratio)
SAMPLER(0, FLOAT_2D, first_image_tx)
SAMPLER(1, FLOAT_2D, second_image_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, first_image_tx)
SAMPLER(1, sampler2D, second_image_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_split.glsl")
GPU_SHADER_CREATE_END()

26
source/blender/compositor/shaders/infos/compositor_summed_area_table_info.hh
View File

@@ -6,9 +6,9 @@
GPU_SHADER_CREATE_INFO(compositor_summed_area_table_compute_incomplete_prologues_shared)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA32F, WRITE, FLOAT_2D, incomplete_x_prologues_img)
IMAGE(1, GPU_RGBA32F, WRITE, FLOAT_2D, incomplete_y_prologues_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA32F, write, image2D, incomplete_x_prologues_img)
IMAGE(1, GPU_RGBA32F, write, image2D, incomplete_y_prologues_img)
COMPUTE_SOURCE("compositor_summed_area_table_compute_incomplete_prologues.glsl")
GPU_SHADER_CREATE_END()
@@ -26,28 +26,28 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_summed_area_table_compute_complete_x_prologues)
LOCAL_GROUP_SIZE(16)
SAMPLER(0, FLOAT_2D, incomplete_x_prologues_tx)
IMAGE(0, GPU_RGBA32F, WRITE, FLOAT_2D, complete_x_prologues_img)
IMAGE(1, GPU_RGBA32F, WRITE, FLOAT_2D, complete_x_prologues_sum_img)
SAMPLER(0, sampler2D, incomplete_x_prologues_tx)
IMAGE(0, GPU_RGBA32F, write, image2D, complete_x_prologues_img)
IMAGE(1, GPU_RGBA32F, write, image2D, complete_x_prologues_sum_img)
COMPUTE_SOURCE("compositor_summed_area_table_compute_complete_x_prologues.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_summed_area_table_compute_complete_y_prologues)
LOCAL_GROUP_SIZE(16)
SAMPLER(0, FLOAT_2D, incomplete_y_prologues_tx)
SAMPLER(1, FLOAT_2D, complete_x_prologues_sum_tx)
IMAGE(0, GPU_RGBA32F, WRITE, FLOAT_2D, complete_y_prologues_img)
SAMPLER(0, sampler2D, incomplete_y_prologues_tx)
SAMPLER(1, sampler2D, complete_x_prologues_sum_tx)
IMAGE(0, GPU_RGBA32F, write, image2D, complete_y_prologues_img)
COMPUTE_SOURCE("compositor_summed_area_table_compute_complete_y_prologues.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_summed_area_table_compute_complete_blocks_shared)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, complete_x_prologues_tx)
SAMPLER(2, FLOAT_2D, complete_y_prologues_tx)
IMAGE(0, GPU_RGBA32F, READ_WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, complete_x_prologues_tx)
SAMPLER(2, sampler2D, complete_y_prologues_tx)
IMAGE(0, GPU_RGBA32F, read_write, image2D, output_img)
COMPUTE_SOURCE("compositor_summed_area_table_compute_complete_blocks.glsl")
GPU_SHADER_CREATE_END()

4
source/blender/compositor/shaders/infos/compositor_sun_beams_info.hh
View File

@@ -8,8 +8,8 @@ GPU_SHADER_CREATE_INFO(compositor_sun_beams)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float2, source)
PUSH_CONSTANT(int, max_steps)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_sun_beams.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

6
source/blender/compositor/shaders/infos/compositor_symmetric_blur_info.hh
View File

@@ -7,9 +7,9 @@
GPU_SHADER_CREATE_INFO(compositor_symmetric_blur)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(bool, extend_bounds)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, weights_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, weights_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_symmetric_blur.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

8
source/blender/compositor/shaders/infos/compositor_symmetric_blur_variable_size_info.hh
View File

@@ -7,10 +7,10 @@
GPU_SHADER_CREATE_INFO(compositor_symmetric_blur_variable_size)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(bool, extend_bounds)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, weights_tx)
SAMPLER(2, FLOAT_2D, size_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, weights_tx)
SAMPLER(2, sampler2D, size_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_symmetric_blur_variable_size.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

8
source/blender/compositor/shaders/infos/compositor_symmetric_separable_blur_info.hh
View File

@@ -7,19 +7,19 @@
GPU_SHADER_CREATE_INFO(compositor_symmetric_separable_blur_shared)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(bool, extend_bounds)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, weights_tx)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, weights_tx)
COMPUTE_SOURCE("compositor_symmetric_separable_blur.glsl")
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_symmetric_separable_blur_float)
ADDITIONAL_INFO(compositor_symmetric_separable_blur_shared)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_R16F, write, image2D, output_img)
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_symmetric_separable_blur_float4)
ADDITIONAL_INFO(compositor_symmetric_separable_blur_shared)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

8
source/blender/compositor/shaders/infos/compositor_symmetric_separable_blur_variable_size_info.hh
View File

@@ -7,10 +7,10 @@
GPU_SHADER_CREATE_INFO(compositor_symmetric_separable_blur_variable_size)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(bool, is_vertical_pass)
SAMPLER(0, FLOAT_2D, input_tx)
SAMPLER(1, FLOAT_2D, weights_tx)
SAMPLER(2, FLOAT_2D, radius_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
SAMPLER(1, sampler2D, weights_tx)
SAMPLER(2, sampler2D, radius_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_symmetric_separable_blur_variable_size.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

2
source/blender/compositor/shaders/infos/compositor_texture_coordinates_info.hh
View File

@@ -6,7 +6,7 @@
GPU_SHADER_CREATE_INFO(compositor_texture_coordinates)
LOCAL_GROUP_SIZE(16, 16)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_texture_coordinates.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

4
source/blender/compositor/shaders/infos/compositor_tone_map_photoreceptor_info.hh
View File

@@ -12,8 +12,8 @@ PUSH_CONSTANT(float, intensity)
PUSH_CONSTANT(float, chromatic_adaptation)
PUSH_CONSTANT(float, light_adaptation)
PUSH_CONSTANT(float3, luminance_coefficients)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_tone_map_photoreceptor.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

4
source/blender/compositor/shaders/infos/compositor_tone_map_simple_info.hh
View File

@@ -9,8 +9,8 @@ LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float, luminance_scale)
PUSH_CONSTANT(float, luminance_scale_blend_factor)
PUSH_CONSTANT(float, inverse_gamma)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_tone_map_simple.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

4
source/blender/compositor/shaders/infos/compositor_translate_wrapped_info.hh
View File

@@ -7,8 +7,8 @@
GPU_SHADER_CREATE_INFO(compositor_translate_wrapped_shared)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(float2, translation)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_translate_wrapped.glsl")
GPU_SHADER_CREATE_END()

20
source/blender/compositor/shaders/infos/compositor_van_vliet_gaussian_blur_info.hh
View File

@@ -16,22 +16,22 @@ PUSH_CONSTANT(float, first_causal_boundary_coefficient)
PUSH_CONSTANT(float, first_non_causal_boundary_coefficient)
PUSH_CONSTANT(float, second_causal_boundary_coefficient)
PUSH_CONSTANT(float, second_non_causal_boundary_coefficient)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, first_causal_output_img)
IMAGE(1, GPU_RGBA16F, WRITE, FLOAT_2D, first_non_causal_output_img)
IMAGE(2, GPU_RGBA16F, WRITE, FLOAT_2D, second_causal_output_img)
IMAGE(3, GPU_RGBA16F, WRITE, FLOAT_2D, second_non_causal_output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, first_causal_output_img)
IMAGE(1, GPU_RGBA16F, write, image2D, first_non_causal_output_img)
IMAGE(2, GPU_RGBA16F, write, image2D, second_causal_output_img)
IMAGE(3, GPU_RGBA16F, write, image2D, second_non_causal_output_img)
COMPUTE_SOURCE("compositor_van_vliet_gaussian_blur.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_van_vliet_gaussian_blur_sum)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, first_causal_input_tx)
SAMPLER(1, FLOAT_2D, first_non_causal_input_tx)
SAMPLER(2, FLOAT_2D, second_causal_input_tx)
SAMPLER(3, FLOAT_2D, second_non_causal_input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, first_causal_input_tx)
SAMPLER(1, sampler2D, first_non_causal_input_tx)
SAMPLER(2, sampler2D, second_causal_input_tx)
SAMPLER(3, sampler2D, second_non_causal_input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_van_vliet_gaussian_blur_sum.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

6
source/blender/compositor/shaders/infos/compositor_write_output_info.hh
View File

@@ -8,8 +8,8 @@ GPU_SHADER_CREATE_INFO(compositor_write_output_shared)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(int2, lower_bound)
PUSH_CONSTANT(int2, upper_bound)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("compositor_write_output.glsl")
GPU_SHADER_CREATE_END()
@@ -27,7 +27,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_write_output_alpha)
ADDITIONAL_INFO(compositor_write_output_shared)
SAMPLER(1, FLOAT_2D, alpha_tx)
SAMPLER(1, sampler2D, alpha_tx)
DEFINE("ALPHA_OUTPUT")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

36
source/blender/compositor/shaders/infos/compositor_z_combine_info.hh
View File

@@ -7,29 +7,29 @@
GPU_SHADER_CREATE_INFO(compositor_z_combine_simple_image)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(bool, use_alpha)
SAMPLER(0, FLOAT_2D, first_tx)
SAMPLER(1, FLOAT_2D, first_z_tx)
SAMPLER(2, FLOAT_2D, second_tx)
SAMPLER(3, FLOAT_2D, second_z_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, combined_img)
SAMPLER(0, sampler2D, first_tx)
SAMPLER(1, sampler2D, first_z_tx)
SAMPLER(2, sampler2D, second_tx)
SAMPLER(3, sampler2D, second_z_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, combined_img)
COMPUTE_SOURCE("compositor_z_combine_simple_image.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_z_combine_simple_depth)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, first_z_tx)
SAMPLER(1, FLOAT_2D, second_z_tx)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, combined_z_img)
SAMPLER(0, sampler2D, first_z_tx)
SAMPLER(1, sampler2D, second_z_tx)
IMAGE(0, GPU_R16F, write, image2D, combined_z_img)
COMPUTE_SOURCE("compositor_z_combine_simple_depth.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_z_combine_compute_mask)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, first_z_tx)
SAMPLER(1, FLOAT_2D, second_z_tx)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, mask_img)
SAMPLER(0, sampler2D, first_z_tx)
SAMPLER(1, sampler2D, second_z_tx)
IMAGE(0, GPU_R16F, write, image2D, mask_img)
COMPUTE_SOURCE("compositor_z_combine_compute_mask.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -37,19 +37,19 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_z_combine_from_mask_image)
LOCAL_GROUP_SIZE(16, 16)
PUSH_CONSTANT(bool, use_alpha)
SAMPLER(0, FLOAT_2D, first_tx)
SAMPLER(2, FLOAT_2D, second_tx)
SAMPLER(4, FLOAT_2D, mask_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, combined_img)
SAMPLER(0, sampler2D, first_tx)
SAMPLER(2, sampler2D, second_tx)
SAMPLER(4, sampler2D, mask_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, combined_img)
COMPUTE_SOURCE("compositor_z_combine_from_mask_image.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(compositor_z_combine_from_mask_depth)
LOCAL_GROUP_SIZE(16, 16)
SAMPLER(0, FLOAT_2D, first_z_tx)
SAMPLER(1, FLOAT_2D, second_z_tx)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, combined_z_img)
SAMPLER(0, sampler2D, first_z_tx)
SAMPLER(1, sampler2D, second_z_tx)
IMAGE(0, GPU_R16F, write, image2D, combined_z_img)
COMPUTE_SOURCE("compositor_z_combine_from_mask_depth.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

8
source/blender/draw/engines/eevee/eevee_shader.cc
View File

@@ -646,7 +646,7 @@ void ShaderModule::material_create_info_amend(GPUMaterial *gpumat, GPUCodegenOut
/* TODO(fclem): Eventually, we could add support for loading both. For now, remove the
* vertex inputs after conversion (avoid name collision). */
for (auto &input : info.vertex_inputs_) {
info.sampler(sampler_slots.get(), ImageType::FLOAT_3D, input.name, Frequency::BATCH);
info.sampler(sampler_slots.get(), ImageType::Float3D, input.name, Frequency::BATCH);
}
info.vertex_inputs_.clear();
/* Volume materials require these for loading the grid attributes from smoke sims. */
@@ -662,7 +662,7 @@ void ShaderModule::material_create_info_amend(GPUMaterial *gpumat, GPUCodegenOut
global_vars << input.type << " " << input.name << ";\n";
}
else {
info.sampler(sampler_slots.get(), ImageType::FLOAT_BUFFER, input.name, Frequency::BATCH);
info.sampler(sampler_slots.get(), ImageType::FloatBuffer, input.name, Frequency::BATCH);
}
}
info.vertex_inputs_.clear();
@@ -672,7 +672,7 @@ void ShaderModule::material_create_info_amend(GPUMaterial *gpumat, GPUCodegenOut
/* Even if world do not have grid attributes, we use dummy texture binds to pass correct
* defaults. So we have to replace all attributes as samplers. */
for (auto &input : info.vertex_inputs_) {
info.sampler(sampler_slots.get(), ImageType::FLOAT_3D, input.name, Frequency::BATCH);
info.sampler(sampler_slots.get(), ImageType::Float3D, input.name, Frequency::BATCH);
}
info.vertex_inputs_.clear();
}
@@ -695,7 +695,7 @@ void ShaderModule::material_create_info_amend(GPUMaterial *gpumat, GPUCodegenOut
case MAT_GEOM_VOLUME:
/** Volume grid attributes come from 3D textures. Transfer attributes to samplers. */
for (auto &input : info.vertex_inputs_) {
info.sampler(sampler_slots.get(), ImageType::FLOAT_3D, input.name, Frequency::BATCH);
info.sampler(sampler_slots.get(), ImageType::Float3D, input.name, Frequency::BATCH);
}
info.vertex_inputs_.clear();
break;

2
source/blender/draw/engines/eevee/shaders/eevee_depth_of_field_accumulator_lib.glsl
View File

@@ -608,7 +608,7 @@ void dof_gather_accumulator(sampler2D color_tx,
* The full pixel neighborhood is gathered.
* \{ */
void dof_slight_focus_gather(depth2D depth_tx,
void dof_slight_focus_gather(sampler2DDepth depth_tx,
sampler2D color_tx,
sampler2D bkh_lut_tx, /* Renamed because of ugly macro job. */
float radius,

2
source/blender/draw/engines/eevee/shaders/eevee_ray_trace_screen_lib.glsl
View File

@@ -169,7 +169,7 @@ METAL_ATTR ScreenTraceHitData raytrace_screen(RayTraceData rt_data,
#ifdef PLANAR_PROBES
ScreenTraceHitData raytrace_planar(RayTraceData rt_data,
depth2DArray planar_depth_tx,
sampler2DArrayDepth planar_depth_tx,
PlanarProbeData planar,
float stride_rand,
Ray ray)

4
source/blender/draw/engines/eevee/shaders/infos/eevee_ambient_occlusion_info.hh
View File

@@ -19,9 +19,9 @@ GPU_SHADER_CREATE_INFO(eevee_ambient_occlusion_pass)
DEFINE("HORIZON_OCCLUSION")
COMPUTE_SOURCE("eevee_ambient_occlusion_pass_comp.glsl")
LOCAL_GROUP_SIZE(AMBIENT_OCCLUSION_PASS_TILE_SIZE, AMBIENT_OCCLUSION_PASS_TILE_SIZE)
IMAGE(0, GPU_RGBA16F, READ, FLOAT_2D_ARRAY, in_normal_img)
IMAGE(0, GPU_RGBA16F, read, image2DArray, in_normal_img)
PUSH_CONSTANT(int, in_normal_img_layer_index)
IMAGE(1, GPU_R16F, WRITE, FLOAT_2D_ARRAY, out_ao_img)
IMAGE(1, GPU_R16F, write, image2DArray, out_ao_img)
PUSH_CONSTANT(int, out_ao_img_layer_index)
SPECIALIZATION_CONSTANT(int, ao_slice_count, 2)
SPECIALIZATION_CONSTANT(int, ao_step_count, 8)

61
source/blender/draw/engines/eevee/shaders/infos/eevee_common_info.hh
View File

@@ -15,6 +15,7 @@
# define MAT_CLIP_PLANE
# define PLANAR_PROBES
# define MAT_RENDER_PASS_SUPPORT
# define SHADOW_READ_ATOMIC
/* Stub for C++ compilation. */
struct NodeTree {
@@ -48,19 +49,19 @@ UNIFORM_BUF(UNIFORM_BUF_SLOT, UniformData, uniform_buf)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_hiz_data)
SAMPLER(HIZ_TEX_SLOT, FLOAT_2D, hiz_tx)
SAMPLER(HIZ_TEX_SLOT, sampler2D, hiz_tx)
ADDITIONAL_INFO(eevee_global_ubo)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_sampling_data)
DEFINE("EEVEE_SAMPLING_DATA")
ADDITIONAL_INFO(eevee_shared)
STORAGE_BUF(SAMPLING_BUF_SLOT, READ, SamplingData, sampling_buf)
STORAGE_BUF(SAMPLING_BUF_SLOT, read, SamplingData, sampling_buf)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_utility_texture)
DEFINE("EEVEE_UTILITY_TX")
SAMPLER(RBUFS_UTILITY_TEX_SLOT, FLOAT_2D_ARRAY, utility_tx)
SAMPLER(RBUFS_UTILITY_TEX_SLOT, sampler2DArray, utility_tx)
GPU_SHADER_CREATE_END()
GPU_SHADER_NAMED_INTERFACE_INFO(eevee_clip_plane_iface, clip_interp)
@@ -76,23 +77,23 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_lightprobe_sphere_data)
DEFINE("SPHERE_PROBE")
UNIFORM_BUF(SPHERE_PROBE_BUF_SLOT, SphereProbeData, lightprobe_sphere_buf[SPHERE_PROBE_MAX])
SAMPLER(SPHERE_PROBE_TEX_SLOT, FLOAT_2D_ARRAY, lightprobe_spheres_tx)
SAMPLER(SPHERE_PROBE_TEX_SLOT, sampler2DArray, lightprobe_spheres_tx)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_volume_probe_data)
UNIFORM_BUF(IRRADIANCE_GRID_BUF_SLOT, VolumeProbeData, grids_infos_buf[IRRADIANCE_GRID_MAX])
/* NOTE: Use uint instead of IrradianceBrickPacked because Metal needs to know the exact type.
*/
STORAGE_BUF(IRRADIANCE_BRICK_BUF_SLOT, READ, uint, bricks_infos_buf[])
SAMPLER(VOLUME_PROBE_TEX_SLOT, FLOAT_3D, irradiance_atlas_tx)
STORAGE_BUF(IRRADIANCE_BRICK_BUF_SLOT, read, uint, bricks_infos_buf[])
SAMPLER(VOLUME_PROBE_TEX_SLOT, sampler3D, irradiance_atlas_tx)
DEFINE("IRRADIANCE_GRID_SAMPLING")
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_lightprobe_planar_data)
DEFINE("SPHERE_PROBE")
UNIFORM_BUF(PLANAR_PROBE_BUF_SLOT, PlanarProbeData, probe_planar_buf[PLANAR_PROBE_MAX])
SAMPLER(PLANAR_PROBE_RADIANCE_TEX_SLOT, FLOAT_2D_ARRAY, planar_radiance_tx)
SAMPLER(PLANAR_PROBE_DEPTH_TEX_SLOT, DEPTH_2D_ARRAY, planar_depth_tx)
SAMPLER(PLANAR_PROBE_RADIANCE_TEX_SLOT, sampler2DArray, planar_radiance_tx)
SAMPLER(PLANAR_PROBE_DEPTH_TEX_SLOT, sampler2DArrayDepth, planar_depth_tx)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_lightprobe_data)
@@ -101,10 +102,10 @@ ADDITIONAL_INFO(eevee_volume_probe_data)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_light_data)
STORAGE_BUF(LIGHT_CULL_BUF_SLOT, READ, LightCullingData, light_cull_buf)
STORAGE_BUF(LIGHT_BUF_SLOT, READ, LightData, light_buf[])
STORAGE_BUF(LIGHT_ZBIN_BUF_SLOT, READ, uint, light_zbin_buf[])
STORAGE_BUF(LIGHT_TILE_BUF_SLOT, READ, uint, light_tile_buf[])
STORAGE_BUF(LIGHT_CULL_BUF_SLOT, read, LightCullingData, light_cull_buf)
STORAGE_BUF(LIGHT_BUF_SLOT, read, LightData, light_buf[])
STORAGE_BUF(LIGHT_ZBIN_BUF_SLOT, read, uint, light_zbin_buf[])
STORAGE_BUF(LIGHT_TILE_BUF_SLOT, read, uint, light_tile_buf[])
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_shadow_data)
@@ -112,46 +113,46 @@ GPU_SHADER_CREATE_INFO(eevee_shadow_data)
* the atlas type. */
DEFINE("SHADOW_READ_ATOMIC")
BUILTINS(BuiltinBits::TEXTURE_ATOMIC)
SAMPLER(SHADOW_ATLAS_TEX_SLOT, UINT_2D_ARRAY_ATOMIC, shadow_atlas_tx)
SAMPLER(SHADOW_TILEMAPS_TEX_SLOT, UINT_2D, shadow_tilemaps_tx)
SAMPLER(SHADOW_ATLAS_TEX_SLOT, usampler2DArrayAtomic, shadow_atlas_tx)
SAMPLER(SHADOW_TILEMAPS_TEX_SLOT, usampler2D, shadow_tilemaps_tx)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_shadow_data_non_atomic)
SAMPLER(SHADOW_ATLAS_TEX_SLOT, UINT_2D_ARRAY, shadow_atlas_tx)
SAMPLER(SHADOW_TILEMAPS_TEX_SLOT, UINT_2D, shadow_tilemaps_tx)
SAMPLER(SHADOW_ATLAS_TEX_SLOT, usampler2DArray, shadow_atlas_tx)
SAMPLER(SHADOW_TILEMAPS_TEX_SLOT, usampler2D, shadow_tilemaps_tx)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_surfel_common)
STORAGE_BUF(SURFEL_BUF_SLOT, READ_WRITE, Surfel, surfel_buf[])
STORAGE_BUF(CAPTURE_BUF_SLOT, READ, CaptureInfoData, capture_info_buf)
STORAGE_BUF(SURFEL_BUF_SLOT, read_write, Surfel, surfel_buf[])
STORAGE_BUF(CAPTURE_BUF_SLOT, read, CaptureInfoData, capture_info_buf)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_volume_properties_data)
ADDITIONAL_INFO(eevee_global_ubo)
IMAGE(VOLUME_PROP_SCATTERING_IMG_SLOT, GPU_R11F_G11F_B10F, READ, FLOAT_3D, in_scattering_img)
IMAGE(VOLUME_PROP_EXTINCTION_IMG_SLOT, GPU_R11F_G11F_B10F, READ, FLOAT_3D, in_extinction_img)
IMAGE(VOLUME_PROP_EMISSION_IMG_SLOT, GPU_R11F_G11F_B10F, READ, FLOAT_3D, in_emission_img)
IMAGE(VOLUME_PROP_PHASE_IMG_SLOT, GPU_R16F, READ, FLOAT_3D, in_phase_img)
IMAGE(VOLUME_PROP_PHASE_WEIGHT_IMG_SLOT, GPU_R16F, READ, FLOAT_3D, in_phase_weight_img)
IMAGE(VOLUME_PROP_SCATTERING_IMG_SLOT, GPU_R11F_G11F_B10F, read, image3D, in_scattering_img)
IMAGE(VOLUME_PROP_EXTINCTION_IMG_SLOT, GPU_R11F_G11F_B10F, read, image3D, in_extinction_img)
IMAGE(VOLUME_PROP_EMISSION_IMG_SLOT, GPU_R11F_G11F_B10F, read, image3D, in_emission_img)
IMAGE(VOLUME_PROP_PHASE_IMG_SLOT, GPU_R16F, read, image3D, in_phase_img)
IMAGE(VOLUME_PROP_PHASE_WEIGHT_IMG_SLOT, GPU_R16F, read, image3D, in_phase_weight_img)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_gbuffer_data)
DEFINE("GBUFFER_LOAD")
SAMPLER(12, UINT_2D_ARRAY, gbuf_header_tx)
SAMPLER(13, FLOAT_2D_ARRAY, gbuf_closure_tx)
SAMPLER(14, FLOAT_2D_ARRAY, gbuf_normal_tx)
SAMPLER(12, usampler2DArray, gbuf_header_tx)
SAMPLER(13, sampler2DArray, gbuf_closure_tx)
SAMPLER(14, sampler2DArray, gbuf_normal_tx)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_render_pass_out)
DEFINE("MAT_RENDER_PASS_SUPPORT")
ADDITIONAL_INFO(eevee_global_ubo)
IMAGE_FREQ(RBUFS_COLOR_SLOT, GPU_RGBA16F, WRITE, FLOAT_2D_ARRAY, rp_color_img, PASS)
IMAGE_FREQ(RBUFS_VALUE_SLOT, GPU_R16F, WRITE, FLOAT_2D_ARRAY, rp_value_img, PASS)
IMAGE_FREQ(RBUFS_COLOR_SLOT, GPU_RGBA16F, write, image2DArray, rp_color_img, PASS)
IMAGE_FREQ(RBUFS_VALUE_SLOT, GPU_R16F, write, image2DArray, rp_value_img, PASS)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_cryptomatte_out)
STORAGE_BUF(CRYPTOMATTE_BUF_SLOT, READ, float2, cryptomatte_object_buf[])
IMAGE_FREQ(RBUFS_CRYPTOMATTE_SLOT, GPU_RGBA32F, WRITE, FLOAT_2D, rp_cryptomatte_img, PASS)
STORAGE_BUF(CRYPTOMATTE_BUF_SLOT, read, float2, cryptomatte_object_buf[])
IMAGE_FREQ(RBUFS_CRYPTOMATTE_SLOT, GPU_RGBA32F, write, image2D, rp_cryptomatte_img, PASS)
GPU_SHADER_CREATE_END()
/** \} */

40
source/blender/draw/engines/eevee/shaders/infos/eevee_deferred_info.hh
View File

@@ -15,13 +15,13 @@
#include "gpu_shader_create_info.hh"
#define image_out(slot, format, name) \
image(slot, format, Qualifier::WRITE, ImageType::FLOAT_2D, name, Frequency::PASS)
image(slot, format, Qualifier::write, ImageType::Float2D, name, Frequency::PASS)
#define uimage_out(slot, format, name) \
image(slot, format, Qualifier::WRITE, ImageType::UINT_2D, name, Frequency::PASS)
image(slot, format, Qualifier::write, ImageType::Uint2D, name, Frequency::PASS)
#define image_in(slot, format, name) \
image(slot, format, Qualifier::READ, ImageType::FLOAT_2D, name, Frequency::PASS)
image(slot, format, Qualifier::read, ImageType::Float2D, name, Frequency::PASS)
#define image_array_out(slot, qualifier, format, name) \
image(slot, format, qualifier, ImageType::FLOAT_2D_ARRAY, name, Frequency::PASS)
image(slot, format, qualifier, ImageType::Float2DArray, name, Frequency::PASS)
/* -------------------------------------------------------------------- */
/** \name Thickness Amend
@@ -30,8 +30,8 @@
GPU_SHADER_CREATE_INFO(eevee_deferred_thickness_amend)
DO_STATIC_COMPILATION()
DEFINE("GBUFFER_LOAD")
SAMPLER(0, UINT_2D_ARRAY, gbuf_header_tx)
IMAGE(0, GPU_RG16, READ_WRITE, FLOAT_2D_ARRAY, gbuf_normal_img)
SAMPLER(0, usampler2DArray, gbuf_header_tx)
IMAGE(0, GPU_RG16, read_write, image2DArray, gbuf_normal_img)
/* Early fragment test is needed to discard fragment that do not need this processing. */
EARLY_FRAGMENT_TEST(true)
FRAGMENT_SOURCE("eevee_deferred_thickness_amend_frag.glsl")
@@ -50,7 +50,7 @@ GPU_SHADER_CREATE_INFO(eevee_deferred_tile_classify)
FRAGMENT_SOURCE("eevee_deferred_tile_classify_frag.glsl")
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(gpu_fullscreen)
SUBPASS_IN(1, uint, UINT_2D_ARRAY, in_gbuffer_header, DEFERRED_GBUFFER_ROG_ID)
SUBPASS_IN(1, uint, Uint2DArray, in_gbuffer_header, DEFERRED_GBUFFER_ROG_ID)
TYPEDEF_SOURCE("draw_shader_shared.hh")
PUSH_CONSTANT(int, current_bit)
DO_STATIC_COMPILATION()
@@ -62,13 +62,13 @@ FRAGMENT_SOURCE("eevee_deferred_light_frag.glsl")
EARLY_FRAGMENT_TEST(true)
FRAGMENT_OUT(0, float4, out_combined)
/* Chaining to next pass. */
IMAGE_FREQ(2, DEFERRED_RADIANCE_FORMAT, WRITE, UINT_2D, direct_radiance_1_img, PASS)
IMAGE_FREQ(3, DEFERRED_RADIANCE_FORMAT, WRITE, UINT_2D, direct_radiance_2_img, PASS)
IMAGE_FREQ(4, DEFERRED_RADIANCE_FORMAT, WRITE, UINT_2D, direct_radiance_3_img, PASS)
IMAGE_FREQ(2, DEFERRED_RADIANCE_FORMAT, write, uimage2D, direct_radiance_1_img, PASS)
IMAGE_FREQ(3, DEFERRED_RADIANCE_FORMAT, write, uimage2D, direct_radiance_2_img, PASS)
IMAGE_FREQ(4, DEFERRED_RADIANCE_FORMAT, write, uimage2D, direct_radiance_3_img, PASS)
/* Optimized out if use_split_indirect is false. */
IMAGE_FREQ(5, RAYTRACE_RADIANCE_FORMAT, WRITE, FLOAT_2D, indirect_radiance_1_img, PASS)
IMAGE_FREQ(6, RAYTRACE_RADIANCE_FORMAT, WRITE, FLOAT_2D, indirect_radiance_2_img, PASS)
IMAGE_FREQ(7, RAYTRACE_RADIANCE_FORMAT, WRITE, FLOAT_2D, indirect_radiance_3_img, PASS)
IMAGE_FREQ(5, RAYTRACE_RADIANCE_FORMAT, write, image2D, indirect_radiance_1_img, PASS)
IMAGE_FREQ(6, RAYTRACE_RADIANCE_FORMAT, write, image2D, indirect_radiance_2_img, PASS)
IMAGE_FREQ(7, RAYTRACE_RADIANCE_FORMAT, write, image2D, indirect_radiance_3_img, PASS)
SPECIALIZATION_CONSTANT(bool, use_split_indirect, false)
SPECIALIZATION_CONSTANT(bool, use_lightprobe_eval, false)
SPECIALIZATION_CONSTANT(bool, use_transmission, false)
@@ -112,13 +112,13 @@ GPU_SHADER_CREATE_INFO(eevee_deferred_combine)
/* Early fragment test is needed to avoid processing fragments background fragments. */
EARLY_FRAGMENT_TEST(true)
/* Inputs. */
SAMPLER(2, UINT_2D, direct_radiance_1_tx)
SAMPLER(3, UINT_2D, direct_radiance_2_tx)
SAMPLER(4, UINT_2D, direct_radiance_3_tx)
SAMPLER(5, FLOAT_2D, indirect_radiance_1_tx)
SAMPLER(6, FLOAT_2D, indirect_radiance_2_tx)
SAMPLER(7, FLOAT_2D, indirect_radiance_3_tx)
IMAGE(5, GPU_RGBA16F, READ_WRITE, FLOAT_2D, radiance_feedback_img)
SAMPLER(2, usampler2D, direct_radiance_1_tx)
SAMPLER(3, usampler2D, direct_radiance_2_tx)
SAMPLER(4, usampler2D, direct_radiance_3_tx)
SAMPLER(5, sampler2D, indirect_radiance_1_tx)
SAMPLER(6, sampler2D, indirect_radiance_2_tx)
SAMPLER(7, sampler2D, indirect_radiance_3_tx)
IMAGE(5, GPU_RGBA16F, read_write, image2D, radiance_feedback_img)
FRAGMENT_OUT(0, float4, out_combined)
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(eevee_gbuffer_data)

124
source/blender/draw/engines/eevee/shaders/infos/eevee_depth_of_field_info.hh
View File

@@ -21,8 +21,8 @@
#include "gpu_shader_create_info.hh"
GPU_SHADER_CREATE_INFO(eevee_depth_of_field_tiles_common)
IMAGE(0, GPU_R11F_G11F_B10F, READ, FLOAT_2D, in_tiles_fg_img)
IMAGE(1, GPU_R11F_G11F_B10F, READ, FLOAT_2D, in_tiles_bg_img)
IMAGE(0, GPU_R11F_G11F_B10F, read, image2D, in_tiles_fg_img)
IMAGE(1, GPU_R11F_G11F_B10F, read, image2D, in_tiles_bg_img)
GPU_SHADER_CREATE_END()
/* -------------------------------------------------------------------- */
@@ -35,9 +35,9 @@ LOCAL_GROUP_SIZE(DOF_BOKEH_LUT_SIZE, DOF_BOKEH_LUT_SIZE)
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
UNIFORM_BUF(6, DepthOfFieldData, dof_buf)
IMAGE(0, GPU_RG16F, WRITE, FLOAT_2D, out_gather_lut_img)
IMAGE(1, GPU_R16F, WRITE, FLOAT_2D, out_scatter_lut_img)
IMAGE(2, GPU_R16F, WRITE, FLOAT_2D, out_resolve_lut_img)
IMAGE(0, GPU_RG16F, write, image2D, out_gather_lut_img)
IMAGE(1, GPU_R16F, write, image2D, out_scatter_lut_img)
IMAGE(2, GPU_R16F, write, image2D, out_resolve_lut_img)
COMPUTE_SOURCE("eevee_depth_of_field_bokeh_lut_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -47,10 +47,10 @@ LOCAL_GROUP_SIZE(DOF_DEFAULT_GROUP_SIZE, DOF_DEFAULT_GROUP_SIZE)
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
UNIFORM_BUF(6, DepthOfFieldData, dof_buf)
SAMPLER(0, FLOAT_2D, color_tx)
SAMPLER(1, DEPTH_2D, depth_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, out_color_img)
IMAGE(1, GPU_R16F, WRITE, FLOAT_2D, out_coc_img)
SAMPLER(0, sampler2D, color_tx)
SAMPLER(1, sampler2DDepth, depth_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, out_color_img)
IMAGE(1, GPU_R16F, write, image2D, out_coc_img)
COMPUTE_SOURCE("eevee_depth_of_field_setup_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -61,15 +61,15 @@ ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(eevee_velocity_camera)
UNIFORM_BUF(6, DepthOfFieldData, dof_buf)
SAMPLER(0, FLOAT_2D, coc_tx)
SAMPLER(1, FLOAT_2D, color_tx)
SAMPLER(2, FLOAT_2D, velocity_tx)
SAMPLER(3, FLOAT_2D, in_history_tx)
SAMPLER(4, DEPTH_2D, depth_tx)
SAMPLER(0, sampler2D, coc_tx)
SAMPLER(1, sampler2D, color_tx)
SAMPLER(2, sampler2D, velocity_tx)
SAMPLER(3, sampler2D, in_history_tx)
SAMPLER(4, sampler2DDepth, depth_tx)
PUSH_CONSTANT(bool, u_use_history)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, out_color_img)
IMAGE(1, GPU_R16F, WRITE, FLOAT_2D, out_coc_img)
IMAGE(2, GPU_RGBA16F, WRITE, FLOAT_2D, out_history_img)
IMAGE(0, GPU_RGBA16F, write, image2D, out_color_img)
IMAGE(1, GPU_R16F, write, image2D, out_coc_img)
IMAGE(2, GPU_RGBA16F, write, image2D, out_history_img)
COMPUTE_SOURCE("eevee_depth_of_field_stabilize_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -78,9 +78,9 @@ DO_STATIC_COMPILATION()
LOCAL_GROUP_SIZE(DOF_DEFAULT_GROUP_SIZE, DOF_DEFAULT_GROUP_SIZE)
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
SAMPLER(0, FLOAT_2D, color_tx)
SAMPLER(1, FLOAT_2D, coc_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, out_color_img)
SAMPLER(0, sampler2D, color_tx)
SAMPLER(1, sampler2D, coc_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, out_color_img)
COMPUTE_SOURCE("eevee_depth_of_field_downsample_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -90,19 +90,19 @@ LOCAL_GROUP_SIZE(DOF_REDUCE_GROUP_SIZE, DOF_REDUCE_GROUP_SIZE)
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
UNIFORM_BUF(6, DepthOfFieldData, dof_buf)
SAMPLER(0, FLOAT_2D, downsample_tx)
STORAGE_BUF(0, WRITE, ScatterRect, scatter_fg_list_buf[])
STORAGE_BUF(1, WRITE, ScatterRect, scatter_bg_list_buf[])
STORAGE_BUF(2, READ_WRITE, DrawCommand, scatter_fg_indirect_buf)
STORAGE_BUF(3, READ_WRITE, DrawCommand, scatter_bg_indirect_buf)
IMAGE(0, GPU_RGBA16F, READ_WRITE, FLOAT_2D, inout_color_lod0_img)
IMAGE(1, GPU_RGBA16F, WRITE, FLOAT_2D, out_color_lod1_img)
IMAGE(2, GPU_RGBA16F, WRITE, FLOAT_2D, out_color_lod2_img)
IMAGE(3, GPU_RGBA16F, WRITE, FLOAT_2D, out_color_lod3_img)
IMAGE(4, GPU_R16F, READ, FLOAT_2D, in_coc_lod0_img)
IMAGE(5, GPU_R16F, WRITE, FLOAT_2D, out_coc_lod1_img)
IMAGE(6, GPU_R16F, WRITE, FLOAT_2D, out_coc_lod2_img)
IMAGE(7, GPU_R16F, WRITE, FLOAT_2D, out_coc_lod3_img)
SAMPLER(0, sampler2D, downsample_tx)
STORAGE_BUF(0, write, ScatterRect, scatter_fg_list_buf[])
STORAGE_BUF(1, write, ScatterRect, scatter_bg_list_buf[])
STORAGE_BUF(2, read_write, DrawCommand, scatter_fg_indirect_buf)
STORAGE_BUF(3, read_write, DrawCommand, scatter_bg_indirect_buf)
IMAGE(0, GPU_RGBA16F, read_write, image2D, inout_color_lod0_img)
IMAGE(1, GPU_RGBA16F, write, image2D, out_color_lod1_img)
IMAGE(2, GPU_RGBA16F, write, image2D, out_color_lod2_img)
IMAGE(3, GPU_RGBA16F, write, image2D, out_color_lod3_img)
IMAGE(4, GPU_R16F, read, image2D, in_coc_lod0_img)
IMAGE(5, GPU_R16F, write, image2D, out_coc_lod1_img)
IMAGE(6, GPU_R16F, write, image2D, out_coc_lod2_img)
IMAGE(7, GPU_R16F, write, image2D, out_coc_lod3_img)
COMPUTE_SOURCE("eevee_depth_of_field_reduce_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -117,9 +117,9 @@ DO_STATIC_COMPILATION()
LOCAL_GROUP_SIZE(DOF_TILES_FLATTEN_GROUP_SIZE, DOF_TILES_FLATTEN_GROUP_SIZE)
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
SAMPLER(0, FLOAT_2D, coc_tx)
IMAGE(2, GPU_R11F_G11F_B10F, WRITE, FLOAT_2D, out_tiles_fg_img)
IMAGE(3, GPU_R11F_G11F_B10F, WRITE, FLOAT_2D, out_tiles_bg_img)
SAMPLER(0, sampler2D, coc_tx)
IMAGE(2, GPU_R11F_G11F_B10F, write, image2D, out_tiles_fg_img)
IMAGE(3, GPU_R11F_G11F_B10F, write, image2D, out_tiles_bg_img)
COMPUTE_SOURCE("eevee_depth_of_field_tiles_flatten_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -128,8 +128,8 @@ ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(eevee_depth_of_field_tiles_common)
LOCAL_GROUP_SIZE(DOF_TILES_DILATE_GROUP_SIZE, DOF_TILES_DILATE_GROUP_SIZE)
IMAGE(2, GPU_R11F_G11F_B10F, WRITE, FLOAT_2D, out_tiles_fg_img)
IMAGE(3, GPU_R11F_G11F_B10F, WRITE, FLOAT_2D, out_tiles_bg_img)
IMAGE(2, GPU_R11F_G11F_B10F, write, image2D, out_tiles_fg_img)
IMAGE(3, GPU_R11F_G11F_B10F, write, image2D, out_tiles_bg_img)
PUSH_CONSTANT(int, ring_count)
PUSH_CONSTANT(int, ring_width_multiplier)
COMPUTE_SOURCE("eevee_depth_of_field_tiles_dilate_comp.glsl")
@@ -164,7 +164,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_depth_of_field_lut)
DEFINE_VALUE("DOF_BOKEH_TEXTURE", "true")
SAMPLER(5, FLOAT_2D, bokeh_lut_tx)
SAMPLER(5, sampler2D, bokeh_lut_tx)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_depth_of_field_background)
@@ -195,15 +195,15 @@ ADDITIONAL_INFO(eevee_depth_of_field_tiles_common)
ADDITIONAL_INFO(eevee_sampling_data)
UNIFORM_BUF(6, DepthOfFieldData, dof_buf)
LOCAL_GROUP_SIZE(DOF_GATHER_GROUP_SIZE, DOF_GATHER_GROUP_SIZE)
SAMPLER(0, FLOAT_2D, color_tx)
SAMPLER(1, FLOAT_2D, color_bilinear_tx)
SAMPLER(2, FLOAT_2D, coc_tx)
IMAGE(2, GPU_RGBA16F, WRITE, FLOAT_2D, out_color_img)
IMAGE(3, GPU_R16F, WRITE, FLOAT_2D, out_weight_img)
SAMPLER(0, sampler2D, color_tx)
SAMPLER(1, sampler2D, color_bilinear_tx)
SAMPLER(2, sampler2D, coc_tx)
IMAGE(2, GPU_RGBA16F, write, image2D, out_color_img)
IMAGE(3, GPU_R16F, write, image2D, out_weight_img)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_depth_of_field_gather)
IMAGE(4, GPU_RG16F, WRITE, FLOAT_2D, out_occlusion_img)
IMAGE(4, GPU_RG16F, write, image2D, out_occlusion_img)
COMPUTE_SOURCE("eevee_depth_of_field_gather_comp.glsl")
ADDITIONAL_INFO(eevee_depth_of_field_gather_common)
GPU_SHADER_CREATE_END()
@@ -221,10 +221,10 @@ GPU_SHADER_CREATE_INFO(eevee_depth_of_field_filter)
DO_STATIC_COMPILATION()
LOCAL_GROUP_SIZE(DOF_FILTER_GROUP_SIZE, DOF_FILTER_GROUP_SIZE)
ADDITIONAL_INFO(eevee_shared)
SAMPLER(0, FLOAT_2D, color_tx)
SAMPLER(1, FLOAT_2D, weight_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, out_color_img)
IMAGE(1, GPU_R16F, WRITE, FLOAT_2D, out_weight_img)
SAMPLER(0, sampler2D, color_tx)
SAMPLER(1, sampler2D, weight_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, out_color_img)
IMAGE(1, GPU_R16F, write, image2D, out_weight_img)
COMPUTE_SOURCE("eevee_depth_of_field_filter_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -256,10 +256,10 @@ GPU_SHADER_CREATE_INFO(eevee_depth_of_field_scatter)
DO_STATIC_COMPILATION()
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
SAMPLER(0, FLOAT_2D, occlusion_tx)
SAMPLER(1, FLOAT_2D, bokeh_lut_tx)
SAMPLER(0, sampler2D, occlusion_tx)
SAMPLER(1, sampler2D, bokeh_lut_tx)
UNIFORM_BUF(6, DepthOfFieldData, dof_buf)
STORAGE_BUF(0, READ, ScatterRect, scatter_list_buf[])
STORAGE_BUF(0, read, ScatterRect, scatter_list_buf[])
FRAGMENT_OUT(0, float4, out_color)
PUSH_CONSTANT(bool, use_bokeh_lut)
VERTEX_OUT(eevee_depth_of_field_scatter_flat_iface)
@@ -283,16 +283,16 @@ ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(eevee_depth_of_field_tiles_common)
ADDITIONAL_INFO(eevee_sampling_data)
UNIFORM_BUF(6, DepthOfFieldData, dof_buf)
SAMPLER(0, DEPTH_2D, depth_tx)
SAMPLER(1, FLOAT_2D, color_tx)
SAMPLER(2, FLOAT_2D, color_bg_tx)
SAMPLER(3, FLOAT_2D, color_fg_tx)
SAMPLER(4, FLOAT_2D, color_hole_fill_tx)
SAMPLER(7, FLOAT_2D, weight_bg_tx)
SAMPLER(8, FLOAT_2D, weight_fg_tx)
SAMPLER(9, FLOAT_2D, weight_hole_fill_tx)
SAMPLER(10, FLOAT_2D, stable_color_tx)
IMAGE(2, GPU_RGBA16F, WRITE, FLOAT_2D, out_color_img)
SAMPLER(0, sampler2DDepth, depth_tx)
SAMPLER(1, sampler2D, color_tx)
SAMPLER(2, sampler2D, color_bg_tx)
SAMPLER(3, sampler2D, color_fg_tx)
SAMPLER(4, sampler2D, color_hole_fill_tx)
SAMPLER(7, sampler2D, weight_bg_tx)
SAMPLER(8, sampler2D, weight_fg_tx)
SAMPLER(9, sampler2D, weight_hole_fill_tx)
SAMPLER(10, sampler2D, stable_color_tx)
IMAGE(2, GPU_RGBA16F, write, image2D, out_color_img)
COMPUTE_SOURCE("eevee_depth_of_field_resolve_comp.glsl")
GPU_SHADER_CREATE_END()

62
source/blender/draw/engines/eevee/shaders/infos/eevee_film_info.hh
View File

@@ -17,16 +17,16 @@
#include "gpu_shader_create_info.hh"
GPU_SHADER_CREATE_INFO(eevee_film_base)
SAMPLER(0, DEPTH_2D, depth_tx)
SAMPLER(1, FLOAT_2D, combined_tx)
SAMPLER(2, FLOAT_2D, vector_tx)
SAMPLER(3, FLOAT_2D_ARRAY, rp_color_tx)
SAMPLER(4, FLOAT_2D_ARRAY, rp_value_tx)
SAMPLER(0, sampler2DDepth, depth_tx)
SAMPLER(1, sampler2D, combined_tx)
SAMPLER(2, sampler2D, vector_tx)
SAMPLER(3, sampler2DArray, rp_color_tx)
SAMPLER(4, sampler2DArray, rp_value_tx)
/* Color History for TAA needs to be sampler to leverage bilinear sampling. */
SAMPLER(5, FLOAT_2D, in_combined_tx)
SAMPLER(6, FLOAT_2D, cryptomatte_tx)
IMAGE(0, GPU_R32F, READ, FLOAT_2D_ARRAY, in_weight_img)
IMAGE(1, GPU_R32F, WRITE, FLOAT_2D_ARRAY, out_weight_img)
SAMPLER(5, sampler2D, in_combined_tx)
SAMPLER(6, sampler2D, cryptomatte_tx)
IMAGE(0, GPU_R32F, read, image2DArray, in_weight_img)
IMAGE(1, GPU_R32F, write, image2DArray, out_weight_img)
SPECIALIZATION_CONSTANT(uint, enabled_categories, 0)
SPECIALIZATION_CONSTANT(int, samples_len, 0)
SPECIALIZATION_CONSTANT(bool, use_reprojection, false)
@@ -42,12 +42,12 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_film)
/* Color History for TAA needs to be sampler to leverage bilinear sampling. */
// IMAGE(2, GPU_RGBA16F, READ, FLOAT_2D, in_combined_img)
IMAGE(3, GPU_RGBA16F, WRITE, FLOAT_2D, out_combined_img)
IMAGE(4, GPU_R32F, READ_WRITE, FLOAT_2D, depth_img)
IMAGE(5, GPU_RGBA16F, READ_WRITE, FLOAT_2D_ARRAY, color_accum_img)
IMAGE(6, GPU_R16F, READ_WRITE, FLOAT_2D_ARRAY, value_accum_img)
IMAGE(7, GPU_RGBA32F, READ_WRITE, FLOAT_2D_ARRAY, cryptomatte_img)
// IMAGE(2, GPU_RGBA16F, read, image2D, in_combined_img)
IMAGE(3, GPU_RGBA16F, write, image2D, out_combined_img)
IMAGE(4, GPU_R32F, read_write, image2D, depth_img)
IMAGE(5, GPU_RGBA16F, read_write, image2DArray, color_accum_img)
IMAGE(6, GPU_R16F, read_write, image2DArray, value_accum_img)
IMAGE(7, GPU_RGBA32F, read_write, image2DArray, cryptomatte_img)
ADDITIONAL_INFO(eevee_film_base)
GPU_SHADER_CREATE_END()
@@ -69,7 +69,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_film_cryptomatte_post)
DO_STATIC_COMPILATION()
IMAGE(0, GPU_RGBA32F, READ_WRITE, FLOAT_2D_ARRAY, cryptomatte_img)
IMAGE(0, GPU_RGBA32F, read_write, image2DArray, cryptomatte_img)
PUSH_CONSTANT(int, cryptomatte_layer_len)
PUSH_CONSTANT(int, cryptomatte_samples_per_layer)
LOCAL_GROUP_SIZE(FILM_GROUP_SIZE, FILM_GROUP_SIZE)
@@ -80,11 +80,11 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_film_copy_frag)
DO_STATIC_COMPILATION()
IMAGE(3, GPU_RGBA16F, READ, FLOAT_2D, out_combined_img)
IMAGE(4, GPU_R32F, READ, FLOAT_2D, depth_img)
IMAGE(5, GPU_RGBA16F, READ, FLOAT_2D_ARRAY, color_accum_img)
IMAGE(6, GPU_R16F, READ, FLOAT_2D_ARRAY, value_accum_img)
IMAGE(7, GPU_RGBA32F, READ, FLOAT_2D_ARRAY, cryptomatte_img)
IMAGE(3, GPU_RGBA16F, read, image2D, out_combined_img)
IMAGE(4, GPU_R32F, read, image2D, depth_img)
IMAGE(5, GPU_RGBA16F, read, image2DArray, color_accum_img)
IMAGE(6, GPU_R16F, read, image2DArray, value_accum_img)
IMAGE(7, GPU_RGBA32F, read, image2DArray, cryptomatte_img)
DEPTH_WRITE(DepthWrite::ANY)
FRAGMENT_OUT(0, float4, out_color)
FRAGMENT_SOURCE("eevee_film_copy_frag.glsl")
@@ -97,8 +97,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_film_pass_convert_combined)
LOCAL_GROUP_SIZE(FILM_GROUP_SIZE, FILM_GROUP_SIZE)
PUSH_CONSTANT(int2, offset)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("eevee_film_pass_convert_comp.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -107,8 +107,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_film_pass_convert_depth)
LOCAL_GROUP_SIZE(FILM_GROUP_SIZE, FILM_GROUP_SIZE)
PUSH_CONSTANT(int2, offset)
SAMPLER(0, FLOAT_2D, input_tx)
IMAGE(0, GPU_R32F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2D, input_tx)
IMAGE(0, GPU_R32F, write, image2D, output_img)
COMPUTE_SOURCE("eevee_film_pass_convert_comp.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -118,8 +118,8 @@ GPU_SHADER_CREATE_INFO(eevee_film_pass_convert_value)
LOCAL_GROUP_SIZE(FILM_GROUP_SIZE, FILM_GROUP_SIZE)
PUSH_CONSTANT(int2, offset)
DEFINE("IS_ARRAY_INPUT")
SAMPLER(0, FLOAT_2D_ARRAY, input_tx)
IMAGE(0, GPU_R16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2DArray, input_tx)
IMAGE(0, GPU_R16F, write, image2D, output_img)
COMPUTE_SOURCE("eevee_film_pass_convert_comp.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -129,8 +129,8 @@ GPU_SHADER_CREATE_INFO(eevee_film_pass_convert_color)
LOCAL_GROUP_SIZE(FILM_GROUP_SIZE, FILM_GROUP_SIZE)
PUSH_CONSTANT(int2, offset)
DEFINE("IS_ARRAY_INPUT")
SAMPLER(0, FLOAT_2D_ARRAY, input_tx)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2DArray, input_tx)
IMAGE(0, GPU_RGBA16F, write, image2D, output_img)
COMPUTE_SOURCE("eevee_film_pass_convert_comp.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -140,8 +140,8 @@ GPU_SHADER_CREATE_INFO(eevee_film_pass_convert_cryptomatte)
LOCAL_GROUP_SIZE(FILM_GROUP_SIZE, FILM_GROUP_SIZE)
PUSH_CONSTANT(int2, offset)
DEFINE("IS_ARRAY_INPUT")
SAMPLER(0, FLOAT_2D_ARRAY, input_tx)
IMAGE(0, GPU_RGBA32F, WRITE, FLOAT_2D, output_img)
SAMPLER(0, sampler2DArray, input_tx)
IMAGE(0, GPU_RGBA32F, write, image2D, output_img)
COMPUTE_SOURCE("eevee_film_pass_convert_comp.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

20
source/blender/draw/engines/eevee/shaders/infos/eevee_hiz_info.hh
View File

@@ -16,28 +16,28 @@
GPU_SHADER_CREATE_INFO(eevee_hiz_update_base)
LOCAL_GROUP_SIZE(FILM_GROUP_SIZE, FILM_GROUP_SIZE)
STORAGE_BUF(0, READ_WRITE, uint, finished_tile_counter)
IMAGE(0, GPU_R32F, WRITE, FLOAT_2D, out_mip_0)
IMAGE(1, GPU_R32F, WRITE, FLOAT_2D, out_mip_1)
IMAGE(2, GPU_R32F, WRITE, FLOAT_2D, out_mip_2)
IMAGE(3, GPU_R32F, WRITE, FLOAT_2D, out_mip_3)
IMAGE(4, GPU_R32F, WRITE, FLOAT_2D, out_mip_4)
IMAGE(5, GPU_R32F, READ_WRITE, FLOAT_2D, out_mip_5)
IMAGE(6, GPU_R32F, WRITE, FLOAT_2D, out_mip_6)
STORAGE_BUF(0, read_write, uint, finished_tile_counter)
IMAGE(0, GPU_R32F, write, image2D, out_mip_0)
IMAGE(1, GPU_R32F, write, image2D, out_mip_1)
IMAGE(2, GPU_R32F, write, image2D, out_mip_2)
IMAGE(3, GPU_R32F, write, image2D, out_mip_3)
IMAGE(4, GPU_R32F, write, image2D, out_mip_4)
IMAGE(5, GPU_R32F, read_write, image2D, out_mip_5)
IMAGE(6, GPU_R32F, write, image2D, out_mip_6)
SPECIALIZATION_CONSTANT(bool, update_mip_0, true)
COMPUTE_SOURCE("eevee_hiz_update_comp.glsl")
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_hiz_update)
DO_STATIC_COMPILATION()
SAMPLER(0, DEPTH_2D, depth_tx)
SAMPLER(0, sampler2DDepth, depth_tx)
ADDITIONAL_INFO(eevee_hiz_update_base)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_hiz_update_layer)
DO_STATIC_COMPILATION()
DEFINE("HIZ_LAYER")
SAMPLER(1, DEPTH_2D_ARRAY, depth_layered_tx)
SAMPLER(1, sampler2DArrayDepth, depth_layered_tx)
PUSH_CONSTANT(int, layer_id)
ADDITIONAL_INFO(eevee_hiz_update_base)
GPU_SHADER_CREATE_END()

40
source/blender/draw/engines/eevee/shaders/infos/eevee_light_culling_info.hh
View File

@@ -28,11 +28,11 @@ ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(draw_view_culling)
LOCAL_GROUP_SIZE(CULLING_SELECT_GROUP_SIZE)
STORAGE_BUF(0, READ_WRITE, LightCullingData, light_cull_buf)
STORAGE_BUF(1, READ, LightData, in_light_buf[])
STORAGE_BUF(2, WRITE, LightData, out_light_buf[])
STORAGE_BUF(3, WRITE, float, out_zdist_buf[])
STORAGE_BUF(4, WRITE, uint, out_key_buf[])
STORAGE_BUF(0, read_write, LightCullingData, light_cull_buf)
STORAGE_BUF(1, read, LightData, in_light_buf[])
STORAGE_BUF(2, write, LightData, out_light_buf[])
STORAGE_BUF(3, write, float, out_zdist_buf[])
STORAGE_BUF(4, write, uint, out_key_buf[])
UNIFORM_BUF(0, LightData, sunlight_buf)
COMPUTE_SOURCE("eevee_light_culling_select_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -41,11 +41,11 @@ GPU_SHADER_CREATE_INFO(eevee_light_culling_sort)
DO_STATIC_COMPILATION()
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
STORAGE_BUF(0, READ, LightCullingData, light_cull_buf)
STORAGE_BUF(1, READ, LightData, in_light_buf[])
STORAGE_BUF(2, WRITE, LightData, out_light_buf[])
STORAGE_BUF(3, READ, float, in_zdist_buf[])
STORAGE_BUF(4, READ, uint, in_key_buf[])
STORAGE_BUF(0, read, LightCullingData, light_cull_buf)
STORAGE_BUF(1, read, LightData, in_light_buf[])
STORAGE_BUF(2, write, LightData, out_light_buf[])
STORAGE_BUF(3, read, float, in_zdist_buf[])
STORAGE_BUF(4, read, uint, in_key_buf[])
LOCAL_GROUP_SIZE(CULLING_SORT_GROUP_SIZE)
COMPUTE_SOURCE("eevee_light_culling_sort_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -55,9 +55,9 @@ DO_STATIC_COMPILATION()
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
LOCAL_GROUP_SIZE(CULLING_ZBIN_GROUP_SIZE)
STORAGE_BUF(0, READ, LightCullingData, light_cull_buf)
STORAGE_BUF(1, READ, LightData, light_buf[])
STORAGE_BUF(2, WRITE, uint, out_zbin_buf[])
STORAGE_BUF(0, read, LightCullingData, light_cull_buf)
STORAGE_BUF(1, read, LightData, light_buf[])
STORAGE_BUF(2, write, uint, out_zbin_buf[])
COMPUTE_SOURCE("eevee_light_culling_zbin_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -67,9 +67,9 @@ ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(draw_view_culling)
LOCAL_GROUP_SIZE(CULLING_TILE_GROUP_SIZE)
STORAGE_BUF(0, READ, LightCullingData, light_cull_buf)
STORAGE_BUF(1, READ, LightData, light_buf[])
STORAGE_BUF(2, WRITE, uint, out_light_tile_buf[])
STORAGE_BUF(0, read, LightCullingData, light_cull_buf)
STORAGE_BUF(1, read, LightData, light_buf[])
STORAGE_BUF(2, write, uint, out_light_tile_buf[])
COMPUTE_SOURCE("eevee_light_culling_tile_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -79,10 +79,10 @@ ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(eevee_sampling_data)
ADDITIONAL_INFO(eevee_global_ubo)
LOCAL_GROUP_SIZE(CULLING_SELECT_GROUP_SIZE)
STORAGE_BUF(0, READ, LightCullingData, light_cull_buf)
STORAGE_BUF(1, READ_WRITE, LightData, light_buf[])
STORAGE_BUF(2, READ_WRITE, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(3, READ_WRITE, ShadowTileMapClip, tilemaps_clip_buf[])
STORAGE_BUF(0, read, LightCullingData, light_cull_buf)
STORAGE_BUF(1, read_write, LightData, light_buf[])
STORAGE_BUF(2, read_write, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(3, read_write, ShadowTileMapClip, tilemaps_clip_buf[])
COMPUTE_SOURCE("eevee_light_shadow_setup_comp.glsl")
GPU_SHADER_CREATE_END()

30
source/blender/draw/engines/eevee/shaders/infos/eevee_lightprobe_sphere_info.hh
View File

@@ -26,11 +26,11 @@ SPECIALIZATION_CONSTANT(bool, extract_sun, true)
PUSH_CONSTANT(int4, probe_coord_packed)
PUSH_CONSTANT(int4, write_coord_packed)
PUSH_CONSTANT(int4, world_coord_packed)
SAMPLER(0, FLOAT_CUBE, cubemap_tx)
SAMPLER(1, FLOAT_2D_ARRAY, atlas_tx)
STORAGE_BUF(0, WRITE, SphereProbeHarmonic, out_sh[])
STORAGE_BUF(1, WRITE, SphereProbeSunLight, out_sun[])
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D_ARRAY, atlas_img)
SAMPLER(0, samplerCube, cubemap_tx)
SAMPLER(1, sampler2DArray, atlas_tx)
STORAGE_BUF(0, write, SphereProbeHarmonic, out_sh[])
STORAGE_BUF(1, write, SphereProbeSunLight, out_sun[])
IMAGE(0, GPU_RGBA16F, write, image2DArray, atlas_img)
COMPUTE_SOURCE("eevee_lightprobe_sphere_remap_comp.glsl")
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(eevee_global_ubo)
@@ -40,8 +40,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_lightprobe_sphere_irradiance)
LOCAL_GROUP_SIZE(SPHERE_PROBE_SH_GROUP_SIZE)
PUSH_CONSTANT(int3, probe_remap_dispatch_size)
STORAGE_BUF(0, READ, SphereProbeHarmonic, in_sh[])
STORAGE_BUF(1, WRITE, SphereProbeHarmonic, out_sh)
STORAGE_BUF(0, read, SphereProbeHarmonic, in_sh[])
STORAGE_BUF(1, write, SphereProbeHarmonic, out_sh)
ADDITIONAL_INFO(eevee_shared)
DO_STATIC_COMPILATION()
COMPUTE_SOURCE("eevee_lightprobe_sphere_irradiance_comp.glsl")
@@ -50,8 +50,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_lightprobe_sphere_sunlight)
LOCAL_GROUP_SIZE(SPHERE_PROBE_SH_GROUP_SIZE)
PUSH_CONSTANT(int3, probe_remap_dispatch_size)
STORAGE_BUF(0, READ, SphereProbeSunLight, in_sun[])
STORAGE_BUF(1, WRITE, LightData, sunlight_buf)
STORAGE_BUF(0, read, SphereProbeSunLight, in_sun[])
STORAGE_BUF(1, write, LightData, sunlight_buf)
ADDITIONAL_INFO(eevee_shared)
DO_STATIC_COMPILATION()
COMPUTE_SOURCE("eevee_lightprobe_sphere_sunlight_comp.glsl")
@@ -59,7 +59,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_lightprobe_sphere_select)
LOCAL_GROUP_SIZE(SPHERE_PROBE_SELECT_GROUP_SIZE)
STORAGE_BUF(0, READ_WRITE, SphereProbeData, lightprobe_sphere_buf[SPHERE_PROBE_MAX])
STORAGE_BUF(0, read_write, SphereProbeData, lightprobe_sphere_buf[SPHERE_PROBE_MAX])
PUSH_CONSTANT(int, lightprobe_sphere_count)
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(eevee_sampling_data)
@@ -76,9 +76,9 @@ PUSH_CONSTANT(int4, probe_coord_packed)
PUSH_CONSTANT(int4, write_coord_packed)
PUSH_CONSTANT(int4, read_coord_packed)
PUSH_CONSTANT(int, read_lod)
SAMPLER(0, FLOAT_CUBE, cubemap_tx)
SAMPLER(1, FLOAT_2D_ARRAY, in_atlas_mip_tx)
IMAGE(1, GPU_RGBA16F, WRITE, FLOAT_2D_ARRAY, out_atlas_mip_img)
SAMPLER(0, samplerCube, cubemap_tx)
SAMPLER(1, sampler2DArray, in_atlas_mip_tx)
IMAGE(1, GPU_RGBA16F, write, image2DArray, out_atlas_mip_img)
COMPUTE_SOURCE("eevee_lightprobe_sphere_convolve_comp.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -93,7 +93,7 @@ GPU_SHADER_CREATE_INFO(eevee_display_lightprobe_sphere)
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(eevee_lightprobe_sphere_data)
STORAGE_BUF(0, READ, SphereProbeDisplayData, display_data_buf[])
STORAGE_BUF(0, read, SphereProbeDisplayData, display_data_buf[])
VERTEX_SOURCE("eevee_display_lightprobe_sphere_vert.glsl")
VERTEX_OUT(eevee_display_lightprobe_sphere_iface)
FRAGMENT_SOURCE("eevee_display_lightprobe_sphere_frag.glsl")
@@ -112,7 +112,7 @@ ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(eevee_lightprobe_planar_data)
ADDITIONAL_INFO(eevee_lightprobe_sphere_data)
STORAGE_BUF(0, READ, PlanarProbeDisplayData, display_data_buf[])
STORAGE_BUF(0, read, PlanarProbeDisplayData, display_data_buf[])
VERTEX_SOURCE("eevee_display_lightprobe_planar_vert.glsl")
VERTEX_OUT(eevee_display_lightprobe_planar_iface)
FRAGMENT_SOURCE("eevee_display_lightprobe_planar_frag.glsl")

82
source/blender/draw/engines/eevee/shaders/infos/eevee_lightprobe_volume_info.hh
View File

@@ -33,7 +33,7 @@ VERTEX_SOURCE("eevee_debug_surfels_vert.glsl")
VERTEX_OUT(eevee_debug_surfel_iface)
FRAGMENT_SOURCE("eevee_debug_surfels_frag.glsl")
FRAGMENT_OUT(0, float4, out_color)
STORAGE_BUF(0, READ, Surfel, surfels_buf[])
STORAGE_BUF(0, read, Surfel, surfels_buf[])
PUSH_CONSTANT(float, debug_surfel_radius)
PUSH_CONSTANT(int, debug_mode)
DO_STATIC_COMPILATION()
@@ -48,7 +48,7 @@ ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
FRAGMENT_OUT(0, float4, out_color)
VERTEX_OUT(eevee_debug_irradiance_grid_iface)
SAMPLER(0, FLOAT_3D, debug_data_tx)
SAMPLER(0, sampler3D, debug_data_tx)
PUSH_CONSTANT(float4x4, grid_mat)
PUSH_CONSTANT(int, debug_mode)
PUSH_CONSTANT(float, debug_value)
@@ -74,11 +74,11 @@ PUSH_CONSTANT(int3, grid_resolution)
PUSH_CONSTANT(float4x4, grid_to_world)
PUSH_CONSTANT(float4x4, world_to_grid)
PUSH_CONSTANT(bool, display_validity)
SAMPLER(0, FLOAT_3D, irradiance_a_tx)
SAMPLER(1, FLOAT_3D, irradiance_b_tx)
SAMPLER(2, FLOAT_3D, irradiance_c_tx)
SAMPLER(3, FLOAT_3D, irradiance_d_tx)
SAMPLER(4, FLOAT_3D, validity_tx)
SAMPLER(0, sampler3D, irradiance_a_tx)
SAMPLER(1, sampler3D, irradiance_b_tx)
SAMPLER(2, sampler3D, irradiance_c_tx)
SAMPLER(3, sampler3D, irradiance_d_tx)
SAMPLER(4, sampler3D, validity_tx)
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -109,7 +109,7 @@ BUILTINS(BuiltinBits::TEXTURE_ATOMIC)
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(eevee_surfel_common)
ADDITIONAL_INFO(draw_view)
IMAGE(0, GPU_R32I, READ_WRITE, INT_3D_ATOMIC, cluster_list_img)
IMAGE(0, GPU_R32I, read_write, iimage3DAtomic, cluster_list_img)
COMPUTE_SOURCE("eevee_surfel_cluster_build_comp.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -120,8 +120,8 @@ BUILTINS(BuiltinBits::TEXTURE_ATOMIC)
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(eevee_surfel_common)
ADDITIONAL_INFO(draw_view)
STORAGE_BUF(0, READ_WRITE, int, list_start_buf[])
STORAGE_BUF(6, READ_WRITE, SurfelListInfoData, list_info_buf)
STORAGE_BUF(0, read_write, int, list_start_buf[])
STORAGE_BUF(6, read_write, SurfelListInfoData, list_info_buf)
COMPUTE_SOURCE("eevee_surfel_list_build_comp.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -131,8 +131,8 @@ LOCAL_GROUP_SIZE(SURFEL_LIST_GROUP_SIZE)
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(eevee_surfel_common)
ADDITIONAL_INFO(draw_view)
STORAGE_BUF(0, READ_WRITE, int, list_start_buf[])
STORAGE_BUF(6, READ, SurfelListInfoData, list_info_buf)
STORAGE_BUF(0, read_write, int, list_start_buf[])
STORAGE_BUF(6, read, SurfelListInfoData, list_info_buf)
COMPUTE_SOURCE("eevee_surfel_list_sort_comp.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -152,8 +152,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_lightprobe_volume_bounds)
DO_STATIC_COMPILATION()
LOCAL_GROUP_SIZE(IRRADIANCE_BOUNDS_GROUP_SIZE)
STORAGE_BUF(0, READ_WRITE, CaptureInfoData, capture_info_buf)
STORAGE_BUF(1, READ, ObjectBounds, bounds_buf[])
STORAGE_BUF(0, read_write, CaptureInfoData, capture_info_buf)
STORAGE_BUF(1, read, ObjectBounds, bounds_buf[])
PUSH_CONSTANT(int, resource_len)
TYPEDEF_SOURCE("draw_shader_shared.hh")
ADDITIONAL_INFO(eevee_shared)
@@ -169,14 +169,14 @@ ADDITIONAL_INFO(eevee_surfel_common)
ADDITIONAL_INFO(eevee_lightprobe_sphere_data)
ADDITIONAL_INFO(draw_view)
PUSH_CONSTANT(int, radiance_src)
STORAGE_BUF(0, READ, int, list_start_buf[])
STORAGE_BUF(6, READ, SurfelListInfoData, list_info_buf)
IMAGE(0, GPU_RGBA32F, READ_WRITE, FLOAT_3D, irradiance_L0_img)
IMAGE(1, GPU_RGBA32F, READ_WRITE, FLOAT_3D, irradiance_L1_a_img)
IMAGE(2, GPU_RGBA32F, READ_WRITE, FLOAT_3D, irradiance_L1_b_img)
IMAGE(3, GPU_RGBA32F, READ_WRITE, FLOAT_3D, irradiance_L1_c_img)
IMAGE(4, GPU_RGBA16F, READ, FLOAT_3D, virtual_offset_img)
IMAGE(5, GPU_R32F, READ_WRITE, FLOAT_3D, validity_img)
STORAGE_BUF(0, read, int, list_start_buf[])
STORAGE_BUF(6, read, SurfelListInfoData, list_info_buf)
IMAGE(0, GPU_RGBA32F, read_write, image3D, irradiance_L0_img)
IMAGE(1, GPU_RGBA32F, read_write, image3D, irradiance_L1_a_img)
IMAGE(2, GPU_RGBA32F, read_write, image3D, irradiance_L1_b_img)
IMAGE(3, GPU_RGBA32F, read_write, image3D, irradiance_L1_c_img)
IMAGE(4, GPU_RGBA16F, read, image3D, virtual_offset_img)
IMAGE(5, GPU_R32F, read_write, image3D, validity_img)
COMPUTE_SOURCE("eevee_lightprobe_volume_ray_comp.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -188,10 +188,10 @@ LOCAL_GROUP_SIZE(IRRADIANCE_GRID_GROUP_SIZE,
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(eevee_surfel_common)
ADDITIONAL_INFO(draw_view)
STORAGE_BUF(0, READ, int, list_start_buf[])
STORAGE_BUF(6, READ, SurfelListInfoData, list_info_buf)
IMAGE(0, GPU_R32I, READ, INT_3D_ATOMIC, cluster_list_img)
IMAGE(1, GPU_RGBA16F, READ_WRITE, FLOAT_3D, virtual_offset_img)
STORAGE_BUF(0, read, int, list_start_buf[])
STORAGE_BUF(6, read, SurfelListInfoData, list_info_buf)
IMAGE(0, GPU_R32I, read, iimage3DAtomic, cluster_list_img)
IMAGE(1, GPU_RGBA16F, read_write, image3D, virtual_offset_img)
COMPUTE_SOURCE("eevee_lightprobe_volume_offset_comp.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -210,10 +210,10 @@ DEFINE("IRRADIANCE_GRID_UPLOAD")
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(eevee_global_ubo)
PUSH_CONSTANT(int, grid_index)
STORAGE_BUF(0, READ, uint, bricks_infos_buf[])
STORAGE_BUF(1, READ, SphereProbeHarmonic, harmonic_buf)
STORAGE_BUF(0, read, uint, bricks_infos_buf[])
STORAGE_BUF(1, read, SphereProbeHarmonic, harmonic_buf)
UNIFORM_BUF(0, VolumeProbeData, grids_infos_buf[IRRADIANCE_GRID_MAX])
IMAGE(0, VOLUME_PROBE_FORMAT, WRITE, FLOAT_3D, irradiance_atlas_img)
IMAGE(0, VOLUME_PROBE_FORMAT, write, image3D, irradiance_atlas_img)
COMPUTE_SOURCE("eevee_lightprobe_volume_world_comp.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -233,18 +233,18 @@ PUSH_CONSTANT(float, dilation_threshold)
PUSH_CONSTANT(float, dilation_radius)
PUSH_CONSTANT(float, grid_intensity_factor)
UNIFORM_BUF(0, VolumeProbeData, grids_infos_buf[IRRADIANCE_GRID_MAX])
STORAGE_BUF(0, READ, uint, bricks_infos_buf[])
SAMPLER(0, FLOAT_3D, irradiance_a_tx)
SAMPLER(1, FLOAT_3D, irradiance_b_tx)
SAMPLER(2, FLOAT_3D, irradiance_c_tx)
SAMPLER(3, FLOAT_3D, irradiance_d_tx)
SAMPLER(4, FLOAT_3D, visibility_a_tx)
SAMPLER(5, FLOAT_3D, visibility_b_tx)
SAMPLER(6, FLOAT_3D, visibility_c_tx)
SAMPLER(7, FLOAT_3D, visibility_d_tx)
SAMPLER(8, FLOAT_3D, irradiance_atlas_tx)
SAMPLER(9, FLOAT_3D, validity_tx)
IMAGE(0, VOLUME_PROBE_FORMAT, WRITE, FLOAT_3D, irradiance_atlas_img)
STORAGE_BUF(0, read, uint, bricks_infos_buf[])
SAMPLER(0, sampler3D, irradiance_a_tx)
SAMPLER(1, sampler3D, irradiance_b_tx)
SAMPLER(2, sampler3D, irradiance_c_tx)
SAMPLER(3, sampler3D, irradiance_d_tx)
SAMPLER(4, sampler3D, visibility_a_tx)
SAMPLER(5, sampler3D, visibility_b_tx)
SAMPLER(6, sampler3D, visibility_c_tx)
SAMPLER(7, sampler3D, visibility_d_tx)
SAMPLER(8, sampler3D, irradiance_atlas_tx)
SAMPLER(9, sampler3D, validity_tx)
IMAGE(0, VOLUME_PROBE_FORMAT, write, image3D, irradiance_atlas_img)
COMPUTE_SOURCE("eevee_lightprobe_volume_load_comp.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

4
source/blender/draw/engines/eevee/shaders/infos/eevee_lookdev_info.hh
View File

@@ -25,8 +25,8 @@ VERTEX_OUT(eevee_lookdev_display_iface)
PUSH_CONSTANT(float2, viewportSize)
PUSH_CONSTANT(float2, invertedViewportSize)
PUSH_CONSTANT(int2, anchor)
SAMPLER(0, FLOAT_2D, metallic_tx)
SAMPLER(1, FLOAT_2D, diffuse_tx)
SAMPLER(0, sampler2D, metallic_tx)
SAMPLER(1, sampler2D, diffuse_tx)
FRAGMENT_OUT(0, float4, out_color)
FRAGMENT_SOURCE("eevee_lookdev_display_frag.glsl")
DEPTH_WRITE(DepthWrite::ANY)

2
source/blender/draw/engines/eevee/shaders/infos/eevee_lut_info.hh
View File

@@ -16,7 +16,7 @@ GPU_SHADER_CREATE_INFO(eevee_lut)
LOCAL_GROUP_SIZE(LUT_WORKGROUP_SIZE, LUT_WORKGROUP_SIZE, 1)
PUSH_CONSTANT(int, table_type)
PUSH_CONSTANT(int3, table_extent)
IMAGE(0, GPU_RGBA32F, READ_WRITE, FLOAT_3D, table_img)
IMAGE(0, GPU_RGBA32F, read_write, image3D, table_img)
ADDITIONAL_INFO(eevee_shared)
COMPUTE_SOURCE("eevee_lut_comp.glsl")
DO_STATIC_COMPILATION()

40
source/blender/draw/engines/eevee/shaders/infos/eevee_material_info.hh
View File

@@ -148,9 +148,9 @@ GPU_SHADER_CREATE_END()
* \{ */
#define image_out(slot, qualifier, format, name) \
image(slot, format, qualifier, ImageType::FLOAT_2D, name, Frequency::PASS)
image(slot, format, qualifier, ImageType::Float2D, name, Frequency::PASS)
#define image_array_out(slot, qualifier, format, name) \
image(slot, format, qualifier, ImageType::FLOAT_2D_ARRAY, name, Frequency::PASS)
image(slot, format, qualifier, ImageType::Float2DArray, name, Frequency::PASS)
GPU_SHADER_CREATE_INFO(eevee_surf_deferred_base)
DEFINE("MAT_DEFERRED")
@@ -165,10 +165,10 @@ FRAGMENT_OUT(3, float4, out_gbuf_closure1)
FRAGMENT_OUT(4, float4, out_gbuf_closure2)
/* Everything is stored inside a two layered target, one for each format. This is to fit the
* limitation of the number of images we can bind on a single shader. */
IMAGE_FREQ(GBUF_CLOSURE_SLOT, GPU_RGB10_A2, WRITE, FLOAT_2D_ARRAY, out_gbuf_closure_img, PASS)
IMAGE_FREQ(GBUF_NORMAL_SLOT, GPU_RG16, WRITE, FLOAT_2D_ARRAY, out_gbuf_normal_img, PASS)
IMAGE_FREQ(GBUF_CLOSURE_SLOT, GPU_RGB10_A2, write, image2DArray, out_gbuf_closure_img, PASS)
IMAGE_FREQ(GBUF_NORMAL_SLOT, GPU_RG16, write, image2DArray, out_gbuf_normal_img, PASS)
/* Storage for additional infos that are shared across closures. */
IMAGE_FREQ(GBUF_HEADER_SLOT, GPU_R32UI, WRITE, UINT_2D_ARRAY, out_gbuf_header_img, PASS)
IMAGE_FREQ(GBUF_HEADER_SLOT, GPU_R32UI, write, uimage2DArray, out_gbuf_header_img, PASS)
/* Added at runtime because of test shaders not having `node_tree`. */
// ADDITIONAL_INFO(eevee_render_pass_out)
// ADDITIONAL_INFO(eevee_cryptomatte_out)
@@ -214,8 +214,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_surf_capture)
DEFINE("MAT_CAPTURE")
STORAGE_BUF(SURFEL_BUF_SLOT, WRITE, Surfel, surfel_buf[])
STORAGE_BUF(CAPTURE_BUF_SLOT, READ_WRITE, CaptureInfoData, capture_info_buf)
STORAGE_BUF(SURFEL_BUF_SLOT, write, Surfel, surfel_buf[])
STORAGE_BUF(CAPTURE_BUF_SLOT, read_write, CaptureInfoData, capture_info_buf)
PUSH_CONSTANT(bool, is_double_sided)
FRAGMENT_SOURCE("eevee_surf_capture_frag.glsl")
ADDITIONAL_INFO(eevee_global_ubo)
@@ -272,7 +272,7 @@ DEFINE_VALUE("DRW_VIEW_LEN", STRINGIFY(SHADOW_VIEW_MAX))
DEFINE("MAT_SHADOW")
BUILTINS(BuiltinBits::VIEWPORT_INDEX)
VERTEX_OUT(eevee_surf_shadow_clipping_iface)
STORAGE_BUF(SHADOW_RENDER_VIEW_BUF_SLOT, READ, ShadowRenderView, render_view_buf[SHADOW_VIEW_MAX])
STORAGE_BUF(SHADOW_RENDER_VIEW_BUF_SLOT, read, ShadowRenderView, render_view_buf[SHADOW_VIEW_MAX])
FRAGMENT_SOURCE("eevee_surf_shadow_frag.glsl")
ADDITIONAL_INFO(eevee_global_ubo)
ADDITIONAL_INFO(eevee_utility_texture)
@@ -284,8 +284,8 @@ ADDITIONAL_INFO(eevee_surf_shadow)
DEFINE("SHADOW_UPDATE_ATOMIC_RASTER")
BUILTINS(BuiltinBits::TEXTURE_ATOMIC)
VERTEX_OUT(eevee_surf_shadow_atomic_iface)
STORAGE_BUF(SHADOW_RENDER_MAP_BUF_SLOT, READ, uint, render_map_buf[SHADOW_RENDER_MAP_SIZE])
IMAGE(SHADOW_ATLAS_IMG_SLOT, GPU_R32UI, READ_WRITE, UINT_2D_ARRAY_ATOMIC, shadow_atlas_img)
STORAGE_BUF(SHADOW_RENDER_MAP_BUF_SLOT, read, uint, render_map_buf[SHADOW_RENDER_MAP_SIZE])
IMAGE(SHADOW_ATLAS_IMG_SLOT, GPU_R32UI, read_write, uimage2DArrayAtomic, shadow_atlas_img)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_surf_shadow_tbdr)
@@ -312,14 +312,12 @@ GPU_SHADER_CREATE_INFO(eevee_surf_volume)
DEFINE("MAT_VOLUME")
/* Only the front fragments have to be invoked. */
EARLY_FRAGMENT_TEST(true)
IMAGE(
VOLUME_PROP_SCATTERING_IMG_SLOT, GPU_R11F_G11F_B10F, READ_WRITE, FLOAT_3D, out_scattering_img)
IMAGE(
VOLUME_PROP_EXTINCTION_IMG_SLOT, GPU_R11F_G11F_B10F, READ_WRITE, FLOAT_3D, out_extinction_img)
IMAGE(VOLUME_PROP_EMISSION_IMG_SLOT, GPU_R11F_G11F_B10F, READ_WRITE, FLOAT_3D, out_emissive_img)
IMAGE(VOLUME_PROP_PHASE_IMG_SLOT, GPU_R16F, READ_WRITE, FLOAT_3D, out_phase_img)
IMAGE(VOLUME_PROP_PHASE_WEIGHT_IMG_SLOT, GPU_R16F, READ_WRITE, FLOAT_3D, out_phase_weight_img)
IMAGE(VOLUME_OCCUPANCY_SLOT, GPU_R32UI, READ, UINT_3D_ATOMIC, occupancy_img)
IMAGE(VOLUME_PROP_SCATTERING_IMG_SLOT, GPU_R11F_G11F_B10F, read_write, image3D, out_scattering_img)
IMAGE(VOLUME_PROP_EXTINCTION_IMG_SLOT, GPU_R11F_G11F_B10F, read_write, image3D, out_extinction_img)
IMAGE(VOLUME_PROP_EMISSION_IMG_SLOT, GPU_R11F_G11F_B10F, read_write, image3D, out_emissive_img)
IMAGE(VOLUME_PROP_PHASE_IMG_SLOT, GPU_R16F, read_write, image3D, out_phase_img)
IMAGE(VOLUME_PROP_PHASE_WEIGHT_IMG_SLOT, GPU_R16F, read_write, image3D, out_phase_weight_img)
IMAGE(VOLUME_OCCUPANCY_SLOT, GPU_R32UI, read, uimage3DAtomic, occupancy_img)
FRAGMENT_SOURCE("eevee_surf_volume_frag.glsl")
ADDITIONAL_INFO(draw_modelmat_common)
ADDITIONAL_INFO(draw_view)
@@ -335,9 +333,9 @@ DEFINE("MAT_OCCUPANCY")
EARLY_FRAGMENT_TEST(false)
BUILTINS(BuiltinBits::TEXTURE_ATOMIC)
PUSH_CONSTANT(bool, use_fast_method)
IMAGE(VOLUME_HIT_DEPTH_SLOT, GPU_R32F, WRITE, FLOAT_3D, hit_depth_img)
IMAGE(VOLUME_HIT_COUNT_SLOT, GPU_R32UI, READ_WRITE, UINT_2D_ATOMIC, hit_count_img)
IMAGE(VOLUME_OCCUPANCY_SLOT, GPU_R32UI, READ_WRITE, UINT_3D_ATOMIC, occupancy_img)
IMAGE(VOLUME_HIT_DEPTH_SLOT, GPU_R32F, write, image3D, hit_depth_img)
IMAGE(VOLUME_HIT_COUNT_SLOT, GPU_R32UI, read_write, uimage2DAtomic, hit_count_img)
IMAGE(VOLUME_OCCUPANCY_SLOT, GPU_R32UI, read_write, uimage3DAtomic, occupancy_img)
FRAGMENT_SOURCE("eevee_surf_occupancy_frag.glsl")
ADDITIONAL_INFO(eevee_global_ubo)
ADDITIONAL_INFO(eevee_sampling_data)

24
source/blender/draw/engines/eevee/shaders/infos/eevee_motion_blur_info.hh
View File

@@ -20,21 +20,21 @@ ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(eevee_velocity_camera)
UNIFORM_BUF(6, MotionBlurData, motion_blur_buf)
SAMPLER(0, DEPTH_2D, depth_tx)
IMAGE(1, GPU_RGBA16F, WRITE, FLOAT_2D, out_tiles_img)
SAMPLER(0, sampler2DDepth, depth_tx)
IMAGE(1, GPU_RGBA16F, write, image2D, out_tiles_img)
COMPUTE_SOURCE("eevee_motion_blur_flatten_comp.glsl")
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_motion_blur_tiles_flatten_rg)
DO_STATIC_COMPILATION()
DEFINE("FLATTEN_RG")
IMAGE(0, GPU_RG16F, READ_WRITE, FLOAT_2D, velocity_img)
IMAGE(0, GPU_RG16F, read_write, image2D, velocity_img)
ADDITIONAL_INFO(eevee_motion_blur_tiles_flatten)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_motion_blur_tiles_flatten_rgba)
DO_STATIC_COMPILATION()
IMAGE(0, GPU_RGBA16F, READ_WRITE, FLOAT_2D, velocity_img)
IMAGE(0, GPU_RGBA16F, read_write, image2D, velocity_img)
ADDITIONAL_INFO(eevee_motion_blur_tiles_flatten)
GPU_SHADER_CREATE_END()
@@ -43,8 +43,8 @@ DO_STATIC_COMPILATION()
LOCAL_GROUP_SIZE(MOTION_BLUR_GROUP_SIZE, MOTION_BLUR_GROUP_SIZE)
ADDITIONAL_INFO(eevee_shared)
/* NOTE: See MotionBlurTileIndirection. */
STORAGE_BUF(0, READ_WRITE, uint, tile_indirection_buf[])
IMAGE(1, GPU_RGBA16F, READ, FLOAT_2D, in_tiles_img)
STORAGE_BUF(0, read_write, uint, tile_indirection_buf[])
IMAGE(1, GPU_RGBA16F, read, image2D, in_tiles_img)
COMPUTE_SOURCE("eevee_motion_blur_dilate_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -55,12 +55,12 @@ ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(eevee_sampling_data)
UNIFORM_BUF(6, MotionBlurData, motion_blur_buf)
SAMPLER(0, DEPTH_2D, depth_tx)
SAMPLER(1, FLOAT_2D, velocity_tx)
SAMPLER(2, FLOAT_2D, in_color_tx)
SAMPLER(0, sampler2DDepth, depth_tx)
SAMPLER(1, sampler2D, velocity_tx)
SAMPLER(2, sampler2D, in_color_tx)
/* NOTE: See MotionBlurTileIndirection. */
STORAGE_BUF(0, READ, uint, tile_indirection_buf[])
IMAGE(0, GPU_RGBA16F, READ, FLOAT_2D, in_tiles_img)
IMAGE(1, GPU_RGBA16F, WRITE, FLOAT_2D, out_color_img)
STORAGE_BUF(0, read, uint, tile_indirection_buf[])
IMAGE(0, GPU_RGBA16F, read, image2D, in_tiles_img)
IMAGE(1, GPU_RGBA16F, write, image2D, out_color_img)
COMPUTE_SOURCE("eevee_motion_blur_gather_comp.glsl")
GPU_SHADER_CREATE_END()

154
source/blender/draw/engines/eevee/shaders/infos/eevee_shadow_info.hh
View File

@@ -27,7 +27,7 @@
GPU_SHADER_CREATE_INFO(eevee_shadow_clipmap_clear)
DO_STATIC_COMPILATION()
LOCAL_GROUP_SIZE(SHADOW_CLIPMAP_GROUP_SIZE)
STORAGE_BUF(0, WRITE, ShadowTileMapClip, tilemaps_clip_buf[])
STORAGE_BUF(0, write, ShadowTileMapClip, tilemaps_clip_buf[])
PUSH_CONSTANT(int, tilemaps_clip_buf_len)
ADDITIONAL_INFO(eevee_shared)
COMPUTE_SOURCE("eevee_shadow_clipmap_clear_comp.glsl")
@@ -36,12 +36,12 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_shadow_tilemap_bounds)
DO_STATIC_COMPILATION()
LOCAL_GROUP_SIZE(SHADOW_BOUNDS_GROUP_SIZE)
STORAGE_BUF(LIGHT_BUF_SLOT, READ_WRITE, LightData, light_buf[])
STORAGE_BUF(LIGHT_CULL_BUF_SLOT, READ, LightCullingData, light_cull_buf)
STORAGE_BUF(4, READ, uint, casters_id_buf[])
STORAGE_BUF(5, READ_WRITE, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(6, READ, ObjectBounds, bounds_buf[])
STORAGE_BUF(7, READ_WRITE, ShadowTileMapClip, tilemaps_clip_buf[])
STORAGE_BUF(LIGHT_BUF_SLOT, read_write, LightData, light_buf[])
STORAGE_BUF(LIGHT_CULL_BUF_SLOT, read, LightCullingData, light_cull_buf)
STORAGE_BUF(4, read, uint, casters_id_buf[])
STORAGE_BUF(5, read_write, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(6, read, ObjectBounds, bounds_buf[])
STORAGE_BUF(7, read_write, ShadowTileMapClip, tilemaps_clip_buf[])
PUSH_CONSTANT(int, resource_len)
TYPEDEF_SOURCE("draw_shader_shared.hh")
ADDITIONAL_INFO(eevee_shared)
@@ -51,10 +51,10 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_shadow_tilemap_init)
DO_STATIC_COMPILATION()
LOCAL_GROUP_SIZE(SHADOW_TILEMAP_RES, SHADOW_TILEMAP_RES)
STORAGE_BUF(0, READ_WRITE, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(1, READ_WRITE, uint, tiles_buf[])
STORAGE_BUF(2, READ_WRITE, ShadowTileMapClip, tilemaps_clip_buf[])
STORAGE_BUF(4, READ_WRITE, uint2, pages_cached_buf[])
STORAGE_BUF(0, read_write, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(1, read_write, uint, tiles_buf[])
STORAGE_BUF(2, read_write, ShadowTileMapClip, tilemaps_clip_buf[])
STORAGE_BUF(4, read_write, uint2, pages_cached_buf[])
ADDITIONAL_INFO(eevee_shared)
COMPUTE_SOURCE("eevee_shadow_tilemap_init_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -62,10 +62,10 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_shadow_tag_update)
DO_STATIC_COMPILATION()
LOCAL_GROUP_SIZE(1, 1, 1)
STORAGE_BUF(0, READ_WRITE, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(1, READ_WRITE, uint, tiles_buf[])
STORAGE_BUF(5, READ, ObjectBounds, bounds_buf[])
STORAGE_BUF(6, READ, uint, resource_ids_buf[])
STORAGE_BUF(0, read_write, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(1, read_write, uint, tiles_buf[])
STORAGE_BUF(5, read, ObjectBounds, bounds_buf[])
STORAGE_BUF(6, read, uint, resource_ids_buf[])
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(draw_view_culling)
@@ -75,8 +75,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_shadow_tag_usage_opaque)
DO_STATIC_COMPILATION()
LOCAL_GROUP_SIZE(SHADOW_DEPTH_SCAN_GROUP_SIZE, SHADOW_DEPTH_SCAN_GROUP_SIZE)
STORAGE_BUF(5, READ_WRITE, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(6, READ_WRITE, uint, tiles_buf[])
STORAGE_BUF(5, read_write, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(6, read_write, uint, tiles_buf[])
PUSH_CONSTANT(int2, input_depth_extent)
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
@@ -89,8 +89,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_shadow_tag_usage_surfels)
DO_STATIC_COMPILATION()
LOCAL_GROUP_SIZE(SURFEL_GROUP_SIZE)
STORAGE_BUF(6, READ_WRITE, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(7, READ_WRITE, uint, tiles_buf[])
STORAGE_BUF(6, read_write, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(7, read_write, uint, tiles_buf[])
PUSH_CONSTANT(int, directional_level)
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
@@ -113,9 +113,9 @@ GPU_SHADER_NAMED_INTERFACE_END(interp_flat)
GPU_SHADER_CREATE_INFO(eevee_shadow_tag_usage_transparent)
DO_STATIC_COMPILATION()
VERTEX_IN(0, float3, pos)
STORAGE_BUF(4, READ, ObjectBounds, bounds_buf[])
STORAGE_BUF(5, READ_WRITE, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(6, READ_WRITE, uint, tiles_buf[])
STORAGE_BUF(4, read, ObjectBounds, bounds_buf[])
STORAGE_BUF(5, read_write, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(6, read_write, uint, tiles_buf[])
PUSH_CONSTANT(int2, fb_resolution)
PUSH_CONSTANT(int, fb_lod)
VERTEX_OUT(eevee_shadow_tag_transparent_iface)
@@ -134,8 +134,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_shadow_tag_usage_volume)
DO_STATIC_COMPILATION()
LOCAL_GROUP_SIZE(VOLUME_GROUP_SIZE, VOLUME_GROUP_SIZE, VOLUME_GROUP_SIZE)
STORAGE_BUF(4, READ_WRITE, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(5, READ_WRITE, uint, tiles_buf[])
STORAGE_BUF(4, read_write, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(5, read_write, uint, tiles_buf[])
ADDITIONAL_INFO(eevee_volume_properties_data)
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
@@ -150,8 +150,8 @@ GPU_SHADER_CREATE_INFO(eevee_shadow_page_mask)
DO_STATIC_COMPILATION()
LOCAL_GROUP_SIZE(SHADOW_TILEMAP_RES, SHADOW_TILEMAP_RES)
PUSH_CONSTANT(int, max_view_per_tilemap)
STORAGE_BUF(0, READ_WRITE, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(1, READ_WRITE, uint, tiles_buf[])
STORAGE_BUF(0, read_write, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(1, read_write, uint, tiles_buf[])
ADDITIONAL_INFO(eevee_shared)
COMPUTE_SOURCE("eevee_shadow_page_mask_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -159,11 +159,11 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_shadow_page_free)
DO_STATIC_COMPILATION()
LOCAL_GROUP_SIZE(SHADOW_TILEMAP_LOD0_LEN)
STORAGE_BUF(0, READ_WRITE, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(1, READ_WRITE, uint, tiles_buf[])
STORAGE_BUF(2, READ_WRITE, ShadowPagesInfoData, pages_infos_buf)
STORAGE_BUF(3, READ_WRITE, uint, pages_free_buf[])
STORAGE_BUF(4, READ_WRITE, uint2, pages_cached_buf[])
STORAGE_BUF(0, read_write, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(1, read_write, uint, tiles_buf[])
STORAGE_BUF(2, read_write, ShadowPagesInfoData, pages_infos_buf)
STORAGE_BUF(3, read_write, uint, pages_free_buf[])
STORAGE_BUF(4, read_write, uint2, pages_cached_buf[])
ADDITIONAL_INFO(eevee_shared)
COMPUTE_SOURCE("eevee_shadow_page_free_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -172,13 +172,13 @@ GPU_SHADER_CREATE_INFO(eevee_shadow_page_defrag)
DO_STATIC_COMPILATION()
LOCAL_GROUP_SIZE(1)
TYPEDEF_SOURCE("draw_shader_shared.hh")
STORAGE_BUF(1, READ_WRITE, uint, tiles_buf[])
STORAGE_BUF(2, READ_WRITE, ShadowPagesInfoData, pages_infos_buf)
STORAGE_BUF(3, READ_WRITE, uint, pages_free_buf[])
STORAGE_BUF(4, READ_WRITE, uint2, pages_cached_buf[])
STORAGE_BUF(5, WRITE, DispatchCommand, clear_dispatch_buf)
STORAGE_BUF(6, WRITE, DrawCommand, tile_draw_buf)
STORAGE_BUF(7, READ_WRITE, ShadowStatistics, statistics_buf)
STORAGE_BUF(1, read_write, uint, tiles_buf[])
STORAGE_BUF(2, read_write, ShadowPagesInfoData, pages_infos_buf)
STORAGE_BUF(3, read_write, uint, pages_free_buf[])
STORAGE_BUF(4, read_write, uint2, pages_cached_buf[])
STORAGE_BUF(5, write, DispatchCommand, clear_dispatch_buf)
STORAGE_BUF(6, write, DrawCommand, tile_draw_buf)
STORAGE_BUF(7, read_write, ShadowStatistics, statistics_buf)
ADDITIONAL_INFO(eevee_shared)
COMPUTE_SOURCE("eevee_shadow_page_defrag_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -187,12 +187,12 @@ GPU_SHADER_CREATE_INFO(eevee_shadow_page_allocate)
DO_STATIC_COMPILATION()
LOCAL_GROUP_SIZE(SHADOW_TILEMAP_LOD0_LEN)
TYPEDEF_SOURCE("draw_shader_shared.hh")
STORAGE_BUF(0, READ_WRITE, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(1, READ_WRITE, uint, tiles_buf[])
STORAGE_BUF(2, READ_WRITE, ShadowPagesInfoData, pages_infos_buf)
STORAGE_BUF(3, READ_WRITE, uint, pages_free_buf[])
STORAGE_BUF(4, READ_WRITE, uint2, pages_cached_buf[])
STORAGE_BUF(6, READ_WRITE, ShadowStatistics, statistics_buf)
STORAGE_BUF(0, read_write, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(1, read_write, uint, tiles_buf[])
STORAGE_BUF(2, read_write, ShadowPagesInfoData, pages_infos_buf)
STORAGE_BUF(3, read_write, uint, pages_free_buf[])
STORAGE_BUF(4, read_write, uint2, pages_cached_buf[])
STORAGE_BUF(6, read_write, ShadowStatistics, statistics_buf)
ADDITIONAL_INFO(eevee_shared)
COMPUTE_SOURCE("eevee_shadow_page_allocate_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -201,14 +201,14 @@ GPU_SHADER_CREATE_INFO(eevee_shadow_tilemap_finalize)
DO_STATIC_COMPILATION()
TYPEDEF_SOURCE("draw_shader_shared.hh")
LOCAL_GROUP_SIZE(SHADOW_TILEMAP_RES, SHADOW_TILEMAP_RES)
STORAGE_BUF(0, READ, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(1, READ, uint, tiles_buf[])
STORAGE_BUF(2, READ_WRITE, ShadowPagesInfoData, pages_infos_buf)
STORAGE_BUF(3, READ_WRITE, ShadowStatistics, statistics_buf)
STORAGE_BUF(4, WRITE, ViewMatrices, view_infos_buf[SHADOW_VIEW_MAX])
STORAGE_BUF(5, WRITE, ShadowRenderView, render_view_buf[SHADOW_VIEW_MAX])
STORAGE_BUF(6, READ, ShadowTileMapClip, tilemaps_clip_buf[])
IMAGE(0, GPU_R32UI, WRITE, UINT_2D, tilemaps_img)
STORAGE_BUF(0, read, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(1, read, uint, tiles_buf[])
STORAGE_BUF(2, read_write, ShadowPagesInfoData, pages_infos_buf)
STORAGE_BUF(3, read_write, ShadowStatistics, statistics_buf)
STORAGE_BUF(4, write, ViewMatrices, view_infos_buf[SHADOW_VIEW_MAX])
STORAGE_BUF(5, write, ShadowRenderView, render_view_buf[SHADOW_VIEW_MAX])
STORAGE_BUF(6, read, ShadowTileMapClip, tilemaps_clip_buf[])
IMAGE(0, GPU_R32UI, write, uimage2D, tilemaps_img)
ADDITIONAL_INFO(eevee_shared)
COMPUTE_SOURCE("eevee_shadow_tilemap_finalize_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -217,14 +217,14 @@ GPU_SHADER_CREATE_INFO(eevee_shadow_tilemap_rendermap)
DO_STATIC_COMPILATION()
TYPEDEF_SOURCE("draw_shader_shared.hh")
LOCAL_GROUP_SIZE(SHADOW_TILEMAP_RES, SHADOW_TILEMAP_RES)
STORAGE_BUF(0, READ_WRITE, ShadowStatistics, statistics_buf)
STORAGE_BUF(1, READ, ShadowRenderView, render_view_buf[SHADOW_VIEW_MAX])
STORAGE_BUF(2, READ_WRITE, uint, tiles_buf[])
STORAGE_BUF(3, READ_WRITE, DispatchCommand, clear_dispatch_buf)
STORAGE_BUF(4, READ_WRITE, DrawCommand, tile_draw_buf)
STORAGE_BUF(5, WRITE, uint, dst_coord_buf[SHADOW_RENDER_MAP_SIZE])
STORAGE_BUF(6, WRITE, uint, src_coord_buf[SHADOW_RENDER_MAP_SIZE])
STORAGE_BUF(7, WRITE, uint, render_map_buf[SHADOW_RENDER_MAP_SIZE])
STORAGE_BUF(0, read_write, ShadowStatistics, statistics_buf)
STORAGE_BUF(1, read, ShadowRenderView, render_view_buf[SHADOW_VIEW_MAX])
STORAGE_BUF(2, read_write, uint, tiles_buf[])
STORAGE_BUF(3, read_write, DispatchCommand, clear_dispatch_buf)
STORAGE_BUF(4, read_write, DrawCommand, tile_draw_buf)
STORAGE_BUF(5, write, uint, dst_coord_buf[SHADOW_RENDER_MAP_SIZE])
STORAGE_BUF(6, write, uint, src_coord_buf[SHADOW_RENDER_MAP_SIZE])
STORAGE_BUF(7, write, uint, render_map_buf[SHADOW_RENDER_MAP_SIZE])
ADDITIONAL_INFO(eevee_shared)
COMPUTE_SOURCE("eevee_shadow_tilemap_rendermap_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -232,11 +232,11 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_shadow_tilemap_amend)
DO_STATIC_COMPILATION()
LOCAL_GROUP_SIZE(SHADOW_TILEMAP_RES, SHADOW_TILEMAP_RES)
IMAGE(0, GPU_R32UI, READ_WRITE, UINT_2D, tilemaps_img)
STORAGE_BUF(LIGHT_CULL_BUF_SLOT, READ, LightCullingData, light_cull_buf)
STORAGE_BUF(LIGHT_BUF_SLOT, READ_WRITE, LightData, light_buf[])
IMAGE(0, GPU_R32UI, read_write, uimage2D, tilemaps_img)
STORAGE_BUF(LIGHT_CULL_BUF_SLOT, read, LightCullingData, light_cull_buf)
STORAGE_BUF(LIGHT_BUF_SLOT, read_write, LightData, light_buf[])
/* The call bind_resources(lights) also uses LIGHT_ZBIN_BUF_SLOT and LIGHT_TILE_BUF_SLOT. */
STORAGE_BUF(4, READ, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(4, read, ShadowTileMapData, tilemaps_buf[])
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(draw_view)
COMPUTE_SOURCE("eevee_shadow_tilemap_amend_comp.glsl")
@@ -246,11 +246,11 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_shadow_page_clear)
DO_STATIC_COMPILATION()
LOCAL_GROUP_SIZE(SHADOW_PAGE_CLEAR_GROUP_SIZE, SHADOW_PAGE_CLEAR_GROUP_SIZE)
STORAGE_BUF(2, READ, ShadowPagesInfoData, pages_infos_buf)
STORAGE_BUF(6, READ, uint, dst_coord_buf[SHADOW_RENDER_MAP_SIZE])
STORAGE_BUF(2, read, ShadowPagesInfoData, pages_infos_buf)
STORAGE_BUF(6, read, uint, dst_coord_buf[SHADOW_RENDER_MAP_SIZE])
ADDITIONAL_INFO(eevee_shared)
COMPUTE_SOURCE("eevee_shadow_page_clear_comp.glsl")
IMAGE(SHADOW_ATLAS_IMG_SLOT, GPU_R32UI, READ_WRITE, UINT_2D_ARRAY_ATOMIC, shadow_atlas_img)
IMAGE(SHADOW_ATLAS_IMG_SLOT, GPU_R32UI, read_write, uimage2DArrayAtomic, shadow_atlas_img)
GPU_SHADER_CREATE_END()
/* TBDR clear implementation. */
@@ -259,7 +259,7 @@ DO_STATIC_COMPILATION()
DEFINE("PASS_CLEAR")
ADDITIONAL_INFO(eevee_shared)
BUILTINS(BuiltinBits::VIEWPORT_INDEX | BuiltinBits::LAYER)
STORAGE_BUF(8, READ, uint, src_coord_buf[SHADOW_RENDER_MAP_SIZE])
STORAGE_BUF(8, read, uint, src_coord_buf[SHADOW_RENDER_MAP_SIZE])
VERTEX_SOURCE("eevee_shadow_page_tile_vert.glsl")
FRAGMENT_SOURCE("eevee_shadow_page_tile_frag.glsl")
FRAGMENT_OUT_ROG(0, float, out_tile_depth, SHADOW_ROG_ID)
@@ -285,10 +285,10 @@ DO_STATIC_COMPILATION()
DEFINE("PASS_DEPTH_STORE")
ADDITIONAL_INFO(eevee_shared)
BUILTINS(BuiltinBits::VIEWPORT_INDEX | BuiltinBits::LAYER)
STORAGE_BUF(7, READ, uint, dst_coord_buf[SHADOW_RENDER_MAP_SIZE])
STORAGE_BUF(8, READ, uint, src_coord_buf[SHADOW_RENDER_MAP_SIZE])
SUBPASS_IN(0, float, FLOAT_2D_ARRAY, in_tile_depth, SHADOW_ROG_ID)
IMAGE(SHADOW_ATLAS_IMG_SLOT, GPU_R32UI, READ_WRITE, UINT_2D_ARRAY, shadow_atlas_img)
STORAGE_BUF(7, read, uint, dst_coord_buf[SHADOW_RENDER_MAP_SIZE])
STORAGE_BUF(8, read, uint, src_coord_buf[SHADOW_RENDER_MAP_SIZE])
SUBPASS_IN(0, float, Float2DArray, in_tile_depth, SHADOW_ROG_ID)
IMAGE(SHADOW_ATLAS_IMG_SLOT, GPU_R32UI, read_write, uimage2DArray, shadow_atlas_img)
VERTEX_OUT(eevee_shadow_page_tile_store_noperspective_iface)
VERTEX_OUT(eevee_shadow_page_tile_store_flat_iface)
VERTEX_SOURCE("eevee_shadow_page_tile_vert.glsl")
@@ -302,9 +302,9 @@ TYPEDEF_SOURCE("eevee_defines.hh")
TYPEDEF_SOURCE("eevee_shader_shared.hh")
LOCAL_GROUP_SIZE(DRW_VISIBILITY_GROUP_SIZE)
DEFINE_VALUE("DRW_VIEW_LEN", STRINGIFY(DRW_VIEW_MAX))
STORAGE_BUF(0, READ, ObjectBounds, bounds_buf[])
STORAGE_BUF(1, READ_WRITE, uint, visibility_buf[])
STORAGE_BUF(2, READ, ShadowRenderView, render_view_buf[SHADOW_VIEW_MAX])
STORAGE_BUF(0, read, ObjectBounds, bounds_buf[])
STORAGE_BUF(1, read_write, uint, visibility_buf[])
STORAGE_BUF(2, read, ShadowRenderView, render_view_buf[SHADOW_VIEW_MAX])
PUSH_CONSTANT(int, resource_len)
PUSH_CONSTANT(int, view_len)
PUSH_CONSTANT(int, visibility_word_per_draw)
@@ -323,8 +323,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_shadow_debug)
DO_STATIC_COMPILATION()
ADDITIONAL_INFO(eevee_shared)
STORAGE_BUF(5, READ, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(6, READ, uint, tiles_buf[])
STORAGE_BUF(5, read, ShadowTileMapData, tilemaps_buf[])
STORAGE_BUF(6, read, uint, tiles_buf[])
FRAGMENT_OUT_DUAL(0, float4, out_color_add, SRC_0)
FRAGMENT_OUT_DUAL(0, float4, out_color_mul, SRC_1)
PUSH_CONSTANT(int, debug_mode)

26
source/blender/draw/engines/eevee/shaders/infos/eevee_subsurface_info.hh
View File

@@ -19,13 +19,13 @@ TYPEDEF_SOURCE("draw_shader_shared.hh")
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(eevee_gbuffer_data)
SAMPLER(2, DEPTH_2D, depth_tx)
IMAGE(0, DEFERRED_RADIANCE_FORMAT, READ, UINT_2D, direct_light_img)
IMAGE(1, RAYTRACE_RADIANCE_FORMAT, READ, FLOAT_2D, indirect_light_img)
IMAGE(2, SUBSURFACE_OBJECT_ID_FORMAT, WRITE, UINT_2D, object_id_img)
IMAGE(3, SUBSURFACE_RADIANCE_FORMAT, WRITE, FLOAT_2D, radiance_img)
STORAGE_BUF(0, WRITE, uint, convolve_tile_buf[])
STORAGE_BUF(1, READ_WRITE, DispatchCommand, convolve_dispatch_buf)
SAMPLER(2, sampler2DDepth, depth_tx)
IMAGE(0, DEFERRED_RADIANCE_FORMAT, read, uimage2D, direct_light_img)
IMAGE(1, RAYTRACE_RADIANCE_FORMAT, read, image2D, indirect_light_img)
IMAGE(2, SUBSURFACE_OBJECT_ID_FORMAT, write, uimage2D, object_id_img)
IMAGE(3, SUBSURFACE_RADIANCE_FORMAT, write, image2D, radiance_img)
STORAGE_BUF(0, write, uint, convolve_tile_buf[])
STORAGE_BUF(1, read_write, DispatchCommand, convolve_dispatch_buf)
COMPUTE_SOURCE("eevee_subsurface_setup_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -36,11 +36,11 @@ ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(eevee_gbuffer_data)
ADDITIONAL_INFO(eevee_global_ubo)
SAMPLER(2, FLOAT_2D, radiance_tx)
SAMPLER(3, DEPTH_2D, depth_tx)
SAMPLER(4, UINT_2D, object_id_tx)
STORAGE_BUF(0, READ, uint, tiles_coord_buf[])
IMAGE(0, DEFERRED_RADIANCE_FORMAT, WRITE, UINT_2D, out_direct_light_img)
IMAGE(1, RAYTRACE_RADIANCE_FORMAT, WRITE, FLOAT_2D, out_indirect_light_img)
SAMPLER(2, sampler2D, radiance_tx)
SAMPLER(3, sampler2DDepth, depth_tx)
SAMPLER(4, usampler2D, object_id_tx)
STORAGE_BUF(0, read, uint, tiles_coord_buf[])
IMAGE(0, DEFERRED_RADIANCE_FORMAT, write, uimage2D, out_direct_light_img)
IMAGE(1, RAYTRACE_RADIANCE_FORMAT, write, image2D, out_indirect_light_img)
COMPUTE_SOURCE("eevee_subsurface_convolve_comp.glsl")
GPU_SHADER_CREATE_END()

178
source/blender/draw/engines/eevee/shaders/infos/eevee_tracing_info.hh
View File

@@ -21,9 +21,9 @@
* \{ */
#define image_out(slot, format, type, name) \
image(slot, format, Qualifier::WRITE, type, name, Frequency::PASS)
image(slot, format, Qualifier::write, type, name, Frequency::PASS)
#define image_in(slot, format, type, name) \
image(slot, format, Qualifier::READ, type, name, Frequency::PASS)
image(slot, format, Qualifier::read, type, name, Frequency::PASS)
GPU_SHADER_CREATE_INFO(eevee_ray_tile_classify)
DO_STATIC_COMPILATION()
@@ -32,10 +32,10 @@ ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(eevee_gbuffer_data)
ADDITIONAL_INFO(eevee_global_ubo)
TYPEDEF_SOURCE("draw_shader_shared.hh")
IMAGE_FREQ(0, RAYTRACE_TILEMASK_FORMAT, WRITE, UINT_2D_ARRAY, tile_raytrace_denoise_img, PASS)
IMAGE_FREQ(1, RAYTRACE_TILEMASK_FORMAT, WRITE, UINT_2D_ARRAY, tile_raytrace_tracing_img, PASS)
IMAGE_FREQ(2, RAYTRACE_TILEMASK_FORMAT, WRITE, UINT_2D_ARRAY, tile_horizon_denoise_img, PASS)
IMAGE_FREQ(3, RAYTRACE_TILEMASK_FORMAT, WRITE, UINT_2D_ARRAY, tile_horizon_tracing_img, PASS)
IMAGE_FREQ(0, RAYTRACE_TILEMASK_FORMAT, write, uimage2DArray, tile_raytrace_denoise_img, PASS)
IMAGE_FREQ(1, RAYTRACE_TILEMASK_FORMAT, write, uimage2DArray, tile_raytrace_tracing_img, PASS)
IMAGE_FREQ(2, RAYTRACE_TILEMASK_FORMAT, write, uimage2DArray, tile_horizon_denoise_img, PASS)
IMAGE_FREQ(3, RAYTRACE_TILEMASK_FORMAT, write, uimage2DArray, tile_horizon_tracing_img, PASS)
COMPUTE_SOURCE("eevee_ray_tile_classify_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -45,12 +45,12 @@ LOCAL_GROUP_SIZE(RAYTRACE_GROUP_SIZE, RAYTRACE_GROUP_SIZE)
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(eevee_global_ubo)
TYPEDEF_SOURCE("draw_shader_shared.hh")
IMAGE_FREQ(0, RAYTRACE_TILEMASK_FORMAT, READ, UINT_2D_ARRAY, tile_raytrace_denoise_img, PASS)
IMAGE_FREQ(1, RAYTRACE_TILEMASK_FORMAT, READ, UINT_2D_ARRAY, tile_raytrace_tracing_img, PASS)
STORAGE_BUF(0, READ_WRITE, DispatchCommand, raytrace_tracing_dispatch_buf)
STORAGE_BUF(1, READ_WRITE, DispatchCommand, raytrace_denoise_dispatch_buf)
STORAGE_BUF(4, WRITE, uint, raytrace_tracing_tiles_buf[])
STORAGE_BUF(5, WRITE, uint, raytrace_denoise_tiles_buf[])
IMAGE_FREQ(0, RAYTRACE_TILEMASK_FORMAT, read, uimage2DArray, tile_raytrace_denoise_img, PASS)
IMAGE_FREQ(1, RAYTRACE_TILEMASK_FORMAT, read, uimage2DArray, tile_raytrace_tracing_img, PASS)
STORAGE_BUF(0, read_write, DispatchCommand, raytrace_tracing_dispatch_buf)
STORAGE_BUF(1, read_write, DispatchCommand, raytrace_denoise_dispatch_buf)
STORAGE_BUF(4, write, uint, raytrace_tracing_tiles_buf[])
STORAGE_BUF(5, write, uint, raytrace_denoise_tiles_buf[])
SPECIALIZATION_CONSTANT(int, closure_index, 0)
SPECIALIZATION_CONSTANT(int, resolution_scale, 2)
COMPUTE_SOURCE("eevee_ray_tile_compact_comp.glsl")
@@ -65,8 +65,8 @@ ADDITIONAL_INFO(eevee_global_ubo)
ADDITIONAL_INFO(eevee_sampling_data)
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(eevee_utility_texture)
IMAGE(0, GPU_RGBA16F, WRITE, FLOAT_2D, out_ray_data_img)
STORAGE_BUF(4, READ, uint, tiles_coord_buf[])
IMAGE(0, GPU_RGBA16F, write, image2D, out_ray_data_img)
STORAGE_BUF(4, read, uint, tiles_coord_buf[])
SPECIALIZATION_CONSTANT(int, closure_index, 0)
COMPUTE_SOURCE("eevee_ray_generate_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -80,11 +80,11 @@ ADDITIONAL_INFO(eevee_global_ubo)
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(eevee_sampling_data)
ADDITIONAL_INFO(eevee_lightprobe_data)
IMAGE(0, GPU_RGBA16F, READ, FLOAT_2D, ray_data_img)
IMAGE(1, RAYTRACE_RAYTIME_FORMAT, WRITE, FLOAT_2D, ray_time_img)
IMAGE(2, RAYTRACE_RADIANCE_FORMAT, WRITE, FLOAT_2D, ray_radiance_img)
SAMPLER(1, DEPTH_2D, depth_tx)
STORAGE_BUF(5, READ, uint, tiles_coord_buf[])
IMAGE(0, GPU_RGBA16F, read, image2D, ray_data_img)
IMAGE(1, RAYTRACE_RAYTIME_FORMAT, write, image2D, ray_time_img)
IMAGE(2, RAYTRACE_RADIANCE_FORMAT, write, image2D, ray_radiance_img)
SAMPLER(1, sampler2DDepth, depth_tx)
STORAGE_BUF(5, read, uint, tiles_coord_buf[])
SPECIALIZATION_CONSTANT(int, closure_index, 0)
COMPUTE_SOURCE("eevee_ray_trace_fallback_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -100,11 +100,11 @@ ADDITIONAL_INFO(eevee_gbuffer_data)
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(eevee_lightprobe_data)
ADDITIONAL_INFO(eevee_lightprobe_planar_data)
IMAGE(0, GPU_RGBA16F, READ_WRITE, FLOAT_2D, ray_data_img)
IMAGE(1, RAYTRACE_RAYTIME_FORMAT, WRITE, FLOAT_2D, ray_time_img)
IMAGE(2, RAYTRACE_RADIANCE_FORMAT, WRITE, FLOAT_2D, ray_radiance_img)
SAMPLER(2, DEPTH_2D, depth_tx)
STORAGE_BUF(5, READ, uint, tiles_coord_buf[])
IMAGE(0, GPU_RGBA16F, read_write, image2D, ray_data_img)
IMAGE(1, RAYTRACE_RAYTIME_FORMAT, write, image2D, ray_time_img)
IMAGE(2, RAYTRACE_RADIANCE_FORMAT, write, image2D, ray_radiance_img)
SAMPLER(2, sampler2DDepth, depth_tx)
STORAGE_BUF(5, read, uint, tiles_coord_buf[])
SPECIALIZATION_CONSTANT(int, closure_index, 0)
COMPUTE_SOURCE("eevee_ray_trace_planar_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -119,15 +119,15 @@ ADDITIONAL_INFO(eevee_gbuffer_data)
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(eevee_hiz_data)
ADDITIONAL_INFO(eevee_lightprobe_data)
IMAGE(0, GPU_RGBA16F, READ, FLOAT_2D, ray_data_img)
IMAGE(1, RAYTRACE_RAYTIME_FORMAT, WRITE, FLOAT_2D, ray_time_img)
IMAGE(2, RAYTRACE_RADIANCE_FORMAT, WRITE, FLOAT_2D, ray_radiance_img)
SAMPLER(0, DEPTH_2D, depth_tx)
SAMPLER(1, FLOAT_2D, radiance_front_tx)
SAMPLER(2, FLOAT_2D, radiance_back_tx)
SAMPLER(4, FLOAT_2D, hiz_front_tx)
SAMPLER(5, FLOAT_2D, hiz_back_tx)
STORAGE_BUF(5, READ, uint, tiles_coord_buf[])
IMAGE(0, GPU_RGBA16F, read, image2D, ray_data_img)
IMAGE(1, RAYTRACE_RAYTIME_FORMAT, write, image2D, ray_time_img)
IMAGE(2, RAYTRACE_RADIANCE_FORMAT, write, image2D, ray_radiance_img)
SAMPLER(0, sampler2DDepth, depth_tx)
SAMPLER(1, sampler2D, radiance_front_tx)
SAMPLER(2, sampler2D, radiance_back_tx)
SAMPLER(4, sampler2D, hiz_front_tx)
SAMPLER(5, sampler2D, hiz_back_tx)
STORAGE_BUF(5, read, uint, tiles_coord_buf[])
COMPUTE_SOURCE("eevee_ray_trace_screen_comp.glsl")
/* Metal: Provide compiler with hint to tune per-thread resource allocation. */
MTL_MAX_TOTAL_THREADS_PER_THREADGROUP(400)
@@ -145,15 +145,15 @@ ADDITIONAL_INFO(eevee_global_ubo)
ADDITIONAL_INFO(eevee_sampling_data)
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(eevee_utility_texture)
SAMPLER(3, DEPTH_2D, depth_tx)
IMAGE(0, GPU_RGBA16F, READ, FLOAT_2D, ray_data_img)
IMAGE(1, RAYTRACE_RAYTIME_FORMAT, READ, FLOAT_2D, ray_time_img)
IMAGE(2, RAYTRACE_RADIANCE_FORMAT, READ, FLOAT_2D, ray_radiance_img)
IMAGE(3, RAYTRACE_RADIANCE_FORMAT, WRITE, FLOAT_2D, out_radiance_img)
IMAGE(4, RAYTRACE_VARIANCE_FORMAT, WRITE, FLOAT_2D, out_variance_img)
IMAGE(5, GPU_R32F, WRITE, FLOAT_2D, out_hit_depth_img)
IMAGE(6, RAYTRACE_TILEMASK_FORMAT, READ, UINT_2D_ARRAY, tile_mask_img)
STORAGE_BUF(4, READ, uint, tiles_coord_buf[])
SAMPLER(3, sampler2DDepth, depth_tx)
IMAGE(0, GPU_RGBA16F, read, image2D, ray_data_img)
IMAGE(1, RAYTRACE_RAYTIME_FORMAT, read, image2D, ray_time_img)
IMAGE(2, RAYTRACE_RADIANCE_FORMAT, read, image2D, ray_radiance_img)
IMAGE(3, RAYTRACE_RADIANCE_FORMAT, write, image2D, out_radiance_img)
IMAGE(4, RAYTRACE_VARIANCE_FORMAT, write, image2D, out_variance_img)
IMAGE(5, GPU_R32F, write, image2D, out_hit_depth_img)
IMAGE(6, RAYTRACE_TILEMASK_FORMAT, read, uimage2DArray, tile_mask_img)
STORAGE_BUF(4, read, uint, tiles_coord_buf[])
/* Metal: Provide compiler with hint to tune per-thread resource allocation. */
MTL_MAX_TOTAL_THREADS_PER_THREADGROUP(316)
SPECIALIZATION_CONSTANT(int, raytrace_resolution_scale, 2)
@@ -168,16 +168,16 @@ LOCAL_GROUP_SIZE(RAYTRACE_GROUP_SIZE, RAYTRACE_GROUP_SIZE)
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(eevee_global_ubo)
ADDITIONAL_INFO(draw_view)
SAMPLER(0, FLOAT_2D, radiance_history_tx)
SAMPLER(1, FLOAT_2D, variance_history_tx)
SAMPLER(2, UINT_2D_ARRAY, tilemask_history_tx)
SAMPLER(3, DEPTH_2D, depth_tx)
IMAGE(0, GPU_R32F, READ, FLOAT_2D, hit_depth_img)
IMAGE(1, RAYTRACE_RADIANCE_FORMAT, READ, FLOAT_2D, in_radiance_img)
IMAGE(2, RAYTRACE_RADIANCE_FORMAT, WRITE, FLOAT_2D, out_radiance_img)
IMAGE(3, RAYTRACE_VARIANCE_FORMAT, READ, FLOAT_2D, in_variance_img)
IMAGE(4, RAYTRACE_VARIANCE_FORMAT, WRITE, FLOAT_2D, out_variance_img)
STORAGE_BUF(4, READ, uint, tiles_coord_buf[])
SAMPLER(0, sampler2D, radiance_history_tx)
SAMPLER(1, sampler2D, variance_history_tx)
SAMPLER(2, usampler2DArray, tilemask_history_tx)
SAMPLER(3, sampler2DDepth, depth_tx)
IMAGE(0, GPU_R32F, read, image2D, hit_depth_img)
IMAGE(1, RAYTRACE_RADIANCE_FORMAT, read, image2D, in_radiance_img)
IMAGE(2, RAYTRACE_RADIANCE_FORMAT, write, image2D, out_radiance_img)
IMAGE(3, RAYTRACE_VARIANCE_FORMAT, read, image2D, in_variance_img)
IMAGE(4, RAYTRACE_VARIANCE_FORMAT, write, image2D, out_variance_img)
STORAGE_BUF(4, read, uint, tiles_coord_buf[])
COMPUTE_SOURCE("eevee_ray_denoise_temporal_comp.glsl")
/* Metal: Provide compiler with hint to tune per-thread resource allocation. */
MTL_MAX_TOTAL_THREADS_PER_THREADGROUP(512)
@@ -193,12 +193,12 @@ ADDITIONAL_INFO(eevee_gbuffer_data)
ADDITIONAL_INFO(eevee_global_ubo)
ADDITIONAL_INFO(eevee_sampling_data)
ADDITIONAL_INFO(draw_view)
SAMPLER(1, DEPTH_2D, depth_tx)
IMAGE(1, RAYTRACE_RADIANCE_FORMAT, READ, FLOAT_2D, in_radiance_img)
IMAGE(2, RAYTRACE_RADIANCE_FORMAT, WRITE, FLOAT_2D, out_radiance_img)
IMAGE(3, RAYTRACE_VARIANCE_FORMAT, READ, FLOAT_2D, in_variance_img)
IMAGE(6, RAYTRACE_TILEMASK_FORMAT, READ, UINT_2D_ARRAY, tile_mask_img)
STORAGE_BUF(4, READ, uint, tiles_coord_buf[])
SAMPLER(1, sampler2DDepth, depth_tx)
IMAGE(1, RAYTRACE_RADIANCE_FORMAT, read, image2D, in_radiance_img)
IMAGE(2, RAYTRACE_RADIANCE_FORMAT, write, image2D, out_radiance_img)
IMAGE(3, RAYTRACE_VARIANCE_FORMAT, read, image2D, in_variance_img)
IMAGE(6, RAYTRACE_TILEMASK_FORMAT, read, uimage2DArray, tile_mask_img)
STORAGE_BUF(4, read, uint, tiles_coord_buf[])
SPECIALIZATION_CONSTANT(int, closure_index, 0)
COMPUTE_SOURCE("eevee_ray_denoise_bilateral_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -210,10 +210,10 @@ ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(eevee_gbuffer_data)
ADDITIONAL_INFO(eevee_global_ubo)
ADDITIONAL_INFO(draw_view)
SAMPLER(0, DEPTH_2D, depth_tx)
SAMPLER(1, FLOAT_2D, in_radiance_tx)
IMAGE(2, RAYTRACE_RADIANCE_FORMAT, WRITE, FLOAT_2D, out_radiance_img)
IMAGE(3, GPU_RGB10_A2, WRITE, FLOAT_2D, out_normal_img)
SAMPLER(0, sampler2DDepth, depth_tx)
SAMPLER(1, sampler2D, in_radiance_tx)
IMAGE(2, RAYTRACE_RADIANCE_FORMAT, write, image2D, out_radiance_img)
IMAGE(3, GPU_RGB10_A2, write, image2D, out_normal_img)
COMPUTE_SOURCE("eevee_horizon_setup_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -230,13 +230,13 @@ ADDITIONAL_INFO(draw_view)
SPECIALIZATION_CONSTANT(int, fast_gi_slice_count, 2)
SPECIALIZATION_CONSTANT(int, fast_gi_step_count, 8)
SPECIALIZATION_CONSTANT(bool, fast_gi_ao_only, false)
SAMPLER(0, FLOAT_2D, screen_radiance_tx)
SAMPLER(1, FLOAT_2D, screen_normal_tx)
IMAGE(2, GPU_RGBA16F, WRITE, FLOAT_2D, horizon_radiance_0_img)
IMAGE(3, GPU_RGBA8, WRITE, FLOAT_2D, horizon_radiance_1_img)
IMAGE(4, GPU_RGBA8, WRITE, FLOAT_2D, horizon_radiance_2_img)
IMAGE(5, GPU_RGBA8, WRITE, FLOAT_2D, horizon_radiance_3_img)
STORAGE_BUF(7, READ, uint, tiles_coord_buf[])
SAMPLER(0, sampler2D, screen_radiance_tx)
SAMPLER(1, sampler2D, screen_normal_tx)
IMAGE(2, GPU_RGBA16F, write, image2D, horizon_radiance_0_img)
IMAGE(3, GPU_RGBA8, write, image2D, horizon_radiance_1_img)
IMAGE(4, GPU_RGBA8, write, image2D, horizon_radiance_2_img)
IMAGE(5, GPU_RGBA8, write, image2D, horizon_radiance_3_img)
STORAGE_BUF(7, read, uint, tiles_coord_buf[])
/* Metal: Provide compiler with hint to tune per-thread resource allocation. */
MTL_MAX_TOTAL_THREADS_PER_THREADGROUP(400)
COMPUTE_SOURCE("eevee_horizon_scan_comp.glsl")
@@ -250,16 +250,16 @@ ADDITIONAL_INFO(eevee_global_ubo)
ADDITIONAL_INFO(eevee_sampling_data)
ADDITIONAL_INFO(eevee_hiz_data)
ADDITIONAL_INFO(draw_view)
SAMPLER(2, FLOAT_2D, in_sh_0_tx)
SAMPLER(4, FLOAT_2D, in_sh_1_tx)
SAMPLER(5, FLOAT_2D, in_sh_2_tx)
SAMPLER(6, FLOAT_2D, in_sh_3_tx)
SAMPLER(7, FLOAT_2D, screen_normal_tx)
IMAGE(2, GPU_RGBA16F, WRITE, FLOAT_2D, out_sh_0_img)
IMAGE(3, GPU_RGBA8, WRITE, FLOAT_2D, out_sh_1_img)
IMAGE(4, GPU_RGBA8, WRITE, FLOAT_2D, out_sh_2_img)
IMAGE(5, GPU_RGBA8, WRITE, FLOAT_2D, out_sh_3_img)
STORAGE_BUF(7, READ, uint, tiles_coord_buf[])
SAMPLER(2, sampler2D, in_sh_0_tx)
SAMPLER(4, sampler2D, in_sh_1_tx)
SAMPLER(5, sampler2D, in_sh_2_tx)
SAMPLER(6, sampler2D, in_sh_3_tx)
SAMPLER(7, sampler2D, screen_normal_tx)
IMAGE(2, GPU_RGBA16F, write, image2D, out_sh_0_img)
IMAGE(3, GPU_RGBA8, write, image2D, out_sh_1_img)
IMAGE(4, GPU_RGBA8, write, image2D, out_sh_2_img)
IMAGE(5, GPU_RGBA8, write, image2D, out_sh_3_img)
STORAGE_BUF(7, read, uint, tiles_coord_buf[])
COMPUTE_SOURCE("eevee_horizon_denoise_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -272,16 +272,16 @@ ADDITIONAL_INFO(eevee_global_ubo)
ADDITIONAL_INFO(eevee_sampling_data)
ADDITIONAL_INFO(eevee_lightprobe_data)
ADDITIONAL_INFO(draw_view)
SAMPLER(1, DEPTH_2D, depth_tx)
SAMPLER(2, FLOAT_2D, horizon_radiance_0_tx)
SAMPLER(3, FLOAT_2D, horizon_radiance_1_tx)
SAMPLER(4, FLOAT_2D, horizon_radiance_2_tx)
SAMPLER(5, FLOAT_2D, horizon_radiance_3_tx)
SAMPLER(8, FLOAT_2D, screen_normal_tx)
IMAGE(3, RAYTRACE_RADIANCE_FORMAT, READ_WRITE, FLOAT_2D, closure0_img)
IMAGE(4, RAYTRACE_RADIANCE_FORMAT, READ_WRITE, FLOAT_2D, closure1_img)
IMAGE(5, RAYTRACE_RADIANCE_FORMAT, READ_WRITE, FLOAT_2D, closure2_img)
STORAGE_BUF(7, READ, uint, tiles_coord_buf[])
SAMPLER(1, sampler2DDepth, depth_tx)
SAMPLER(2, sampler2D, horizon_radiance_0_tx)
SAMPLER(3, sampler2D, horizon_radiance_1_tx)
SAMPLER(4, sampler2D, horizon_radiance_2_tx)
SAMPLER(5, sampler2D, horizon_radiance_3_tx)
SAMPLER(8, sampler2D, screen_normal_tx)
IMAGE(3, RAYTRACE_RADIANCE_FORMAT, read_write, image2D, closure0_img)
IMAGE(4, RAYTRACE_RADIANCE_FORMAT, read_write, image2D, closure1_img)
IMAGE(5, RAYTRACE_RADIANCE_FORMAT, read_write, image2D, closure2_img)
STORAGE_BUF(7, read, uint, tiles_coord_buf[])
/* Metal: Provide compiler with hint to tune per-thread resource allocation. */
MTL_MAX_TOTAL_THREADS_PER_THREADGROUP(400)
COMPUTE_SOURCE("eevee_horizon_resolve_comp.glsl")

14
source/blender/draw/engines/eevee/shaders/infos/eevee_velocity_info.hh
View File

@@ -40,11 +40,11 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_velocity_geom)
DEFINE("MAT_VELOCITY")
STORAGE_BUF(VELOCITY_OBJ_PREV_BUF_SLOT, READ, float4x4, velocity_obj_prev_buf[])
STORAGE_BUF(VELOCITY_OBJ_NEXT_BUF_SLOT, READ, float4x4, velocity_obj_next_buf[])
STORAGE_BUF(VELOCITY_GEO_PREV_BUF_SLOT, READ, float4, velocity_geo_prev_buf[])
STORAGE_BUF(VELOCITY_GEO_NEXT_BUF_SLOT, READ, float4, velocity_geo_next_buf[])
STORAGE_BUF(VELOCITY_INDIRECTION_BUF_SLOT, READ, VelocityIndex, velocity_indirection_buf[])
STORAGE_BUF(VELOCITY_OBJ_PREV_BUF_SLOT, read, float4x4, velocity_obj_prev_buf[])
STORAGE_BUF(VELOCITY_OBJ_NEXT_BUF_SLOT, read, float4x4, velocity_obj_next_buf[])
STORAGE_BUF(VELOCITY_GEO_PREV_BUF_SLOT, read, float4, velocity_geo_prev_buf[])
STORAGE_BUF(VELOCITY_GEO_NEXT_BUF_SLOT, read, float4, velocity_geo_next_buf[])
STORAGE_BUF(VELOCITY_INDIRECTION_BUF_SLOT, read, VelocityIndex, velocity_indirection_buf[])
VERTEX_OUT(eevee_velocity_surface_iface)
FRAGMENT_OUT(0, float4, out_velocity)
ADDITIONAL_INFO(eevee_velocity_camera)
@@ -53,8 +53,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_vertex_copy)
COMPUTE_SOURCE("eevee_vertex_copy_comp.glsl")
LOCAL_GROUP_SIZE(VERTEX_COPY_GROUP_SIZE)
STORAGE_BUF(0, READ, float, in_buf[])
STORAGE_BUF(1, WRITE, float4, out_buf[])
STORAGE_BUF(0, read, float, in_buf[])
STORAGE_BUF(1, write, float4, out_buf[])
PUSH_CONSTANT(int, start_offset)
PUSH_CONSTANT(int, vertex_stride)
PUSH_CONSTANT(int, vertex_count)

28
source/blender/draw/engines/eevee/shaders/infos/eevee_volume_info.hh
View File

@@ -24,8 +24,8 @@ GPU_SHADER_CREATE_INFO(eevee_volume_lib)
ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(eevee_global_ubo)
ADDITIONAL_INFO(draw_view)
SAMPLER(VOLUME_SCATTERING_TEX_SLOT, FLOAT_3D, volume_scattering_tx)
SAMPLER(VOLUME_TRANSMITTANCE_TEX_SLOT, FLOAT_3D, volume_transmittance_tx)
SAMPLER(VOLUME_SCATTERING_TEX_SLOT, sampler3D, volume_scattering_tx)
SAMPLER(VOLUME_TRANSMITTANCE_TEX_SLOT, sampler3D, volume_transmittance_tx)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(eevee_volume_scatter)
@@ -40,10 +40,10 @@ ADDITIONAL_INFO(eevee_shadow_data)
ADDITIONAL_INFO(eevee_sampling_data)
ADDITIONAL_INFO(eevee_utility_texture)
ADDITIONAL_INFO(eevee_volume_properties_data)
SAMPLER(0, FLOAT_3D, scattering_history_tx)
SAMPLER(1, FLOAT_3D, extinction_history_tx)
IMAGE(5, GPU_R11F_G11F_B10F, WRITE, FLOAT_3D, out_scattering_img)
IMAGE(6, GPU_R11F_G11F_B10F, WRITE, FLOAT_3D, out_extinction_img)
SAMPLER(0, sampler3D, scattering_history_tx)
SAMPLER(1, sampler3D, extinction_history_tx)
IMAGE(5, GPU_R11F_G11F_B10F, write, image3D, out_scattering_img)
IMAGE(6, GPU_R11F_G11F_B10F, write, image3D, out_extinction_img)
COMPUTE_SOURCE("eevee_volume_scatter_comp.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -53,7 +53,7 @@ ADDITIONAL_INFO(eevee_volume_scatter)
DEFINE("VOLUME_LIGHTING")
DEFINE("VOLUME_IRRADIANCE")
DEFINE("VOLUME_SHADOW")
SAMPLER(9, FLOAT_3D, extinction_tx)
SAMPLER(9, sampler3D, extinction_tx)
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -62,9 +62,9 @@ ADDITIONAL_INFO(eevee_shared)
ADDITIONAL_INFO(eevee_global_ubo)
ADDITIONAL_INFO(gpu_fullscreen)
BUILTINS(BuiltinBits::TEXTURE_ATOMIC)
IMAGE(VOLUME_HIT_DEPTH_SLOT, GPU_R32F, READ, FLOAT_3D, hit_depth_img)
IMAGE(VOLUME_HIT_COUNT_SLOT, GPU_R32UI, READ_WRITE, UINT_2D, hit_count_img)
IMAGE(VOLUME_OCCUPANCY_SLOT, GPU_R32UI, READ_WRITE, UINT_3D_ATOMIC, occupancy_img)
IMAGE(VOLUME_HIT_DEPTH_SLOT, GPU_R32F, read, image3D, hit_depth_img)
IMAGE(VOLUME_HIT_COUNT_SLOT, GPU_R32UI, read_write, uimage2D, hit_count_img)
IMAGE(VOLUME_OCCUPANCY_SLOT, GPU_R32UI, read_write, uimage3DAtomic, occupancy_img)
FRAGMENT_SOURCE("eevee_occupancy_convert_frag.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -77,11 +77,11 @@ ADDITIONAL_INFO(eevee_sampling_data)
COMPUTE_SOURCE("eevee_volume_integration_comp.glsl")
LOCAL_GROUP_SIZE(VOLUME_INTEGRATION_GROUP_SIZE, VOLUME_INTEGRATION_GROUP_SIZE, 1)
/* Inputs. */
SAMPLER(0, FLOAT_3D, in_scattering_tx)
SAMPLER(1, FLOAT_3D, in_extinction_tx)
SAMPLER(0, sampler3D, in_scattering_tx)
SAMPLER(1, sampler3D, in_extinction_tx)
/* Outputs. */
IMAGE(0, GPU_R11F_G11F_B10F, WRITE, FLOAT_3D, out_scattering_img)
IMAGE(1, GPU_R11F_G11F_B10F, WRITE, FLOAT_3D, out_transmittance_img)
IMAGE(0, GPU_R11F_G11F_B10F, write, image3D, out_scattering_img)
IMAGE(1, GPU_R11F_G11F_B10F, write, image3D, out_transmittance_img)
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

36
source/blender/draw/engines/gpencil/shaders/infos/gpencil_info.hh
View File

@@ -52,10 +52,10 @@ GPU_SHADER_CREATE_INFO(gpencil_geometry)
DO_STATIC_COMPILATION()
DEFINE("GP_LIGHT")
TYPEDEF_SOURCE("gpencil_defines.hh")
SAMPLER(2, FLOAT_2D, gp_fill_tx)
SAMPLER(3, FLOAT_2D, gp_stroke_tx)
SAMPLER(4, DEPTH_2D, gp_scene_depth_tx)
SAMPLER(5, FLOAT_2D, gp_mask_tx)
SAMPLER(2, sampler2D, gp_fill_tx)
SAMPLER(3, sampler2D, gp_stroke_tx)
SAMPLER(4, sampler2DDepth, gp_scene_depth_tx)
SAMPLER(5, sampler2D, gp_mask_tx)
UNIFORM_BUF_FREQ(4, gpMaterial, gp_materials[GPENCIL_MATERIAL_BUFFER_LEN], BATCH)
UNIFORM_BUF_FREQ(3, gpLight, gp_lights[GPENCIL_LIGHT_BUFFER_LEN], BATCH)
PUSH_CONSTANT(float2, viewport_size)
@@ -89,9 +89,9 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(gpencil_layer_blend)
DO_STATIC_COMPILATION()
SAMPLER(0, FLOAT_2D, color_buf)
SAMPLER(1, FLOAT_2D, reveal_buf)
SAMPLER(2, FLOAT_2D, mask_buf)
SAMPLER(0, sampler2D, color_buf)
SAMPLER(1, sampler2D, reveal_buf)
SAMPLER(2, sampler2D, mask_buf)
PUSH_CONSTANT(int, blend_mode)
PUSH_CONSTANT(float, blend_opacity)
/* Reminder: This is considered SRC color in blend equations.
@@ -114,7 +114,7 @@ GPU_SHADER_CREATE_INFO(gpencil_depth_merge)
DO_STATIC_COMPILATION()
PUSH_CONSTANT(float4x4, gp_model_matrix)
PUSH_CONSTANT(bool, stroke_order3d)
SAMPLER(0, DEPTH_2D, depth_buf)
SAMPLER(0, sampler2DDepth, depth_buf)
VERTEX_SOURCE("gpencil_depth_merge_vert.glsl")
FRAGMENT_SOURCE("gpencil_depth_merge_frag.glsl")
DEPTH_WRITE(DepthWrite::ANY)
@@ -148,8 +148,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(gpencil_antialiasing_stage_0)
DEFINE_VALUE("SMAA_STAGE", "0")
SAMPLER(0, FLOAT_2D, color_tx)
SAMPLER(1, FLOAT_2D, reveal_tx)
SAMPLER(0, sampler2D, color_tx)
SAMPLER(1, sampler2D, reveal_tx)
FRAGMENT_OUT(0, float2, out_edges)
ADDITIONAL_INFO(gpencil_antialiasing)
DO_STATIC_COMPILATION()
@@ -157,9 +157,9 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(gpencil_antialiasing_stage_1)
DEFINE_VALUE("SMAA_STAGE", "1")
SAMPLER(0, FLOAT_2D, edges_tx)
SAMPLER(1, FLOAT_2D, area_tx)
SAMPLER(2, FLOAT_2D, search_tx)
SAMPLER(0, sampler2D, edges_tx)
SAMPLER(1, sampler2D, area_tx)
SAMPLER(2, sampler2D, search_tx)
FRAGMENT_OUT(0, float4, out_weights)
ADDITIONAL_INFO(gpencil_antialiasing)
DO_STATIC_COMPILATION()
@@ -167,9 +167,9 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(gpencil_antialiasing_stage_2)
DEFINE_VALUE("SMAA_STAGE", "2")
SAMPLER(0, FLOAT_2D, color_tx)
SAMPLER(1, FLOAT_2D, reveal_tx)
SAMPLER(2, FLOAT_2D, blend_tx)
SAMPLER(0, sampler2D, color_tx)
SAMPLER(1, sampler2D, reveal_tx)
SAMPLER(2, sampler2D, blend_tx)
PUSH_CONSTANT(float, mix_factor)
PUSH_CONSTANT(float, taa_accumulated_weight)
PUSH_CONSTANT(bool, do_anti_aliasing)
@@ -182,8 +182,8 @@ DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(gpencil_antialiasing_accumulation)
IMAGE(0, GPENCIL_RENDER_FORMAT, READ, FLOAT_2D, src_img)
IMAGE(1, GPENCIL_ACCUM_FORMAT, READ_WRITE, FLOAT_2D, dst_img)
IMAGE(0, GPENCIL_RENDER_FORMAT, read, image2D, src_img)
IMAGE(1, GPENCIL_ACCUM_FORMAT, read_write, image2D, dst_img)
PUSH_CONSTANT(float, weight_src)
PUSH_CONSTANT(float, weight_dst)
FRAGMENT_SOURCE("gpencil_antialiasing_accumulation_frag.glsl")

4
source/blender/draw/engines/gpencil/shaders/infos/gpencil_vfx_info.hh
View File

@@ -18,8 +18,8 @@
#include "gpu_shader_create_info.hh"
GPU_SHADER_CREATE_INFO(gpencil_fx_common)
SAMPLER(0, FLOAT_2D, color_buf)
SAMPLER(1, FLOAT_2D, reveal_buf)
SAMPLER(0, sampler2D, color_buf)
SAMPLER(1, sampler2D, reveal_buf)
/* Reminder: This is considered SRC color in blend equations.
* Same operation on all buffers. */
FRAGMENT_OUT(0, float4, frag_color)

4
source/blender/draw/engines/image/shaders/infos/engine_image_info.hh
View File

@@ -17,8 +17,8 @@ PUSH_CONSTANT(float2, far_near_distances)
PUSH_CONSTANT(int2, offset)
PUSH_CONSTANT(int, draw_flags)
PUSH_CONSTANT(bool, is_image_premultiplied)
SAMPLER(0, FLOAT_2D, image_tx)
SAMPLER(1, DEPTH_2D, depth_tx)
SAMPLER(0, sampler2D, image_tx)
SAMPLER(1, sampler2DDepth, depth_tx)
VERTEX_SOURCE("image_engine_color_vert.glsl")
FRAGMENT_SOURCE("image_engine_color_frag.glsl")
ADDITIONAL_INFO(draw_view)

14
source/blender/draw/engines/overlay/shaders/infos/overlay_antialiasing_info.hh
View File

@@ -15,9 +15,9 @@
GPU_SHADER_CREATE_INFO(overlay_antialiasing)
DO_STATIC_COMPILATION()
SAMPLER(0, DEPTH_2D, depth_tx)
SAMPLER(1, FLOAT_2D, color_tx)
SAMPLER(2, FLOAT_2D, line_tx)
SAMPLER(0, sampler2DDepth, depth_tx)
SAMPLER(1, sampler2D, color_tx)
SAMPLER(2, sampler2D, line_tx)
PUSH_CONSTANT(bool, do_smooth_lines)
FRAGMENT_OUT(0, float4, frag_color)
TYPEDEF_SOURCE("overlay_shader_shared.hh")
@@ -28,12 +28,12 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(overlay_xray_fade)
DO_STATIC_COMPILATION()
SAMPLER(0, DEPTH_2D, depth_tx)
SAMPLER(1, DEPTH_2D, xray_depth_tx)
SAMPLER(0, sampler2DDepth, depth_tx)
SAMPLER(1, sampler2DDepth, xray_depth_tx)
PUSH_CONSTANT(float, opacity)
FRAGMENT_OUT(0, float4, frag_color)
FRAGMENT_SOURCE("overlay_xray_fade_frag.glsl")
ADDITIONAL_INFO(gpu_fullscreen)
SAMPLER(2, DEPTH_2D, xray_depth_txInfront)
SAMPLER(3, DEPTH_2D, depth_txInfront)
SAMPLER(2, sampler2DDepth, xray_depth_txInfront)
SAMPLER(3, sampler2DDepth, depth_txInfront)
GPU_SHADER_CREATE_END()

24
source/blender/draw/engines/overlay/shaders/infos/overlay_armature_info.hh
View File

@@ -47,7 +47,7 @@ FRAGMENT_SOURCE("overlay_armature_wire_frag.glsl")
ADDITIONAL_INFO(overlay_frag_output)
ADDITIONAL_INFO(overlay_armature_common)
ADDITIONAL_INFO(draw_globals)
STORAGE_BUF(0, READ, float4x4, data_buf[])
STORAGE_BUF(0, read, float4x4, data_buf[])
GPU_SHADER_CREATE_END()
OVERLAY_INFO_VARIATIONS(overlay_armature_sphere_outline)
@@ -71,7 +71,7 @@ FRAGMENT_SOURCE("overlay_armature_sphere_solid_frag.glsl")
ADDITIONAL_INFO(overlay_frag_output)
ADDITIONAL_INFO(overlay_armature_common)
ADDITIONAL_INFO(draw_globals)
STORAGE_BUF(0, READ, float4x4, data_buf[])
STORAGE_BUF(0, read, float4x4, data_buf[])
GPU_SHADER_CREATE_END()
OVERLAY_INFO_VARIATIONS(overlay_armature_sphere_solid)
@@ -90,8 +90,8 @@ GPU_SHADER_INTERFACE_END()
GPU_SHADER_CREATE_INFO(overlay_armature_shape_outline)
DO_STATIC_COMPILATION()
STORAGE_BUF_FREQ(0, READ, float, pos[], GEOMETRY)
STORAGE_BUF(1, READ, float4x4, data_buf[])
STORAGE_BUF_FREQ(0, read, float, pos[], GEOMETRY)
STORAGE_BUF(1, read, float4x4, data_buf[])
PUSH_CONSTANT(int2, gpu_attr_0)
VERTEX_OUT(overlay_armature_shape_outline_iface)
VERTEX_SOURCE("overlay_armature_shape_outline_vert.glsl")
@@ -121,7 +121,7 @@ FRAGMENT_SOURCE("overlay_armature_shape_solid_frag.glsl")
ADDITIONAL_INFO(overlay_frag_output)
ADDITIONAL_INFO(overlay_armature_common)
ADDITIONAL_INFO(draw_globals)
STORAGE_BUF(0, READ, float4x4, data_buf[])
STORAGE_BUF(0, read, float4x4, data_buf[])
GPU_SHADER_CREATE_END()
OVERLAY_INFO_VARIATIONS(overlay_armature_shape_solid)
@@ -135,8 +135,8 @@ GPU_SHADER_INTERFACE_END()
GPU_SHADER_CREATE_INFO(overlay_armature_shape_wire)
DO_STATIC_COMPILATION()
PUSH_CONSTANT(bool, do_smooth_wire)
STORAGE_BUF_FREQ(0, READ, float, pos[], GEOMETRY)
STORAGE_BUF(1, READ, float4x4, data_buf[])
STORAGE_BUF_FREQ(0, read, float, pos[], GEOMETRY)
STORAGE_BUF(1, read, float4x4, data_buf[])
PUSH_CONSTANT(int2, gpu_attr_0)
PUSH_CONSTANT(bool, use_arrow_drawing)
VERTEX_OUT(overlay_armature_shape_wire_iface)
@@ -177,7 +177,7 @@ FRAGMENT_SOURCE("overlay_armature_wire_frag.glsl")
ADDITIONAL_INFO(overlay_frag_output)
ADDITIONAL_INFO(overlay_armature_common)
ADDITIONAL_INFO(draw_globals)
STORAGE_BUF(0, READ, BoneEnvelopeData, data_buf[])
STORAGE_BUF(0, read, BoneEnvelopeData, data_buf[])
GPU_SHADER_CREATE_END()
OVERLAY_INFO_VARIATIONS(overlay_armature_envelope_outline)
@@ -199,7 +199,7 @@ FRAGMENT_SOURCE("overlay_armature_envelope_solid_frag.glsl")
ADDITIONAL_INFO(overlay_frag_output)
ADDITIONAL_INFO(overlay_armature_common)
ADDITIONAL_INFO(draw_globals)
STORAGE_BUF(0, READ, BoneEnvelopeData, data_buf[])
STORAGE_BUF(0, read, BoneEnvelopeData, data_buf[])
GPU_SHADER_CREATE_END()
OVERLAY_INFO_VARIATIONS(overlay_armature_envelope_solid)
@@ -227,7 +227,7 @@ FRAGMENT_SOURCE("overlay_armature_stick_frag.glsl")
ADDITIONAL_INFO(overlay_frag_output)
ADDITIONAL_INFO(overlay_armature_common)
ADDITIONAL_INFO(draw_globals)
STORAGE_BUF(0, READ, BoneStickData, data_buf[])
STORAGE_BUF(0, read, BoneStickData, data_buf[])
GPU_SHADER_CREATE_END()
OVERLAY_INFO_VARIATIONS_MODELMAT(overlay_armature_stick, overlay_armature_stick_base)
@@ -248,7 +248,7 @@ FRAGMENT_SOURCE("overlay_armature_dof_solid_frag.glsl")
ADDITIONAL_INFO(overlay_frag_output)
ADDITIONAL_INFO(overlay_armature_common)
ADDITIONAL_INFO(draw_globals)
STORAGE_BUF(0, READ, ExtraInstanceData, data_buf[])
STORAGE_BUF(0, read, ExtraInstanceData, data_buf[])
GPU_SHADER_CREATE_END()
OVERLAY_INFO_CLIP_VARIATION(overlay_armature_dof)
@@ -268,7 +268,7 @@ FRAGMENT_SOURCE("overlay_armature_wire_frag.glsl")
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(overlay_frag_output)
ADDITIONAL_INFO(draw_globals)
STORAGE_BUF(0, READ, VertexData, data_buf[])
STORAGE_BUF(0, read, VertexData, data_buf[])
GPU_SHADER_CREATE_END()
OVERLAY_INFO_VARIATIONS_MODELMAT(overlay_armature_wire, overlay_armature_wire_base)

4
source/blender/draw/engines/overlay/shaders/infos/overlay_background_info.hh
View File

@@ -19,8 +19,8 @@
GPU_SHADER_CREATE_INFO(overlay_background)
DO_STATIC_COMPILATION()
TYPEDEF_SOURCE("overlay_shader_shared.hh")
SAMPLER(0, FLOAT_2D, color_buffer)
SAMPLER(1, DEPTH_2D, depth_buffer)
SAMPLER(0, sampler2D, color_buffer)
SAMPLER(1, sampler2DDepth, depth_buffer)
PUSH_CONSTANT(int, bg_type)
PUSH_CONSTANT(float4, color_override)
FRAGMENT_SOURCE("overlay_background_frag.glsl")

4
source/blender/draw/engines/overlay/shaders/infos/overlay_common_info.hh
View File

@@ -34,9 +34,9 @@ VERTEX_OUT(select_id_patch_iface)
// EARLY_FRAGMENT_TEST(true)
UNIFORM_BUF(SELECT_DATA, SelectInfoData, select_info_buf)
/* Select IDs for instanced draw-calls not using #PassMain. */
STORAGE_BUF(SELECT_ID_IN, READ, uint, in_select_buf[])
STORAGE_BUF(SELECT_ID_IN, read, uint, in_select_buf[])
/* Stores the result of the whole selection drawing. Content depends on selection mode. */
STORAGE_BUF(SELECT_ID_OUT, READ_WRITE, uint, out_select_buf[])
STORAGE_BUF(SELECT_ID_OUT, read_write, uint, out_select_buf[])
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(overlay_select)

74
source/blender/draw/engines/overlay/shaders/infos/overlay_edit_mode_info.hh
View File

@@ -39,7 +39,7 @@ GPU_SHADER_INTERFACE_END()
GPU_SHADER_CREATE_INFO(overlay_edit_mesh_common)
DEFINE_VALUE("blender_srgb_to_framebuffer_space(a)", "a")
SAMPLER(0, DEPTH_2D, depth_tx)
SAMPLER(0, sampler2DDepth, depth_tx)
DEFINE("LINE_OUTPUT")
FRAGMENT_OUT(0, float4, frag_color)
FRAGMENT_OUT(1, float4, line_output)
@@ -106,9 +106,9 @@ GPU_SHADER_NAMED_INTERFACE_END(geometry_noperspective_out)
GPU_SHADER_CREATE_INFO(overlay_edit_mesh_edge)
DO_STATIC_COMPILATION()
DEFINE("EDGE")
STORAGE_BUF_FREQ(0, READ, float, pos[], GEOMETRY)
STORAGE_BUF_FREQ(1, READ, uint, vnor[], GEOMETRY)
STORAGE_BUF_FREQ(2, READ, uint, data[], GEOMETRY)
STORAGE_BUF_FREQ(0, read, float, pos[], GEOMETRY)
STORAGE_BUF_FREQ(1, read, uint, vnor[], GEOMETRY)
STORAGE_BUF_FREQ(2, read, uint, data[], GEOMETRY)
PUSH_CONSTANT(int2, gpu_attr_0)
PUSH_CONSTANT(int2, gpu_attr_1)
PUSH_CONSTANT(int2, gpu_attr_2)
@@ -163,7 +163,7 @@ OVERLAY_INFO_CLIP_VARIATION(overlay_edit_mesh_facedot)
GPU_SHADER_CREATE_INFO(overlay_edit_mesh_normal)
PUSH_CONSTANT(int2, gpu_attr_0)
PUSH_CONSTANT(int2, gpu_attr_1)
SAMPLER(0, DEPTH_2D, depth_tx)
SAMPLER(0, sampler2DDepth, depth_tx)
PUSH_CONSTANT(float, normal_size)
PUSH_CONSTANT(float, normal_screen_size)
PUSH_CONSTANT(float, alpha)
@@ -183,10 +183,10 @@ ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(draw_modelmat)
ADDITIONAL_INFO(draw_globals)
ADDITIONAL_INFO(gpu_index_buffer_load)
STORAGE_BUF_FREQ(1, READ, float, pos[], GEOMETRY)
STORAGE_BUF_FREQ(1, read, float, pos[], GEOMETRY)
DEFINE("FACE_NORMAL")
PUSH_CONSTANT(bool, hq_normals)
STORAGE_BUF_FREQ(0, READ, uint, norAndFlag[], GEOMETRY)
STORAGE_BUF_FREQ(0, read, uint, norAndFlag[], GEOMETRY)
GPU_SHADER_CREATE_END()
OVERLAY_INFO_CLIP_VARIATION(overlay_mesh_face_normal)
@@ -198,10 +198,10 @@ ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(draw_modelmat)
ADDITIONAL_INFO(draw_globals)
ADDITIONAL_INFO(gpu_index_buffer_load)
STORAGE_BUF_FREQ(1, READ, float, pos[], GEOMETRY)
STORAGE_BUF_FREQ(1, read, float, pos[], GEOMETRY)
DEFINE("FACE_NORMAL")
DEFINE("FLOAT_NORMAL")
STORAGE_BUF_FREQ(0, READ, float4, norAndFlag[], GEOMETRY)
STORAGE_BUF_FREQ(0, read, float4, norAndFlag[], GEOMETRY)
GPU_SHADER_CREATE_END()
OVERLAY_INFO_CLIP_VARIATION(overlay_mesh_face_normal_subdiv)
@@ -213,10 +213,10 @@ ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(draw_modelmat)
ADDITIONAL_INFO(draw_globals)
ADDITIONAL_INFO(gpu_index_buffer_load)
STORAGE_BUF_FREQ(1, READ, float, pos[], GEOMETRY)
STORAGE_BUF_FREQ(1, read, float, pos[], GEOMETRY)
DEFINE("LOOP_NORMAL")
PUSH_CONSTANT(bool, hq_normals)
STORAGE_BUF_FREQ(0, READ, uint, lnor[], GEOMETRY)
STORAGE_BUF_FREQ(0, read, uint, lnor[], GEOMETRY)
GPU_SHADER_CREATE_END()
OVERLAY_INFO_CLIP_VARIATION(overlay_mesh_loop_normal)
@@ -228,10 +228,10 @@ ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(draw_modelmat)
ADDITIONAL_INFO(draw_globals)
ADDITIONAL_INFO(gpu_index_buffer_load)
STORAGE_BUF_FREQ(1, READ, float, pos[], GEOMETRY)
STORAGE_BUF_FREQ(1, read, float, pos[], GEOMETRY)
DEFINE("LOOP_NORMAL")
DEFINE("FLOAT_NORMAL")
STORAGE_BUF_FREQ(0, READ, float4, lnor[], GEOMETRY)
STORAGE_BUF_FREQ(0, read, float4, lnor[], GEOMETRY)
GPU_SHADER_CREATE_END()
OVERLAY_INFO_CLIP_VARIATION(overlay_mesh_loop_normal_subdiv)
@@ -243,9 +243,9 @@ ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(draw_modelmat)
ADDITIONAL_INFO(draw_globals)
ADDITIONAL_INFO(gpu_index_buffer_load)
STORAGE_BUF_FREQ(1, READ, float, pos[], GEOMETRY)
STORAGE_BUF_FREQ(1, read, float, pos[], GEOMETRY)
DEFINE("VERT_NORMAL")
STORAGE_BUF_FREQ(0, READ, uint, vnor[], GEOMETRY)
STORAGE_BUF_FREQ(0, read, uint, vnor[], GEOMETRY)
GPU_SHADER_CREATE_END()
OVERLAY_INFO_CLIP_VARIATION(overlay_mesh_vert_normal)
@@ -257,10 +257,10 @@ ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(draw_modelmat)
ADDITIONAL_INFO(draw_globals)
ADDITIONAL_INFO(gpu_index_buffer_load)
STORAGE_BUF_FREQ(1, READ, float, pos[], GEOMETRY)
STORAGE_BUF_FREQ(1, read, float, pos[], GEOMETRY)
DEFINE("VERT_NORMAL")
DEFINE("FLOAT_NORMAL")
STORAGE_BUF_FREQ(0, READ, float, vnor[], GEOMETRY)
STORAGE_BUF_FREQ(0, read, float, vnor[], GEOMETRY)
GPU_SHADER_CREATE_END()
OVERLAY_INFO_CLIP_VARIATION(overlay_mesh_vert_normal_subdiv)
@@ -273,7 +273,7 @@ GPU_SHADER_CREATE_INFO(overlay_edit_mesh_analysis)
DO_STATIC_COMPILATION()
VERTEX_IN(0, float3, pos)
VERTEX_IN(1, float, weight)
SAMPLER(0, FLOAT_1D, weight_tx)
SAMPLER(0, sampler1D, weight_tx)
FRAGMENT_OUT(0, float4, frag_color)
FRAGMENT_OUT(1, float4, line_output)
VERTEX_OUT(overlay_edit_mesh_analysis_iface)
@@ -296,7 +296,7 @@ ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(draw_modelmat)
ADDITIONAL_INFO(draw_globals)
/* TODO(fclem): Use correct vertex format. For now we read the format manually. */
STORAGE_BUF_FREQ(0, READ, float, size[], GEOMETRY)
STORAGE_BUF_FREQ(0, read, float, size[], GEOMETRY)
DEFINE("VERTEX_PULL")
GPU_SHADER_CREATE_END()
@@ -317,8 +317,8 @@ GPU_SHADER_INTERFACE_END()
GPU_SHADER_CREATE_INFO(overlay_edit_uv_edges)
DO_STATIC_COMPILATION()
STORAGE_BUF_FREQ(0, READ, float, au[], GEOMETRY)
STORAGE_BUF_FREQ(1, READ, uint, data[], GEOMETRY)
STORAGE_BUF_FREQ(0, read, float, au[], GEOMETRY)
STORAGE_BUF_FREQ(1, read, uint, data[], GEOMETRY)
PUSH_CONSTANT(int2, gpu_attr_0)
PUSH_CONSTANT(int2, gpu_attr_1)
PUSH_CONSTANT(int, line_style)
@@ -412,7 +412,7 @@ DO_STATIC_COMPILATION()
VERTEX_IN(0, float3, pos)
VERTEX_OUT(edit_uv_image_iface)
VERTEX_SOURCE("overlay_edit_uv_image_vert.glsl")
SAMPLER(0, FLOAT_2D, img_tx)
SAMPLER(0, sampler2D, img_tx)
PUSH_CONSTANT(bool, img_premultiplied)
PUSH_CONSTANT(bool, img_alpha_blend)
PUSH_CONSTANT(float4, ucolor)
@@ -427,7 +427,7 @@ GPU_SHADER_CREATE_INFO(overlay_edit_uv_mask_image)
DO_STATIC_COMPILATION()
VERTEX_IN(0, float3, pos)
VERTEX_OUT(edit_uv_image_iface)
SAMPLER(0, FLOAT_2D, img_tx)
SAMPLER(0, sampler2D, img_tx)
PUSH_CONSTANT(float4, color)
PUSH_CONSTANT(float, opacity)
FRAGMENT_OUT(0, float4, frag_color)
@@ -484,8 +484,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(overlay_edit_curve_handle)
DO_STATIC_COMPILATION()
TYPEDEF_SOURCE("overlay_shader_shared.hh")
STORAGE_BUF_FREQ(0, READ, float, pos[], GEOMETRY)
STORAGE_BUF_FREQ(1, READ, uint, data[], GEOMETRY)
STORAGE_BUF_FREQ(0, read, float, pos[], GEOMETRY)
STORAGE_BUF_FREQ(1, read, uint, data[], GEOMETRY)
PUSH_CONSTANT(int2, gpu_attr_0)
PUSH_CONSTANT(int2, gpu_attr_1)
VERTEX_OUT(overlay_edit_smooth_color_iface)
@@ -543,10 +543,10 @@ OVERLAY_INFO_CLIP_VARIATION(overlay_edit_curve_wire)
GPU_SHADER_CREATE_INFO(overlay_edit_curve_normals)
DO_STATIC_COMPILATION()
STORAGE_BUF_FREQ(0, READ, float, pos[], GEOMETRY)
STORAGE_BUF_FREQ(1, READ, float, rad[], GEOMETRY)
STORAGE_BUF_FREQ(2, READ, uint, nor[], GEOMETRY)
STORAGE_BUF_FREQ(3, READ, uint, tangent[], GEOMETRY)
STORAGE_BUF_FREQ(0, read, float, pos[], GEOMETRY)
STORAGE_BUF_FREQ(1, read, float, rad[], GEOMETRY)
STORAGE_BUF_FREQ(2, read, uint, nor[], GEOMETRY)
STORAGE_BUF_FREQ(3, read, uint, tangent[], GEOMETRY)
PUSH_CONSTANT(int2, gpu_attr_0)
PUSH_CONSTANT(int2, gpu_attr_1)
PUSH_CONSTANT(int2, gpu_attr_2)
@@ -574,9 +574,9 @@ OVERLAY_INFO_CLIP_VARIATION(overlay_edit_curve_normals)
GPU_SHADER_CREATE_INFO(overlay_edit_curves_handle)
DO_STATIC_COMPILATION()
TYPEDEF_SOURCE("overlay_shader_shared.hh")
STORAGE_BUF_FREQ(0, READ, float, pos[], GEOMETRY)
STORAGE_BUF_FREQ(1, READ, uint, data[], GEOMETRY)
STORAGE_BUF_FREQ(2, READ, float, selection[], GEOMETRY)
STORAGE_BUF_FREQ(0, read, float, pos[], GEOMETRY)
STORAGE_BUF_FREQ(1, read, uint, data[], GEOMETRY)
STORAGE_BUF_FREQ(2, read, float, selection[], GEOMETRY)
PUSH_CONSTANT(int2, gpu_attr_0)
PUSH_CONSTANT(int2, gpu_attr_1)
PUSH_CONSTANT(int2, gpu_attr_2)
@@ -606,7 +606,7 @@ VERTEX_IN(3, uint, vflag)
PUSH_CONSTANT(bool, do_stroke_endpoints)
#endif
VERTEX_OUT(overlay_edit_flat_color_iface)
SAMPLER(0, FLOAT_1D, weight_tx)
SAMPLER(0, sampler1D, weight_tx)
PUSH_CONSTANT(bool, use_weight)
PUSH_CONSTANT(bool, use_grease_pencil)
PUSH_CONSTANT(int, curve_handle_display)
@@ -644,7 +644,7 @@ OVERLAY_INFO_VARIATIONS_MODELMAT(overlay_edit_lattice_point, overlay_edit_lattic
GPU_SHADER_CREATE_INFO(overlay_edit_lattice_wire_base)
VERTEX_IN(0, float3, pos)
VERTEX_IN(1, float, weight)
SAMPLER(0, FLOAT_1D, weight_tx)
SAMPLER(0, sampler1D, weight_tx)
VERTEX_OUT(overlay_edit_smooth_color_iface)
DEFINE("LINE_OUTPUT")
FRAGMENT_OUT(0, float4, frag_color)
@@ -667,7 +667,7 @@ GPU_SHADER_CREATE_INFO(overlay_edit_particle_strand)
DO_STATIC_COMPILATION()
VERTEX_IN(0, float3, pos)
VERTEX_IN(1, float, selection)
SAMPLER(0, FLOAT_1D, weight_tx)
SAMPLER(0, sampler1D, weight_tx)
PUSH_CONSTANT(bool, use_weight)
PUSH_CONSTANT(bool, use_grease_pencil)
VERTEX_OUT(overlay_edit_smooth_color_iface)
@@ -686,7 +686,7 @@ DO_STATIC_COMPILATION()
VERTEX_IN(0, float3, pos)
VERTEX_IN(1, float, selection)
VERTEX_OUT(overlay_edit_flat_color_iface)
SAMPLER(0, FLOAT_1D, weight_tx)
SAMPLER(0, sampler1D, weight_tx)
PUSH_CONSTANT(bool, use_weight)
PUSH_CONSTANT(bool, use_grease_pencil)
FRAGMENT_OUT(0, float4, frag_color)
@@ -744,7 +744,7 @@ GPU_SHADER_CREATE_END()
OVERLAY_INFO_VARIATIONS_MODELMAT(overlay_depth_mesh, overlay_depth_mesh_base)
GPU_SHADER_CREATE_INFO(overlay_depth_mesh_conservative_base)
STORAGE_BUF_FREQ(0, READ, float, pos[], GEOMETRY)
STORAGE_BUF_FREQ(0, read, float, pos[], GEOMETRY)
PUSH_CONSTANT(int2, gpu_attr_0)
VERTEX_SOURCE("overlay_depth_only_mesh_conservative_vert.glsl")
FRAGMENT_SOURCE("overlay_depth_only_frag.glsl")

22
source/blender/draw/engines/overlay/shaders/infos/overlay_extra_info.hh
View File

@@ -39,7 +39,7 @@ VERTEX_SOURCE("overlay_extra_vert.glsl")
FRAGMENT_SOURCE("overlay_extra_frag.glsl")
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(draw_globals)
STORAGE_BUF(0, READ, ExtraInstanceData, data_buf[])
STORAGE_BUF(0, read, ExtraInstanceData, data_buf[])
GPU_SHADER_CREATE_END()
OVERLAY_INFO_VARIATIONS(overlay_extra)
@@ -63,7 +63,7 @@ FLAT(float4, final_color)
GPU_SHADER_INTERFACE_END()
GPU_SHADER_CREATE_INFO(overlay_extra_grid_base)
SAMPLER(0, DEPTH_2D, depth_buffer)
SAMPLER(0, sampler2DDepth, depth_buffer)
PUSH_CONSTANT(float4x4, grid_model_matrix)
PUSH_CONSTANT(bool, is_transform)
VERTEX_OUT(overlay_extra_grid_iface)
@@ -93,7 +93,7 @@ VERTEX_SOURCE("overlay_extra_groundline_vert.glsl")
FRAGMENT_SOURCE("overlay_extra_frag.glsl")
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(draw_globals)
STORAGE_BUF(0, READ, float4, data_buf[])
STORAGE_BUF(0, read, float4, data_buf[])
GPU_SHADER_CREATE_END()
OVERLAY_INFO_VARIATIONS(overlay_extra_groundline)
@@ -117,7 +117,7 @@ FRAGMENT_OUT(1, float4, line_output)
VERTEX_SOURCE("overlay_extra_wire_vert.glsl")
FRAGMENT_SOURCE("overlay_extra_wire_frag.glsl")
TYPEDEF_SOURCE("overlay_shader_shared.hh")
STORAGE_BUF(0, READ, VertexData, data_buf[])
STORAGE_BUF(0, read, VertexData, data_buf[])
PUSH_CONSTANT(int, colorid)
DEFINE_VALUE("pos", "data_buf[gl_VertexID].pos_.xyz")
DEFINE_VALUE("color", "data_buf[gl_VertexID].color_")
@@ -166,7 +166,7 @@ FRAGMENT_SOURCE("overlay_point_varying_color_varying_outline_aa_frag.glsl")
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(draw_globals)
TYPEDEF_SOURCE("overlay_shader_shared.hh")
STORAGE_BUF(0, READ, VertexData, data_buf[])
STORAGE_BUF(0, read, VertexData, data_buf[])
GPU_SHADER_CREATE_END()
OVERLAY_INFO_VARIATIONS_MODELMAT(overlay_extra_point, overlay_extra_point_base)
@@ -182,7 +182,7 @@ FRAGMENT_OUT(1, float4, line_output)
VERTEX_SOURCE("overlay_extra_loose_point_vert.glsl")
FRAGMENT_SOURCE("overlay_extra_loose_point_frag.glsl")
TYPEDEF_SOURCE("overlay_shader_shared.hh")
STORAGE_BUF(0, READ, VertexData, data_buf[])
STORAGE_BUF(0, read, VertexData, data_buf[])
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(draw_globals)
GPU_SHADER_CREATE_END()
@@ -201,7 +201,7 @@ GPU_SHADER_NAMED_INTERFACE_END(interp)
GPU_SHADER_CREATE_INFO(overlay_motion_path_line)
DO_STATIC_COMPILATION()
STORAGE_BUF_FREQ(0, READ, float, pos[], GEOMETRY)
STORAGE_BUF_FREQ(0, read, float, pos[], GEOMETRY)
PUSH_CONSTANT(int2, gpu_attr_0)
PUSH_CONSTANT(int4, mpath_line_settings)
PUSH_CONSTANT(bool, selected)
@@ -262,7 +262,7 @@ PUSH_CONSTANT(bool, img_alpha_blend)
PUSH_CONSTANT(float4, ucolor)
VERTEX_IN(0, float3, pos)
VERTEX_OUT(overlay_image_iface)
SAMPLER(0, FLOAT_2D, img_tx)
SAMPLER(0, sampler2D, img_tx)
FRAGMENT_OUT(0, float4, frag_color)
VERTEX_SOURCE("overlay_image_vert.glsl")
FRAGMENT_SOURCE("overlay_image_frag.glsl")
@@ -316,7 +316,7 @@ FLAT(float4, final_color)
GPU_SHADER_INTERFACE_END()
GPU_SHADER_CREATE_INFO(overlay_particle_dot_base)
SAMPLER(0, FLOAT_1D, weight_tx)
SAMPLER(0, sampler1D, weight_tx)
PUSH_CONSTANT(float4, ucolor) /* Draw-size packed in alpha. */
VERTEX_IN(0, float3, part_pos)
VERTEX_IN(1, float4, part_rot)
@@ -334,11 +334,11 @@ OVERLAY_INFO_VARIATIONS_MODELMAT(overlay_particle_dot, overlay_particle_dot_base
GPU_SHADER_CREATE_INFO(overlay_particle_shape_base)
TYPEDEF_SOURCE("overlay_shader_shared.hh")
SAMPLER(0, FLOAT_1D, weight_tx)
SAMPLER(0, sampler1D, weight_tx)
PUSH_CONSTANT(float4, ucolor) /* Draw-size packed in alpha. */
PUSH_CONSTANT(int, shape_type)
/* Use first attribute to only bind one buffer. */
STORAGE_BUF_FREQ(0, READ, ParticlePointData, part_pos[], GEOMETRY)
STORAGE_BUF_FREQ(0, read, ParticlePointData, part_pos[], GEOMETRY)
VERTEX_OUT(overlay_extra_iface)
FRAGMENT_OUT(0, float4, frag_color)
FRAGMENT_OUT(1, float4, line_output)

8
source/blender/draw/engines/overlay/shaders/infos/overlay_grid_info.hh
View File

@@ -25,8 +25,8 @@ TYPEDEF_SOURCE("overlay_shader_shared.hh")
VERTEX_IN(0, float3, pos)
VERTEX_OUT(overlay_grid_iface)
FRAGMENT_OUT(0, float4, out_color)
SAMPLER(0, DEPTH_2D, depth_tx)
SAMPLER(1, DEPTH_2D, depth_infront_tx)
SAMPLER(0, sampler2DDepth, depth_tx)
SAMPLER(1, sampler2DDepth, depth_infront_tx)
UNIFORM_BUF(3, OVERLAY_GridData, grid_buf)
PUSH_CONSTANT(float3, plane_axes)
PUSH_CONSTANT(int, grid_flag)
@@ -39,7 +39,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(overlay_grid_background)
DO_STATIC_COMPILATION()
VERTEX_IN(0, float3, pos)
SAMPLER(0, DEPTH_2D, depth_buffer)
SAMPLER(0, sampler2DDepth, depth_buffer)
PUSH_CONSTANT(float4, ucolor)
FRAGMENT_OUT(0, float4, frag_color)
VERTEX_SOURCE("overlay_edit_uv_tiled_image_borders_vert.glsl")
@@ -61,7 +61,7 @@ FRAGMENT_SOURCE("overlay_uniform_color_frag.glsl")
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(draw_modelmat)
ADDITIONAL_INFO(draw_globals)
STORAGE_BUF(0, READ, float3, tile_pos_buf[])
STORAGE_BUF(0, read, float3, tile_pos_buf[])
DEFINE_VALUE("tile_pos", "tile_pos_buf[gl_InstanceID]")
DEFINE_VALUE("tile_scale", "float3(1.0f)");
GPU_SHADER_CREATE_END()

8
source/blender/draw/engines/overlay/shaders/infos/overlay_outline_info.hh
View File

@@ -80,7 +80,7 @@ ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(draw_mesh)
ADDITIONAL_INFO(draw_object_infos)
ADDITIONAL_INFO(gpu_index_buffer_load)
STORAGE_BUF_FREQ(0, READ, float, pos[], GEOMETRY)
STORAGE_BUF_FREQ(0, read, float, pos[], GEOMETRY)
PUSH_CONSTANT(int2, gpu_attr_0)
VERTEX_SOURCE("overlay_outline_prepass_wire_vert.glsl")
GPU_SHADER_CREATE_END()
@@ -145,9 +145,9 @@ PUSH_CONSTANT(float, alpha_occlu)
PUSH_CONSTANT(bool, is_xray_wires)
PUSH_CONSTANT(bool, do_anti_aliasing)
PUSH_CONSTANT(bool, do_thick_outlines)
SAMPLER(0, UINT_2D, outline_id_tx)
SAMPLER(1, DEPTH_2D, outline_depth_tx)
SAMPLER(2, DEPTH_2D, scene_depth_tx)
SAMPLER(0, usampler2D, outline_id_tx)
SAMPLER(1, sampler2DDepth, outline_depth_tx)
SAMPLER(2, sampler2DDepth, scene_depth_tx)
FRAGMENT_OUT(0, float4, frag_color)
FRAGMENT_OUT(1, float4, line_output)
FRAGMENT_SOURCE("overlay_outline_detect_frag.glsl")

4
source/blender/draw/engines/overlay/shaders/infos/overlay_paint_info.hh
View File

@@ -78,7 +78,7 @@ DO_STATIC_COMPILATION()
VERTEX_IN(0, float3, pos)
VERTEX_IN(1, float2, mu) /* Masking uv map. */
VERTEX_OUT(overlay_paint_texture_iface)
SAMPLER(0, FLOAT_2D, mask_image)
SAMPLER(0, sampler2D, mask_image)
PUSH_CONSTANT(float3, mask_color)
PUSH_CONSTANT(float, opacity) /* `1.0f` by default. */
PUSH_CONSTANT(bool, mask_invert_stencil)
@@ -113,7 +113,7 @@ VERTEX_IN(0, float, weight)
VERTEX_IN(1, float3, pos)
VERTEX_IN(2, float3, nor)
VERTEX_OUT(overlay_paint_weight_iface)
SAMPLER(0, FLOAT_1D, colorramp)
SAMPLER(0, sampler1D, colorramp)
PUSH_CONSTANT(float, opacity) /* `1.0f` by default. */
PUSH_CONSTANT(bool, draw_contours) /* `false` by default. */
FRAGMENT_OUT(0, float4, frag_color)

2
source/blender/draw/engines/overlay/shaders/infos/overlay_sculpt_curves_info.hh
View File

@@ -24,7 +24,7 @@ GPU_SHADER_CREATE_INFO(overlay_sculpt_curves_selection)
DO_STATIC_COMPILATION()
PUSH_CONSTANT(bool, is_point_domain)
PUSH_CONSTANT(float, selection_opacity)
SAMPLER(1, FLOAT_BUFFER, selection_tx)
SAMPLER(1, samplerBuffer, selection_tx)
VERTEX_OUT(overlay_sculpt_curves_selection_iface)
VERTEX_SOURCE("overlay_sculpt_curves_selection_vert.glsl")
FRAGMENT_SOURCE("overlay_sculpt_curves_selection_frag.glsl")

4
source/blender/draw/engines/overlay/shaders/infos/overlay_viewer_attribute_info.hh
View File

@@ -51,7 +51,7 @@ VERTEX_SOURCE("overlay_viewer_attribute_pointcloud_vert.glsl")
FRAGMENT_SOURCE("overlay_viewer_attribute_frag.glsl")
FRAGMENT_OUT(0, float4, out_color)
FRAGMENT_OUT(1, float4, line_output)
SAMPLER(3, FLOAT_BUFFER, attribute_tx)
SAMPLER(3, samplerBuffer, attribute_tx)
VERTEX_OUT(overlay_viewer_attribute_iface)
ADDITIONAL_INFO(overlay_viewer_attribute_common)
ADDITIONAL_INFO(draw_pointcloud)
@@ -85,7 +85,7 @@ VERTEX_SOURCE("overlay_viewer_attribute_curves_vert.glsl")
FRAGMENT_SOURCE("overlay_viewer_attribute_frag.glsl")
FRAGMENT_OUT(0, float4, out_color)
FRAGMENT_OUT(1, float4, line_output)
SAMPLER(1, FLOAT_BUFFER, color_tx)
SAMPLER(1, samplerBuffer, color_tx)
PUSH_CONSTANT(bool, is_point_domain)
VERTEX_OUT(overlay_viewer_attribute_iface)
ADDITIONAL_INFO(overlay_viewer_attribute_common)

12
source/blender/draw/engines/overlay/shaders/infos/overlay_volume_info.hh
View File

@@ -26,9 +26,9 @@ SMOOTH(float4, final_color)
GPU_SHADER_INTERFACE_END()
GPU_SHADER_CREATE_INFO(overlay_volume_velocity)
SAMPLER(0, FLOAT_3D, velocity_x)
SAMPLER(1, FLOAT_3D, velocity_y)
SAMPLER(2, FLOAT_3D, velocity_z)
SAMPLER(0, sampler3D, velocity_x)
SAMPLER(1, sampler3D, velocity_y)
SAMPLER(2, sampler3D, velocity_z)
PUSH_CONSTANT(float, display_size)
PUSH_CONSTANT(float, slice_position)
PUSH_CONSTANT(int, slice_axis)
@@ -119,7 +119,7 @@ OVERLAY_INFO_SELECT_VARIATION(overlay_volume_gridlines_flat)
GPU_SHADER_CREATE_INFO(overlay_volume_gridlines_flags)
DO_STATIC_COMPILATION()
DEFINE("SHOW_FLAGS")
SAMPLER(0, UINT_3D, flag_tx)
SAMPLER(0, usampler3D, flag_tx)
ADDITIONAL_INFO(draw_volume)
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(overlay_volume_gridlines)
@@ -134,8 +134,8 @@ PUSH_CONSTANT(float, lower_bound)
PUSH_CONSTANT(float, upper_bound)
PUSH_CONSTANT(float4, range_color)
PUSH_CONSTANT(int, cell_filter)
SAMPLER(0, UINT_3D, flag_tx)
SAMPLER(1, FLOAT_3D, field_tx)
SAMPLER(0, usampler3D, flag_tx)
SAMPLER(1, sampler3D, field_tx)
ADDITIONAL_INFO(draw_volume)
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(overlay_volume_gridlines)

4
source/blender/draw/engines/overlay/shaders/infos/overlay_wireframe_info.hh
View File

@@ -33,7 +33,7 @@ PUSH_CONSTANT(int, color_type)
PUSH_CONSTANT(bool, is_hair)
PUSH_CONSTANT(float4x4, hair_dupli_matrix)
/* Scene Depth texture copy for manual depth test. */
SAMPLER(0, DEPTH_2D, depth_tx)
SAMPLER(0, sampler2DDepth, depth_tx)
VERTEX_IN(0, float3, pos)
VERTEX_IN(1, float3, nor)
VERTEX_IN(2, float, wd) /* wire-data. */
@@ -105,7 +105,7 @@ GPU_SHADER_INTERFACE_END()
GPU_SHADER_CREATE_INFO(overlay_wireframe_uv)
DO_STATIC_COMPILATION()
DEFINE("WIREFRAME")
STORAGE_BUF_FREQ(0, READ, float, au[], GEOMETRY)
STORAGE_BUF_FREQ(0, read, float, au[], GEOMETRY)
PUSH_CONSTANT(int2, gpu_attr_0)
DEFINE_VALUE("line_style", "4u" /* OVERLAY_UV_LINE_STYLE_SHADOW */)
DEFINE_VALUE("dash_length", "1" /* Not used by this line style */)

2
source/blender/draw/engines/select/shaders/infos/select_id_info.hh
View File

@@ -63,7 +63,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(select_debug_fullscreen)
ADDITIONAL_INFO(gpu_fullscreen)
FRAGMENT_SOURCE("select_debug_frag.glsl")
SAMPLER(0, UINT_2D, image)
SAMPLER(0, usampler2D, image)
FRAGMENT_OUT(0, float4, frag_color)
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

14
source/blender/draw/engines/workbench/shaders/infos/workbench_composite_info.hh
View File

@@ -29,9 +29,9 @@
* \{ */
GPU_SHADER_CREATE_INFO(workbench_composite)
SAMPLER(3, DEPTH_2D, depth_tx)
SAMPLER(4, FLOAT_2D, normal_tx)
SAMPLER(5, FLOAT_2D, material_tx)
SAMPLER(3, sampler2DDepth, depth_tx)
SAMPLER(4, sampler2D, normal_tx)
SAMPLER(5, sampler2D, material_tx)
UNIFORM_BUF(WB_WORLD_SLOT, WorldData, world_data)
TYPEDEF_SOURCE("workbench_shader_shared.hh")
PUSH_CONSTANT(bool, force_shadowing)
@@ -49,7 +49,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_resolve_opaque_matcap)
DEFINE("WORKBENCH_LIGHTING_MATCAP")
SAMPLER(WB_MATCAP_SLOT, FLOAT_2D_ARRAY, matcap_tx)
SAMPLER(WB_MATCAP_SLOT, sampler2DArray, matcap_tx)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_resolve_opaque_flat)
@@ -60,20 +60,20 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_resolve_curvature)
DEFINE("WORKBENCH_CURVATURE")
SAMPLER(6, UINT_2D, object_id_tx)
SAMPLER(6, usampler2D, object_id_tx)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_resolve_cavity)
DEFINE("WORKBENCH_CAVITY")
/* TODO(@pragma37): GPU_SAMPLER_EXTEND_MODE_REPEAT is set in CavityEffect,
* it doesn't work here? */
SAMPLER(7, FLOAT_2D, jitter_tx)
SAMPLER(7, sampler2D, jitter_tx)
UNIFORM_BUF(5, float4, cavity_samples[512])
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_resolve_shadow)
DEFINE("WORKBENCH_SHADOW")
SAMPLER(8, UINT_2D, stencil_tx)
SAMPLER(8, usampler2D, stencil_tx)
GPU_SHADER_CREATE_END()
/* Variations */

2
source/blender/draw/engines/workbench/shaders/infos/workbench_depth_info.hh
View File

@@ -12,7 +12,7 @@
#include "gpu_shader_create_info.hh"
GPU_SHADER_CREATE_INFO(workbench_merge_depth)
SAMPLER(0, DEPTH_2D, depth_tx)
SAMPLER(0, sampler2DDepth, depth_tx)
FRAGMENT_SOURCE("workbench_merge_depth_frag.glsl")
ADDITIONAL_INFO(gpu_fullscreen)
DEPTH_WRITE(DepthWrite::ANY)

14
source/blender/draw/engines/workbench/shaders/infos/workbench_effect_antialiasing_info.hh
View File

@@ -23,7 +23,7 @@
* \{ */
GPU_SHADER_CREATE_INFO(workbench_taa)
SAMPLER(0, FLOAT_2D, color_buffer)
SAMPLER(0, sampler2D, color_buffer)
PUSH_CONSTANT_ARRAY(float, samplesWeights, 9)
FRAGMENT_OUT(0, float4, frag_color)
FRAGMENT_SOURCE("workbench_effect_taa_frag.glsl")
@@ -57,7 +57,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_smaa_stage_0)
DEFINE_VALUE("SMAA_STAGE", "0")
SAMPLER(0, FLOAT_2D, color_tx)
SAMPLER(0, sampler2D, color_tx)
FRAGMENT_OUT(0, float2, out_edges)
ADDITIONAL_INFO(workbench_smaa)
DO_STATIC_COMPILATION()
@@ -65,9 +65,9 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_smaa_stage_1)
DEFINE_VALUE("SMAA_STAGE", "1")
SAMPLER(0, FLOAT_2D, edges_tx)
SAMPLER(1, FLOAT_2D, area_tx)
SAMPLER(2, FLOAT_2D, search_tx)
SAMPLER(0, sampler2D, edges_tx)
SAMPLER(1, sampler2D, area_tx)
SAMPLER(2, sampler2D, search_tx)
FRAGMENT_OUT(0, float4, out_weights)
ADDITIONAL_INFO(workbench_smaa)
DO_STATIC_COMPILATION()
@@ -75,8 +75,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_smaa_stage_2)
DEFINE_VALUE("SMAA_STAGE", "2")
SAMPLER(0, FLOAT_2D, color_tx)
SAMPLER(1, FLOAT_2D, blend_tx)
SAMPLER(0, sampler2D, color_tx)
SAMPLER(1, sampler2D, blend_tx)
PUSH_CONSTANT(float, mix_factor)
PUSH_CONSTANT(float, taa_accumulated_weight)
FRAGMENT_OUT(0, float4, out_color)

36
source/blender/draw/engines/workbench/shaders/infos/workbench_effect_dof_info.hh
View File

@@ -24,12 +24,12 @@
/*
* NOTE: Keep the sampler bind points consistent between the steps.
*
* SAMPLER(0, FLOAT_2D, input_coc_tx)
* SAMPLER(1, FLOAT_2D, scene_color_tx)
* SAMPLER(2, FLOAT_2D, scene_depth_tx)
* SAMPLER(3, FLOAT_2D, half_res_color_tx)
* SAMPLER(4, FLOAT_2D, blur_tx)
* SAMPLER(5, FLOAT_2D, noise_tx)
* SAMPLER(0, sampler2D, input_coc_tx)
* SAMPLER(1, sampler2D, scene_color_tx)
* SAMPLER(2, sampler2D, scene_depth_tx)
* SAMPLER(3, sampler2D, half_res_color_tx)
* SAMPLER(4, sampler2D, blur_tx)
* SAMPLER(5, sampler2D, noise_tx)
*/
GPU_SHADER_CREATE_INFO(workbench_effect_dof)
@@ -42,8 +42,8 @@ ADDITIONAL_INFO(draw_view)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_effect_dof_prepare)
SAMPLER(1, FLOAT_2D, scene_color_tx)
SAMPLER(2, FLOAT_2D, scene_depth_tx)
SAMPLER(1, sampler2D, scene_color_tx)
SAMPLER(2, sampler2D, scene_depth_tx)
FRAGMENT_OUT(0, float4, halfResColor)
FRAGMENT_OUT(1, float2, normalizedCoc)
FRAGMENT_SOURCE("workbench_effect_dof_prepare_frag.glsl")
@@ -52,8 +52,8 @@ DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_effect_dof_downsample)
SAMPLER(0, FLOAT_2D, input_coc_tx)
SAMPLER(1, FLOAT_2D, scene_color_tx)
SAMPLER(0, sampler2D, input_coc_tx)
SAMPLER(1, sampler2D, scene_color_tx)
FRAGMENT_OUT(0, float4, outColor)
FRAGMENT_OUT(1, float2, outCocs)
FRAGMENT_SOURCE("workbench_effect_dof_downsample_frag.glsl")
@@ -63,9 +63,9 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_effect_dof_blur1)
DEFINE_VALUE("NUM_SAMPLES", "49")
SAMPLER(0, FLOAT_2D, input_coc_tx)
SAMPLER(3, FLOAT_2D, half_res_color_tx)
SAMPLER(5, FLOAT_2D, noise_tx)
SAMPLER(0, sampler2D, input_coc_tx)
SAMPLER(3, sampler2D, half_res_color_tx)
SAMPLER(5, sampler2D, noise_tx)
UNIFORM_BUF(1, float4, samples[49])
FRAGMENT_OUT(0, float4, blurColor)
FRAGMENT_SOURCE("workbench_effect_dof_blur1_frag.glsl")
@@ -74,8 +74,8 @@ DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_effect_dof_blur2)
SAMPLER(0, FLOAT_2D, input_coc_tx)
SAMPLER(4, FLOAT_2D, blur_tx)
SAMPLER(0, sampler2D, input_coc_tx)
SAMPLER(4, sampler2D, blur_tx)
FRAGMENT_OUT(0, float4, final_color)
FRAGMENT_SOURCE("workbench_effect_dof_blur2_frag.glsl")
ADDITIONAL_INFO(workbench_effect_dof)
@@ -83,9 +83,9 @@ DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_effect_dof_resolve)
SAMPLER(1, FLOAT_2D, scene_color_tx)
SAMPLER(2, FLOAT_2D, scene_depth_tx)
SAMPLER(3, FLOAT_2D, half_res_color_tx)
SAMPLER(1, sampler2D, scene_color_tx)
SAMPLER(2, sampler2D, scene_depth_tx)
SAMPLER(3, sampler2D, half_res_color_tx)
FRAGMENT_OUT_DUAL(0, float4, final_colorAdd, SRC_0)
FRAGMENT_OUT_DUAL(0, float4, final_colorMul, SRC_1)
FRAGMENT_SOURCE("workbench_effect_dof_resolve_frag.glsl")

2
source/blender/draw/engines/workbench/shaders/infos/workbench_effect_outline_info.hh
View File

@@ -16,7 +16,7 @@
GPU_SHADER_CREATE_INFO(workbench_effect_outline)
TYPEDEF_SOURCE("workbench_shader_shared.hh")
FRAGMENT_SOURCE("workbench_effect_outline_frag.glsl")
SAMPLER(0, UINT_2D, object_id_buffer)
SAMPLER(0, usampler2D, object_id_buffer)
UNIFORM_BUF(WB_WORLD_SLOT, WorldData, world_data)
FRAGMENT_OUT(0, float4, frag_color)
ADDITIONAL_INFO(gpu_fullscreen)

16
source/blender/draw/engines/workbench/shaders/infos/workbench_prepass_info.hh
View File

@@ -44,8 +44,8 @@ ADDITIONAL_INFO(draw_modelmat_with_custom_id)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_curves)
SAMPLER_FREQ(WB_CURVES_COLOR_SLOT, FLOAT_BUFFER, ac, BATCH)
SAMPLER_FREQ(WB_CURVES_UV_SLOT, FLOAT_BUFFER, au, BATCH)
SAMPLER_FREQ(WB_CURVES_COLOR_SLOT, samplerBuffer, ac, BATCH)
SAMPLER_FREQ(WB_CURVES_UV_SLOT, samplerBuffer, au, BATCH)
PUSH_CONSTANT(int, emitter_object_id)
VERTEX_SOURCE("workbench_prepass_hair_vert.glsl")
ADDITIONAL_INFO(draw_modelmat_with_custom_id)
@@ -72,7 +72,7 @@ DEFINE("WORKBENCH_LIGHTING_STUDIO")
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_lighting_matcap)
DEFINE("WORKBENCH_LIGHTING_MATCAP")
SAMPLER(WB_MATCAP_SLOT, FLOAT_2D_ARRAY, matcap_tx)
SAMPLER(WB_MATCAP_SLOT, sampler2DArray, matcap_tx)
GPU_SHADER_CREATE_END()
/** \} */
@@ -93,17 +93,17 @@ GPU_SHADER_INTERFACE_END()
GPU_SHADER_CREATE_INFO(workbench_color_material)
DEFINE("WORKBENCH_COLOR_MATERIAL")
STORAGE_BUF(WB_MATERIAL_SLOT, READ, float4, materials_data[])
STORAGE_BUF(WB_MATERIAL_SLOT, read, float4, materials_data[])
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_color_texture)
DEFINE("WORKBENCH_COLOR_TEXTURE")
DEFINE("WORKBENCH_TEXTURE_IMAGE_ARRAY")
DEFINE("WORKBENCH_COLOR_MATERIAL")
STORAGE_BUF(WB_MATERIAL_SLOT, READ, float4, materials_data[])
SAMPLER_FREQ(WB_TEXTURE_SLOT, FLOAT_2D, imageTexture, BATCH)
SAMPLER_FREQ(WB_TILE_ARRAY_SLOT, FLOAT_2D_ARRAY, imageTileArray, BATCH)
SAMPLER_FREQ(WB_TILE_DATA_SLOT, FLOAT_1D_ARRAY, imageTileData, BATCH)
STORAGE_BUF(WB_MATERIAL_SLOT, read, float4, materials_data[])
SAMPLER_FREQ(WB_TEXTURE_SLOT, sampler2D, imageTexture, BATCH)
SAMPLER_FREQ(WB_TILE_ARRAY_SLOT, sampler2DArray, imageTileArray, BATCH)
SAMPLER_FREQ(WB_TILE_DATA_SLOT, sampler1DArray, imageTileData, BATCH)
PUSH_CONSTANT(bool, is_image_tile)
PUSH_CONSTANT(bool, image_premult)
PUSH_CONSTANT(float, image_transparency_cutoff)

10
source/blender/draw/engines/workbench/shaders/infos/workbench_shadow_info.hh
View File

@@ -29,7 +29,7 @@
* \{ */
GPU_SHADER_CREATE_INFO(workbench_shadow_common)
STORAGE_BUF_FREQ(3, READ, float, pos[], GEOMETRY)
STORAGE_BUF_FREQ(3, read, float, pos[], GEOMETRY)
/* WORKAROUND: Needed to support OpenSubdiv vertex format. Should be removed. */
PUSH_CONSTANT(int2, gpu_attr_3)
UNIFORM_BUF(1, ShadowPassData, pass_data)
@@ -42,7 +42,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_shadow_visibility_compute_common)
LOCAL_GROUP_SIZE(DRW_VISIBILITY_GROUP_SIZE)
DEFINE_VALUE("DRW_VIEW_LEN", "64")
STORAGE_BUF(0, READ, ObjectBounds, bounds_buf[])
STORAGE_BUF(0, read, ObjectBounds, bounds_buf[])
UNIFORM_BUF(2, ExtrudedFrustum, extruded_frustum)
PUSH_CONSTANT(int, resource_len)
PUSH_CONSTANT(int, view_len)
@@ -58,14 +58,14 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_shadow_visibility_compute_dynamic_pass_type)
ADDITIONAL_INFO(workbench_shadow_visibility_compute_common)
DEFINE("DYNAMIC_PASS_SELECTION")
STORAGE_BUF(1, READ_WRITE, uint, pass_visibility_buf[])
STORAGE_BUF(2, READ_WRITE, uint, fail_visibility_buf[])
STORAGE_BUF(1, read_write, uint, pass_visibility_buf[])
STORAGE_BUF(2, read_write, uint, fail_visibility_buf[])
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_shadow_visibility_compute_static_pass_type)
ADDITIONAL_INFO(workbench_shadow_visibility_compute_common)
STORAGE_BUF(1, READ_WRITE, uint, visibility_buf[])
STORAGE_BUF(1, read_write, uint, visibility_buf[])
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

4
source/blender/draw/engines/workbench/shaders/infos/workbench_transparent_resolve_info.hh
View File

@@ -13,8 +13,8 @@
GPU_SHADER_CREATE_INFO(workbench_transparent_resolve)
FRAGMENT_OUT(0, float4, frag_color)
SAMPLER(0, FLOAT_2D, transparent_accum)
SAMPLER(1, FLOAT_2D, transparent_revealage)
SAMPLER(0, sampler2D, transparent_accum)
SAMPLER(1, sampler2D, transparent_revealage)
FRAGMENT_SOURCE("workbench_transparent_resolve_frag.glsl")
ADDITIONAL_INFO(gpu_fullscreen)
DO_STATIC_COMPILATION()

16
source/blender/draw/engines/workbench/shaders/infos/workbench_volume_info.hh
View File

@@ -29,8 +29,8 @@
GPU_SHADER_CREATE_INFO(workbench_volume_common)
VERTEX_IN(0, float3, pos)
FRAGMENT_OUT(0, float4, frag_color)
SAMPLER(0, DEPTH_2D, depth_buffer)
SAMPLER(1, FLOAT_3D, density_tx)
SAMPLER(0, sampler2DDepth, depth_buffer)
SAMPLER(1, sampler3D, density_tx)
PUSH_CONSTANT(int, samples_len)
PUSH_CONSTANT(float, noise_ofs)
PUSH_CONSTANT(float, step_length)
@@ -41,7 +41,7 @@ FRAGMENT_SOURCE("workbench_volume_frag.glsl")
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_volume)
SAMPLER(6, UINT_2D, stencil_tx)
SAMPLER(6, usampler2D, stencil_tx)
ADDITIONAL_INFO(workbench_volume_common)
ADDITIONAL_INFO(draw_object_infos)
ADDITIONAL_INFO(draw_view)
@@ -54,8 +54,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_volume_smoke_common)
DEFINE("VOLUME_SMOKE")
SAMPLER(2, FLOAT_3D, flame_tx)
SAMPLER(3, FLOAT_1D, flame_color_tx)
SAMPLER(2, sampler3D, flame_tx)
SAMPLER(3, sampler1D, flame_color_tx)
ADDITIONAL_INFO(draw_resource_id_varying)
GPU_SHADER_CREATE_END()
@@ -85,8 +85,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_volume_coba)
DEFINE("USE_COBA")
SAMPLER(4, UINT_3D, flag_tx)
SAMPLER(5, FLOAT_1D, transfer_tx)
SAMPLER(4, usampler3D, flag_tx)
SAMPLER(5, sampler1D, transfer_tx)
PUSH_CONSTANT(bool, show_phi)
PUSH_CONSTANT(bool, show_flags)
PUSH_CONSTANT(bool, show_pressure)
@@ -94,7 +94,7 @@ PUSH_CONSTANT(float, grid_scale)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(workbench_volume_no_coba)
SAMPLER(4, FLOAT_3D, shadow_tx)
SAMPLER(4, sampler3D, shadow_tx)
PUSH_CONSTANT(float3, active_color)
GPU_SHADER_CREATE_END()

2
source/blender/draw/engines/workbench/shaders/workbench_cavity_lib.glsl
View File

@@ -24,7 +24,7 @@ SHADER_LIBRARY_CREATE_INFO(workbench_resolve_cavity)
#ifdef USE_CAVITY
void cavity_compute(float2 screenco,
depth2D depth_buffer,
sampler2DDepth depth_buffer,
sampler2D normalBuffer,
out float cavities,
out float edges)

6
source/blender/draw/intern/shaders/draw_debug_info.hh
View File

@@ -22,7 +22,7 @@
GPU_SHADER_CREATE_INFO(draw_debug_draw)
DEFINE("DRW_DEBUG_DRAW")
TYPEDEF_SOURCE("draw_shader_shared.hh")
STORAGE_BUF(DRW_DEBUG_DRAW_SLOT, READ_WRITE, DRWDebugVertPair, drw_debug_lines_buf[])
STORAGE_BUF(DRW_DEBUG_DRAW_SLOT, read_write, DRWDebugVertPair, drw_debug_lines_buf[])
GPU_SHADER_CREATE_END()
GPU_SHADER_INTERFACE_INFO(draw_debug_draw_display_iface)
@@ -34,8 +34,8 @@ GPU_SHADER_INTERFACE_END()
GPU_SHADER_CREATE_INFO(draw_debug_draw_display)
DO_STATIC_COMPILATION()
TYPEDEF_SOURCE("draw_shader_shared.hh")
STORAGE_BUF(DRW_DEBUG_DRAW_SLOT, READ, DRWDebugVertPair, in_debug_lines_buf[])
STORAGE_BUF(DRW_DEBUG_DRAW_FEEDBACK_SLOT, READ_WRITE, DRWDebugVertPair, out_debug_lines_buf[])
STORAGE_BUF(DRW_DEBUG_DRAW_SLOT, read, DRWDebugVertPair, in_debug_lines_buf[])
STORAGE_BUF(DRW_DEBUG_DRAW_FEEDBACK_SLOT, read_write, DRWDebugVertPair, out_debug_lines_buf[])
VERTEX_OUT(draw_debug_draw_display_iface)
FRAGMENT_OUT(0, float4, out_color)
FRAGMENT_OUT(1, float4, out_line_data)

6
source/blender/draw/intern/shaders/draw_hair_refine_info.hh
View File

@@ -21,10 +21,10 @@
GPU_SHADER_CREATE_INFO(draw_hair_refine_compute)
LOCAL_GROUP_SIZE(1, 1)
STORAGE_BUF(0, WRITE, float4, posTime[])
STORAGE_BUF(0, write, float4, posTime[])
/* Per strands data. */
SAMPLER(1, UINT_BUFFER, hairStrandBuffer)
SAMPLER(2, UINT_BUFFER, hairStrandSegBuffer)
SAMPLER(1, usamplerBuffer, hairStrandBuffer)
SAMPLER(2, usamplerBuffer, hairStrandSegBuffer)
COMPUTE_SOURCE("draw_hair_refine_comp.glsl")
DEFINE("HAIR_PHASE_SUBDIV")
ADDITIONAL_INFO(draw_hair)

12
source/blender/draw/intern/shaders/draw_object_infos_info.hh
View File

@@ -41,13 +41,13 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(draw_object_infos)
TYPEDEF_SOURCE("draw_shader_shared.hh")
DEFINE("OBINFO_LIB")
STORAGE_BUF(DRW_OBJ_INFOS_SLOT, READ, ObjectInfos, drw_infos[])
STORAGE_BUF(DRW_OBJ_INFOS_SLOT, read, ObjectInfos, drw_infos[])
GPU_SHADER_CREATE_END()
/** \note Requires draw_object_infos. */
GPU_SHADER_CREATE_INFO(draw_object_attributes)
DEFINE("OBATTR_LIB")
STORAGE_BUF(DRW_OBJ_ATTR_SLOT, READ, ObjectAttribute, drw_attrs[])
STORAGE_BUF(DRW_OBJ_ATTR_SLOT, read, ObjectAttribute, drw_attrs[])
ADDITIONAL_INFO(draw_object_infos)
GPU_SHADER_CREATE_END()
@@ -65,7 +65,7 @@ DEFINE("DRW_HAIR_INFO")
/* Per control points data inside subdivision shader
* or
* per tessellated point inside final shader. */
SAMPLER(0, FLOAT_BUFFER, hairPointBuffer)
SAMPLER(0, samplerBuffer, hairPointBuffer)
/* TODO(@fclem): Pack these into one UBO. */
/* hairStrandsRes: Number of points per hair strand.
* 2 - no subdivision
@@ -89,7 +89,7 @@ PUSH_CONSTANT(float4x4, hairDupliMatrix)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(draw_pointcloud)
SAMPLER_FREQ(0, FLOAT_BUFFER, ptcloud_pos_rad_tx, BATCH)
SAMPLER_FREQ(0, samplerBuffer, ptcloud_pos_rad_tx, BATCH)
DEFINE("POINTCLOUD_SHADER")
DEFINE("DRW_POINTCLOUD_INFO")
GPU_SHADER_CREATE_END()
@@ -101,8 +101,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(draw_gpencil)
TYPEDEF_SOURCE("gpencil_shader_shared.hh")
DEFINE("DRW_GPENCIL_INFO")
SAMPLER(0, FLOAT_BUFFER, gp_pos_tx)
SAMPLER(1, FLOAT_BUFFER, gp_col_tx)
SAMPLER(0, samplerBuffer, gp_pos_tx)
SAMPLER(1, samplerBuffer, gp_col_tx)
ADDITIONAL_INFO(draw_resource_id_varying)
ADDITIONAL_INFO(draw_view)
ADDITIONAL_INFO(draw_object_infos)

28
source/blender/draw/intern/shaders/draw_view_info.hh
View File

@@ -41,12 +41,12 @@ GEOMETRY_OUT(draw_resource_id_iface)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(draw_resource_id)
STORAGE_BUF(DRW_RESOURCE_ID_SLOT, READ, uint, resource_id_buf[])
STORAGE_BUF(DRW_RESOURCE_ID_SLOT, read, uint, resource_id_buf[])
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(draw_resource_with_custom_id)
DEFINE("WITH_CUSTOM_IDS")
STORAGE_BUF(DRW_RESOURCE_ID_SLOT, READ, uint2, resource_id_buf[])
STORAGE_BUF(DRW_RESOURCE_ID_SLOT, read, uint2, resource_id_buf[])
GPU_SHADER_CREATE_END()
/**
@@ -71,7 +71,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(draw_modelmat_common)
TYPEDEF_SOURCE("draw_shader_shared.hh")
STORAGE_BUF(DRW_OBJ_MAT_SLOT, READ, ObjectMatrices, drw_matrix_buf[])
STORAGE_BUF(DRW_OBJ_MAT_SLOT, read, ObjectMatrices, drw_matrix_buf[])
DEFINE("DRAW_MODELMAT_CREATE_INFO")
GPU_SHADER_CREATE_END()
@@ -126,9 +126,9 @@ DO_STATIC_COMPILATION()
TYPEDEF_SOURCE("draw_shader_shared.hh")
DEFINE("DRAW_FINALIZE_SHADER")
LOCAL_GROUP_SIZE(DRW_FINALIZE_GROUP_SIZE)
STORAGE_BUF(0, READ, ObjectMatrices, matrix_buf[])
STORAGE_BUF(1, READ_WRITE, ObjectBounds, bounds_buf[])
STORAGE_BUF(2, READ_WRITE, ObjectInfos, infos_buf[])
STORAGE_BUF(0, read, ObjectMatrices, matrix_buf[])
STORAGE_BUF(1, read_write, ObjectBounds, bounds_buf[])
STORAGE_BUF(2, read_write, ObjectInfos, infos_buf[])
PUSH_CONSTANT(int, resource_len)
COMPUTE_SOURCE("draw_resource_finalize_comp.glsl")
GPU_SHADER_CREATE_END()
@@ -137,7 +137,7 @@ GPU_SHADER_CREATE_INFO(draw_view_finalize)
DO_STATIC_COMPILATION()
LOCAL_GROUP_SIZE(DRW_VIEW_MAX)
DEFINE_VALUE("DRW_VIEW_LEN", STRINGIFY(DRW_VIEW_MAX))
STORAGE_BUF(0, READ_WRITE, ViewCullingData, view_culling_buf[DRW_VIEW_LEN])
STORAGE_BUF(0, read_write, ViewCullingData, view_culling_buf[DRW_VIEW_LEN])
COMPUTE_SOURCE("draw_view_finalize_comp.glsl")
ADDITIONAL_INFO(draw_view)
GPU_SHADER_CREATE_END()
@@ -146,8 +146,8 @@ GPU_SHADER_CREATE_INFO(draw_visibility_compute)
DO_STATIC_COMPILATION()
LOCAL_GROUP_SIZE(DRW_VISIBILITY_GROUP_SIZE)
DEFINE_VALUE("DRW_VIEW_LEN", STRINGIFY(DRW_VIEW_MAX))
STORAGE_BUF(0, READ, ObjectBounds, bounds_buf[])
STORAGE_BUF(1, READ_WRITE, uint, visibility_buf[])
STORAGE_BUF(0, read, ObjectBounds, bounds_buf[])
STORAGE_BUF(1, read_write, uint, visibility_buf[])
PUSH_CONSTANT(int, resource_len)
PUSH_CONSTANT(int, view_len)
PUSH_CONSTANT(int, visibility_word_per_draw)
@@ -161,11 +161,11 @@ DO_STATIC_COMPILATION()
TYPEDEF_SOURCE("draw_shader_shared.hh")
TYPEDEF_SOURCE("draw_command_shared.hh")
LOCAL_GROUP_SIZE(DRW_COMMAND_GROUP_SIZE)
STORAGE_BUF(0, READ_WRITE, DrawGroup, group_buf[])
STORAGE_BUF(1, READ, uint, visibility_buf[])
STORAGE_BUF(2, READ, DrawPrototype, prototype_buf[])
STORAGE_BUF(3, WRITE, DrawCommand, command_buf[])
STORAGE_BUF(DRW_RESOURCE_ID_SLOT, WRITE, uint, resource_id_buf[])
STORAGE_BUF(0, read_write, DrawGroup, group_buf[])
STORAGE_BUF(1, read, uint, visibility_buf[])
STORAGE_BUF(2, read, DrawPrototype, prototype_buf[])
STORAGE_BUF(3, write, DrawCommand, command_buf[])
STORAGE_BUF(DRW_RESOURCE_ID_SLOT, write, uint, resource_id_buf[])
PUSH_CONSTANT(int, prototype_len)
PUSH_CONSTANT(int, visibility_word_per_draw)
PUSH_CONSTANT(int, view_shift)

120
source/blender/draw/intern/shaders/subdiv_info.hh
View File

@@ -21,7 +21,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(subdiv_polygon_offset_base)
DEFINE("SUBDIV_POLYGON_OFFSET")
STORAGE_BUF(SUBDIV_FACE_OFFSET_BUF_SLOT, READ, uint, subdiv_face_offset[])
STORAGE_BUF(SUBDIV_FACE_OFFSET_BUF_SLOT, read, uint, subdiv_face_offset[])
ADDITIONAL_INFO(subdiv_base)
GPU_SHADER_CREATE_END()
@@ -40,40 +40,40 @@ GPU_SHADER_CREATE_END()
DEFINE("OPENSUBDIV_GLSL_COMPUTE_USE_1ST_DERIVATIVES") \
TYPEDEF_SOURCE("osd_patch_basis.glsl") \
COMPUTE_SOURCE("subdiv_patch_evaluation_comp.glsl") \
STORAGE_BUF(PATCH_EVALUATION_SOURCE_VERTEX_BUFFER_BUF_SLOT, READ, float, srcVertexBuffer[]) \
STORAGE_BUF(PATCH_EVALUATION_SOURCE_VERTEX_BUFFER_BUF_SLOT, read, float, srcVertexBuffer[]) \
STORAGE_BUF( \
PATCH_EVALUATION_INPUT_PATCH_HANDLES_BUF_SLOT, READ, PatchHandle, input_patch_handles[]) \
STORAGE_BUF(PATCH_EVALUATION_QUAD_NODES_BUF_SLOT, READ, QuadNode, quad_nodes[]) \
STORAGE_BUF(PATCH_EVALUATION_PATCH_COORDS_BUF_SLOT, READ, BlenderPatchCoord, patch_coords[]) \
PATCH_EVALUATION_INPUT_PATCH_HANDLES_BUF_SLOT, read, PatchHandle, input_patch_handles[]) \
STORAGE_BUF(PATCH_EVALUATION_QUAD_NODES_BUF_SLOT, read, QuadNode, quad_nodes[]) \
STORAGE_BUF(PATCH_EVALUATION_PATCH_COORDS_BUF_SLOT, read, BlenderPatchCoord, patch_coords[]) \
STORAGE_BUF( \
PATCH_EVALUATION_INPUT_VERTEX_ORIG_INDEX_BUF_SLOT, READ, int, input_vert_origindex[]) \
PATCH_EVALUATION_INPUT_VERTEX_ORIG_INDEX_BUF_SLOT, read, int, input_vert_origindex[]) \
STORAGE_BUF( \
PATCH_EVALUATION_PATCH_ARRAY_BUFFER_BUF_SLOT, READ, OsdPatchArray, patchArrayBuffer[]) \
STORAGE_BUF(PATCH_EVALUATION_PATCH_INDEX_BUFFER_BUF_SLOT, READ, int, patchIndexBuffer[]) \
PATCH_EVALUATION_PATCH_ARRAY_BUFFER_BUF_SLOT, read, OsdPatchArray, patchArrayBuffer[]) \
STORAGE_BUF(PATCH_EVALUATION_PATCH_INDEX_BUFFER_BUF_SLOT, read, int, patchIndexBuffer[]) \
STORAGE_BUF( \
PATCH_EVALUATION_PATCH_PARAM_BUFFER_BUF_SLOT, READ, OsdPatchParam, patchParamBuffer[]) \
PATCH_EVALUATION_PATCH_PARAM_BUFFER_BUF_SLOT, read, OsdPatchParam, patchParamBuffer[]) \
ADDITIONAL_INFO(subdiv_base)
#define SUBDIV_PATCH_EVALUATION_FDOTS() \
SUBDIV_PATCH_EVALUATION_BASIS() \
DEFINE("FDOTS_EVALUATION") \
STORAGE_BUF( \
PATCH_EVALUATION_OUTPUT_FDOTS_VERTEX_BUFFER_BUF_SLOT, WRITE, FDotVert, output_verts[]) \
STORAGE_BUF(PATCH_EVALUATION_OUTPUT_INDICES_BUF_SLOT, WRITE, uint, output_indices[]) \
PATCH_EVALUATION_OUTPUT_FDOTS_VERTEX_BUFFER_BUF_SLOT, write, FDotVert, output_verts[]) \
STORAGE_BUF(PATCH_EVALUATION_OUTPUT_INDICES_BUF_SLOT, write, uint, output_indices[]) \
STORAGE_BUF( \
PATCH_EVALUATION_EXTRA_COARSE_FACE_DATA_BUF_SLOT, READ, uint, extra_coarse_face_data[])
PATCH_EVALUATION_EXTRA_COARSE_FACE_DATA_BUF_SLOT, read, uint, extra_coarse_face_data[])
#define SUBDIV_PATCH_EVALUATION_VERTS() \
SUBDIV_PATCH_EVALUATION_BASIS() \
DEFINE("VERTS_EVALUATION") \
STORAGE_BUF(PATCH_EVALUATION_FLAGS_BUFFER_BUF_SLOT, READ, int, flags_buffer[]) \
STORAGE_BUF(PATCH_EVALUATION_OUTPUT_VERTS_BUF_SLOT, WRITE, PosNorLoop, output_verts[])
STORAGE_BUF(PATCH_EVALUATION_FLAGS_BUFFER_BUF_SLOT, read, int, flags_buffer[]) \
STORAGE_BUF(PATCH_EVALUATION_OUTPUT_VERTS_BUF_SLOT, write, PosNorLoop, output_verts[])
GPU_SHADER_CREATE_INFO(subdiv_patch_evaluation_fvar)
DO_STATIC_COMPILATION()
SUBDIV_PATCH_EVALUATION_BASIS()
DEFINE("FVAR_EVALUATION")
STORAGE_BUF(PATCH_EVALUATION_OUTPUT_FVAR_BUF_SLOT, WRITE, packed_float2, output_fvar[])
STORAGE_BUF(PATCH_EVALUATION_OUTPUT_FVAR_BUF_SLOT, write, packed_float2, output_fvar[])
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(subdiv_patch_evaluation_fdots)
@@ -85,7 +85,7 @@ GPU_SHADER_CREATE_INFO(subdiv_patch_evaluation_fdots_normals)
DO_STATIC_COMPILATION()
SUBDIV_PATCH_EVALUATION_FDOTS()
DEFINE("FDOTS_NORMALS")
STORAGE_BUF(PATCH_EVALUATION_OUTPUT_NORMALS_BUF_SLOT, WRITE, FDotNor, output_nors[])
STORAGE_BUF(PATCH_EVALUATION_OUTPUT_NORMALS_BUF_SLOT, write, FDotNor, output_nors[])
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(subdiv_patch_evaluation_verts)
@@ -98,10 +98,10 @@ DO_STATIC_COMPILATION()
SUBDIV_PATCH_EVALUATION_VERTS()
DEFINE("ORCO_EVALUATION")
STORAGE_BUF(PATCH_EVALUATION_SOURCE_EXTRA_VERTEX_BUFFER_BUF_SLOT,
READ,
read,
float,
srcExtraVertexBuffer[])
STORAGE_BUF(PATCH_EVALUATION_OUTPUT_ORCOS_BUF_SLOT, WRITE, float4, output_orcos[])
STORAGE_BUF(PATCH_EVALUATION_OUTPUT_ORCOS_BUF_SLOT, write, float4, output_orcos[])
GPU_SHADER_CREATE_END()
/** \} */
@@ -112,10 +112,10 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(subdiv_loop_normals)
DO_STATIC_COMPILATION()
STORAGE_BUF(LOOP_NORMALS_POS_NOR_BUF_SLOT, READ, PosNorLoop, pos_nor[])
STORAGE_BUF(LOOP_NORMALS_EXTRA_COARSE_FACE_DATA_BUF_SLOT, READ, uint, extra_coarse_face_data[])
STORAGE_BUF(LOOP_NORMALS_INPUT_VERT_ORIG_INDEX_BUF_SLOT, READ, int, input_vert_origindex[])
STORAGE_BUF(LOOP_NORMALS_OUTPUT_LNOR_BUF_SLOT, WRITE, LoopNormal, output_lnor[])
STORAGE_BUF(LOOP_NORMALS_POS_NOR_BUF_SLOT, read, PosNorLoop, pos_nor[])
STORAGE_BUF(LOOP_NORMALS_EXTRA_COARSE_FACE_DATA_BUF_SLOT, read, uint, extra_coarse_face_data[])
STORAGE_BUF(LOOP_NORMALS_INPUT_VERT_ORIG_INDEX_BUF_SLOT, read, int, input_vert_origindex[])
STORAGE_BUF(LOOP_NORMALS_OUTPUT_LNOR_BUF_SLOT, write, LoopNormal, output_lnor[])
COMPUTE_SOURCE("subdiv_vbo_lnor_comp.glsl")
ADDITIONAL_INFO(subdiv_polygon_offset_base)
GPU_SHADER_CREATE_END()
@@ -129,17 +129,17 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(subdiv_tris_single_material)
DO_STATIC_COMPILATION()
DEFINE("SINGLE_MATERIAL")
STORAGE_BUF(TRIS_EXTRA_COARSE_FACE_DATA_BUF_SLOT, READ, uint, extra_coarse_face_data[])
STORAGE_BUF(TRIS_OUTPUT_TRIS_BUF_SLOT, WRITE, uint, output_tris[])
STORAGE_BUF(TRIS_EXTRA_COARSE_FACE_DATA_BUF_SLOT, read, uint, extra_coarse_face_data[])
STORAGE_BUF(TRIS_OUTPUT_TRIS_BUF_SLOT, write, uint, output_tris[])
COMPUTE_SOURCE("subdiv_ibo_tris_comp.glsl")
ADDITIONAL_INFO(subdiv_polygon_offset_base)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(subdiv_tris_multiple_materials)
DO_STATIC_COMPILATION()
STORAGE_BUF(TRIS_EXTRA_COARSE_FACE_DATA_BUF_SLOT, READ, uint, extra_coarse_face_data[])
STORAGE_BUF(TRIS_OUTPUT_TRIS_BUF_SLOT, WRITE, uint, output_tris[])
STORAGE_BUF(TRIS_FACE_MAT_OFFSET, READ, uint, face_mat_offset[])
STORAGE_BUF(TRIS_EXTRA_COARSE_FACE_DATA_BUF_SLOT, read, uint, extra_coarse_face_data[])
STORAGE_BUF(TRIS_OUTPUT_TRIS_BUF_SLOT, write, uint, output_tris[])
STORAGE_BUF(TRIS_FACE_MAT_OFFSET, read, uint, face_mat_offset[])
COMPUTE_SOURCE("subdiv_ibo_tris_comp.glsl")
ADDITIONAL_INFO(subdiv_polygon_offset_base)
GPU_SHADER_CREATE_END()
@@ -152,9 +152,9 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(subdiv_lines)
DO_STATIC_COMPILATION()
STORAGE_BUF(LINES_INPUT_EDGE_DRAW_FLAG_BUF_SLOT, READ, int, input_edge_draw_flag[])
STORAGE_BUF(LINES_EXTRA_COARSE_FACE_DATA_BUF_SLOT, READ, uint, extra_coarse_face_data[])
STORAGE_BUF(LINES_OUTPUT_LINES_BUF_SLOT, WRITE, uint, output_lines[])
STORAGE_BUF(LINES_INPUT_EDGE_DRAW_FLAG_BUF_SLOT, read, int, input_edge_draw_flag[])
STORAGE_BUF(LINES_EXTRA_COARSE_FACE_DATA_BUF_SLOT, read, uint, extra_coarse_face_data[])
STORAGE_BUF(LINES_OUTPUT_LINES_BUF_SLOT, write, uint, output_lines[])
COMPUTE_SOURCE("subdiv_ibo_lines_comp.glsl")
ADDITIONAL_INFO(subdiv_polygon_offset_base)
GPU_SHADER_CREATE_END()
@@ -162,8 +162,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(subdiv_lines_loose)
DO_STATIC_COMPILATION()
DEFINE("LINES_LOOSE")
STORAGE_BUF(LINES_OUTPUT_LINES_BUF_SLOT, WRITE, uint, output_lines[])
STORAGE_BUF(LINES_LINES_LOOSE_FLAGS, READ, uint, lines_loose_flags[])
STORAGE_BUF(LINES_OUTPUT_LINES_BUF_SLOT, write, uint, output_lines[])
STORAGE_BUF(LINES_LINES_LOOSE_FLAGS, read, uint, lines_loose_flags[])
COMPUTE_SOURCE("subdiv_ibo_lines_comp.glsl")
ADDITIONAL_INFO(subdiv_base)
GPU_SHADER_CREATE_END()
@@ -176,22 +176,22 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(subdiv_edge_fac_base)
ADDITIONAL_INFO(subdiv_base)
STORAGE_BUF(EDGE_FAC_POS_NOR_BUF_SLOT, READ, PosNorLoop, pos_nor[])
STORAGE_BUF(EDGE_FAC_EDGE_DRAW_FLAG_BUF_SLOT, READ, uint, input_edge_draw_flag[])
STORAGE_BUF(EDGE_FAC_POLY_OTHER_MAP_BUF_SLOT, READ, int, input_poly_other_map[])
STORAGE_BUF(EDGE_FAC_POS_NOR_BUF_SLOT, read, PosNorLoop, pos_nor[])
STORAGE_BUF(EDGE_FAC_EDGE_DRAW_FLAG_BUF_SLOT, read, uint, input_edge_draw_flag[])
STORAGE_BUF(EDGE_FAC_POLY_OTHER_MAP_BUF_SLOT, read, int, input_poly_other_map[])
COMPUTE_SOURCE("subdiv_vbo_edge_fac_comp.glsl")
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(subdiv_edge_fac)
DO_STATIC_COMPILATION()
STORAGE_BUF(EDGE_FAC_EDGE_FAC_BUF_SLOT, WRITE, uint, output_edge_fac[])
STORAGE_BUF(EDGE_FAC_EDGE_FAC_BUF_SLOT, write, uint, output_edge_fac[])
ADDITIONAL_INFO(subdiv_edge_fac_base)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(subdiv_edge_fac_amd_legacy)
DO_STATIC_COMPILATION()
DEFINE("GPU_AMD_DRIVER_BYTE_BUG")
STORAGE_BUF(EDGE_FAC_EDGE_FAC_BUF_SLOT, WRITE, float, output_edge_fac[])
STORAGE_BUF(EDGE_FAC_EDGE_FAC_BUF_SLOT, write, float, output_edge_fac[])
ADDITIONAL_INFO(subdiv_edge_fac_base)
GPU_SHADER_CREATE_END()
@@ -207,11 +207,11 @@ GPU_SHADER_CREATE_END()
DEFINE(gpu_comp_type) \
DEFINE(dimension) \
COMPUTE_SOURCE("subdiv_custom_data_interp_comp.glsl") \
STORAGE_BUF(CUSTOM_DATA_FACE_PTEX_OFFSET_BUF_SLOT, READ, uint, face_ptex_offset[]) \
STORAGE_BUF(CUSTOM_DATA_PATCH_COORDS_BUF_SLOT, READ, BlenderPatchCoord, patch_coords[]) \
STORAGE_BUF(CUSTOM_DATA_EXTRA_COARSE_FACE_DATA_BUF_SLOT, READ, uint, extra_coarse_face_data[]) \
STORAGE_BUF(CUSTOM_DATA_SOURCE_DATA_BUF_SLOT, READ, data_type, src_data[]) \
STORAGE_BUF(CUSTOM_DATA_DESTINATION_DATA_BUF_SLOT, WRITE, data_type, dst_data[]) \
STORAGE_BUF(CUSTOM_DATA_FACE_PTEX_OFFSET_BUF_SLOT, read, uint, face_ptex_offset[]) \
STORAGE_BUF(CUSTOM_DATA_PATCH_COORDS_BUF_SLOT, read, BlenderPatchCoord, patch_coords[]) \
STORAGE_BUF(CUSTOM_DATA_EXTRA_COARSE_FACE_DATA_BUF_SLOT, read, uint, extra_coarse_face_data[]) \
STORAGE_BUF(CUSTOM_DATA_SOURCE_DATA_BUF_SLOT, read, data_type, src_data[]) \
STORAGE_BUF(CUSTOM_DATA_DESTINATION_DATA_BUF_SLOT, write, data_type, dst_data[]) \
ADDITIONAL_INFO(subdiv_polygon_offset_base) \
GPU_SHADER_CREATE_END()
@@ -235,9 +235,9 @@ SUBDIV_CUSTOM_DATA_VARIANT(4d_f32, "GPU_COMP_F32", float, "DIMENSIONS_4")
GPU_SHADER_CREATE_INFO(subdiv_sculpt_data)
DO_STATIC_COMPILATION()
STORAGE_BUF(SCULPT_DATA_SCULPT_MASK_BUF_SLOT, READ, float, sculpt_mask[])
STORAGE_BUF(SCULPT_DATA_SCULPT_FACE_SET_COLOR_BUF_SLOT, READ, uint, sculpt_face_set_color[])
STORAGE_BUF(SCULPT_DATA_SCULPT_DATA_BUF_SLOT, WRITE, SculptData, sculpt_data[])
STORAGE_BUF(SCULPT_DATA_SCULPT_MASK_BUF_SLOT, read, float, sculpt_mask[])
STORAGE_BUF(SCULPT_DATA_SCULPT_FACE_SET_COLOR_BUF_SLOT, read, uint, sculpt_face_set_color[])
STORAGE_BUF(SCULPT_DATA_SCULPT_DATA_BUF_SLOT, write, SculptData, sculpt_data[])
COMPUTE_SOURCE("subdiv_vbo_sculpt_data_comp.glsl")
ADDITIONAL_INFO(subdiv_base)
GPU_SHADER_CREATE_END()
@@ -250,17 +250,17 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(subdiv_edituv_stretch_angle)
DO_STATIC_COMPILATION()
STORAGE_BUF(STRETCH_ANGLE_POS_NOR_BUF_SLOT, READ, PosNorLoop, pos_nor[])
STORAGE_BUF(STRETCH_ANGLE_UVS_BUF_SLOT, READ, packed_float2, uvs[])
STORAGE_BUF(STRETCH_ANGLE_UV_STRETCHES_BUF_SLOT, WRITE, UVStretchAngle, uv_stretches[])
STORAGE_BUF(STRETCH_ANGLE_POS_NOR_BUF_SLOT, read, PosNorLoop, pos_nor[])
STORAGE_BUF(STRETCH_ANGLE_UVS_BUF_SLOT, read, packed_float2, uvs[])
STORAGE_BUF(STRETCH_ANGLE_UV_STRETCHES_BUF_SLOT, write, UVStretchAngle, uv_stretches[])
COMPUTE_SOURCE("subdiv_vbo_edituv_strech_angle_comp.glsl")
ADDITIONAL_INFO(subdiv_base)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(subdiv_edituv_stretch_area)
DO_STATIC_COMPILATION()
STORAGE_BUF(STRETCH_AREA_COARSE_STRETCH_AREA_BUF_SLOT, READ, float, coarse_stretch_area[])
STORAGE_BUF(STRETCH_AREA_SUBDIV_STRETCH_AREA_BUF_SLOT, WRITE, float, subdiv_stretch_area[])
STORAGE_BUF(STRETCH_AREA_COARSE_STRETCH_AREA_BUF_SLOT, read, float, coarse_stretch_area[])
STORAGE_BUF(STRETCH_AREA_SUBDIV_STRETCH_AREA_BUF_SLOT, write, float, subdiv_stretch_area[])
COMPUTE_SOURCE("subdiv_vbo_edituv_strech_area_comp.glsl")
ADDITIONAL_INFO(subdiv_polygon_offset_base)
GPU_SHADER_CREATE_END()
@@ -273,23 +273,23 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(subdiv_normals_accumulate)
DO_STATIC_COMPILATION()
STORAGE_BUF(NORMALS_ACCUMULATE_POS_NOR_BUF_SLOT, READ, PosNorLoop, pos_nor[])
STORAGE_BUF(NORMALS_ACCUMULATE_POS_NOR_BUF_SLOT, read, PosNorLoop, pos_nor[])
STORAGE_BUF(NORMALS_ACCUMULATE_FACE_ADJACENCY_OFFSETS_BUF_SLOT,
READ,
read,
uint,
face_adjacency_offsets[])
STORAGE_BUF(NORMALS_ACCUMULATE_FACE_ADJACENCY_LISTS_BUF_SLOT, READ, uint, face_adjacency_lists[])
STORAGE_BUF(NORMALS_ACCUMULATE_VERTEX_LOOP_MAP_BUF_SLOT, READ, uint, vert_loop_map[])
STORAGE_BUF(NORMALS_ACCUMULATE_NORMALS_BUF_SLOT, WRITE, packed_float3, normals[])
STORAGE_BUF(NORMALS_ACCUMULATE_FACE_ADJACENCY_LISTS_BUF_SLOT, read, uint, face_adjacency_lists[])
STORAGE_BUF(NORMALS_ACCUMULATE_VERTEX_LOOP_MAP_BUF_SLOT, read, uint, vert_loop_map[])
STORAGE_BUF(NORMALS_ACCUMULATE_NORMALS_BUF_SLOT, write, packed_float3, normals[])
COMPUTE_SOURCE("subdiv_normals_accumulate_comp.glsl")
ADDITIONAL_INFO(subdiv_base)
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(subdiv_normals_finalize)
DO_STATIC_COMPILATION()
STORAGE_BUF(NORMALS_FINALIZE_VERTEX_NORMALS_BUF_SLOT, READ, packed_float3, vertex_normals[])
STORAGE_BUF(NORMALS_FINALIZE_VERTEX_LOOP_MAP_BUF_SLOT, READ, uint, vert_loop_map[])
STORAGE_BUF(NORMALS_FINALIZE_POS_NOR_BUF_SLOT, READ_WRITE, PosNorLoop, pos_nor[])
STORAGE_BUF(NORMALS_FINALIZE_VERTEX_NORMALS_BUF_SLOT, read, packed_float3, vertex_normals[])
STORAGE_BUF(NORMALS_FINALIZE_VERTEX_LOOP_MAP_BUF_SLOT, read, uint, vert_loop_map[])
STORAGE_BUF(NORMALS_FINALIZE_POS_NOR_BUF_SLOT, read_write, PosNorLoop, pos_nor[])
COMPUTE_SOURCE("subdiv_normals_finalize_comp.glsl")
ADDITIONAL_INFO(subdiv_base)
GPU_SHADER_CREATE_END()
@@ -298,8 +298,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(subdiv_custom_normals_finalize)
DO_STATIC_COMPILATION()
DEFINE("CUSTOM_NORMALS")
STORAGE_BUF(NORMALS_FINALIZE_CUSTOM_NORMALS_BUF_SLOT, READ, CustomNormal, custom_normals[])
STORAGE_BUF(NORMALS_FINALIZE_POS_NOR_BUF_SLOT, READ_WRITE, PosNorLoop, pos_nor[])
STORAGE_BUF(NORMALS_FINALIZE_CUSTOM_NORMALS_BUF_SLOT, read, CustomNormal, custom_normals[])
STORAGE_BUF(NORMALS_FINALIZE_POS_NOR_BUF_SLOT, read_write, PosNorLoop, pos_nor[])
COMPUTE_SOURCE("subdiv_normals_finalize_comp.glsl")
ADDITIONAL_INFO(subdiv_base)
GPU_SHADER_CREATE_END()

10
source/blender/gpu/intern/gpu_codegen.cc
View File

@@ -407,22 +407,22 @@ void GPUCodegen::generate_resources()
LISTBASE_FOREACH (GPUMaterialTexture *, tex, &graph.textures) {
if (tex->colorband) {
const char *name = info.name_buffer.append_sampler_name(tex->sampler_name);
info.sampler(slot++, ImageType::FLOAT_1D_ARRAY, name, Frequency::BATCH);
info.sampler(slot++, ImageType::Float1DArray, name, Frequency::BATCH);
}
else if (tex->sky) {
const char *name = info.name_buffer.append_sampler_name(tex->sampler_name);
info.sampler(0, ImageType::FLOAT_2D_ARRAY, name, Frequency::BATCH);
info.sampler(0, ImageType::Float2DArray, name, Frequency::BATCH);
}
else if (tex->tiled_mapping_name[0] != '\0') {
const char *name = info.name_buffer.append_sampler_name(tex->sampler_name);
info.sampler(slot++, ImageType::FLOAT_2D_ARRAY, name, Frequency::BATCH);
info.sampler(slot++, ImageType::Float2DArray, name, Frequency::BATCH);
const char *name_mapping = info.name_buffer.append_sampler_name(tex->tiled_mapping_name);
info.sampler(slot++, ImageType::FLOAT_1D_ARRAY, name_mapping, Frequency::BATCH);
info.sampler(slot++, ImageType::Float1DArray, name_mapping, Frequency::BATCH);
}
else {
const char *name = info.name_buffer.append_sampler_name(tex->sampler_name);
info.sampler(slot++, ImageType::FLOAT_2D, name, Frequency::BATCH);
info.sampler(slot++, ImageType::Float2D, name, Frequency::BATCH);
}
}

2
source/blender/gpu/intern/gpu_shader_create_info.cc
View File

@@ -481,7 +481,7 @@ void gpu_shader_create_info_init()
if (GPU_stencil_clasify_buffer_workaround()) {
/* WORKAROUND: Adding a dummy buffer that isn't used fixes a bug inside the Qualcomm driver. */
eevee_deferred_tile_classify.storage_buf(
12, Qualifier::READ_WRITE, "uint", "dummy_workaround_buf[]");
12, Qualifier::read_write, "uint", "dummy_workaround_buf[]");
}
for (ShaderCreateInfo *info : g_create_infos->values()) {

172
source/blender/gpu/intern/gpu_shader_create_info.hh
View File

@@ -155,9 +155,9 @@
.sampler(slot, ImageType::type, #name, Frequency::freq)
# define IMAGE(slot, format, qualifiers, type, name) \
.image(slot, format, Qualifier::qualifiers, ImageType::type, #name)
.image(slot, format, Qualifier::qualifiers, ImageReadWriteType::type, #name)
# define IMAGE_FREQ(slot, format, qualifiers, type, name, freq) \
.image(slot, format, Qualifier::qualifiers, ImageType::type, #name, Frequency::freq)
.image(slot, format, Qualifier::qualifiers, ImageReadWriteType::type, #name, Frequency::freq)
# define BUILTINS(builtin) .builtins(builtin)
@@ -182,48 +182,9 @@
#else
# define READ const
# define WRITE
# define READ_WRITE
# define _FLOAT_BUFFER(T) T##Buffer
# define _FLOAT_1D(T) T##1D
# define _FLOAT_1D_ARRAY(T) T##1DArray
# define _FLOAT_2D(T) T##2D
# define _FLOAT_2D_ARRAY(T) T##2DArray
# define _FLOAT_3D(T) T##3D
# define _FLOAT_CUBE(T) T##Cube
# define _FLOAT_CUBE_ARRAY(T) T##CubeArray
# define _INT_BUFFER(T) i##T##Buffer
# define _INT_1D(T) i##T##1D
# define _INT_1D_ARRAY(T) i##T##1DArray
# define _INT_2D(T) i##T##2D
# define _INT_2D_ATOMIC(T) i##T##2D
# define _INT_2D_ARRAY(T) i##T##2DArray
# define _INT_2D_ARRAY_ATOMIC(T) i##T##2DArray
# define _INT_3D(T) i##T##3D
# define _INT_3D_ATOMIC(T) i##T##3D
# define _INT_CUBE(T) i##T##Cube
# define _INT_CUBE_ARRAY(T) i##T##CubeArray
# define _UINT_BUFFER(T) u##T##Buffer
# define _UINT_1D(T) u##T##1D
# define _UINT_1D_ARRAY(T) u##T##1DArray
# define _UINT_2D(T) u##T##2D
# define _UINT_2D_ATOMIC(T) u##T##2D
# define _UINT_2D_ARRAY(T) u##T##2DArray
# define _UINT_2D_ARRAY_ATOMIC(T) u##T##2DArray
# define _UINT_3D(T) u##T##3D
# define _UINT_3D_ATOMIC(T) u##T##3D
# define _UINT_CUBE(T) u##T##Cube
# define _UINT_CUBE_ARRAY(T) u##T##CubeArray
# define _SHADOW_2D(T) T##2DShadow
# define _SHADOW_2D_ARRAY(T) T##2DArrayShadow
# define _SHADOW_CUBE(T) T##CubeShadow
# define _SHADOW_CUBE_ARRAY(T) T##CubeArrayShadow
# define _DEPTH_2D(T) T##2D
# define _DEPTH_2D_ARRAY(T) T##2DArray
# define _DEPTH_CUBE(T) T##Cube
# define _DEPTH_CUBE_ARRAY(T) T##CubeArray
# define _read const
# define _write
# define _read_write
# define SMOOTH(type, name) type name = {};
# define FLAT(type, name) type name = {};
@@ -268,15 +229,15 @@
# define UNIFORM_BUF(slot, type_name, name) extern const type_name name;
# define UNIFORM_BUF_FREQ(slot, type_name, name, freq) extern const type_name name;
# define STORAGE_BUF(slot, qualifiers, type_name, name) extern qualifiers type_name name;
# define STORAGE_BUF(slot, qualifiers, type_name, name) extern _##qualifiers type_name name;
# define STORAGE_BUF_FREQ(slot, qualifiers, type_name, name, freq) \
extern qualifiers type_name name;
extern _##qualifiers type_name name;
# define SAMPLER(slot, type, name) _##type(sampler) name;
# define SAMPLER_FREQ(slot, type, name, freq) _##type(sampler) name;
# define SAMPLER(slot, type, name) type name;
# define SAMPLER_FREQ(slot, type, name, freq) type name;
# define IMAGE(slot, format, qualifiers, type, name) qualifiers _##type(image) name;
# define IMAGE_FREQ(slot, format, qualifiers, type, name, freq) qualifiers _##type(image) name;
# define IMAGE(slot, format, qualifiers, type, name) _##qualifiers type name;
# define IMAGE_FREQ(slot, format, qualifiers, type, name, freq) _##qualifiers type name;
# define BUILTINS(builtin)
@@ -481,40 +442,32 @@ enum class DepthWrite {
/* Samplers & images. */
enum class ImageType {
undefined = 0,
# define TYPES_EXPAND(s) \
Float##s, Uint##s, Int##s, sampler##s = Float##s, usampler##s = Uint##s, isampler##s = Int##s
/** Color samplers/image. */
FLOAT_BUFFER = 0,
FLOAT_1D,
FLOAT_1D_ARRAY,
FLOAT_2D,
FLOAT_2D_ARRAY,
FLOAT_3D,
FLOAT_CUBE,
FLOAT_CUBE_ARRAY,
INT_BUFFER,
INT_1D,
INT_1D_ARRAY,
INT_2D,
INT_2D_ARRAY,
INT_3D,
INT_CUBE,
INT_CUBE_ARRAY,
UINT_BUFFER,
UINT_1D,
UINT_1D_ARRAY,
UINT_2D,
UINT_2D_ARRAY,
UINT_3D,
UINT_CUBE,
UINT_CUBE_ARRAY,
TYPES_EXPAND(1D),
TYPES_EXPAND(1DArray),
TYPES_EXPAND(2D),
TYPES_EXPAND(2DArray),
TYPES_EXPAND(3D),
TYPES_EXPAND(Cube),
TYPES_EXPAND(CubeArray),
TYPES_EXPAND(Buffer),
# undef TYPES_EXPAND
# define TYPES_EXPAND(s) \
Shadow##s, Depth##s, sampler##s##Shadow = Shadow##s, sampler##s##Depth = Depth##s
/** Depth samplers (not supported as image). */
SHADOW_2D,
SHADOW_2D_ARRAY,
SHADOW_CUBE,
SHADOW_CUBE_ARRAY,
DEPTH_2D,
DEPTH_2D_ARRAY,
DEPTH_CUBE,
DEPTH_CUBE_ARRAY,
TYPES_EXPAND(2D),
TYPES_EXPAND(2DArray),
TYPES_EXPAND(Cube),
TYPES_EXPAND(CubeArray),
# undef TYPES_EXPAND
# define TYPES_EXPAND(s) \
AtomicUint##s, AtomicInt##s, usampler##s##Atomic = AtomicUint##s, \
isampler##s##Atomic = AtomicInt##s
/** Atomic texture type wrappers.
* For OpenGL, these map to the equivalent (U)INT_* types.
* NOTE: Atomic variants MUST be used if the texture bound to this resource has usage flag:
@@ -523,23 +476,52 @@ enum class ImageType {
* The shader source MUST also utilize the correct atomic sampler handle e.g.
* `usampler2DAtomic` in conjunction with these types, for passing texture/image resources into
* functions. */
UINT_2D_ATOMIC,
UINT_2D_ARRAY_ATOMIC,
UINT_3D_ATOMIC,
INT_2D_ATOMIC,
INT_2D_ARRAY_ATOMIC,
INT_3D_ATOMIC
TYPES_EXPAND(2D),
TYPES_EXPAND(2DArray),
TYPES_EXPAND(3D),
# undef TYPES_EXPAND
};
/* Samplers & images. */
enum class ImageReadWriteType {
undefined = 0,
# define TYPES_EXPAND(s) \
Float##s = int(ImageType::Float##s), Uint##s = int(ImageType::Uint##s), \
Int##s = int(ImageType::Int##s), image##s = Float##s, uimage##s = Uint##s, iimage##s = Int##s
/** Color image. */
TYPES_EXPAND(1D),
TYPES_EXPAND(1DArray),
TYPES_EXPAND(2D),
TYPES_EXPAND(2DArray),
TYPES_EXPAND(3D),
# undef TYPES_EXPAND
# define TYPES_EXPAND(s) \
AtomicUint##s = int(ImageType::AtomicUint##s), AtomicInt##s = int(ImageType::AtomicInt##s), \
uimage##s##Atomic = AtomicUint##s, iimage##s##Atomic = AtomicInt##s
/** Atomic texture type wrappers.
* For OpenGL, these map to the equivalent (U)INT_* types.
* NOTE: Atomic variants MUST be used if the texture bound to this resource has usage flag:
* `GPU_TEXTURE_USAGE_ATOMIC`, even if atomic texture operations are not used in the given
* shader.
* The shader source MUST also utilize the correct atomic sampler handle e.g.
* `usampler2DAtomic` in conjunction with these types, for passing texture/image resources into
* functions. */
TYPES_EXPAND(2D),
TYPES_EXPAND(2DArray),
TYPES_EXPAND(3D),
# undef TYPES_EXPAND
};
/* Storage qualifiers. */
enum class Qualifier {
/** Restrict flag is set by default. Unless specified otherwise. */
NO_RESTRICT = (1 << 0),
READ = (1 << 1),
WRITE = (1 << 2),
no_restrict = (1 << 0),
read = (1 << 1),
write = (1 << 2),
/** Shorthand version of combined flags. */
READ_WRITE = READ | WRITE,
QUALIFIER_MAX = (WRITE << 1) - 1,
read_write = read | write,
QUALIFIER_MAX = (write << 1) - 1,
};
ENUM_OPERATORS(Qualifier, Qualifier::QUALIFIER_MAX);
@@ -1096,14 +1078,14 @@ struct ShaderCreateInfo {
Self &image(int slot,
eGPUTextureFormat format,
Qualifier qualifiers,
ImageType type,
ImageReadWriteType type,
StringRefNull name,
Frequency freq = Frequency::PASS)
{
Resource res(Resource::BindType::IMAGE, slot);
res.image.format = format;
res.image.qualifiers = qualifiers;
res.image.type = type;
res.image.type = ImageType(type);
res.image.name = name;
resources_get_(freq).append(res);
interface_names_size_ += name.size() + 1;

6
source/blender/gpu/metal/kernels/depth_2d_update_info.hh
View File

@@ -24,7 +24,7 @@ GPU_SHADER_CREATE_INFO(depth_2d_update_info_base)
GPU_SHADER_CREATE_INFO(depth_2d_update_float)
.metal_backend_only(true)
.fragment_source("depth_2d_update_float_frag.glsl")
.sampler(0, ImageType::FLOAT_2D, "source_data", Frequency::PASS)
.sampler(0, ImageType::Float2D, "source_data", Frequency::PASS)
.additional_info("depth_2d_update_info_base")
.do_static_compilation(true)
.depth_write(DepthWrite::ANY);
@@ -33,7 +33,7 @@ GPU_SHADER_CREATE_INFO(depth_2d_update_int24)
.metal_backend_only(true)
.fragment_source("depth_2d_update_int24_frag.glsl")
.additional_info("depth_2d_update_info_base")
.sampler(0, ImageType::INT_2D, "source_data", Frequency::PASS)
.sampler(0, ImageType::Int2D, "source_data", Frequency::PASS)
.do_static_compilation(true)
.depth_write(DepthWrite::ANY);
@@ -41,6 +41,6 @@ GPU_SHADER_CREATE_INFO(depth_2d_update_int32)
.metal_backend_only(true)
.fragment_source("depth_2d_update_int32_frag.glsl")
.additional_info("depth_2d_update_info_base")
.sampler(0, ImageType::INT_2D, "source_data", Frequency::PASS)
.sampler(0, ImageType::Int2D, "source_data", Frequency::PASS)
.do_static_compilation(true)
.depth_write(DepthWrite::ANY);

2
source/blender/gpu/metal/kernels/gpu_shader_fullscreen_blit_info.hh
View File

@@ -21,7 +21,7 @@ GPU_SHADER_CREATE_INFO(fullscreen_blit)
.push_constant(Type::float2_t, "dst_offset")
.push_constant(Type::float2_t, "src_offset")
.push_constant(Type::int_t, "mip")
.sampler(0, ImageType::FLOAT_2D, "imageTexture", Frequency::PASS)
.sampler(0, ImageType::Float2D, "imageTexture", Frequency::PASS)
.vertex_source("gpu_shader_fullscreen_blit_vert.glsl")
.fragment_source("gpu_shader_fullscreen_blit_frag.glsl")
.do_static_compilation(true);

429
source/blender/gpu/metal/mtl_shader_generator.mm
View File

@@ -206,8 +206,8 @@ static void print_resource(std::ostream &os, const ShaderCreateInfo::Resource &r
}
case ShaderCreateInfo::Resource::BindType::STORAGE_BUFFER: {
int64_t array_offset = res.storagebuf.name.find_first_of("[");
bool writeable = (res.storagebuf.qualifiers & shader::Qualifier::WRITE) ==
shader::Qualifier::WRITE;
bool writeable = (res.storagebuf.qualifiers & shader::Qualifier::write) ==
shader::Qualifier::write;
const char *memory_scope = ((writeable) ? "device " : "constant ");
if (array_offset == -1) {
/* Create local class member as device pointer reference to bound SSBO.
@@ -1072,9 +1072,8 @@ void MSLGeneratorInterface::prepare_from_createinfo(const shader::ShaderCreateIn
/* Samplers to have access::sample by default. */
MSLTextureSamplerAccess access = MSLTextureSamplerAccess::TEXTURE_ACCESS_SAMPLE;
/* TextureBuffers must have read/write/read-write access pattern. */
if (res.sampler.type == ImageType::FLOAT_BUFFER ||
res.sampler.type == ImageType::INT_BUFFER ||
res.sampler.type == ImageType::UINT_BUFFER)
if (res.sampler.type == ImageType::FloatBuffer ||
res.sampler.type == ImageType::IntBuffer || res.sampler.type == ImageType::UintBuffer)
{
access = MSLTextureSamplerAccess::TEXTURE_ACCESS_READ;
}
@@ -1096,10 +1095,10 @@ void MSLGeneratorInterface::prepare_from_createinfo(const shader::ShaderCreateIn
case shader::ShaderCreateInfo::Resource::BindType::IMAGE: {
/* Flatten qualifier flags into final access state. */
MSLTextureSamplerAccess access;
if ((res.image.qualifiers & Qualifier::READ_WRITE) == Qualifier::READ_WRITE) {
if ((res.image.qualifiers & Qualifier::read_write) == Qualifier::read_write) {
access = MSLTextureSamplerAccess::TEXTURE_ACCESS_READWRITE;
}
else if (bool(res.image.qualifiers & Qualifier::WRITE)) {
else if (bool(res.image.qualifiers & Qualifier::write)) {
access = MSLTextureSamplerAccess::TEXTURE_ACCESS_WRITE;
}
else {
@@ -1137,7 +1136,7 @@ void MSLGeneratorInterface::prepare_from_createinfo(const shader::ShaderCreateIn
BLI_assert(ubo.location >= 0 && ubo.location < MTL_MAX_BUFFER_BINDINGS);
ubo.qualifiers = shader::Qualifier::READ;
ubo.qualifiers = shader::Qualifier::read;
ubo.type_name = res.uniformbuf.type_name;
ubo.is_texture_buffer = false;
ubo.is_array = (array_offset > -1);
@@ -1193,12 +1192,12 @@ void MSLGeneratorInterface::prepare_from_createinfo(const shader::ShaderCreateIn
uint atomic_fallback_buffer_count = 0;
for (MSLTextureResource &tex : texture_samplers) {
if (ELEM(tex.type,
ImageType::UINT_2D_ATOMIC,
ImageType::UINT_2D_ARRAY_ATOMIC,
ImageType::UINT_3D_ATOMIC,
ImageType::INT_2D_ATOMIC,
ImageType::INT_2D_ARRAY_ATOMIC,
ImageType::INT_3D_ATOMIC))
ImageType::AtomicUint2D,
ImageType::AtomicUint2DArray,
ImageType::AtomicUint3D,
ImageType::AtomicInt2D,
ImageType::AtomicInt2DArray,
ImageType::AtomicInt3D))
{
/* Add storage-buffer bind-point. */
MSLBufferBlock ssbo;
@@ -1219,7 +1218,7 @@ void MSLGeneratorInterface::prepare_from_createinfo(const shader::ShaderCreateIn
BLI_assert(ssbo.location >= 0 && ssbo.location < MTL_MAX_BUFFER_BINDINGS);
/* Qualifier should be read write and type is either uint or int. */
ssbo.qualifiers = Qualifier::READ_WRITE;
ssbo.qualifiers = Qualifier::read_write;
ssbo.type_name = tex.get_msl_return_type_str();
ssbo.is_array = false;
ssbo.name = tex.name + "_storagebuf";
@@ -1296,9 +1295,9 @@ void MSLGeneratorInterface::prepare_from_createinfo(const shader::ShaderCreateIn
mtl_frag_in.name = frag_tile_in.name;
mtl_frag_in.raster_order_group = frag_tile_in.raster_order_group;
mtl_frag_in.is_layered_input = ELEM(frag_tile_in.img_type,
ImageType::UINT_2D_ARRAY,
ImageType::INT_2D_ARRAY,
ImageType::FLOAT_2D_ARRAY);
ImageType::Uint2DArray,
ImageType::Int2DArray,
ImageType::Float2DArray);
fragment_tile_inputs.append(mtl_frag_in);
@@ -1687,7 +1686,7 @@ void MSLGeneratorInterface::generate_msl_uniforms_input_string(std::stringstream
out << "const ";
}
/* For literal/existing global types, we do not need the class name-space accessor. */
bool writeable = (ssbo.qualifiers & shader::Qualifier::WRITE) == shader::Qualifier::WRITE;
bool writeable = (ssbo.qualifiers & shader::Qualifier::write) == shader::Qualifier::write;
const char *memory_scope = ((writeable) ? "device " : "constant ");
out << memory_scope;
if (!is_builtin_type(ssbo.type_name)) {
@@ -2185,7 +2184,7 @@ std::string MSLGeneratorInterface::generate_msl_uniform_block_population(ShaderS
out << " = ";
if (bool(stage & ShaderStage::VERTEX)) {
bool writeable = bool(ssbo.qualifiers & shader::Qualifier::WRITE);
bool writeable = bool(ssbo.qualifiers & shader::Qualifier::write);
const char *memory_scope = ((writeable) ? "device " : "constant ");
out << "const_cast<" << memory_scope;
@@ -2573,7 +2572,7 @@ std::string MSLGeneratorInterface::generate_msl_texture_vars(ShaderStage shader_
<< this->texture_samplers[i].name << ".atomic.buffer = ";
if (bool(shader_stage & ShaderStage::VERTEX)) {
bool writeable = bool(ssbo.qualifiers & shader::Qualifier::WRITE);
bool writeable = bool(ssbo.qualifiers & shader::Qualifier::write);
const char *memory_scope = ((writeable) ? "device " : "constant ");
out << "const_cast<" << memory_scope;
@@ -2596,10 +2595,10 @@ std::string MSLGeneratorInterface::generate_msl_texture_vars(ShaderStage shader_
/* Buffer-backed 2D Array and 3D texture types are not natively supported so texture size
* is passed in as uniform metadata for 3D to 2D coordinate remapping. */
if (ELEM(this->texture_samplers[i].type,
ImageType::UINT_2D_ARRAY_ATOMIC,
ImageType::UINT_3D_ATOMIC,
ImageType::INT_2D_ARRAY_ATOMIC,
ImageType::INT_3D_ATOMIC))
ImageType::AtomicUint2DArray,
ImageType::AtomicUint3D,
ImageType::AtomicInt2DArray,
ImageType::AtomicInt3D))
{
out << "\t" << get_shader_stage_instance_name(shader_stage) << "."
<< this->texture_samplers[i].name << ".atomic.texture_size = ushort3(uniforms->"
@@ -2886,110 +2885,110 @@ std::string MSLTextureResource::get_msl_texture_type_str() const
bool supports_native_atomics = MTLBackend::get_capabilities().supports_texture_atomics;
/* Add Types as needed. */
switch (this->type) {
case ImageType::FLOAT_1D: {
case ImageType::Float1D: {
return "texture1d";
}
case ImageType::FLOAT_2D: {
case ImageType::Float2D: {
return "texture2d";
}
case ImageType::FLOAT_3D: {
case ImageType::Float3D: {
return "texture3d";
}
case ImageType::FLOAT_CUBE: {
case ImageType::FloatCube: {
return "texturecube";
}
case ImageType::FLOAT_1D_ARRAY: {
case ImageType::Float1DArray: {
return "texture1d_array";
}
case ImageType::FLOAT_2D_ARRAY: {
case ImageType::Float2DArray: {
return "texture2d_array";
}
case ImageType::FLOAT_CUBE_ARRAY: {
case ImageType::FloatCubeArray: {
return "texturecube_array";
}
case ImageType::FLOAT_BUFFER: {
case ImageType::FloatBuffer: {
return "texture_buffer";
}
case ImageType::DEPTH_2D: {
case ImageType::Depth2D: {
return "depth2d";
}
case ImageType::SHADOW_2D: {
case ImageType::Shadow2D: {
return "depth2d";
}
case ImageType::DEPTH_2D_ARRAY: {
case ImageType::Depth2DArray: {
return "depth2d_array";
}
case ImageType::SHADOW_2D_ARRAY: {
case ImageType::Shadow2DArray: {
return "depth2d_array";
}
case ImageType::DEPTH_CUBE: {
case ImageType::DepthCube: {
return "depthcube";
}
case ImageType::SHADOW_CUBE: {
case ImageType::ShadowCube: {
return "depthcube";
}
case ImageType::DEPTH_CUBE_ARRAY: {
case ImageType::DepthCubeArray: {
return "depthcube_array";
}
case ImageType::SHADOW_CUBE_ARRAY: {
case ImageType::ShadowCubeArray: {
return "depthcube_array";
}
case ImageType::INT_1D: {
case ImageType::Int1D: {
return "texture1d";
}
case ImageType::INT_2D: {
case ImageType::Int2D: {
return "texture2d";
}
case ImageType::INT_3D: {
case ImageType::Int3D: {
return "texture3d";
}
case ImageType::INT_CUBE: {
case ImageType::IntCube: {
return "texturecube";
}
case ImageType::INT_1D_ARRAY: {
case ImageType::Int1DArray: {
return "texture1d_array";
}
case ImageType::INT_2D_ARRAY: {
case ImageType::Int2DArray: {
return "texture2d_array";
}
case ImageType::INT_CUBE_ARRAY: {
case ImageType::IntCubeArray: {
return "texturecube_array";
}
case ImageType::INT_BUFFER: {
case ImageType::IntBuffer: {
return "texture_buffer";
}
case ImageType::UINT_1D: {
case ImageType::Uint1D: {
return "texture1d";
}
case ImageType::UINT_2D: {
case ImageType::Uint2D: {
return "texture2d";
}
case ImageType::UINT_3D: {
case ImageType::Uint3D: {
return "texture3d";
}
case ImageType::UINT_CUBE: {
case ImageType::UintCube: {
return "texturecube";
}
case ImageType::UINT_1D_ARRAY: {
case ImageType::Uint1DArray: {
return "texture1d_array";
}
case ImageType::UINT_2D_ARRAY: {
case ImageType::Uint2DArray: {
return "texture2d_array";
}
case ImageType::UINT_CUBE_ARRAY: {
case ImageType::UintCubeArray: {
return "texturecube_array";
}
case ImageType::UINT_BUFFER: {
case ImageType::UintBuffer: {
return "texture_buffer";
}
/* If texture atomics are natively supported, we use the native texture type, otherwise all
* other formats are implemented via texture2d. */
case ImageType::INT_2D_ATOMIC:
case ImageType::UINT_2D_ATOMIC: {
case ImageType::AtomicInt2D:
case ImageType::AtomicUint2D: {
return "texture2d";
}
case ImageType::INT_2D_ARRAY_ATOMIC:
case ImageType::UINT_2D_ARRAY_ATOMIC: {
case ImageType::AtomicInt2DArray:
case ImageType::AtomicUint2DArray: {
if (supports_native_atomics) {
return "texture2d_array";
}
@@ -2997,8 +2996,8 @@ std::string MSLTextureResource::get_msl_texture_type_str() const
return "texture2d";
}
}
case ImageType::INT_3D_ATOMIC:
case ImageType::UINT_3D_ATOMIC: {
case ImageType::AtomicInt3D:
case ImageType::AtomicUint3D: {
if (supports_native_atomics) {
return "texture3d";
}
@@ -3020,106 +3019,106 @@ std::string MSLTextureResource::get_msl_wrapper_type_str() const
bool supports_native_atomics = MTLBackend::get_capabilities().supports_texture_atomics;
/* Add Types as needed. */
switch (this->type) {
case ImageType::FLOAT_1D: {
case ImageType::Float1D: {
return "_mtl_sampler_1d";
}
case ImageType::FLOAT_2D: {
case ImageType::Float2D: {
return "_mtl_sampler_2d";
}
case ImageType::FLOAT_3D: {
case ImageType::Float3D: {
return "_mtl_sampler_3d";
}
case ImageType::FLOAT_CUBE: {
case ImageType::FloatCube: {
return "_mtl_sampler_cube";
}
case ImageType::FLOAT_1D_ARRAY: {
case ImageType::Float1DArray: {
return "_mtl_sampler_1d_array";
}
case ImageType::FLOAT_2D_ARRAY: {
case ImageType::Float2DArray: {
return "_mtl_sampler_2d_array";
}
case ImageType::FLOAT_CUBE_ARRAY: {
case ImageType::FloatCubeArray: {
return "_mtl_sampler_cube_array";
}
case ImageType::FLOAT_BUFFER: {
case ImageType::FloatBuffer: {
return "_mtl_sampler_buffer";
}
case ImageType::DEPTH_2D: {
case ImageType::Depth2D: {
return "_mtl_sampler_depth_2d";
}
case ImageType::SHADOW_2D: {
case ImageType::Shadow2D: {
return "_mtl_sampler_depth_2d";
}
case ImageType::DEPTH_2D_ARRAY: {
case ImageType::Depth2DArray: {
return "_mtl_sampler_depth_2d_array";
}
case ImageType::SHADOW_2D_ARRAY: {
case ImageType::Shadow2DArray: {
return "_mtl_sampler_depth_2d_array";
}
case ImageType::DEPTH_CUBE: {
case ImageType::DepthCube: {
return "_mtl_sampler_depth_cube";
}
case ImageType::SHADOW_CUBE: {
case ImageType::ShadowCube: {
return "_mtl_sampler_depth_cube";
}
case ImageType::DEPTH_CUBE_ARRAY: {
case ImageType::DepthCubeArray: {
return "_mtl_sampler_depth_cube_array";
}
case ImageType::SHADOW_CUBE_ARRAY: {
case ImageType::ShadowCubeArray: {
return "_mtl_sampler_depth_cube_array";
}
case ImageType::INT_1D: {
case ImageType::Int1D: {
return "_mtl_sampler_1d";
}
case ImageType::INT_2D: {
case ImageType::Int2D: {
return "_mtl_sampler_2d";
}
case ImageType::INT_3D: {
case ImageType::Int3D: {
return "_mtl_sampler_3d";
}
case ImageType::INT_CUBE: {
case ImageType::IntCube: {
return "_mtl_sampler_cube";
}
case ImageType::INT_1D_ARRAY: {
case ImageType::Int1DArray: {
return "_mtl_sampler_1d_array";
}
case ImageType::INT_2D_ARRAY: {
case ImageType::Int2DArray: {
return "_mtl_sampler_2d_array";
}
case ImageType::INT_CUBE_ARRAY: {
case ImageType::IntCubeArray: {
return "_mtl_sampler_cube_array";
}
case ImageType::INT_BUFFER: {
case ImageType::IntBuffer: {
return "_mtl_sampler_buffer";
}
case ImageType::UINT_1D: {
case ImageType::Uint1D: {
return "_mtl_sampler_1d";
}
case ImageType::UINT_2D: {
case ImageType::Uint2D: {
return "_mtl_sampler_2d";
}
case ImageType::UINT_3D: {
case ImageType::Uint3D: {
return "_mtl_sampler_3d";
}
case ImageType::UINT_CUBE: {
case ImageType::UintCube: {
return "_mtl_sampler_cube";
}
case ImageType::UINT_1D_ARRAY: {
case ImageType::Uint1DArray: {
return "_mtl_sampler_1d_array";
}
case ImageType::UINT_2D_ARRAY: {
case ImageType::Uint2DArray: {
return "_mtl_sampler_2d_array";
}
case ImageType::UINT_CUBE_ARRAY: {
case ImageType::UintCubeArray: {
return "_mtl_sampler_cube_array";
}
case ImageType::UINT_BUFFER: {
case ImageType::UintBuffer: {
return "_mtl_sampler_buffer";
}
/* If native texture atomics are unsupported, map types to fallback atomic structures which
* contain a buffer pointer and metadata members for size and alignment. */
case ImageType::INT_2D_ATOMIC:
case ImageType::UINT_2D_ATOMIC: {
case ImageType::AtomicInt2D:
case ImageType::AtomicUint2D: {
if (supports_native_atomics) {
return "_mtl_sampler_2d";
}
@@ -3127,8 +3126,8 @@ std::string MSLTextureResource::get_msl_wrapper_type_str() const
return "_mtl_sampler_2d_atomic";
}
}
case ImageType::INT_3D_ATOMIC:
case ImageType::UINT_3D_ATOMIC: {
case ImageType::AtomicInt3D:
case ImageType::AtomicUint3D: {
if (supports_native_atomics) {
return "_mtl_sampler_3d";
}
@@ -3136,8 +3135,8 @@ std::string MSLTextureResource::get_msl_wrapper_type_str() const
return "_mtl_sampler_3d_atomic";
}
}
case ImageType::INT_2D_ARRAY_ATOMIC:
case ImageType::UINT_2D_ARRAY_ATOMIC: {
case ImageType::AtomicInt2DArray:
case ImageType::AtomicUint2DArray: {
if (supports_native_atomics) {
return "_mtl_sampler_2d_array";
}
@@ -3158,51 +3157,51 @@ std::string MSLTextureResource::get_msl_return_type_str() const
/* Add Types as needed */
switch (this->type) {
/* Floating point return. */
case ImageType::FLOAT_1D:
case ImageType::FLOAT_2D:
case ImageType::FLOAT_3D:
case ImageType::FLOAT_CUBE:
case ImageType::FLOAT_1D_ARRAY:
case ImageType::FLOAT_2D_ARRAY:
case ImageType::FLOAT_CUBE_ARRAY:
case ImageType::FLOAT_BUFFER:
case ImageType::DEPTH_2D:
case ImageType::SHADOW_2D:
case ImageType::DEPTH_2D_ARRAY:
case ImageType::SHADOW_2D_ARRAY:
case ImageType::DEPTH_CUBE:
case ImageType::SHADOW_CUBE:
case ImageType::DEPTH_CUBE_ARRAY:
case ImageType::SHADOW_CUBE_ARRAY: {
case ImageType::Float1D:
case ImageType::Float2D:
case ImageType::Float3D:
case ImageType::FloatCube:
case ImageType::Float1DArray:
case ImageType::Float2DArray:
case ImageType::FloatCubeArray:
case ImageType::FloatBuffer:
case ImageType::Depth2D:
case ImageType::Shadow2D:
case ImageType::Depth2DArray:
case ImageType::Shadow2DArray:
case ImageType::DepthCube:
case ImageType::ShadowCube:
case ImageType::DepthCubeArray:
case ImageType::ShadowCubeArray: {
return "float";
}
/* Integer return. */
case ImageType::INT_1D:
case ImageType::INT_2D:
case ImageType::INT_3D:
case ImageType::INT_CUBE:
case ImageType::INT_1D_ARRAY:
case ImageType::INT_2D_ARRAY:
case ImageType::INT_CUBE_ARRAY:
case ImageType::INT_BUFFER:
case ImageType::INT_2D_ATOMIC:
case ImageType::INT_2D_ARRAY_ATOMIC:
case ImageType::INT_3D_ATOMIC: {
case ImageType::Int1D:
case ImageType::Int2D:
case ImageType::Int3D:
case ImageType::IntCube:
case ImageType::Int1DArray:
case ImageType::Int2DArray:
case ImageType::IntCubeArray:
case ImageType::IntBuffer:
case ImageType::AtomicInt2D:
case ImageType::AtomicInt2DArray:
case ImageType::AtomicInt3D: {
return "int";
}
/* Unsigned Integer return. */
case ImageType::UINT_1D:
case ImageType::UINT_2D:
case ImageType::UINT_3D:
case ImageType::UINT_CUBE:
case ImageType::UINT_1D_ARRAY:
case ImageType::UINT_2D_ARRAY:
case ImageType::UINT_CUBE_ARRAY:
case ImageType::UINT_BUFFER:
case ImageType::UINT_2D_ATOMIC:
case ImageType::UINT_2D_ARRAY_ATOMIC:
case ImageType::UINT_3D_ATOMIC: {
case ImageType::Uint1D:
case ImageType::Uint2D:
case ImageType::Uint3D:
case ImageType::UintCube:
case ImageType::Uint1DArray:
case ImageType::Uint2DArray:
case ImageType::UintCubeArray:
case ImageType::UintBuffer:
case ImageType::AtomicUint2D:
case ImageType::AtomicUint2DArray:
case ImageType::AtomicUint3D: {
return "uint32_t";
}
@@ -3218,106 +3217,106 @@ eGPUTextureType MSLTextureResource::get_texture_binding_type() const
{
/* Add Types as needed */
switch (this->type) {
case ImageType::FLOAT_1D: {
case ImageType::Float1D: {
return GPU_TEXTURE_1D;
}
case ImageType::FLOAT_2D: {
case ImageType::Float2D: {
return GPU_TEXTURE_2D;
}
case ImageType::FLOAT_3D: {
case ImageType::Float3D: {
return GPU_TEXTURE_3D;
}
case ImageType::FLOAT_CUBE: {
case ImageType::FloatCube: {
return GPU_TEXTURE_CUBE;
}
case ImageType::FLOAT_1D_ARRAY: {
case ImageType::Float1DArray: {
return GPU_TEXTURE_1D_ARRAY;
}
case ImageType::FLOAT_2D_ARRAY: {
case ImageType::Float2DArray: {
return GPU_TEXTURE_2D_ARRAY;
}
case ImageType::FLOAT_CUBE_ARRAY: {
case ImageType::FloatCubeArray: {
return GPU_TEXTURE_CUBE_ARRAY;
}
case ImageType::FLOAT_BUFFER: {
case ImageType::FloatBuffer: {
return GPU_TEXTURE_BUFFER;
}
case ImageType::DEPTH_2D: {
case ImageType::Depth2D: {
return GPU_TEXTURE_2D;
}
case ImageType::SHADOW_2D: {
case ImageType::Shadow2D: {
return GPU_TEXTURE_2D;
}
case ImageType::DEPTH_2D_ARRAY: {
case ImageType::Depth2DArray: {
return GPU_TEXTURE_2D_ARRAY;
}
case ImageType::SHADOW_2D_ARRAY: {
case ImageType::Shadow2DArray: {
return GPU_TEXTURE_2D_ARRAY;
}
case ImageType::DEPTH_CUBE: {
case ImageType::DepthCube: {
return GPU_TEXTURE_CUBE;
}
case ImageType::SHADOW_CUBE: {
case ImageType::ShadowCube: {
return GPU_TEXTURE_CUBE;
}
case ImageType::DEPTH_CUBE_ARRAY: {
case ImageType::DepthCubeArray: {
return GPU_TEXTURE_CUBE_ARRAY;
}
case ImageType::SHADOW_CUBE_ARRAY: {
case ImageType::ShadowCubeArray: {
return GPU_TEXTURE_CUBE_ARRAY;
}
case ImageType::INT_1D: {
case ImageType::Int1D: {
return GPU_TEXTURE_1D;
}
case ImageType::INT_2D: {
case ImageType::Int2D: {
return GPU_TEXTURE_2D;
}
case ImageType::INT_3D: {
case ImageType::Int3D: {
return GPU_TEXTURE_3D;
}
case ImageType::INT_CUBE: {
case ImageType::IntCube: {
return GPU_TEXTURE_CUBE;
}
case ImageType::INT_1D_ARRAY: {
case ImageType::Int1DArray: {
return GPU_TEXTURE_1D_ARRAY;
}
case ImageType::INT_2D_ARRAY: {
case ImageType::Int2DArray: {
return GPU_TEXTURE_2D_ARRAY;
}
case ImageType::INT_CUBE_ARRAY: {
case ImageType::IntCubeArray: {
return GPU_TEXTURE_CUBE_ARRAY;
}
case ImageType::INT_BUFFER: {
case ImageType::IntBuffer: {
return GPU_TEXTURE_BUFFER;
}
case ImageType::UINT_1D: {
case ImageType::Uint1D: {
return GPU_TEXTURE_1D;
}
case ImageType::UINT_2D:
case ImageType::UINT_2D_ATOMIC:
case ImageType::INT_2D_ATOMIC: {
case ImageType::Uint2D:
case ImageType::AtomicUint2D:
case ImageType::AtomicInt2D: {
return GPU_TEXTURE_2D;
}
case ImageType::UINT_3D:
case ImageType::UINT_3D_ATOMIC:
case ImageType::INT_3D_ATOMIC: {
case ImageType::Uint3D:
case ImageType::AtomicUint3D:
case ImageType::AtomicInt3D: {
return GPU_TEXTURE_3D;
}
case ImageType::UINT_CUBE: {
case ImageType::UintCube: {
return GPU_TEXTURE_CUBE;
}
case ImageType::UINT_1D_ARRAY: {
case ImageType::Uint1DArray: {
return GPU_TEXTURE_1D_ARRAY;
}
case ImageType::UINT_2D_ARRAY:
case ImageType::UINT_2D_ARRAY_ATOMIC:
case ImageType::INT_2D_ARRAY_ATOMIC: {
case ImageType::Uint2DArray:
case ImageType::AtomicUint2DArray:
case ImageType::AtomicInt2DArray: {
return GPU_TEXTURE_2D_ARRAY;
}
case ImageType::UINT_CUBE_ARRAY: {
case ImageType::UintCubeArray: {
return GPU_TEXTURE_CUBE_ARRAY;
}
case ImageType::UINT_BUFFER: {
case ImageType::UintBuffer: {
return GPU_TEXTURE_BUFFER;
}
default: {
@@ -3330,47 +3329,47 @@ eGPUTextureType MSLTextureResource::get_texture_binding_type() const
eGPUSamplerFormat MSLTextureResource::get_sampler_format() const
{
switch (this->type) {
case ImageType::FLOAT_BUFFER:
case ImageType::FLOAT_1D:
case ImageType::FLOAT_1D_ARRAY:
case ImageType::FLOAT_2D:
case ImageType::FLOAT_2D_ARRAY:
case ImageType::FLOAT_3D:
case ImageType::FLOAT_CUBE:
case ImageType::FLOAT_CUBE_ARRAY:
case ImageType::FloatBuffer:
case ImageType::Float1D:
case ImageType::Float1DArray:
case ImageType::Float2D:
case ImageType::Float2DArray:
case ImageType::Float3D:
case ImageType::FloatCube:
case ImageType::FloatCubeArray:
return GPU_SAMPLER_TYPE_FLOAT;
case ImageType::INT_BUFFER:
case ImageType::INT_1D:
case ImageType::INT_1D_ARRAY:
case ImageType::INT_2D:
case ImageType::INT_2D_ARRAY:
case ImageType::INT_3D:
case ImageType::INT_CUBE:
case ImageType::INT_CUBE_ARRAY:
case ImageType::INT_2D_ATOMIC:
case ImageType::INT_3D_ATOMIC:
case ImageType::INT_2D_ARRAY_ATOMIC:
case ImageType::IntBuffer:
case ImageType::Int1D:
case ImageType::Int1DArray:
case ImageType::Int2D:
case ImageType::Int2DArray:
case ImageType::Int3D:
case ImageType::IntCube:
case ImageType::IntCubeArray:
case ImageType::AtomicInt2D:
case ImageType::AtomicInt3D:
case ImageType::AtomicInt2DArray:
return GPU_SAMPLER_TYPE_INT;
case ImageType::UINT_BUFFER:
case ImageType::UINT_1D:
case ImageType::UINT_1D_ARRAY:
case ImageType::UINT_2D:
case ImageType::UINT_2D_ARRAY:
case ImageType::UINT_3D:
case ImageType::UINT_CUBE:
case ImageType::UINT_CUBE_ARRAY:
case ImageType::UINT_2D_ATOMIC:
case ImageType::UINT_3D_ATOMIC:
case ImageType::UINT_2D_ARRAY_ATOMIC:
case ImageType::UintBuffer:
case ImageType::Uint1D:
case ImageType::Uint1DArray:
case ImageType::Uint2D:
case ImageType::Uint2DArray:
case ImageType::Uint3D:
case ImageType::UintCube:
case ImageType::UintCubeArray:
case ImageType::AtomicUint2D:
case ImageType::AtomicUint3D:
case ImageType::AtomicUint2DArray:
return GPU_SAMPLER_TYPE_UINT;
case ImageType::SHADOW_2D:
case ImageType::SHADOW_2D_ARRAY:
case ImageType::SHADOW_CUBE:
case ImageType::SHADOW_CUBE_ARRAY:
case ImageType::DEPTH_2D:
case ImageType::DEPTH_2D_ARRAY:
case ImageType::DEPTH_CUBE:
case ImageType::DEPTH_CUBE_ARRAY:
case ImageType::Shadow2D:
case ImageType::Shadow2DArray:
case ImageType::ShadowCube:
case ImageType::ShadowCubeArray:
case ImageType::Depth2D:
case ImageType::Depth2DArray:
case ImageType::DepthCube:
case ImageType::DepthCubeArray:
return GPU_SAMPLER_TYPE_DEPTH;
default:
BLI_assert_unreachable();

2
source/blender/gpu/metal/mtl_texture.mm
View File

@@ -610,7 +610,7 @@ void gpu::MTLTexture::update_sub(
if (is_depth_format) {
if (type_ == GPU_TEXTURE_2D || type_ == GPU_TEXTURE_2D_ARRAY) {
/* Workaround for crash in validation layer when blitting to depth2D target with
/* Workaround for crash in validation layer when blitting to sampler2DDepth target with
* dimensions (1, 1, 1); */
if (extent[0] == 1 && extent[1] == 1 && extent[2] == 1 && totalsize == 4) {
can_use_direct_blit = false;

168
source/blender/gpu/opengl/gl_shader.cc
View File

@@ -328,30 +328,30 @@ static void print_image_type(std::ostream &os,
const ShaderCreateInfo::Resource::BindType bind_type)
{
switch (type) {
case ImageType::INT_BUFFER:
case ImageType::INT_1D:
case ImageType::INT_1D_ARRAY:
case ImageType::INT_2D:
case ImageType::INT_2D_ARRAY:
case ImageType::INT_3D:
case ImageType::INT_CUBE:
case ImageType::INT_CUBE_ARRAY:
case ImageType::INT_2D_ATOMIC:
case ImageType::INT_2D_ARRAY_ATOMIC:
case ImageType::INT_3D_ATOMIC:
case ImageType::IntBuffer:
case ImageType::Int1D:
case ImageType::Int1DArray:
case ImageType::Int2D:
case ImageType::Int2DArray:
case ImageType::Int3D:
case ImageType::IntCube:
case ImageType::IntCubeArray:
case ImageType::AtomicInt2D:
case ImageType::AtomicInt2DArray:
case ImageType::AtomicInt3D:
os << "i";
break;
case ImageType::UINT_BUFFER:
case ImageType::UINT_1D:
case ImageType::UINT_1D_ARRAY:
case ImageType::UINT_2D:
case ImageType::UINT_2D_ARRAY:
case ImageType::UINT_3D:
case ImageType::UINT_CUBE:
case ImageType::UINT_CUBE_ARRAY:
case ImageType::UINT_2D_ATOMIC:
case ImageType::UINT_2D_ARRAY_ATOMIC:
case ImageType::UINT_3D_ATOMIC:
case ImageType::UintBuffer:
case ImageType::Uint1D:
case ImageType::Uint1DArray:
case ImageType::Uint2D:
case ImageType::Uint2DArray:
case ImageType::Uint3D:
case ImageType::UintCube:
case ImageType::UintCubeArray:
case ImageType::AtomicUint2D:
case ImageType::AtomicUint2DArray:
case ImageType::AtomicUint3D:
os << "u";
break;
default:
@@ -366,52 +366,52 @@ static void print_image_type(std::ostream &os,
}
switch (type) {
case ImageType::FLOAT_BUFFER:
case ImageType::INT_BUFFER:
case ImageType::UINT_BUFFER:
case ImageType::FloatBuffer:
case ImageType::IntBuffer:
case ImageType::UintBuffer:
os << "Buffer";
break;
case ImageType::FLOAT_1D:
case ImageType::FLOAT_1D_ARRAY:
case ImageType::INT_1D:
case ImageType::INT_1D_ARRAY:
case ImageType::UINT_1D:
case ImageType::UINT_1D_ARRAY:
case ImageType::Float1D:
case ImageType::Float1DArray:
case ImageType::Int1D:
case ImageType::Int1DArray:
case ImageType::Uint1D:
case ImageType::Uint1DArray:
os << "1D";
break;
case ImageType::FLOAT_2D:
case ImageType::FLOAT_2D_ARRAY:
case ImageType::INT_2D:
case ImageType::INT_2D_ARRAY:
case ImageType::INT_2D_ATOMIC:
case ImageType::INT_2D_ARRAY_ATOMIC:
case ImageType::UINT_2D:
case ImageType::UINT_2D_ARRAY:
case ImageType::UINT_2D_ATOMIC:
case ImageType::UINT_2D_ARRAY_ATOMIC:
case ImageType::SHADOW_2D:
case ImageType::SHADOW_2D_ARRAY:
case ImageType::DEPTH_2D:
case ImageType::DEPTH_2D_ARRAY:
case ImageType::Float2D:
case ImageType::Float2DArray:
case ImageType::Int2D:
case ImageType::Int2DArray:
case ImageType::AtomicInt2D:
case ImageType::AtomicInt2DArray:
case ImageType::Uint2D:
case ImageType::Uint2DArray:
case ImageType::AtomicUint2D:
case ImageType::AtomicUint2DArray:
case ImageType::Shadow2D:
case ImageType::Shadow2DArray:
case ImageType::Depth2D:
case ImageType::Depth2DArray:
os << "2D";
break;
case ImageType::FLOAT_3D:
case ImageType::INT_3D:
case ImageType::UINT_3D:
case ImageType::INT_3D_ATOMIC:
case ImageType::UINT_3D_ATOMIC:
case ImageType::Float3D:
case ImageType::Int3D:
case ImageType::Uint3D:
case ImageType::AtomicInt3D:
case ImageType::AtomicUint3D:
os << "3D";
break;
case ImageType::FLOAT_CUBE:
case ImageType::FLOAT_CUBE_ARRAY:
case ImageType::INT_CUBE:
case ImageType::INT_CUBE_ARRAY:
case ImageType::UINT_CUBE:
case ImageType::UINT_CUBE_ARRAY:
case ImageType::SHADOW_CUBE:
case ImageType::SHADOW_CUBE_ARRAY:
case ImageType::DEPTH_CUBE:
case ImageType::DEPTH_CUBE_ARRAY:
case ImageType::FloatCube:
case ImageType::FloatCubeArray:
case ImageType::IntCube:
case ImageType::IntCubeArray:
case ImageType::UintCube:
case ImageType::UintCubeArray:
case ImageType::ShadowCube:
case ImageType::ShadowCubeArray:
case ImageType::DepthCube:
case ImageType::DepthCubeArray:
os << "Cube";
break;
default:
@@ -419,20 +419,20 @@ static void print_image_type(std::ostream &os,
}
switch (type) {
case ImageType::FLOAT_1D_ARRAY:
case ImageType::FLOAT_2D_ARRAY:
case ImageType::FLOAT_CUBE_ARRAY:
case ImageType::INT_1D_ARRAY:
case ImageType::INT_2D_ARRAY:
case ImageType::INT_CUBE_ARRAY:
case ImageType::UINT_1D_ARRAY:
case ImageType::UINT_2D_ARRAY:
case ImageType::UINT_2D_ARRAY_ATOMIC:
case ImageType::UINT_CUBE_ARRAY:
case ImageType::SHADOW_2D_ARRAY:
case ImageType::SHADOW_CUBE_ARRAY:
case ImageType::DEPTH_2D_ARRAY:
case ImageType::DEPTH_CUBE_ARRAY:
case ImageType::Float1DArray:
case ImageType::Float2DArray:
case ImageType::FloatCubeArray:
case ImageType::Int1DArray:
case ImageType::Int2DArray:
case ImageType::IntCubeArray:
case ImageType::Uint1DArray:
case ImageType::Uint2DArray:
case ImageType::AtomicUint2DArray:
case ImageType::UintCubeArray:
case ImageType::Shadow2DArray:
case ImageType::ShadowCubeArray:
case ImageType::Depth2DArray:
case ImageType::DepthCubeArray:
os << "Array";
break;
default:
@@ -440,10 +440,10 @@ static void print_image_type(std::ostream &os,
}
switch (type) {
case ImageType::SHADOW_2D:
case ImageType::SHADOW_2D_ARRAY:
case ImageType::SHADOW_CUBE:
case ImageType::SHADOW_CUBE_ARRAY:
case ImageType::Shadow2D:
case ImageType::Shadow2DArray:
case ImageType::ShadowCube:
case ImageType::ShadowCubeArray:
os << "Shadow";
break;
default:
@@ -454,13 +454,13 @@ static void print_image_type(std::ostream &os,
static std::ostream &print_qualifier(std::ostream &os, const Qualifier &qualifiers)
{
if (bool(qualifiers & Qualifier::NO_RESTRICT) == false) {
if (bool(qualifiers & Qualifier::no_restrict) == false) {
os << "restrict ";
}
if (bool(qualifiers & Qualifier::READ) == false) {
if (bool(qualifiers & Qualifier::read) == false) {
os << "writeonly ";
}
if (bool(qualifiers & Qualifier::WRITE) == false) {
if (bool(qualifiers & Qualifier::write) == false) {
os << "readonly ";
}
return os;
@@ -800,10 +800,8 @@ std::string GLShader::fragment_interface_declare(const ShaderCreateInfo &info) c
/* IMPORTANT: We assume that the frame-buffer will be layered or not based on the layer
* built-in flag. */
bool is_layered_fb = bool(info.builtins_ & BuiltinBits::LAYER);
bool is_layered_input = ELEM(input.img_type,
ImageType::UINT_2D_ARRAY,
ImageType::INT_2D_ARRAY,
ImageType::FLOAT_2D_ARRAY);
bool is_layered_input = ELEM(
input.img_type, ImageType::Uint2DArray, ImageType::Int2DArray, ImageType::Float2DArray);
/* Declare image. */
using Resource = ShaderCreateInfo::Resource;

25
source/blender/gpu/shaders/gpu_glsl_cpp_stubs.hh
View File

@@ -511,7 +511,12 @@ RESHAPE(float3x3, float3x4, m[0].xyz, m[1].xyz, m[2].xyz)
/** \name Sampler Types
* \{ */
template<typename T, int Dimensions, bool Cube = false, bool Array = false, bool Atomic = false>
template<typename T,
int Dimensions,
bool Cube = false,
bool Array = false,
bool Atomic = false,
bool Depth = false>
struct SamplerBase {
static constexpr int coord_dim = Dimensions + int(Cube) + int(Array);
static constexpr int deriv_dim = Dimensions + int(Cube);
@@ -581,10 +586,10 @@ using isampler2DAtomic = SamplerBase<int, 2, false, false, true>;
using isampler2DArrayAtomic = SamplerBase<int, 2, false, true, true>;
using isampler3DAtomic = SamplerBase<int, 3, false, false, true>;
using depth2D = sampler2D;
using depth2DArray = sampler2DArray;
using depthCube = samplerCube;
using depthCubeArray = samplerCubeArray;
using sampler2DDepth = SamplerBase<float, 2, false, false, false, true>;
using sampler2DArrayDepth = SamplerBase<float, 2, false, true, false, true>;
using samplerCubeDepth = SamplerBase<float, 2, true, false, false, true>;
using samplerCubeArrayDepth = SamplerBase<float, 2, true, true, false, true>;
/* Sampler Buffers do not have LOD. */
float4 texelFetch(samplerBuffer, int) RET;
@@ -597,7 +602,7 @@ uint4 texelFetch(usamplerBuffer, int) RET;
/** \name Image Types
* \{ */
template<typename T, int Dimensions, bool Array = false> struct ImageBase {
template<typename T, int Dimensions, bool Array = false, bool Atomic = false> struct ImageBase {
static constexpr int coord_dim = Dimensions + int(Array);
using int_coord_type = VecBase<int, coord_dim>;
@@ -659,6 +664,14 @@ using iimage2DArray = ImageBase<int, 2, true>;
using uimage1DArray = ImageBase<uint, 1, true>;
using uimage2DArray = ImageBase<uint, 2, true>;
using iimage2DAtomic = ImageBase<int, 2, false, true>;
using iimage3DAtomic = ImageBase<int, 3, false, true>;
using uimage2DAtomic = ImageBase<uint, 2, false, true>;
using uimage3DAtomic = ImageBase<uint, 3, false, true>;
using iimage2DArrayAtomic = ImageBase<int, 2, true, true>;
using uimage2DArrayAtomic = ImageBase<uint, 2, true, true>;
/* Forbid Cube and cube arrays. Bind them as 3D textures instead. */
/** \} */

2
source/blender/gpu/shaders/infos/gpu_index_load_info.hh
View File

@@ -23,6 +23,6 @@ GPU_SHADER_CREATE_INFO(gpu_index_buffer_load)
PUSH_CONSTANT(bool, gpu_index_no_buffer)
PUSH_CONSTANT(bool, gpu_index_16bit)
PUSH_CONSTANT(int, gpu_index_base_index)
STORAGE_BUF_FREQ(GPU_SSBO_INDEX_BUF_SLOT, READ, uint, gpu_index_buf[], GEOMETRY)
STORAGE_BUF_FREQ(GPU_SSBO_INDEX_BUF_SLOT, read, uint, gpu_index_buf[], GEOMETRY)
DEFINE("GPU_INDEX_LOAD")
GPU_SHADER_CREATE_END()

2
source/blender/gpu/shaders/infos/gpu_shader_2D_image_info.hh
View File

@@ -22,6 +22,6 @@ VERTEX_IN(1, float2, texCoord)
VERTEX_OUT(smooth_tex_coord_interp_iface)
FRAGMENT_OUT(0, float4, fragColor)
PUSH_CONSTANT(float4x4, ModelViewProjectionMatrix)
SAMPLER(0, FLOAT_2D, image)
SAMPLER(0, sampler2D, image)
VERTEX_SOURCE("gpu_shader_2D_image_vert.glsl")
GPU_SHADER_CREATE_END()

6
source/blender/gpu/shaders/infos/gpu_shader_2D_image_overlays_merge_info.hh
View File

@@ -26,8 +26,8 @@ PUSH_CONSTANT(bool, display_transform)
PUSH_CONSTANT(bool, overlay)
PUSH_CONSTANT(bool, use_hdr)
/* Sampler slots should match OCIO's. */
SAMPLER(0, FLOAT_2D, image_texture)
SAMPLER(1, FLOAT_2D, overlays_texture)
SAMPLER(0, sampler2D, image_texture)
SAMPLER(1, sampler2D, overlays_texture)
VERTEX_SOURCE("gpu_shader_2D_image_vert.glsl")
FRAGMENT_SOURCE("gpu_shader_image_overlays_merge_frag.glsl")
DO_STATIC_COMPILATION()
@@ -40,7 +40,7 @@ VERTEX_IN(1, float2, texCoord)
VERTEX_OUT(smooth_tex_coord_interp_iface)
FRAGMENT_OUT(0, float4, fragColor)
PUSH_CONSTANT(float2, fullscreen)
SAMPLER(0, FLOAT_2D, image_texture)
SAMPLER(0, sampler2D, image_texture)
VERTEX_SOURCE("gpu_shader_display_fallback_vert.glsl")
FRAGMENT_SOURCE("gpu_shader_display_fallback_frag.glsl")
DO_STATIC_COMPILATION()

4
source/blender/gpu/shaders/infos/gpu_shader_2D_image_overlays_stereo_merge_info.hh
View File

@@ -19,8 +19,8 @@ GPU_SHADER_CREATE_INFO(gpu_shader_2D_image_overlays_stereo_merge)
VERTEX_IN(0, float2, pos)
FRAGMENT_OUT(0, float4, overlayColor)
FRAGMENT_OUT(1, float4, imageColor)
SAMPLER(0, FLOAT_2D, imageTexture)
SAMPLER(1, FLOAT_2D, overlayTexture)
SAMPLER(0, sampler2D, imageTexture)
SAMPLER(1, sampler2D, overlayTexture)
PUSH_CONSTANT(float4x4, ModelViewProjectionMatrix)
PUSH_CONSTANT(int, stereoDisplaySettings)
VERTEX_SOURCE("gpu_shader_2D_vert.glsl")

2
source/blender/gpu/shaders/infos/gpu_shader_2D_image_rect_color_info.hh
View File

@@ -23,7 +23,7 @@ PUSH_CONSTANT(float4x4, ModelViewProjectionMatrix)
PUSH_CONSTANT(float4, color)
PUSH_CONSTANT(float4, rect_icon)
PUSH_CONSTANT(float4, rect_geom)
SAMPLER(0, FLOAT_2D, image)
SAMPLER(0, sampler2D, image)
VERTEX_SOURCE("gpu_shader_2D_image_rect_vert.glsl")
FRAGMENT_SOURCE("gpu_shader_image_color_frag.glsl")
DO_STATIC_COMPILATION()

2
source/blender/gpu/shaders/infos/gpu_shader_3D_image_info.hh
View File

@@ -22,7 +22,7 @@ VERTEX_IN(1, float2, texCoord)
VERTEX_OUT(smooth_tex_coord_interp_iface)
FRAGMENT_OUT(0, float4, fragColor)
PUSH_CONSTANT(float4x4, ModelViewProjectionMatrix)
SAMPLER(0, FLOAT_2D, image)
SAMPLER(0, sampler2D, image)
VERTEX_SOURCE("gpu_shader_3D_image_vert.glsl")
GPU_SHADER_CREATE_END()

6
source/blender/gpu/shaders/infos/gpu_shader_3D_polyline_info.hh
View File

@@ -31,7 +31,7 @@ PUSH_CONSTANT(float4x4, ModelViewProjectionMatrix)
PUSH_CONSTANT(float2, viewportSize)
PUSH_CONSTANT(float, lineWidth)
PUSH_CONSTANT(bool, lineSmooth)
STORAGE_BUF_FREQ(GPU_SSBO_POLYLINE_POS_BUF_SLOT, READ, float, pos[], GEOMETRY)
STORAGE_BUF_FREQ(GPU_SSBO_POLYLINE_POS_BUF_SLOT, read, float, pos[], GEOMETRY)
PUSH_CONSTANT(int2, gpu_attr_0)
PUSH_CONSTANT(int3, gpu_vert_stride_count_offset)
PUSH_CONSTANT(int, gpu_attr_0_len)
@@ -64,7 +64,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(gpu_shader_3D_polyline_flat_color)
DO_STATIC_COMPILATION()
DEFINE("FLAT")
STORAGE_BUF_FREQ(GPU_SSBO_POLYLINE_COL_BUF_SLOT, READ, float, color[], GEOMETRY)
STORAGE_BUF_FREQ(GPU_SSBO_POLYLINE_COL_BUF_SLOT, read, float, color[], GEOMETRY)
PUSH_CONSTANT(int2, gpu_attr_1)
PUSH_CONSTANT(int, gpu_attr_1_len)
ADDITIONAL_INFO(gpu_shader_3D_polyline)
@@ -73,7 +73,7 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(gpu_shader_3D_polyline_smooth_color)
DO_STATIC_COMPILATION()
DEFINE("SMOOTH")
STORAGE_BUF_FREQ(GPU_SSBO_POLYLINE_COL_BUF_SLOT, READ, float, color[], GEOMETRY)
STORAGE_BUF_FREQ(GPU_SSBO_POLYLINE_COL_BUF_SLOT, read, float, color[], GEOMETRY)
PUSH_CONSTANT(int2, gpu_attr_1)
PUSH_CONSTANT(int, gpu_attr_1_len)
ADDITIONAL_INFO(gpu_shader_3D_polyline)

2
source/blender/gpu/shaders/infos/gpu_shader_gpencil_stroke_info.hh
View File

@@ -22,7 +22,7 @@ GPU_SHADER_NAMED_INTERFACE_END(interp)
GPU_SHADER_CREATE_INFO(gpu_shader_gpencil_stroke)
TYPEDEF_SOURCE("GPU_shader_shared.hh")
STORAGE_BUF_FREQ(0, READ, GreasePencilStrokeData, gp_vert_data[], GEOMETRY)
STORAGE_BUF_FREQ(0, read, GreasePencilStrokeData, gp_vert_data[], GEOMETRY)
VERTEX_OUT(gpencil_stroke_vert_iface)
FRAGMENT_OUT(0, float4, fragColor)
UNIFORM_BUF(0, GPencilStrokeData, gpencil_stroke_data)

4
source/blender/gpu/shaders/infos/gpu_shader_icon_info.hh
View File

@@ -26,7 +26,7 @@ PUSH_CONSTANT(float4, finalColor)
PUSH_CONSTANT(float4, rect_icon)
PUSH_CONSTANT(float4, rect_geom)
PUSH_CONSTANT(float, text_width)
SAMPLER(0, FLOAT_2D, image)
SAMPLER(0, sampler2D, image)
VERTEX_SOURCE("gpu_shader_icon_vert.glsl")
FRAGMENT_SOURCE("gpu_shader_icon_frag.glsl")
DO_STATIC_COMPILATION()
@@ -37,7 +37,7 @@ VERTEX_IN(0, float2, pos)
VERTEX_OUT(flat_color_smooth_tex_coord_interp_iface)
FRAGMENT_OUT(0, float4, fragColor)
UNIFORM_BUF(0, MultiIconCallData, multi_icon_data)
SAMPLER(0, FLOAT_2D, image)
SAMPLER(0, sampler2D, image)
TYPEDEF_SOURCE("GPU_shader_shared.hh")
VERTEX_SOURCE("gpu_shader_icon_multi_vert.glsl")
FRAGMENT_SOURCE("gpu_shader_icon_frag.glsl")

6
source/blender/gpu/shaders/infos/gpu_shader_index_info.hh
View File

@@ -20,7 +20,7 @@ GPU_SHADER_CREATE_INFO(gpu_shader_index_2d_array_points)
LOCAL_GROUP_SIZE(16, 16, 1)
PUSH_CONSTANT(int, elements_per_curve)
PUSH_CONSTANT(int, ncurves)
STORAGE_BUF(0, WRITE, uint, out_indices[])
STORAGE_BUF(0, write, uint, out_indices[])
COMPUTE_SOURCE("gpu_shader_index_2d_array_points.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -29,7 +29,7 @@ GPU_SHADER_CREATE_INFO(gpu_shader_index_2d_array_lines)
LOCAL_GROUP_SIZE(16, 16, 1)
PUSH_CONSTANT(int, elements_per_curve)
PUSH_CONSTANT(int, ncurves)
STORAGE_BUF(0, WRITE, uint, out_indices[])
STORAGE_BUF(0, write, uint, out_indices[])
COMPUTE_SOURCE("gpu_shader_index_2d_array_lines.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -38,7 +38,7 @@ GPU_SHADER_CREATE_INFO(gpu_shader_index_2d_array_tris)
LOCAL_GROUP_SIZE(16, 16, 1)
PUSH_CONSTANT(int, elements_per_curve)
PUSH_CONSTANT(int, ncurves)
STORAGE_BUF(0, WRITE, uint, out_indices[])
STORAGE_BUF(0, write, uint, out_indices[])
COMPUTE_SOURCE("gpu_shader_index_2d_array_tris.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()

2
source/blender/gpu/shaders/infos/gpu_shader_print_info.hh
View File

@@ -16,6 +16,6 @@
#include "gpu_shader_create_info.hh"
GPU_SHADER_CREATE_INFO(gpu_print)
STORAGE_BUF_FREQ(GPU_SHADER_PRINTF_SLOT, READ_WRITE, uint, gpu_print_buf[], PASS)
STORAGE_BUF_FREQ(GPU_SHADER_PRINTF_SLOT, read_write, uint, gpu_print_buf[], PASS)
DEFINE_VALUE("GPU_SHADER_PRINTF_MAX_CAPACITY", STRINGIFY(GPU_SHADER_PRINTF_MAX_CAPACITY))
GPU_SHADER_CREATE_END()

2
source/blender/gpu/shaders/infos/gpu_shader_sequencer_info.hh
View File

@@ -45,7 +45,7 @@ FRAGMENT_OUT(0, float4, fragColor)
PUSH_CONSTANT(float4x4, ModelViewProjectionMatrix)
UNIFORM_BUF(0, SeqStripThumbData, thumb_data[GPU_SEQ_STRIP_DRAW_DATA_LEN])
UNIFORM_BUF(1, SeqContextDrawData, context_data)
SAMPLER(0, FLOAT_2D, image)
SAMPLER(0, sampler2D, image)
TYPEDEF_SOURCE("GPU_shader_shared.hh")
VERTEX_SOURCE("gpu_shader_sequencer_thumbs_vert.glsl")
FRAGMENT_SOURCE("gpu_shader_sequencer_thumbs_frag.glsl")

22
source/blender/gpu/shaders/infos/gpu_shader_test_info.hh
View File

@@ -30,43 +30,43 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(gpu_compute_1d_test)
LOCAL_GROUP_SIZE(1)
IMAGE(1, GPU_RGBA32F, WRITE, FLOAT_1D, img_output)
IMAGE(1, GPU_RGBA32F, write, image1D, img_output)
COMPUTE_SOURCE("gpu_compute_1d_test.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(gpu_compute_2d_test)
LOCAL_GROUP_SIZE(1, 1)
IMAGE(1, GPU_RGBA32F, WRITE, FLOAT_2D, img_output)
IMAGE(1, GPU_RGBA32F, write, image2D, img_output)
COMPUTE_SOURCE("gpu_compute_2d_test.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(gpu_compute_ibo_test)
LOCAL_GROUP_SIZE(1)
STORAGE_BUF(0, WRITE, uint, out_indices[])
STORAGE_BUF(0, write, uint, out_indices[])
COMPUTE_SOURCE("gpu_compute_ibo_test.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(gpu_compute_vbo_test)
LOCAL_GROUP_SIZE(1)
STORAGE_BUF(0, WRITE, vec4, out_positions[])
STORAGE_BUF(0, write, vec4, out_positions[])
COMPUTE_SOURCE("gpu_compute_vbo_test.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(gpu_compute_ssbo_test)
LOCAL_GROUP_SIZE(1)
STORAGE_BUF(0, WRITE, int, data_out[])
STORAGE_BUF(0, write, int, data_out[])
COMPUTE_SOURCE("gpu_compute_ssbo_test.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(gpu_compute_ssbo_binding_test)
LOCAL_GROUP_SIZE(1)
STORAGE_BUF(0, WRITE, int, data0[])
STORAGE_BUF(1, WRITE, int, data1[])
STORAGE_BUF(0, write, int, data0[])
STORAGE_BUF(1, write, int, data1[])
COMPUTE_SOURCE("gpu_compute_dummy_test.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -74,7 +74,7 @@ GPU_SHADER_CREATE_END()
/* Push constants. */
GPU_SHADER_CREATE_INFO(gpu_push_constants_base_test)
LOCAL_GROUP_SIZE(1)
STORAGE_BUF(0, WRITE, float, data_out[])
STORAGE_BUF(0, write, float, data_out[])
COMPUTE_SOURCE("gpu_push_constants_test.glsl")
GPU_SHADER_CREATE_END()
@@ -114,8 +114,8 @@ GPU_SHADER_CREATE_END()
GPU_SHADER_CREATE_INFO(gpu_buffer_texture_test)
LOCAL_GROUP_SIZE(1)
SAMPLER(0, FLOAT_BUFFER, bufferTexture)
STORAGE_BUF(0, WRITE, float, data_out[])
SAMPLER(0, samplerBuffer, bufferTexture)
STORAGE_BUF(0, write, float, data_out[])
COMPUTE_SOURCE("gpu_buffer_texture_test.glsl")
DO_STATIC_COMPILATION()
GPU_SHADER_CREATE_END()
@@ -123,7 +123,7 @@ GPU_SHADER_CREATE_END()
/* Specialization constants. */
GPU_SHADER_CREATE_INFO(gpu_specialization_constants_base_test)
STORAGE_BUF(0, WRITE, int, data_out[])
STORAGE_BUF(0, write, int, data_out[])
SPECIALIZATION_CONSTANT(float, float_in, 2)
SPECIALIZATION_CONSTANT(uint, uint_in, 3)
SPECIALIZATION_CONSTANT(int, int_in, 4)

2
source/blender/gpu/shaders/infos/gpu_shader_text_info.hh
View File

@@ -35,7 +35,7 @@ FRAGMENT_OUT(0, float4, fragColor)
PUSH_CONSTANT(float4x4, ModelViewProjectionMatrix)
PUSH_CONSTANT(int, glyph_tex_width_mask)
PUSH_CONSTANT(int, glyph_tex_width_shift)
SAMPLER_FREQ(0, FLOAT_2D, glyph, PASS)
SAMPLER_FREQ(0, sampler2D, glyph, PASS)
VERTEX_SOURCE("gpu_shader_text_vert.glsl")
FRAGMENT_SOURCE("gpu_shader_text_frag.glsl")
ADDITIONAL_INFO(gpu_srgb_to_framebuffer_space) DO_STATIC_COMPILATION() GPU_SHADER_CREATE_END()

24
source/blender/gpu/shaders/metal/mtl_shader_defines.msl
View File

@@ -720,8 +720,8 @@ IMAGE_FN AtomicT imageAtomicExchange(SamplerT texture, IntCoord coord, AtomicT d
/* Add any types as needed. */
#define TEMPLATE template<typename T = float, access A = access::sample>
TEMPLATE using depth2D = _mtl_sampler<T, A, depth2d<T, A>, true, 2, 0, 0>;
TEMPLATE using depth2DArray = _mtl_sampler<T, A, depth2d_array<T, A>, true, 2, 0, 1>;
TEMPLATE using sampler2DDepth = _mtl_sampler<T, A, depth2d<T, A>, true, 2, 0, 0>;
TEMPLATE using sampler2DArrayDepth = _mtl_sampler<T, A, depth2d_array<T, A>, true, 2, 0, 1>;
TEMPLATE using depthCube = _mtl_sampler<T, A, texturecube<T, A>, true, 2, 1, 1>;
TEMPLATE using depthCubeArray = _mtl_sampler<T, A, texturecube_array<T, A>, true, 2, 1, 1>;
TEMPLATE using sampler1D = _mtl_sampler<T, A, texture1d<T, A>, false, 1, 0, 0>;
@@ -738,8 +738,8 @@ TEMPLATE using sampler2DArrayAtomic = _mtl_sampler<T, A, texture2d<T, A>, false,
TEMPLATE using sampler3DAtomic = _mtl_sampler<T, A, texture2d<T, A>, false, 3, 0, 0, true>;
/* Used by backend to declare the samplers. Could be removed. */
TEMPLATE using _mtl_sampler_depth_2d = depth2D<T, A>;
TEMPLATE using _mtl_sampler_depth_2d_array = depth2DArray<T, A>;
TEMPLATE using _mtl_sampler_depth_2d = sampler2DDepth<T, A>;
TEMPLATE using _mtl_sampler_depth_2d_array = sampler2DArrayDepth<T, A>;
TEMPLATE using _mtl_sampler_depth_cube = depthCube<T, A>;
TEMPLATE using _mtl_sampler_depth_cube_array = depthCubeArray<T, A>;
TEMPLATE using _mtl_sampler_1d = sampler1D<T, A>;
@@ -795,23 +795,24 @@ struct SStruct {
#define sampler1D thread _mtl_sampler_1d<float>
#define sampler1DArray thread _mtl_sampler_1d_array<float>
#define sampler2D thread _mtl_sampler_2d<float>
#define depth2D thread _mtl_sampler_depth_2d<float>
#define sampler2DDepth thread _mtl_sampler_depth_2d<float>
#define sampler2DShadow thread _mtl_sampler_depth_2d<float>
#define sampler2DArray thread _mtl_sampler_2d_array<float>
#define sampler2DArrayDepth thread _mtl_sampler_depth_2d_array<float>
#define sampler2DArrayShadow thread _mtl_sampler_depth_2d_array<float>
#define depth2DArray thread _mtl_sampler_depth_2d_array<float>
#define depth2DArrayShadow thread _mtl_sampler_depth_2d_array<float>
#define sampler3D thread _mtl_sampler_3d<float>
#define samplerBuffer thread _mtl_sampler_buffer<float, access::read>
#define samplerCube thread _mtl_sampler_cube<float>
#define samplerCubeDepth thread _mtl_sampler_depth_cube<float>
#define samplerCubeShadow thread _mtl_sampler_depth_cube<float>
#define samplerCubeArray thread _mtl_sampler_cube_array<float>
#define samplerCubeArrayDepth thread _mtl_sampler_depth_cube_array<float>
#define samplerCubeArrayShadow thread _mtl_sampler_depth_cube_array<float>
#define usampler1D thread _mtl_sampler_1d<uint>
#define usampler1DArray thread _mtl_sampler_1d_array<uint>
#define usampler2D thread _mtl_sampler_2d<uint>
#define udepth2D thread _mtl_sampler_depth_2d<uint>
#define usampler2DArray thread _mtl_sampler_2d_array<uint>
#define usampler2DArrayShadow thread _mtl_sampler_depth_2d_array<uint>
#define udepth2DArrayShadow thread _mtl_sampler_depth_2d_array<uint>
#define usampler3D thread _mtl_sampler_3d<uint>
#define usamplerBuffer thread _mtl_sampler_buffer<uint, access::read>
#define usamplerCube thread _mtl_sampler_cube<uint>
@@ -820,10 +821,7 @@ struct SStruct {
#define isampler1D thread _mtl_sampler_1d<int>
#define isampler1DArray thread _mtl_sampler_1d_array<int>
#define isampler2D thread _mtl_sampler_2d<int>
#define idepth2D thread _mtl_sampler_depth_2d<int>
#define isampler2DArray thread _mtl_sampler_2d_array<int>
#define isampler2DArrayShadow thread _mtl_sampler_depth_2d_array<int>
#define idepth2DArrayShadow thread _mtl_sampler_depth_2d_array<int>
#define isampler3D thread _mtl_sampler_3d<int>
#define isamplerBuffer thread _mtl_sampler_buffer<int, access::read>
#define isamplerCube thread _mtl_sampler_cube<int>

11
source/blender/gpu/shaders/opengl/glsl_shader_defines.glsl
View File

@@ -98,13 +98,10 @@ RESHAPE(float3x3, mat3x3, mat3x4)
#define imageLoadFast imageLoad
/* Texture format tokens -- Type explicitness required by other Graphics APIs. */
#define depth2D sampler2D
#define depth2DArray sampler2DArray
#define depth2DMS sampler2DMS
#define depth2DMSArray sampler2DMSArray
#define depthCube samplerCube
#define depthCubeArray samplerCubeArray
#define depth2DArrayShadow sampler2DArrayShadow
#define sampler2DDepth sampler2D
#define sampler2DArrayDepth sampler2DArray
#define samplerCubeDepth sampler2D
#define samplerCubeArrayDepth sampler2DArray
#define usampler2DArrayAtomic usampler2DArray
#define usampler2DAtomic usampler2D

2
source/blender/gpu/tests/framebuffer_test.cc
View File

@@ -361,7 +361,7 @@ static void test_framebuffer_subpass_input()
create_info_read.define("READ");
create_info_read.vertex_source("gpu_framebuffer_subpass_input_test.glsl");
create_info_read.fragment_source("gpu_framebuffer_subpass_input_test.glsl");
create_info_read.subpass_in(0, Type::int_t, ImageType::INT_2D, "in_value", 0);
create_info_read.subpass_in(0, Type::int_t, ImageType::Int2D, "in_value", 0);
create_info_read.fragment_out(1, Type::int_t, "out_value");
GPUShader *shader_read = GPU_shader_create_from_info(

136
source/blender/gpu/vulkan/vk_common.cc
View File

@@ -917,38 +917,38 @@ VkSamplerAddressMode to_vk_sampler_address_mode(const GPUSamplerExtendMode exten
static VkDescriptorType to_vk_descriptor_type_image(const shader::ImageType &image_type)
{
switch (image_type) {
case shader::ImageType::FLOAT_1D:
case shader::ImageType::FLOAT_1D_ARRAY:
case shader::ImageType::FLOAT_2D:
case shader::ImageType::FLOAT_2D_ARRAY:
case shader::ImageType::FLOAT_3D:
case shader::ImageType::FLOAT_CUBE:
case shader::ImageType::FLOAT_CUBE_ARRAY:
case shader::ImageType::INT_1D:
case shader::ImageType::INT_1D_ARRAY:
case shader::ImageType::INT_2D:
case shader::ImageType::INT_2D_ARRAY:
case shader::ImageType::INT_3D:
case shader::ImageType::INT_CUBE:
case shader::ImageType::INT_CUBE_ARRAY:
case shader::ImageType::INT_2D_ATOMIC:
case shader::ImageType::INT_2D_ARRAY_ATOMIC:
case shader::ImageType::INT_3D_ATOMIC:
case shader::ImageType::UINT_1D:
case shader::ImageType::UINT_1D_ARRAY:
case shader::ImageType::UINT_2D:
case shader::ImageType::UINT_2D_ARRAY:
case shader::ImageType::UINT_3D:
case shader::ImageType::UINT_CUBE:
case shader::ImageType::UINT_CUBE_ARRAY:
case shader::ImageType::UINT_2D_ATOMIC:
case shader::ImageType::UINT_2D_ARRAY_ATOMIC:
case shader::ImageType::UINT_3D_ATOMIC:
case shader::ImageType::Float1D:
case shader::ImageType::Float1DArray:
case shader::ImageType::Float2D:
case shader::ImageType::Float2DArray:
case shader::ImageType::Float3D:
case shader::ImageType::FloatCube:
case shader::ImageType::FloatCubeArray:
case shader::ImageType::Int1D:
case shader::ImageType::Int1DArray:
case shader::ImageType::Int2D:
case shader::ImageType::Int2DArray:
case shader::ImageType::Int3D:
case shader::ImageType::IntCube:
case shader::ImageType::IntCubeArray:
case shader::ImageType::AtomicInt2D:
case shader::ImageType::AtomicInt2DArray:
case shader::ImageType::AtomicInt3D:
case shader::ImageType::Uint1D:
case shader::ImageType::Uint1DArray:
case shader::ImageType::Uint2D:
case shader::ImageType::Uint2DArray:
case shader::ImageType::Uint3D:
case shader::ImageType::UintCube:
case shader::ImageType::UintCubeArray:
case shader::ImageType::AtomicUint2D:
case shader::ImageType::AtomicUint2DArray:
case shader::ImageType::AtomicUint3D:
return VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
case shader::ImageType::FLOAT_BUFFER:
case shader::ImageType::INT_BUFFER:
case shader::ImageType::UINT_BUFFER:
case shader::ImageType::FloatBuffer:
case shader::ImageType::IntBuffer:
case shader::ImageType::UintBuffer:
return VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
default:
@@ -961,46 +961,46 @@ static VkDescriptorType to_vk_descriptor_type_image(const shader::ImageType &ima
static VkDescriptorType to_vk_descriptor_type_sampler(const shader::ImageType &image_type)
{
switch (image_type) {
case shader::ImageType::FLOAT_1D:
case shader::ImageType::FLOAT_1D_ARRAY:
case shader::ImageType::FLOAT_2D:
case shader::ImageType::FLOAT_2D_ARRAY:
case shader::ImageType::FLOAT_3D:
case shader::ImageType::FLOAT_CUBE:
case shader::ImageType::FLOAT_CUBE_ARRAY:
case shader::ImageType::INT_1D:
case shader::ImageType::INT_1D_ARRAY:
case shader::ImageType::INT_2D:
case shader::ImageType::INT_2D_ARRAY:
case shader::ImageType::INT_3D:
case shader::ImageType::INT_CUBE:
case shader::ImageType::INT_CUBE_ARRAY:
case shader::ImageType::INT_2D_ATOMIC:
case shader::ImageType::INT_2D_ARRAY_ATOMIC:
case shader::ImageType::INT_3D_ATOMIC:
case shader::ImageType::UINT_1D:
case shader::ImageType::UINT_1D_ARRAY:
case shader::ImageType::UINT_2D:
case shader::ImageType::UINT_2D_ARRAY:
case shader::ImageType::UINT_3D:
case shader::ImageType::UINT_CUBE:
case shader::ImageType::UINT_CUBE_ARRAY:
case shader::ImageType::UINT_2D_ATOMIC:
case shader::ImageType::UINT_2D_ARRAY_ATOMIC:
case shader::ImageType::UINT_3D_ATOMIC:
case shader::ImageType::SHADOW_2D:
case shader::ImageType::SHADOW_2D_ARRAY:
case shader::ImageType::SHADOW_CUBE:
case shader::ImageType::SHADOW_CUBE_ARRAY:
case shader::ImageType::DEPTH_2D:
case shader::ImageType::DEPTH_2D_ARRAY:
case shader::ImageType::DEPTH_CUBE:
case shader::ImageType::DEPTH_CUBE_ARRAY:
case shader::ImageType::Float1D:
case shader::ImageType::Float1DArray:
case shader::ImageType::Float2D:
case shader::ImageType::Float2DArray:
case shader::ImageType::Float3D:
case shader::ImageType::FloatCube:
case shader::ImageType::FloatCubeArray:
case shader::ImageType::Int1D:
case shader::ImageType::Int1DArray:
case shader::ImageType::Int2D:
case shader::ImageType::Int2DArray:
case shader::ImageType::Int3D:
case shader::ImageType::IntCube:
case shader::ImageType::IntCubeArray:
case shader::ImageType::AtomicInt2D:
case shader::ImageType::AtomicInt2DArray:
case shader::ImageType::AtomicInt3D:
case shader::ImageType::Uint1D:
case shader::ImageType::Uint1DArray:
case shader::ImageType::Uint2D:
case shader::ImageType::Uint2DArray:
case shader::ImageType::Uint3D:
case shader::ImageType::UintCube:
case shader::ImageType::UintCubeArray:
case shader::ImageType::AtomicUint2D:
case shader::ImageType::AtomicUint2DArray:
case shader::ImageType::AtomicUint3D:
case shader::ImageType::Shadow2D:
case shader::ImageType::Shadow2DArray:
case shader::ImageType::ShadowCube:
case shader::ImageType::ShadowCubeArray:
case shader::ImageType::Depth2D:
case shader::ImageType::Depth2DArray:
case shader::ImageType::DepthCube:
case shader::ImageType::DepthCubeArray:
return VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
case shader::ImageType::FLOAT_BUFFER:
case shader::ImageType::INT_BUFFER:
case shader::ImageType::UINT_BUFFER:
case shader::ImageType::FloatBuffer:
case shader::ImageType::IntBuffer:
case shader::ImageType::UintBuffer:
return VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
}

168
source/blender/gpu/vulkan/vk_shader.cc
View File

@@ -209,30 +209,30 @@ static void print_image_type(std::ostream &os,
const ShaderCreateInfo::Resource::BindType bind_type)
{
switch (type) {
case ImageType::INT_BUFFER:
case ImageType::INT_1D:
case ImageType::INT_1D_ARRAY:
case ImageType::INT_2D:
case ImageType::INT_2D_ARRAY:
case ImageType::INT_3D:
case ImageType::INT_CUBE:
case ImageType::INT_CUBE_ARRAY:
case ImageType::INT_2D_ATOMIC:
case ImageType::INT_2D_ARRAY_ATOMIC:
case ImageType::INT_3D_ATOMIC:
case ImageType::IntBuffer:
case ImageType::Int1D:
case ImageType::Int1DArray:
case ImageType::Int2D:
case ImageType::Int2DArray:
case ImageType::Int3D:
case ImageType::IntCube:
case ImageType::IntCubeArray:
case ImageType::AtomicInt2D:
case ImageType::AtomicInt2DArray:
case ImageType::AtomicInt3D:
os << "i";
break;
case ImageType::UINT_BUFFER:
case ImageType::UINT_1D:
case ImageType::UINT_1D_ARRAY:
case ImageType::UINT_2D:
case ImageType::UINT_2D_ARRAY:
case ImageType::UINT_3D:
case ImageType::UINT_CUBE:
case ImageType::UINT_CUBE_ARRAY:
case ImageType::UINT_2D_ATOMIC:
case ImageType::UINT_2D_ARRAY_ATOMIC:
case ImageType::UINT_3D_ATOMIC:
case ImageType::UintBuffer:
case ImageType::Uint1D:
case ImageType::Uint1DArray:
case ImageType::Uint2D:
case ImageType::Uint2DArray:
case ImageType::Uint3D:
case ImageType::UintCube:
case ImageType::UintCubeArray:
case ImageType::AtomicUint2D:
case ImageType::AtomicUint2DArray:
case ImageType::AtomicUint3D:
os << "u";
break;
default:
@@ -247,52 +247,52 @@ static void print_image_type(std::ostream &os,
}
switch (type) {
case ImageType::FLOAT_BUFFER:
case ImageType::INT_BUFFER:
case ImageType::UINT_BUFFER:
case ImageType::FloatBuffer:
case ImageType::IntBuffer:
case ImageType::UintBuffer:
os << "Buffer";
break;
case ImageType::FLOAT_1D:
case ImageType::FLOAT_1D_ARRAY:
case ImageType::INT_1D:
case ImageType::INT_1D_ARRAY:
case ImageType::UINT_1D:
case ImageType::UINT_1D_ARRAY:
case ImageType::Float1D:
case ImageType::Float1DArray:
case ImageType::Int1D:
case ImageType::Int1DArray:
case ImageType::Uint1D:
case ImageType::Uint1DArray:
os << "1D";
break;
case ImageType::FLOAT_2D:
case ImageType::FLOAT_2D_ARRAY:
case ImageType::INT_2D:
case ImageType::INT_2D_ARRAY:
case ImageType::UINT_2D:
case ImageType::UINT_2D_ARRAY:
case ImageType::SHADOW_2D:
case ImageType::SHADOW_2D_ARRAY:
case ImageType::DEPTH_2D:
case ImageType::DEPTH_2D_ARRAY:
case ImageType::INT_2D_ATOMIC:
case ImageType::INT_2D_ARRAY_ATOMIC:
case ImageType::UINT_2D_ATOMIC:
case ImageType::UINT_2D_ARRAY_ATOMIC:
case ImageType::Float2D:
case ImageType::Float2DArray:
case ImageType::Int2D:
case ImageType::Int2DArray:
case ImageType::Uint2D:
case ImageType::Uint2DArray:
case ImageType::Shadow2D:
case ImageType::Shadow2DArray:
case ImageType::Depth2D:
case ImageType::Depth2DArray:
case ImageType::AtomicInt2D:
case ImageType::AtomicInt2DArray:
case ImageType::AtomicUint2D:
case ImageType::AtomicUint2DArray:
os << "2D";
break;
case ImageType::FLOAT_3D:
case ImageType::INT_3D:
case ImageType::INT_3D_ATOMIC:
case ImageType::UINT_3D:
case ImageType::UINT_3D_ATOMIC:
case ImageType::Float3D:
case ImageType::Int3D:
case ImageType::AtomicInt3D:
case ImageType::Uint3D:
case ImageType::AtomicUint3D:
os << "3D";
break;
case ImageType::FLOAT_CUBE:
case ImageType::FLOAT_CUBE_ARRAY:
case ImageType::INT_CUBE:
case ImageType::INT_CUBE_ARRAY:
case ImageType::UINT_CUBE:
case ImageType::UINT_CUBE_ARRAY:
case ImageType::SHADOW_CUBE:
case ImageType::SHADOW_CUBE_ARRAY:
case ImageType::DEPTH_CUBE:
case ImageType::DEPTH_CUBE_ARRAY:
case ImageType::FloatCube:
case ImageType::FloatCubeArray:
case ImageType::IntCube:
case ImageType::IntCubeArray:
case ImageType::UintCube:
case ImageType::UintCubeArray:
case ImageType::ShadowCube:
case ImageType::ShadowCubeArray:
case ImageType::DepthCube:
case ImageType::DepthCubeArray:
os << "Cube";
break;
default:
@@ -300,20 +300,20 @@ static void print_image_type(std::ostream &os,
}
switch (type) {
case ImageType::FLOAT_1D_ARRAY:
case ImageType::FLOAT_2D_ARRAY:
case ImageType::FLOAT_CUBE_ARRAY:
case ImageType::INT_1D_ARRAY:
case ImageType::INT_2D_ARRAY:
case ImageType::INT_CUBE_ARRAY:
case ImageType::UINT_1D_ARRAY:
case ImageType::UINT_2D_ARRAY:
case ImageType::UINT_CUBE_ARRAY:
case ImageType::SHADOW_2D_ARRAY:
case ImageType::SHADOW_CUBE_ARRAY:
case ImageType::DEPTH_2D_ARRAY:
case ImageType::DEPTH_CUBE_ARRAY:
case ImageType::UINT_2D_ARRAY_ATOMIC:
case ImageType::Float1DArray:
case ImageType::Float2DArray:
case ImageType::FloatCubeArray:
case ImageType::Int1DArray:
case ImageType::Int2DArray:
case ImageType::IntCubeArray:
case ImageType::Uint1DArray:
case ImageType::Uint2DArray:
case ImageType::UintCubeArray:
case ImageType::Shadow2DArray:
case ImageType::ShadowCubeArray:
case ImageType::Depth2DArray:
case ImageType::DepthCubeArray:
case ImageType::AtomicUint2DArray:
os << "Array";
break;
default:
@@ -321,10 +321,10 @@ static void print_image_type(std::ostream &os,
}
switch (type) {
case ImageType::SHADOW_2D:
case ImageType::SHADOW_2D_ARRAY:
case ImageType::SHADOW_CUBE:
case ImageType::SHADOW_CUBE_ARRAY:
case ImageType::Shadow2D:
case ImageType::Shadow2DArray:
case ImageType::ShadowCube:
case ImageType::ShadowCubeArray:
os << "Shadow";
break;
default:
@@ -335,13 +335,13 @@ static void print_image_type(std::ostream &os,
static std::ostream &print_qualifier(std::ostream &os, const Qualifier &qualifiers)
{
if (bool(qualifiers & Qualifier::NO_RESTRICT) == false) {
if (bool(qualifiers & Qualifier::no_restrict) == false) {
os << "restrict ";
}
if (bool(qualifiers & Qualifier::READ) == false) {
if (bool(qualifiers & Qualifier::read) == false) {
os << "writeonly ";
}
if (bool(qualifiers & Qualifier::WRITE) == false) {
if (bool(qualifiers & Qualifier::write) == false) {
os << "readonly ";
}
return os;
@@ -997,10 +997,8 @@ std::string VKShader::fragment_interface_declare(const shader::ShaderCreateInfo
/* IMPORTANT: We assume that the frame-buffer will be layered or not based on the layer
* built-in flag. */
bool is_layered_fb = bool(info.builtins_ & BuiltinBits::LAYER);
bool is_layered_input = ELEM(input.img_type,
ImageType::UINT_2D_ARRAY,
ImageType::INT_2D_ARRAY,
ImageType::FLOAT_2D_ARRAY);
bool is_layered_input = ELEM(
input.img_type, ImageType::Uint2DArray, ImageType::Int2DArray, ImageType::Float2DArray);
/* Declare image. */
using Resource = ShaderCreateInfo::Resource;
/* NOTE(fclem): Using the attachment index as resource index might be problematic as it might

60
source/blender/gpu/vulkan/vk_shader_interface.cc
View File

@@ -216,37 +216,37 @@ void VKShaderInterface::init(const shader::ShaderCreateInfo &info)
VKImageViewArrayed arrayed = VKImageViewArrayed::DONT_CARE;
if (res.bind_type == ShaderCreateInfo::Resource::BindType::IMAGE) {
arrayed = ELEM(res.image.type,
shader::ImageType::FLOAT_1D_ARRAY,
shader::ImageType::FLOAT_2D_ARRAY,
shader::ImageType::FLOAT_CUBE_ARRAY,
shader::ImageType::INT_1D_ARRAY,
shader::ImageType::INT_2D_ARRAY,
shader::ImageType::INT_CUBE_ARRAY,
shader::ImageType::UINT_1D_ARRAY,
shader::ImageType::UINT_2D_ARRAY,
shader::ImageType::UINT_CUBE_ARRAY,
shader::ImageType::UINT_2D_ARRAY_ATOMIC,
shader::ImageType::INT_2D_ARRAY_ATOMIC) ?
shader::ImageType::Float1DArray,
shader::ImageType::Float2DArray,
shader::ImageType::FloatCubeArray,
shader::ImageType::Int1DArray,
shader::ImageType::Int2DArray,
shader::ImageType::IntCubeArray,
shader::ImageType::Uint1DArray,
shader::ImageType::Uint2DArray,
shader::ImageType::UintCubeArray,
shader::ImageType::AtomicUint2DArray,
shader::ImageType::AtomicInt2DArray) ?
VKImageViewArrayed::ARRAYED :
VKImageViewArrayed::NOT_ARRAYED;
}
else if (res.bind_type == ShaderCreateInfo::Resource::BindType::SAMPLER) {
arrayed = ELEM(res.sampler.type,
shader::ImageType::FLOAT_1D_ARRAY,
shader::ImageType::FLOAT_2D_ARRAY,
shader::ImageType::FLOAT_CUBE_ARRAY,
shader::ImageType::INT_1D_ARRAY,
shader::ImageType::INT_2D_ARRAY,
shader::ImageType::INT_CUBE_ARRAY,
shader::ImageType::UINT_1D_ARRAY,
shader::ImageType::UINT_2D_ARRAY,
shader::ImageType::UINT_CUBE_ARRAY,
shader::ImageType::SHADOW_2D_ARRAY,
shader::ImageType::SHADOW_CUBE_ARRAY,
shader::ImageType::DEPTH_2D_ARRAY,
shader::ImageType::DEPTH_CUBE_ARRAY,
shader::ImageType::UINT_2D_ARRAY_ATOMIC,
shader::ImageType::INT_2D_ARRAY_ATOMIC) ?
shader::ImageType::Float1DArray,
shader::ImageType::Float2DArray,
shader::ImageType::FloatCubeArray,
shader::ImageType::Int1DArray,
shader::ImageType::Int2DArray,
shader::ImageType::IntCubeArray,
shader::ImageType::Uint1DArray,
shader::ImageType::Uint2DArray,
shader::ImageType::UintCubeArray,
shader::ImageType::Shadow2DArray,
shader::ImageType::ShadowCubeArray,
shader::ImageType::Depth2DArray,
shader::ImageType::DepthCubeArray,
shader::ImageType::AtomicUint2DArray,
shader::ImageType::AtomicInt2DArray) ?
VKImageViewArrayed::ARRAYED :
VKImageViewArrayed::NOT_ARRAYED;
}
@@ -306,19 +306,19 @@ void VKShaderInterface::descriptor_set_location_update(
break;
case shader::ShaderCreateInfo::Resource::BindType::STORAGE_BUFFER:
if (bool(resource->storagebuf.qualifiers & shader::Qualifier::READ) == true) {
if (bool(resource->storagebuf.qualifiers & shader::Qualifier::read) == true) {
vk_access_flags |= VK_ACCESS_SHADER_READ_BIT;
}
if (bool(resource->storagebuf.qualifiers & shader::Qualifier::WRITE) == true) {
if (bool(resource->storagebuf.qualifiers & shader::Qualifier::write) == true) {
vk_access_flags |= VK_ACCESS_SHADER_WRITE_BIT;
}
break;
case shader::ShaderCreateInfo::Resource::BindType::IMAGE:
if (bool(resource->image.qualifiers & shader::Qualifier::READ) == true) {
if (bool(resource->image.qualifiers & shader::Qualifier::read) == true) {
vk_access_flags |= VK_ACCESS_SHADER_READ_BIT;
}
if (bool(resource->image.qualifiers & shader::Qualifier::WRITE) == true) {
if (bool(resource->image.qualifiers & shader::Qualifier::write) == true) {
vk_access_flags |= VK_ACCESS_SHADER_WRITE_BIT;
}
break;

86
source/blender/python/gpu/gpu_py_shader_create_info.cc
View File

@@ -40,9 +40,9 @@ using blender::gpu::shader::Qualifier;
" - ``READ``\n" \
" - ``WRITE``\n"
static const PyC_FlagSet pygpu_qualifiers[] = {
{int(Qualifier::NO_RESTRICT), "NO_RESTRICT"},
{int(Qualifier::READ), "READ"},
{int(Qualifier::WRITE), "WRITE"},
{int(Qualifier::no_restrict), "NO_RESTRICT"},
{int(Qualifier::read), "READ"},
{int(Qualifier::write), "WRITE"},
{0, nullptr},
};
#endif
@@ -116,44 +116,44 @@ const PyC_StringEnumItems pygpu_attrtype_items[] = {
" - ``DEPTH_CUBE``\n" \
" - ``DEPTH_CUBE_ARRAY``\n"
static const PyC_StringEnumItems pygpu_imagetype_items[] = {
{int(ImageType::FLOAT_BUFFER), "FLOAT_BUFFER"},
{int(ImageType::FLOAT_1D), "FLOAT_1D"},
{int(ImageType::FLOAT_1D_ARRAY), "FLOAT_1D_ARRAY"},
{int(ImageType::FLOAT_2D), "FLOAT_2D"},
{int(ImageType::FLOAT_2D_ARRAY), "FLOAT_2D_ARRAY"},
{int(ImageType::FLOAT_3D), "FLOAT_3D"},
{int(ImageType::FLOAT_CUBE), "FLOAT_CUBE"},
{int(ImageType::FLOAT_CUBE_ARRAY), "FLOAT_CUBE_ARRAY"},
{int(ImageType::INT_BUFFER), "INT_BUFFER"},
{int(ImageType::INT_1D), "INT_1D"},
{int(ImageType::INT_1D_ARRAY), "INT_1D_ARRAY"},
{int(ImageType::INT_2D), "INT_2D"},
{int(ImageType::INT_2D_ARRAY), "INT_2D_ARRAY"},
{int(ImageType::INT_3D), "INT_3D"},
{int(ImageType::INT_CUBE), "INT_CUBE"},
{int(ImageType::INT_CUBE_ARRAY), "INT_CUBE_ARRAY"},
{int(ImageType::INT_2D_ATOMIC), "INT_2D_ATOMIC"},
{int(ImageType::INT_2D_ARRAY_ATOMIC), "INT_2D_ARRAY_ATOMIC"},
{int(ImageType::INT_3D_ATOMIC), "INT_3D_ATOMIC"},
{int(ImageType::UINT_BUFFER), "UINT_BUFFER"},
{int(ImageType::UINT_1D), "UINT_1D"},
{int(ImageType::UINT_1D_ARRAY), "UINT_1D_ARRAY"},
{int(ImageType::UINT_2D), "UINT_2D"},
{int(ImageType::UINT_2D_ARRAY), "UINT_2D_ARRAY"},
{int(ImageType::UINT_3D), "UINT_3D"},
{int(ImageType::UINT_CUBE), "UINT_CUBE"},
{int(ImageType::UINT_CUBE_ARRAY), "UINT_CUBE_ARRAY"},
{int(ImageType::UINT_2D_ATOMIC), "UINT_2D_ATOMIC"},
{int(ImageType::UINT_2D_ARRAY_ATOMIC), "UINT_2D_ARRAY_ATOMIC"},
{int(ImageType::UINT_3D_ATOMIC), "UINT_3D_ATOMIC"},
{int(ImageType::SHADOW_2D), "SHADOW_2D"},
{int(ImageType::SHADOW_2D_ARRAY), "SHADOW_2D_ARRAY"},
{int(ImageType::SHADOW_CUBE), "SHADOW_CUBE"},
{int(ImageType::SHADOW_CUBE_ARRAY), "SHADOW_CUBE_ARRAY"},
{int(ImageType::DEPTH_2D), "DEPTH_2D"},
{int(ImageType::DEPTH_2D_ARRAY), "DEPTH_2D_ARRAY"},
{int(ImageType::DEPTH_CUBE), "DEPTH_CUBE"},
{int(ImageType::DEPTH_CUBE_ARRAY), "DEPTH_CUBE_ARRAY"},
{int(ImageType::FloatBuffer), "FLOAT_BUFFER"},
{int(ImageType::Float1D), "FLOAT_1D"},
{int(ImageType::Float1DArray), "FLOAT_1D_ARRAY"},
{int(ImageType::Float2D), "FLOAT_2D"},
{int(ImageType::Float2DArray), "FLOAT_2D_ARRAY"},
{int(ImageType::Float3D), "FLOAT_3D"},
{int(ImageType::FloatCube), "FLOAT_CUBE"},
{int(ImageType::FloatCubeArray), "FLOAT_CUBE_ARRAY"},
{int(ImageType::IntBuffer), "INT_BUFFER"},
{int(ImageType::Int1D), "INT_1D"},
{int(ImageType::Int1DArray), "INT_1D_ARRAY"},
{int(ImageType::Int2D), "INT_2D"},
{int(ImageType::Int2DArray), "INT_2D_ARRAY"},
{int(ImageType::Int3D), "INT_3D"},
{int(ImageType::IntCube), "INT_CUBE"},
{int(ImageType::IntCubeArray), "INT_CUBE_ARRAY"},
{int(ImageType::AtomicInt2D), "INT_2D_ATOMIC"},
{int(ImageType::AtomicInt2DArray), "INT_2D_ARRAY_ATOMIC"},
{int(ImageType::AtomicInt3D), "INT_3D_ATOMIC"},
{int(ImageType::UintBuffer), "UINT_BUFFER"},
{int(ImageType::Uint1D), "UINT_1D"},
{int(ImageType::Uint1DArray), "UINT_1D_ARRAY"},
{int(ImageType::Uint2D), "UINT_2D"},
{int(ImageType::Uint2DArray), "UINT_2D_ARRAY"},
{int(ImageType::Uint3D), "UINT_3D"},
{int(ImageType::UintCube), "UINT_CUBE"},
{int(ImageType::UintCubeArray), "UINT_CUBE_ARRAY"},
{int(ImageType::AtomicUint2D), "UINT_2D_ATOMIC"},
{int(ImageType::AtomicUint2DArray), "UINT_2D_ARRAY_ATOMIC"},
{int(ImageType::AtomicUint3D), "UINT_3D_ATOMIC"},
{int(ImageType::Shadow2D), "SHADOW_2D"},
{int(ImageType::Shadow2DArray), "SHADOW_2D_ARRAY"},
{int(ImageType::ShadowCube), "SHADOW_CUBE"},
{int(ImageType::ShadowCubeArray), "SHADOW_CUBE_ARRAY"},
{int(ImageType::Depth2D), "DEPTH_2D"},
{int(ImageType::Depth2DArray), "DEPTH_2D_ARRAY"},
{int(ImageType::DepthCube), "DEPTH_CUBE"},
{int(ImageType::DepthCubeArray), "DEPTH_CUBE_ARRAY"},
{0, nullptr},
};
@@ -754,7 +754,7 @@ static PyObject *pygpu_shader_info_image(BPyGPUShaderCreateInfo *self,
PyC_StringEnum pygpu_imagetype = {pygpu_imagetype_items};
const char *name;
PyObject *py_qualifiers = nullptr;
Qualifier qualifier = Qualifier::NO_RESTRICT;
Qualifier qualifier = Qualifier::no_restrict;
static const char *_keywords[] = {"slot", "format", "type", "name", "qualifiers", nullptr};
static _PyArg_Parser _parser = {
@@ -798,7 +798,7 @@ static PyObject *pygpu_shader_info_image(BPyGPUShaderCreateInfo *self,
info->image(slot,
(eGPUTextureFormat)pygpu_texformat.value_found,
qualifier,
(ImageType)pygpu_imagetype.value_found,
blender::gpu::shader::ImageReadWriteType(pygpu_imagetype.value_found),
name);
Py_RETURN_NONE;