The editor is broken on macOS since TAA was merged

[aaronfranke]

Godot version

master, this bug happens as of PR #61319

System information

macOS 12.4, M1 Pro (ARM), Godot compiled for ARM.

Issue description

In the latest Godot master, running the editor on an empty project doesn't render anything in 3D, trying to do any action causes the editor to freeze for a long time, and about ten thousand errors are printed per second.

Reverting PR #61319 locally solves this issue.

Steps to reproduce

1. Have a Mac (I'm not sure if this is ARM-specific or what).
2. Compile and run Godot master.
3. Open an empty project with Vulkan Mobile in the editor.
4. Immediately experience the issue.

Minimal reproduction project

Happens on an empty project, either with Vulkan Mobile or Vulkan Clustered with Vulkan Mobile.

[bruvzg]

I can confirm this, it's spamming errors and not rendering any 3D:

  drivers/vulkan/vulkan_context.cpp:159 -  - Message Id Number: 0 | Message Id Name: 
  	VK_ERROR_INVALID_SHADER_NV: Fragment shader function could not be compiled into pipeline. See previous logged error.
  	Objects - 1
  		Object[0] - VK_OBJECT_TYPE_PIPELINE, Handle 13273748992
  vkCreateGraphicsPipelines failed with error -1000012000 for shader 'SceneForwardClusteredShaderRD:7'.
  servers/rendering/renderer_rd/pipeline_cache_rd.cpp:60 - Condition "pipeline.is_null()" is true. Returning: RID()
  This render pipeline requires (0) bytes of push constant data, supplied: (16)
  No render pipeline was set before attempting to draw.

[bruvzg]

Actual shader compiler error (at the start of log):

Log

  drivers/vulkan/vulkan_context.cpp:159 -  - Message Id Number: 0 | Message Id Name: 
  	VK_ERROR_INITIALIZATION_FAILED: Shader library compile failed (Error code 3):
  program_source:481:16: warning: unused variable 'sun_scatter'
          float4 sun_scatter = float4(0.0);
                 ^
  program_source:482:15: warning: unused variable 'sun_total'
          float sun_total = 0.0;
                ^
  program_source:555:39: error: no viable overloaded '='
      scene_data.projection_matrix_view = scene_data_block.data.projection_matrix_view;
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2> &&' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2> &&' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2> &&' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2> &&' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'const spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'const device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2> &' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'const threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2> &' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'const constant spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2> &' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'const threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2> &' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'const ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2> &' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:564:51: error: no viable overloaded '='
      scene_data.directional_penumbra_shadow_kernel = scene_data_block.data.directional_penumbra_shadow_kernel;
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'const spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'const device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32> &' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'const threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32> &' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'const constant spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32> &' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'const threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32> &' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'const ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32> &' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32> &&' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32> &&' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32> &&' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32> &&' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:707:44: error: no viable overloaded '='
      prev_scene_data.projection_matrix_view = scene_data_block.prev_data.projection_matrix_view;
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2> &&' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2> &&' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2> &&' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2> &&' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'const spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'const device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2> &' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'const threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2> &' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'const constant spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2> &' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'const threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2> &' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'metal::float4x4 const constant[2]' to 'const ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2> &' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'device spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'threadgroup_imageblock spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<metal::float4x4, 2>' (aka 'spvUnsafeArray<matrix<float, 4, 4>, 2>')), parameter type must be 'ray_data spvUnsafeArray<metal::matrix<float, 4, 4, void>, 2>'
  program_source:716:56: error: no viable overloaded '='
      prev_scene_data.directional_penumbra_shadow_kernel = scene_data_block.prev_data.directional_penumbra_shadow_kernel;
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'const spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'const device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32> &' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'const threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32> &' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'const constant spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32> &' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'const threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32> &' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'const ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32> &' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32> &&' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32> &&' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32> &&' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: no known conversion from 'float4 const constant[32]' to 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32> &&' for 1st argument
  struct spvUnsafeArray
         ^
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit copy assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'device spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'threadgroup_imageblock spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  program_source:10:8: note: candidate function (the implicit move assignment operator) not viable: address space mismatch in 'this' argument ('spvUnsafeArray<float4, 32>'), parameter type must be 'ray_data spvUnsafeArray<float __attribute__((ext_vector_type(4))), 32>'
  .
  	Objects - 1
  		Object[0] - VK_OBJECT_TYPE_SHADER_MODULE, Handle 5687111456

[JFonS]

@bruvzg Are there any other errors before spamming this one? This usually happens when a shader fails to compile, but the relevant error comes before the spam.

[bruvzg]

Are there any other errors before spamming this one?

One in the second comment (hidden in the collapsible block) is repeated twice, then it's spamming the Fragment shader function could not be compiled into pipeline. See previous logged error. non-stop.

[JFonS]

It looks like an issue in MoltenVK triggered by these lines:

godot/servers/rendering/renderer_rd/shaders/scene_forward_clustered.glsl

Lines 640 to 641 in e414e09

	SceneData scene_data = scene_data_block.data;
	SceneData prev_scene_data = scene_data_block.prev_data;

It seems to be translating them into assignment statements for each individual struct member, and that breaks for array members like projection_matrix_view or directional_penumbra_shadow_kernel.

[JFonS]

I'm not home now, but I can try working around this in a bit.

[JFonS]

I put together this quick diff below. It breaks TAA but if someone can confirm that this has no issues on MoltenVK, I should be able to put together a proper workarond for this issue.

Diff

diff --git a/servers/rendering/renderer_rd/forward_clustered/scene_shader_forward_clustered.cpp b/servers/rendering/renderer_rd/forward_clustered/scene_shader_forward_clustered.cpp
--- a/servers/rendering/renderer_rd/forward_clustered/scene_shader_forward_clustered.cpp	(revision ba832d83b2dafcdbb79b93b1e97fd518c12b97bf)
+++ b/servers/rendering/renderer_rd/forward_clustered/scene_shader_forward_clustered.cpp	(date 1654708857841)
@@ -595,8 +595,8 @@
 
 		actions.renames["MODEL_MATRIX"] = "model_matrix";
 		actions.renames["MODEL_NORMAL_MATRIX"] = "model_normal_matrix";
-		actions.renames["VIEW_MATRIX"] = "scene_data.view_matrix";
-		actions.renames["INV_VIEW_MATRIX"] = "scene_data.inv_view_matrix";
+		actions.renames["VIEW_MATRIX"] = "scene_data_block.data.view_matrix";
+		actions.renames["INV_VIEW_MATRIX"] = "scene_data_block.data.inv_view_matrix";
 		actions.renames["PROJECTION_MATRIX"] = "projection_matrix";
 		actions.renames["INV_PROJECTION_MATRIX"] = "inv_projection_matrix";
 		actions.renames["MODELVIEW_MATRIX"] = "modelview";
@@ -621,11 +621,11 @@
 
 		//builtins
 
-		actions.renames["TIME"] = "scene_data.time";
+		actions.renames["TIME"] = "scene_data_block.data.time";
 		actions.renames["PI"] = _MKSTR(Math_PI);
 		actions.renames["TAU"] = _MKSTR(Math_TAU);
 		actions.renames["E"] = _MKSTR(Math_E);
-		actions.renames["VIEWPORT_SIZE"] = "scene_data.viewport_size";
+		actions.renames["VIEWPORT_SIZE"] = "scene_data_block.data.viewport_size";
 
 		actions.renames["FRAGCOORD"] = "gl_FragCoord";
 		actions.renames["FRONT_FACING"] = "gl_FrontFacing";
Index: drivers/gles3/storage/material_storage.cpp
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/drivers/gles3/storage/material_storage.cpp b/drivers/gles3/storage/material_storage.cpp
--- a/drivers/gles3/storage/material_storage.cpp	(revision ba832d83b2dafcdbb79b93b1e97fd518c12b97bf)
+++ b/drivers/gles3/storage/material_storage.cpp	(date 1654708602847)
@@ -1394,8 +1394,8 @@
 
 		actions.renames["MODEL_MATRIX"] = "model_matrix";
 		actions.renames["MODEL_NORMAL_MATRIX"] = "model_normal_matrix";
-		actions.renames["VIEW_MATRIX"] = "scene_data.view_matrix";
-		actions.renames["INV_VIEW_MATRIX"] = "scene_data.inv_view_matrix";
+		actions.renames["VIEW_MATRIX"] = "scene_data_bock.data.view_matrix";
+		actions.renames["INV_VIEW_MATRIX"] = "scene_data_bock.data.inv_view_matrix";
 		actions.renames["PROJECTION_MATRIX"] = "projection_matrix";
 		actions.renames["INV_PROJECTION_MATRIX"] = "inv_projection_matrix";
 		actions.renames["MODELVIEW_MATRIX"] = "modelview";
@@ -1420,11 +1420,11 @@
 
 		//builtins
 
-		actions.renames["TIME"] = "scene_data.time";
+		actions.renames["TIME"] = "scene_data_bock.data.time";
 		actions.renames["PI"] = _MKSTR(Math_PI);
 		actions.renames["TAU"] = _MKSTR(Math_TAU);
 		actions.renames["E"] = _MKSTR(Math_E);
-		actions.renames["VIEWPORT_SIZE"] = "scene_data.viewport_size";
+		actions.renames["VIEWPORT_SIZE"] = "scene_data_bock.data.viewport_size";
 
 		actions.renames["FRAGCOORD"] = "gl_FragCoord";
 		actions.renames["FRONT_FACING"] = "gl_FrontFacing";
Index: servers/rendering/renderer_rd/shaders/scene_forward_clustered.glsl
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/servers/rendering/renderer_rd/shaders/scene_forward_clustered.glsl b/servers/rendering/renderer_rd/shaders/scene_forward_clustered.glsl
--- a/servers/rendering/renderer_rd/shaders/scene_forward_clustered.glsl	(revision ba832d83b2dafcdbb79b93b1e97fd518c12b97bf)
+++ b/servers/rendering/renderer_rd/shaders/scene_forward_clustered.glsl	(date 1654708415813)
@@ -384,14 +384,13 @@
 
 	instance_index_interp = instance_index;
 
-	SceneData scene_data = scene_data_block.data;
 	mat4 model_matrix = instances.data[instance_index].transform;
 #if defined(MOTION_VECTORS)
 	vertex_shader(instance_index, is_multimesh, scene_data_block.prev_data, instances.data[instance_index].prev_transform, prev_screen_position);
-	vertex_shader(instance_index, is_multimesh, scene_data, model_matrix, screen_position);
+	vertex_shader(instance_index, is_multimesh, scene_data_block.data, model_matrix, screen_position);
 #else
 	vec4 screen_position;
-	vertex_shader(instance_index, is_multimesh, scene_data, model_matrix, screen_position);
+	vertex_shader(instance_index, is_multimesh, scene_data_block.data, model_matrix, screen_position);
 #endif
 }
 
@@ -637,8 +636,6 @@
 		discard;
 #endif
 
-	SceneData scene_data = scene_data_block.data;
-	SceneData prev_scene_data = scene_data_block.prev_data;
 	uint instance_index = instance_index_interp;
 
 	//lay out everything, whatever is unused is optimized away anyway
@@ -710,7 +707,7 @@
 
 	float normal_map_depth = 1.0;
 
-	vec2 screen_uv = gl_FragCoord.xy * scene_data.screen_pixel_size;
+	vec2 screen_uv = gl_FragCoord.xy * scene_data_block.data.screen_pixel_size;
 
 	float sss_strength = 0.0;
 
@@ -764,7 +761,7 @@
 #endif // ALPHA_ANTIALIASING_EDGE_USED
 
 #ifdef USE_OPAQUE_PREPASS
-	if (alpha < scene_data.opaque_prepass_threshold) {
+	if (alpha < scene_data_block.data.opaque_prepass_threshold) {
 		discard;
 	}
 #endif // USE_OPAQUE_PREPASS
@@ -807,13 +804,13 @@
 	// to maximize VGPR usage
 	// Draw "fixed" fog before volumetric fog to ensure volumetric fog can appear in front of the sky.
 
-	if (scene_data.fog_enabled) {
+	if (scene_data_block.data.fog_enabled) {
 		fog = fog_process(vertex);
 	}
 
-	if (scene_data.volumetric_fog_enabled) {
+	if (scene_data_block.data.volumetric_fog_enabled) {
 		vec4 volumetric_fog = volumetric_fog_process(screen_uv, -vertex.z);
-		if (scene_data.fog_enabled) {
+		if (scene_data_block.data.fog_enabled) {
 			//must use the full blending equation here to blend fogs
 			vec4 res;
 			float sa = 1.0 - volumetric_fog.a;
@@ -839,10 +836,10 @@
 
 #ifndef MODE_RENDER_DEPTH
 
-	uvec2 cluster_pos = uvec2(gl_FragCoord.xy) >> scene_data.cluster_shift;
-	uint cluster_offset = (scene_data.cluster_width * cluster_pos.y + cluster_pos.x) * (scene_data.max_cluster_element_count_div_32 + 32);
+	uvec2 cluster_pos = uvec2(gl_FragCoord.xy) >> scene_data_block.data.cluster_shift;
+	uint cluster_offset = (scene_data_block.data.cluster_width * cluster_pos.y + cluster_pos.x) * (scene_data_block.data.max_cluster_element_count_div_32 + 32);
 
-	uint cluster_z = uint(clamp((-vertex.z / scene_data.z_far) * 32.0, 0.0, 31.0));
+	uint cluster_z = uint(clamp((-vertex.z / scene_data_block.data.z_far) * 32.0, 0.0, 31.0));
 
 	//used for interpolating anything cluster related
 	vec3 vertex_ddx = dFdx(vertex);
@@ -850,14 +847,14 @@
 
 	{ // process decals
 
-		uint cluster_decal_offset = cluster_offset + scene_data.cluster_type_size * 2;
+		uint cluster_decal_offset = cluster_offset + scene_data_block.data.cluster_type_size * 2;
 
 		uint item_min;
 		uint item_max;
 		uint item_from;
 		uint item_to;
 
-		cluster_get_item_range(cluster_decal_offset + scene_data.max_cluster_element_count_div_32 + cluster_z, item_min, item_max, item_from, item_to);
+		cluster_get_item_range(cluster_decal_offset + scene_data_block.data.max_cluster_element_count_div_32 + cluster_z, item_min, item_max, item_from, item_to);
 
 #ifdef USE_SUBGROUPS
 		item_from = subgroupBroadcastFirst(subgroupMin(item_from));
@@ -960,12 +957,12 @@
 	/////////////////////// LIGHTING //////////////////////////////
 
 #ifdef NORMAL_USED
-	if (scene_data.roughness_limiter_enabled) {
+	if (scene_data_block.data.roughness_limiter_enabled) {
 		//https://www.jp.square-enix.com/tech/library/pdf/ImprovedGeometricSpecularAA.pdf
 		float roughness2 = roughness * roughness;
 		vec3 dndu = dFdx(normal), dndv = dFdy(normal);
-		float variance = scene_data.roughness_limiter_amount * (dot(dndu, dndu) + dot(dndv, dndv));
-		float kernelRoughness2 = min(2.0 * variance, scene_data.roughness_limiter_limit); //limit effect
+		float variance = scene_data_block.data.roughness_limiter_amount * (dot(dndu, dndu) + dot(dndv, dndv));
+		float kernelRoughness2 = min(2.0 * variance, scene_data_block.data.roughness_limiter_limit); //limit effect
 		float filteredRoughness2 = min(1.0, roughness2 + kernelRoughness2);
 		roughness = sqrt(filteredRoughness2);
 	}
@@ -978,7 +975,7 @@
 
 #if !defined(MODE_RENDER_DEPTH) && !defined(MODE_UNSHADED)
 
-	if (scene_data.use_reflection_cubemap) {
+	if (scene_data_block.data.use_reflection_cubemap) {
 #ifdef LIGHT_ANISOTROPY_USED
 		// https://google.github.io/filament/Filament.html#lighting/imagebasedlights/anisotropy
 		vec3 anisotropic_direction = anisotropy >= 0.0 ? binormal : tangent;
@@ -991,7 +988,7 @@
 #endif
 
 		float horizon = min(1.0 + dot(ref_vec, normal), 1.0);
-		ref_vec = scene_data.radiance_inverse_xform * ref_vec;
+		ref_vec = scene_data_block.data.radiance_inverse_xform * ref_vec;
 #ifdef USE_RADIANCE_CUBEMAP_ARRAY
 
 		float lod, blend;
@@ -1004,7 +1001,7 @@
 
 #endif //USE_RADIANCE_CUBEMAP_ARRAY
 		specular_light *= horizon * horizon;
-		specular_light *= scene_data.ambient_light_color_energy.a;
+		specular_light *= scene_data_block.data.ambient_light_color_energy.a;
 	}
 
 #if defined(CUSTOM_RADIANCE_USED)
@@ -1013,18 +1010,18 @@
 
 #ifndef USE_LIGHTMAP
 	//lightmap overrides everything
-	if (scene_data.use_ambient_light) {
-		ambient_light = scene_data.ambient_light_color_energy.rgb;
+	if (scene_data_block.data.use_ambient_light) {
+		ambient_light = scene_data_block.data.ambient_light_color_energy.rgb;
 
-		if (scene_data.use_ambient_cubemap) {
-			vec3 ambient_dir = scene_data.radiance_inverse_xform * normal;
+		if (scene_data_block.data.use_ambient_cubemap) {
+			vec3 ambient_dir = scene_data_block.data.radiance_inverse_xform * normal;
 #ifdef USE_RADIANCE_CUBEMAP_ARRAY
 			vec3 cubemap_ambient = texture(samplerCubeArray(radiance_cubemap, material_samplers[SAMPLER_LINEAR_WITH_MIPMAPS_CLAMP]), vec4(ambient_dir, MAX_ROUGHNESS_LOD)).rgb;
 #else
 			vec3 cubemap_ambient = textureLod(samplerCube(radiance_cubemap, material_samplers[SAMPLER_LINEAR_WITH_MIPMAPS_CLAMP]), ambient_dir, MAX_ROUGHNESS_LOD).rgb;
 #endif //USE_RADIANCE_CUBEMAP_ARRAY
 
-			ambient_light = mix(ambient_light, cubemap_ambient * scene_data.ambient_light_color_energy.a, scene_data.ambient_color_sky_mix);
+			ambient_light = mix(ambient_light, cubemap_ambient * scene_data_block.data.ambient_light_color_energy.a, scene_data_block.data.ambient_color_sky_mix);
 		}
 	}
 #endif // USE_LIGHTMAP
@@ -1034,7 +1031,7 @@
 
 #ifdef LIGHT_CLEARCOAT_USED
 
-	if (scene_data.use_reflection_cubemap) {
+	if (scene_data_block.data.use_reflection_cubemap) {
 		vec3 n = normalize(normal_interp); // We want to use geometric normal, not normal_map
 		float NoV = max(dot(n, view), 0.0001);
 		vec3 ref_vec = reflect(-view, n);
@@ -1045,7 +1042,7 @@
 		specular_light *= attenuation;
 
 		float horizon = min(1.0 + dot(ref_vec, normal), 1.0);
-		ref_vec = scene_data.radiance_inverse_xform * ref_vec;
+		ref_vec = scene_data_block.data.radiance_inverse_xform * ref_vec;
 		float roughness_lod = mix(0.001, 0.1, clearcoat_roughness) * MAX_ROUGHNESS_LOD;
 #ifdef USE_RADIANCE_CUBEMAP_ARRAY
 
@@ -1058,7 +1055,7 @@
 		vec3 clearcoat_light = textureLod(samplerCube(radiance_cubemap, material_samplers[SAMPLER_LINEAR_WITH_MIPMAPS_CLAMP]), ref_vec, roughness_lod).rgb;
 
 #endif //USE_RADIANCE_CUBEMAP_ARRAY
-		specular_light += clearcoat_light * horizon * horizon * Fc * scene_data.ambient_light_color_energy.a;
+		specular_light += clearcoat_light * horizon * horizon * Fc * scene_data_block.data.ambient_light_color_energy.a;
 	}
 #endif
 #endif //!defined(MODE_RENDER_DEPTH) && !defined(MODE_UNSHADED)
@@ -1074,7 +1071,7 @@
 	if (bool(instances.data[instance_index].flags & INSTANCE_FLAGS_USE_LIGHTMAP_CAPTURE)) { //has lightmap capture
 		uint index = instances.data[instance_index].gi_offset;
 
-		vec3 wnormal = mat3(scene_data.inv_view_matrix) * normal;
+		vec3 wnormal = mat3(scene_data_block.data.inv_view_matrix) * normal;
 		const float c1 = 0.429043;
 		const float c2 = 0.511664;
 		const float c3 = 0.743125;
@@ -1128,9 +1125,9 @@
 	if (sc_use_forward_gi && bool(instances.data[instance_index].flags & INSTANCE_FLAGS_USE_SDFGI)) { //has lightmap capture
 
 		//make vertex orientation the world one, but still align to camera
-		vec3 cam_pos = mat3(scene_data.inv_view_matrix) * vertex;
-		vec3 cam_normal = mat3(scene_data.inv_view_matrix) * normal;
-		vec3 cam_reflection = mat3(scene_data.inv_view_matrix) * reflect(-view, normal);
+		vec3 cam_pos = mat3(scene_data_block.data.inv_view_matrix) * vertex;
+		vec3 cam_normal = mat3(scene_data_block.data.inv_view_matrix) * normal;
+		vec3 cam_reflection = mat3(scene_data_block.data.inv_view_matrix) * reflect(-view, normal);
 
 		//apply y-mult
 		cam_pos.y *= sdfgi.y_mult;
@@ -1233,14 +1230,14 @@
 
 		vec2 coord;
 
-		if (scene_data.gi_upscale_for_msaa) {
+		if (scene_data_block.data.gi_upscale_for_msaa) {
 			vec2 base_coord = screen_uv;
 			vec2 closest_coord = base_coord;
 			float closest_ang = dot(normal, textureLod(sampler2D(normal_roughness_buffer, material_samplers[SAMPLER_LINEAR_CLAMP]), base_coord, 0.0).xyz * 2.0 - 1.0);
 
 			for (int i = 0; i < 4; i++) {
 				const vec2 neighbours[4] = vec2[](vec2(-1, 0), vec2(1, 0), vec2(0, -1), vec2(0, 1));
-				vec2 neighbour_coord = base_coord + neighbours[i] * scene_data.screen_pixel_size;
+				vec2 neighbour_coord = base_coord + neighbours[i] * scene_data_block.data.screen_pixel_size;
 				float neighbour_ang = dot(normal, textureLod(sampler2D(normal_roughness_buffer, material_samplers[SAMPLER_LINEAR_CLAMP]), neighbour_coord, 0.0).xyz * 2.0 - 1.0);
 				if (neighbour_ang > closest_ang) {
 					closest_ang = neighbour_ang;
@@ -1262,10 +1259,10 @@
 	}
 #endif // !USE_LIGHTMAP
 
-	if (bool(scene_data.ss_effects_flags & SCREEN_SPACE_EFFECTS_FLAGS_USE_SSAO)) {
+	if (bool(scene_data_block.data.ss_effects_flags & SCREEN_SPACE_EFFECTS_FLAGS_USE_SSAO)) {
 		float ssao = texture(sampler2D(ao_buffer, material_samplers[SAMPLER_LINEAR_CLAMP]), screen_uv).r;
 		ao = min(ao, ssao);
-		ao_light_affect = mix(ao_light_affect, max(ao_light_affect, scene_data.ssao_light_affect), scene_data.ssao_ao_affect);
+		ao_light_affect = mix(ao_light_affect, max(ao_light_affect, scene_data_block.data.ssao_light_affect), scene_data_block.data.ssao_ao_affect);
 	}
 
 	{ // process reflections
@@ -1273,14 +1270,14 @@
 		vec4 reflection_accum = vec4(0.0, 0.0, 0.0, 0.0);
 		vec4 ambient_accum = vec4(0.0, 0.0, 0.0, 0.0);
 
-		uint cluster_reflection_offset = cluster_offset + scene_data.cluster_type_size * 3;
+		uint cluster_reflection_offset = cluster_offset + scene_data_block.data.cluster_type_size * 3;
 
 		uint item_min;
 		uint item_max;
 		uint item_from;
 		uint item_to;
 
-		cluster_get_item_range(cluster_reflection_offset + scene_data.max_cluster_element_count_div_32 + cluster_z, item_min, item_max, item_from, item_to);
+		cluster_get_item_range(cluster_reflection_offset + scene_data_block.data.max_cluster_element_count_div_32 + cluster_z, item_min, item_max, item_from, item_to);
 
 #ifdef USE_SUBGROUPS
 		item_from = subgroupBroadcastFirst(subgroupMin(item_from));
@@ -1340,7 +1337,7 @@
 	// convert ao to direct light ao
 	ao = mix(1.0, ao, ao_light_affect);
 
-	if (bool(scene_data.ss_effects_flags & SCREEN_SPACE_EFFECTS_FLAGS_USE_SSIL)) {
+	if (bool(scene_data_block.data.ss_effects_flags & SCREEN_SPACE_EFFECTS_FLAGS_USE_SSIL)) {
 		vec4 ssil = textureLod(sampler2D(ssil_buffer, material_samplers[SAMPLER_LINEAR_CLAMP]), screen_uv, 0.0);
 		ambient_light *= 1.0 - ssil.a;
 		ambient_light += ssil.rgb * albedo.rgb;
@@ -1388,7 +1385,7 @@
 		uint shadow1 = 0;
 
 		for (uint i = 0; i < 8; i++) {
-			if (i >= scene_data.directional_light_count) {
+			if (i >= scene_data_block.data.directional_light_count) {
 				break;
 			}
 
@@ -1547,7 +1544,7 @@
 
 					pssm_coord /= pssm_coord.w;
 
-					shadow = sample_directional_pcf_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size * directional_lights.data[i].soft_shadow_scale * blur_factor, pssm_coord);
+					shadow = sample_directional_pcf_shadow(directional_shadow_atlas, scene_data_block.data.directional_shadow_pixel_size * directional_lights.data[i].soft_shadow_scale * blur_factor, pssm_coord);
 
 					if (directional_lights.data[i].blend_splits) {
 						float pssm_blend;
@@ -1581,7 +1578,7 @@
 
 						pssm_coord /= pssm_coord.w;
 
-						float shadow2 = sample_directional_pcf_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size * directional_lights.data[i].soft_shadow_scale * blur_factor2, pssm_coord);
+						float shadow2 = sample_directional_pcf_shadow(directional_shadow_atlas, scene_data_block.data.directional_shadow_pixel_size * directional_lights.data[i].soft_shadow_scale * blur_factor2, pssm_coord);
 						shadow = mix(shadow, shadow2, pssm_blend);
 					}
 				}
@@ -1600,7 +1597,7 @@
 #endif // SHADOWS_DISABLED
 
 		for (uint i = 0; i < 8; i++) {
-			if (i >= scene_data.directional_light_count) {
+			if (i >= scene_data_block.data.directional_light_count) {
 				break;
 			}
 
@@ -1706,7 +1703,7 @@
 		uint item_from;
 		uint item_to;
 
-		cluster_get_item_range(cluster_omni_offset + scene_data.max_cluster_element_count_div_32 + cluster_z, item_min, item_max, item_from, item_to);
+		cluster_get_item_range(cluster_omni_offset + scene_data_block.data.max_cluster_element_count_div_32 + cluster_z, item_min, item_max, item_from, item_to);
 
 #ifdef USE_SUBGROUPS
 		item_from = subgroupBroadcastFirst(subgroupMin(item_from));
@@ -1770,14 +1767,14 @@
 
 	{ //spot lights
 
-		uint cluster_spot_offset = cluster_offset + scene_data.cluster_type_size;
+		uint cluster_spot_offset = cluster_offset + scene_data_block.data.cluster_type_size;
 
 		uint item_min;
 		uint item_max;
 		uint item_from;
 		uint item_to;
 
-		cluster_get_item_range(cluster_spot_offset + scene_data.max_cluster_element_count_div_32 + cluster_z, item_min, item_max, item_from, item_to);
+		cluster_get_item_range(cluster_spot_offset + scene_data_block.data.max_cluster_element_count_div_32 + cluster_z, item_min, item_max, item_from, item_to);
 
 #ifdef USE_SUBGROUPS
 		item_from = subgroupBroadcastFirst(subgroupMin(item_from));
@@ -1852,7 +1849,7 @@
 
 #ifdef USE_OPAQUE_PREPASS
 
-	if (alpha < scene_data.opaque_prepass_threshold) {
+	if (alpha < scene_data_block.data.opaque_prepass_threshold) {
 		discard;
 	}
 
@@ -1867,8 +1864,8 @@
 #ifdef MODE_RENDER_SDF
 
 	{
-		vec3 local_pos = (scene_data.sdf_to_bounds * vec4(vertex, 1.0)).xyz;
-		ivec3 grid_pos = scene_data.sdf_offset + ivec3(local_pos * vec3(scene_data.sdf_size));
+		vec3 local_pos = (scene_data_block.data.sdf_to_bounds * vec4(vertex, 1.0)).xyz;
+		ivec3 grid_pos = scene_data_block.data.sdf_offset + ivec3(local_pos * vec3(scene_data_block.data.sdf_size));
 
 		uint albedo16 = 0x1; //solid flag
 		albedo16 |= clamp(uint(albedo.r * 31.0), 0, 31) << 11;
@@ -1886,7 +1883,7 @@
 				vec3(0, -1, 0),
 				vec3(0, 0, -1));
 
-		vec3 cam_normal = mat3(scene_data.inv_view_matrix) * normalize(normal_interp);
+		vec3 cam_normal = mat3(scene_data_block.data.inv_view_matrix) * normalize(normal_interp);
 
 		float closest_dist = -1e20;
 
@@ -2047,8 +2044,8 @@
 
 #endif //MODE_RENDER_DEPTH
 #ifdef MOTION_VECTORS
-	vec2 position_clip = (screen_position.xy / screen_position.w) - scene_data.taa_jitter;
-	vec2 prev_position_clip = (prev_screen_position.xy / prev_screen_position.w) - prev_scene_data.taa_jitter;
+	vec2 position_clip = (screen_position.xy / screen_position.w) - scene_data_block.data.taa_jitter;
+	vec2 prev_position_clip = (prev_screen_position.xy / prev_screen_position.w) - scene_data_block.prev_data.taa_jitter;
 
 	vec2 position_uv = position_clip * vec2(0.5, 0.5);
 	vec2 prev_position_uv = prev_position_clip * vec2(0.5, 0.5);

[Calinou]

Could this workaround be done in a way to break TAA only on macOS (with #ifdef OSX_ENABLED where appropriate)?

[aaronfranke]

@JFonS I tested your patch and it fixes Vulkan Clustered but not Vulkan Mobile.

[JFonS]

@aaronfranke alright, thanks for testing.

I didn't fix the mobile renderer, so it's expected to be broken, but I will make sure to include it in the final fix.

[JFonS]

I opened #61850 with a workaround.

[aaronfranke]

Re-opening because it's still broken with Vulkan Mobile.

[josephmbustamante]

I can confirm this is broken also on Intel Macs (2017 MacBook Pro, Intel i7). Same as mentioned above too, only the mobile backend has errors.