AuroraMiddleware/SPIRV-Cross
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
120af42616
SPIRV-Cross/spirv_msl.cpp

13774 lines
482 KiB
C++
Raw Normal View History

Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
/*
Update license headers to 2020.
2020-01-16 14:24:37 +00:00
* Copyright 2016-2020 The Brenwill Workshop Ltd.
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "spirv_msl.hpp"
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
#include "GLSL.std.450.h"
msl: Handle writable SSBO in function arguments
2017-01-27 00:40:56 +00:00
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
#include <algorithm>
Support passing implicit frag_coord arguments down to functions.
2018-02-09 11:13:33 +00:00
#include <assert.h>
Run format_all.sh.
2018-02-15 12:32:49 +00:00
#include <numeric>
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
using namespace spv;
Add an option to override the namespace used for spirv_cross. This is a pragmatic trick to avoid symbol collision where a project links against SPIRV-Cross statically, while linking to other projects which also use SPIRV-Cross statically. We can end up with very awkward symbol collisions which can resolve themselves silently because SPIRV-Cross is pulled in as necessary. To fix this, we must use different symbols and embed two copies of SPIRV-Cross in this scenario, now with different namespaces, which in turn leads to different symbols.
2019-03-29 09:29:44 +00:00
using namespace SPIRV_CROSS_NAMESPACE;
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
using namespace std;
Some compat fixes for MSL and Half.
2018-03-06 16:07:59 +00:00
static const uint32_t k_unknown_location = ~0u;
MSL: Account for components when assigning locations to varyings. Two varyings (vertex outputs/fragment inputs) might have the same location but be in different components--e.g. the compiler may have packed what were two different varyings into a single varying vector. Giving both varyings the same `[[user]]` attribute won't work--it may yield unexpected results, or flat out fail to link. We could eventually pack such varyings into a single vector, but that would require us to handle the case where the varyings are different types--e.g. a `float` and a `uint` packed into the same vector. For now, it seems most prudent to give them unique `[[user]]` locations and let Apple's compiler work out the best way to pack them.
2018-09-05 22:31:10 +00:00
static const uint32_t k_unknown_component = ~0u;
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
static const char *force_inline = "static inline __attribute__((always_inline))";
Some compat fixes for MSL and Half.
2018-03-06 16:07:59 +00:00
Do not use SmallVector as input type in public interfaces. This is an API break, which we need to be careful with. Handing out SmallVectors is easier since the interface is basically the same.
2019-04-09 10:46:23 +00:00
CompilerMSL::CompilerMSL(std::vector<uint32_t> spirv_)
CompilerMSL vectorless constructor uses vectorless attribute and resource bindings.
2017-04-04 20:38:17 +00:00
: CompilerGLSL(move(spirv_))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Add clean_func_name() to support overrides to function names.
2017-01-08 03:15:58 +00:00
}
Add a stable C API for SPIRV-Cross. This adds a new C API for SPIRV-Cross which is intended to be stable, both API and ABI wise. The C++ API has been refactored a bit to make the C wrapper easier and cleaner to write. Especially the vertex attribute / resource interfaces for MSL has been rewritten to avoid taking mutable pointers into the interface. This would be very annoying to wrap and it didn't fit well with the rest of the C++ API to begin with. While doing this, I went ahead and removed all the old deprecated interfaces. The CMake build system has also seen an overhaul. It is now possible to build static/shared/CLI separately with -D options. The shared library only exposes the C API, as it is the only ABI-stable API. pkg-configs as well as CMake modules are exported and installed for the shared library configuration.
2019-02-12 10:11:29 +00:00
CompilerMSL::CompilerMSL(const uint32_t *ir_, size_t word_count)
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
: CompilerGLSL(ir_, word_count)
{
}
Add a stable C API for SPIRV-Cross. This adds a new C API for SPIRV-Cross which is intended to be stable, both API and ABI wise. The C++ API has been refactored a bit to make the C wrapper easier and cleaner to write. Especially the vertex attribute / resource interfaces for MSL has been rewritten to avoid taking mutable pointers into the interface. This would be very annoying to wrap and it didn't fit well with the rest of the C++ API to begin with. While doing this, I went ahead and removed all the old deprecated interfaces. The CMake build system has also seen an overhaul. It is now possible to build static/shared/CLI separately with -D options. The shared library only exposes the C API, as it is the only ABI-stable API. pkg-configs as well as CMake modules are exported and installed for the shared library configuration.
2019-02-12 10:11:29 +00:00
CompilerMSL::CompilerMSL(const ParsedIR &ir_)
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
: CompilerGLSL(ir_)
{
}
Add a stable C API for SPIRV-Cross. This adds a new C API for SPIRV-Cross which is intended to be stable, both API and ABI wise. The C++ API has been refactored a bit to make the C wrapper easier and cleaner to write. Especially the vertex attribute / resource interfaces for MSL has been rewritten to avoid taking mutable pointers into the interface. This would be very annoying to wrap and it didn't fit well with the rest of the C++ API to begin with. While doing this, I went ahead and removed all the old deprecated interfaces. The CMake build system has also seen an overhaul. It is now possible to build static/shared/CLI separately with -D options. The shared library only exposes the C API, as it is the only ABI-stable API. pkg-configs as well as CMake modules are exported and installed for the shared library configuration.
2019-02-12 10:11:29 +00:00
CompilerMSL::CompilerMSL(ParsedIR &&ir_)
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
: CompilerGLSL(std::move(ir_))
Add vector-less IR construction to subclasses as well.
2017-04-01 14:08:19 +00:00
{
Add a stable C API for SPIRV-Cross. This adds a new C API for SPIRV-Cross which is intended to be stable, both API and ABI wise. The C++ API has been refactored a bit to make the C wrapper easier and cleaner to write. Especially the vertex attribute / resource interfaces for MSL has been rewritten to avoid taking mutable pointers into the interface. This would be very annoying to wrap and it didn't fit well with the rest of the C++ API to begin with. While doing this, I went ahead and removed all the old deprecated interfaces. The CMake build system has also seen an overhaul. It is now possible to build static/shared/CLI separately with -D options. The shared library only exposes the C API, as it is the only ABI-stable API. pkg-configs as well as CMake modules are exported and installed for the shared library configuration.
2019-02-12 10:11:29 +00:00
}
CompilerMSL vectorless constructor uses vectorless attribute and resource bindings.
2017-04-04 20:38:17 +00:00
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
void CompilerMSL::add_msl_shader_input(const MSLShaderInput &si)
{
inputs_by_location[si.location] = si;
if (si.builtin != BuiltInMax && !inputs_by_builtin.count(si.builtin))
inputs_by_builtin[si.builtin] = si;
}
Add a stable C API for SPIRV-Cross. This adds a new C API for SPIRV-Cross which is intended to be stable, both API and ABI wise. The C++ API has been refactored a bit to make the C wrapper easier and cleaner to write. Especially the vertex attribute / resource interfaces for MSL has been rewritten to avoid taking mutable pointers into the interface. This would be very annoying to wrap and it didn't fit well with the rest of the C++ API to begin with. While doing this, I went ahead and removed all the old deprecated interfaces. The CMake build system has also seen an overhaul. It is now possible to build static/shared/CLI separately with -D options. The shared library only exposes the C API, as it is the only ABI-stable API. pkg-configs as well as CMake modules are exported and installed for the shared library configuration.
2019-02-12 10:11:29 +00:00
void CompilerMSL::add_msl_resource_binding(const MSLResourceBinding &binding)
{
MSL: Support remapping constexpr samplers by set/binding. Older API was oriented around IDs which are not available unless you're doing full reflection, which is awkward for certain use cases which know their set/bindings up front. Optimize resource bindings to be hashmap rather than doing linear seeks all the time.
2019-06-10 13:41:36 +00:00
StageSetBinding tuple = { binding.stage, binding.desc_set, binding.binding };
resource_bindings[tuple] = { binding, false };
Add a stable C API for SPIRV-Cross. This adds a new C API for SPIRV-Cross which is intended to be stable, both API and ABI wise. The C++ API has been refactored a bit to make the C wrapper easier and cleaner to write. Especially the vertex attribute / resource interfaces for MSL has been rewritten to avoid taking mutable pointers into the interface. This would be very annoying to wrap and it didn't fit well with the rest of the C++ API to begin with. While doing this, I went ahead and removed all the old deprecated interfaces. The CMake build system has also seen an overhaul. It is now possible to build static/shared/CLI separately with -D options. The shared library only exposes the C API, as it is the only ABI-stable API. pkg-configs as well as CMake modules are exported and installed for the shared library configuration.
2019-02-12 10:11:29 +00:00
}
MSL: Support dynamic offsets for buffers in argument buffers. Vulkan has two types of buffer descriptors, `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` and `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC`, which allow the client to offset the buffers by an amount given when the descriptor set is bound to a pipeline. Metal provides no direct support for this when the buffer in question is in an argument buffer, so once again we're on our own. These offsets cannot be stored or associated in any way with the argument buffer itself, because they are set at bind time. Different pipelines may have different offsets set. Therefore, we must use a separate buffer, not in any argument buffer, to hold these offsets. Then the shader must manually offset the buffer pointer. This change fully supports arrays, including arrays of arrays, even though Vulkan forbids them. It does not, however, support runtime arrays. Perhaps later.
2019-09-06 04:14:12 +00:00
void CompilerMSL::add_dynamic_buffer(uint32_t desc_set, uint32_t binding, uint32_t index)
{
SetBindingPair pair = { desc_set, binding };
buffers_requiring_dynamic_offset[pair] = { index, 0 };
}
MSL: Support inline uniform blocks in argument buffers. Here, the inline uniform block is explicit: we instantiate the buffer block itself in the argument buffer, instead of a pointer to the buffer. I just hope this will work with the `MTLArgumentDescriptor` API... Note that Metal recursively assigns individual members of embedded structs IDs. This means for automatic assignment that we have to calculate the binding stride for a given buffer block. For MoltenVK, we'll simply increment the ID by the size of the inline uniform block. Then the later IDs will never conflict with the inline uniform block. We can get away with this because Metal doesn't require that IDs be contiguous, only monotonically increasing.
2019-12-17 04:58:16 +00:00
void CompilerMSL::add_inline_uniform_block(uint32_t desc_set, uint32_t binding)
{
SetBindingPair pair = { desc_set, binding };
inline_uniform_blocks.insert(pair);
}
Rename "push descriptor set" to "discrete descriptor set". Check for case where iOS doesn't support writable argument buffer textures.
2019-03-15 20:53:21 +00:00
void CompilerMSL::add_discrete_descriptor_set(uint32_t desc_set)
MSL: Support VK_KHR_push_descriptor. If we have argument buffers, we also need to support using plain descriptor sets for certain cases where API wants it.
2019-03-15 13:07:03 +00:00
{
if (desc_set < kMaxArgumentBuffers)
Rename "push descriptor set" to "discrete descriptor set". Check for case where iOS doesn't support writable argument buffer textures.
2019-03-15 20:53:21 +00:00
argument_buffer_discrete_mask |= 1u << desc_set;
MSL: Support VK_KHR_push_descriptor. If we have argument buffers, we also need to support using plain descriptor sets for certain cases where API wants it.
2019-03-15 13:07:03 +00:00
}
MSL: Add opt-in support for huge IABs. If there are enough members in an IAB, we cannot use the constant address space as MSL compiler complains about there being too many members. Support emitting the device address space instead.
2019-10-14 10:51:48 +00:00
void CompilerMSL::set_argument_buffer_device_address_space(uint32_t desc_set, bool device_storage)
{
if (desc_set < kMaxArgumentBuffers)
{
if (device_storage)
argument_buffer_device_storage_mask |= 1u << desc_set;
else
argument_buffer_device_storage_mask &= ~(1u << desc_set);
}
}
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
bool CompilerMSL::is_msl_shader_input_used(uint32_t location)
{
return inputs_in_use.count(location) != 0;
Add a stable C API for SPIRV-Cross. This adds a new C API for SPIRV-Cross which is intended to be stable, both API and ABI wise. The C++ API has been refactored a bit to make the C wrapper easier and cleaner to write. Especially the vertex attribute / resource interfaces for MSL has been rewritten to avoid taking mutable pointers into the interface. This would be very annoying to wrap and it didn't fit well with the rest of the C++ API to begin with. While doing this, I went ahead and removed all the old deprecated interfaces. The CMake build system has also seen an overhaul. It is now possible to build static/shared/CLI separately with -D options. The shared library only exposes the C API, as it is the only ABI-stable API. pkg-configs as well as CMake modules are exported and installed for the shared library configuration.
2019-02-12 10:11:29 +00:00
}
HLSL: Add a resource remapping API similar to MSL. Allows more flexibility of how resources are assigned without having to remap decorations.
2020-01-09 10:18:14 +00:00
bool CompilerMSL::is_msl_resource_binding_used(ExecutionModel model, uint32_t desc_set, uint32_t binding) const
Add a stable C API for SPIRV-Cross. This adds a new C API for SPIRV-Cross which is intended to be stable, both API and ABI wise. The C++ API has been refactored a bit to make the C wrapper easier and cleaner to write. Especially the vertex attribute / resource interfaces for MSL has been rewritten to avoid taking mutable pointers into the interface. This would be very annoying to wrap and it didn't fit well with the rest of the C++ API to begin with. While doing this, I went ahead and removed all the old deprecated interfaces. The CMake build system has also seen an overhaul. It is now possible to build static/shared/CLI separately with -D options. The shared library only exposes the C API, as it is the only ABI-stable API. pkg-configs as well as CMake modules are exported and installed for the shared library configuration.
2019-02-12 10:11:29 +00:00
{
MSL: Support remapping constexpr samplers by set/binding. Older API was oriented around IDs which are not available unless you're doing full reflection, which is awkward for certain use cases which know their set/bindings up front. Optimize resource bindings to be hashmap rather than doing linear seeks all the time.
2019-06-10 13:41:36 +00:00
StageSetBinding tuple = { model, desc_set, binding };
auto itr = resource_bindings.find(tuple);
return itr != end(resource_bindings) && itr->second.second;
Add vector-less IR construction to subclasses as well.
2017-04-01 14:08:19 +00:00
}
MSL: Add C API for querying automatic resource bindings.
2019-06-21 11:19:59 +00:00
uint32_t CompilerMSL::get_automatic_msl_resource_binding(uint32_t id) const
{
return get_extended_decoration(id, SPIRVCrossDecorationResourceIndexPrimary);
}
uint32_t CompilerMSL::get_automatic_msl_resource_binding_secondary(uint32_t id) const
{
return get_extended_decoration(id, SPIRVCrossDecorationResourceIndexSecondary);
}
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
uint32_t CompilerMSL::get_automatic_msl_resource_binding_tertiary(uint32_t id) const
{
return get_extended_decoration(id, SPIRVCrossDecorationResourceIndexTertiary);
}
uint32_t CompilerMSL::get_automatic_msl_resource_binding_quaternary(uint32_t id) const
{
return get_extended_decoration(id, SPIRVCrossDecorationResourceIndexQuaternary);
}
MSL: Add option to pad fragment outputs. If not enough components are provided in the shader, the shader MSL compiler throws an error rather than make components undefined. This hurts portability, so we need to add explicit padding here.
2019-01-14 13:53:47 +00:00
void CompilerMSL::set_fragment_output_components(uint32_t location, uint32_t components)
{
fragment_output_components[location] = components;
}
Simplified overriding of 'access_chain_internal' function in CompilerMSL.
2019-10-22 15:06:16 +00:00
bool CompilerMSL::builtin_translates_to_nonarray(spv::BuiltIn builtin) const
{
return (builtin == BuiltInSampleMask);
}
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
void CompilerMSL::build_implicit_builtins()
{
MSL: Handle the SamplePosition builtin. This is somewhat tricky, because in MSL this value is obtained through a function, `get_sample_position()`. Since the call expression is an rvalue, it can't be passed by reference, so functions get a copy instead. This was the last piece preventing us from turning on sample-rate shading support in MoltenVK.
2018-09-12 19:05:52 +00:00
bool need_sample_pos = active_input_builtins.get(BuiltInSamplePosition);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
bool need_vertex_params = capture_output_to_buffer && get_execution_model() == ExecutionModelVertex &&
!msl_options.vertex_for_tessellation;
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
bool need_tesc_params = get_execution_model() == ExecutionModelTessellationControl;
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
bool need_subgroup_mask =
active_input_builtins.get(BuiltInSubgroupEqMask) || active_input_builtins.get(BuiltInSubgroupGeMask) ||
active_input_builtins.get(BuiltInSubgroupGtMask) || active_input_builtins.get(BuiltInSubgroupLeMask) ||
active_input_builtins.get(BuiltInSubgroupLtMask);
bool need_subgroup_ge_mask = !msl_options.is_ios() && (active_input_builtins.get(BuiltInSubgroupGeMask) ||
active_input_builtins.get(BuiltInSubgroupGtMask));
Support the SPV_KHR_device_group extension. The only piece added by this extension is the `DeviceIndex` builtin, which tells the shader which device in a grouped logical device it is running on. Metal's pipeline state objects are owned by the `MTLDevice` that created them. Since Metal doesn't support logical grouping of devices the way Vulkan does, we'll thus have to create a pipeline state for each device in a grouped logical device. The upcoming peer group support in Metal 3 will not change this. For this reason, for Metal, the device index is supplied as a constant at pipeline compile time. There's an interaction between `VK_KHR_device_group` and `VK_KHR_multiview` in the `VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT`, which defines the view index to be the same as the device index. The new `view_index_from_device_index` MSL option supports this functionality.
2019-07-13 02:50:50 +00:00
bool need_multiview = get_execution_model() == ExecutionModelVertex && !msl_options.view_index_from_device_index &&
MSL: Don't set the layer for multiview if the device doesn't support it. Some older iOS devices don't support layered rendering. In that case, don't set `[[render_target_array_index]]`, because the compiler will reject the shader in that case. The client will then have to unroll the render pass manually.
2020-08-23 21:44:41 +00:00
msl_options.multiview_layered_rendering &&
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
(msl_options.multiview || active_input_builtins.get(BuiltInViewIndex));
MSL: Adjust BuiltInWorkgroupId for vkCmdDispatchBase(). This command allows the caller to set the base value of `BuiltInWorkgroupId`, and thus of `BuiltInGlobalInvocationId`. Metal provides no direct support for this... but it does provide a builtin, `[[grid_origin]]`, normally used to pass the base values for the stage input region, which we will now abuse to pass the dispatch base and avoid burning a buffer binding. `[[grid_origin]]`, as part of Metal's support for compute stage input, requires MSL 1.2. For 1.0 and 1.1, we're forced to provide a buffer. (Curiously, this builtin was undocumented until the MSL 2.2 release. Go figure.)
2019-07-22 18:08:04 +00:00
bool need_dispatch_base =
msl_options.dispatch_base && get_execution_model() == ExecutionModelGLCompute &&
(active_input_builtins.get(BuiltInWorkgroupId) || active_input_builtins.get(BuiltInGlobalInvocationId));
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
bool need_grid_params = get_execution_model() == ExecutionModelVertex && msl_options.vertex_for_tessellation;
bool need_vertex_base_params =
need_grid_params &&
(active_input_builtins.get(BuiltInVertexId) || active_input_builtins.get(BuiltInVertexIndex) ||
active_input_builtins.get(BuiltInBaseVertex) || active_input_builtins.get(BuiltInInstanceId) ||
active_input_builtins.get(BuiltInInstanceIndex) || active_input_builtins.get(BuiltInBaseInstance));
Enabling setting a fixed sampleMask in Metal fragment shaders. In Metal render pipelines don't have an option to set a sampleMask parameter, the only way to get that functionality is to set the sample_mask output of the fragment shader to this value directly. We also need to take care to combine the fixed sample mask with the one that the shader might possibly output.
2020-07-22 16:37:17 +00:00
bool need_sample_mask = msl_options.additional_fixed_sample_mask != 0xffffffff;
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
if (need_subpass_input || need_sample_pos || need_subgroup_mask || need_vertex_params || need_tesc_params ||
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
need_multiview || need_dispatch_base || need_vertex_base_params || need_grid_params ||
Enabling setting a fixed sampleMask in Metal fragment shaders. In Metal render pipelines don't have an option to set a sampleMask parameter, the only way to get that functionality is to set the sample_mask output of the fragment shader to this value directly. We also need to take care to combine the fixed sample mask with the one that the shader might possibly output.
2020-07-22 16:37:17 +00:00
needs_subgroup_invocation_id || need_sample_mask)
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
{
bool has_frag_coord = false;
MSL: Handle the SamplePosition builtin. This is somewhat tricky, because in MSL this value is obtained through a function, `get_sample_position()`. Since the call expression is an rvalue, it can't be passed by reference, so functions get a copy instead. This was the last piece preventing us from turning on sample-rate shading support in MoltenVK.
2018-09-12 19:05:52 +00:00
bool has_sample_id = false;
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
bool has_vertex_idx = false;
bool has_base_vertex = false;
bool has_instance_idx = false;
bool has_base_instance = false;
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
bool has_invocation_id = false;
bool has_primitive_id = false;
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
bool has_subgroup_invocation_id = false;
bool has_subgroup_size = false;
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
bool has_view_idx = false;
MSL: Support layered input attachments. These need to use arrayed texture types, or Metal will complain when binding the resource. The target layer is addressed relative to the Layer output by the vertex pipeline, or to the ViewIndex if in a multiview pipeline. Unlike with the s/t coordinates, Vulkan does not forbid non-zero layer coordinates here, though this cannot be expressed in Vulkan GLSL. Supporting 3D textures will require additional work. Part of the problem is that Metal does not allow texture views to subset a 3D texture, so we need some way to pass the base depth to the shader.
2020-08-28 00:24:20 +00:00
bool has_layer = false;
MSL: Adjust BuiltInWorkgroupId for vkCmdDispatchBase(). This command allows the caller to set the base value of `BuiltInWorkgroupId`, and thus of `BuiltInGlobalInvocationId`. Metal provides no direct support for this... but it does provide a builtin, `[[grid_origin]]`, normally used to pass the base values for the stage input region, which we will now abuse to pass the dispatch base and avoid burning a buffer binding. `[[grid_origin]]`, as part of Metal's support for compute stage input, requires MSL 1.2. For 1.0 and 1.1, we're forced to provide a buffer. (Curiously, this builtin was undocumented until the MSL 2.2 release. Go figure.)
2019-07-22 18:08:04 +00:00
uint32_t workgroup_id_type = 0;
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
Enabling setting a fixed sampleMask in Metal fragment shaders. In Metal render pipelines don't have an option to set a sampleMask parameter, the only way to get that functionality is to set the sample_mask output of the fragment shader to this value directly. We also need to take care to combine the fixed sample mask with the one that the shader might possibly output.
2020-07-22 16:37:17 +00:00
// FIXME: Investigate the fact that there are no checks for the entry point interface variables.
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
ir.for_each_typed_id<SPIRVariable>([&](uint32_t, SPIRVariable &var) {
Enabling setting a fixed sampleMask in Metal fragment shaders. In Metal render pipelines don't have an option to set a sampleMask parameter, the only way to get that functionality is to set the sample_mask output of the fragment shader to this value directly. We also need to take care to combine the fixed sample mask with the one that the shader might possibly output.
2020-07-22 16:37:17 +00:00
if (!ir.meta[var.self].decoration.builtin)
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
return;
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
// Use Metal's native frame-buffer fetch API for subpass inputs.
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
BuiltIn builtin = ir.meta[var.self].decoration.builtin_type;
Enabling setting a fixed sampleMask in Metal fragment shaders. In Metal render pipelines don't have an option to set a sampleMask parameter, the only way to get that functionality is to set the sample_mask output of the fragment shader to this value directly. We also need to take care to combine the fixed sample mask with the one that the shader might possibly output.
2020-07-22 16:37:17 +00:00
if (var.storage == StorageClassOutput)
{
if (need_sample_mask && builtin == BuiltInSampleMask)
{
builtin_sample_mask_id = var.self;
mark_implicit_builtin(StorageClassOutput, BuiltInSampleMask, var.self);
does_shader_write_sample_mask = true;
}
}
if (var.storage != StorageClassInput)
return;
MSL: Support layered input attachments. These need to use arrayed texture types, or Metal will complain when binding the resource. The target layer is addressed relative to the Layer output by the vertex pipeline, or to the ViewIndex if in a multiview pipeline. Unlike with the s/t coordinates, Vulkan does not forbid non-zero layer coordinates here, though this cannot be expressed in Vulkan GLSL. Supporting 3D textures will require additional work. Part of the problem is that Metal does not allow texture views to subset a 3D texture, so we need some way to pass the base depth to the shader.
2020-08-28 00:24:20 +00:00
if (need_subpass_input && (!msl_options.is_ios() || !msl_options.ios_use_framebuffer_fetch_subpasses))
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
{
MSL: Support layered input attachments. These need to use arrayed texture types, or Metal will complain when binding the resource. The target layer is addressed relative to the Layer output by the vertex pipeline, or to the ViewIndex if in a multiview pipeline. Unlike with the s/t coordinates, Vulkan does not forbid non-zero layer coordinates here, though this cannot be expressed in Vulkan GLSL. Supporting 3D textures will require additional work. Part of the problem is that Metal does not allow texture views to subset a 3D texture, so we need some way to pass the base depth to the shader.
2020-08-28 00:24:20 +00:00
switch (builtin)
{
case BuiltInFragCoord:
mark_implicit_builtin(StorageClassInput, BuiltInFragCoord, var.self);
builtin_frag_coord_id = var.self;
has_frag_coord = true;
break;
case BuiltInLayer:
if (!msl_options.arrayed_subpass_input || msl_options.multiview)
break;
mark_implicit_builtin(StorageClassInput, BuiltInLayer, var.self);
builtin_layer_id = var.self;
has_layer = true;
break;
case BuiltInViewIndex:
if (!msl_options.multiview)
break;
mark_implicit_builtin(StorageClassInput, BuiltInViewIndex, var.self);
builtin_view_idx_id = var.self;
has_view_idx = true;
break;
default:
break;
}
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
}
MSL: Handle the SamplePosition builtin. This is somewhat tricky, because in MSL this value is obtained through a function, `get_sample_position()`. Since the call expression is an rvalue, it can't be passed by reference, so functions get a copy instead. This was the last piece preventing us from turning on sample-rate shading support in MoltenVK.
2018-09-12 19:05:52 +00:00
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
if (need_sample_pos && builtin == BuiltInSampleId)
MSL: Handle the SamplePosition builtin. This is somewhat tricky, because in MSL this value is obtained through a function, `get_sample_position()`. Since the call expression is an rvalue, it can't be passed by reference, so functions get a copy instead. This was the last piece preventing us from turning on sample-rate shading support in MoltenVK.
2018-09-12 19:05:52 +00:00
{
builtin_sample_id_id = var.self;
MSL: Deal with cases where builtin is implicitly needed, declared, but unused. We need to make sure any builtins which are declared and unused are emitted as active variables.
2020-04-03 10:50:21 +00:00
mark_implicit_builtin(StorageClassInput, BuiltInSampleId, var.self);
MSL: Handle the SamplePosition builtin. This is somewhat tricky, because in MSL this value is obtained through a function, `get_sample_position()`. Since the call expression is an rvalue, it can't be passed by reference, so functions get a copy instead. This was the last piece preventing us from turning on sample-rate shading support in MoltenVK.
2018-09-12 19:05:52 +00:00
has_sample_id = true;
}
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
if (need_vertex_params)
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
{
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
switch (builtin)
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
{
case BuiltInVertexIndex:
builtin_vertex_idx_id = var.self;
MSL: Deal with cases where builtin is implicitly needed, declared, but unused. We need to make sure any builtins which are declared and unused are emitted as active variables.
2020-04-03 10:50:21 +00:00
mark_implicit_builtin(StorageClassInput, BuiltInVertexIndex, var.self);
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
has_vertex_idx = true;
break;
case BuiltInBaseVertex:
builtin_base_vertex_id = var.self;
MSL: Deal with cases where builtin is implicitly needed, declared, but unused. We need to make sure any builtins which are declared and unused are emitted as active variables.
2020-04-03 10:50:21 +00:00
mark_implicit_builtin(StorageClassInput, BuiltInBaseVertex, var.self);
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
has_base_vertex = true;
break;
case BuiltInInstanceIndex:
builtin_instance_idx_id = var.self;
MSL: Deal with cases where builtin is implicitly needed, declared, but unused. We need to make sure any builtins which are declared and unused are emitted as active variables.
2020-04-03 10:50:21 +00:00
mark_implicit_builtin(StorageClassInput, BuiltInInstanceIndex, var.self);
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
has_instance_idx = true;
break;
case BuiltInBaseInstance:
builtin_base_instance_id = var.self;
MSL: Deal with cases where builtin is implicitly needed, declared, but unused. We need to make sure any builtins which are declared and unused are emitted as active variables.
2020-04-03 10:50:21 +00:00
mark_implicit_builtin(StorageClassInput, BuiltInBaseInstance, var.self);
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
has_base_instance = true;
break;
default:
break;
}
}
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
if (need_tesc_params)
{
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
switch (builtin)
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
{
case BuiltInInvocationId:
builtin_invocation_id_id = var.self;
MSL: Deal with cases where builtin is implicitly needed, declared, but unused. We need to make sure any builtins which are declared and unused are emitted as active variables.
2020-04-03 10:50:21 +00:00
mark_implicit_builtin(StorageClassInput, BuiltInInvocationId, var.self);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
has_invocation_id = true;
break;
case BuiltInPrimitiveId:
builtin_primitive_id_id = var.self;
MSL: Deal with cases where builtin is implicitly needed, declared, but unused. We need to make sure any builtins which are declared and unused are emitted as active variables.
2020-04-03 10:50:21 +00:00
mark_implicit_builtin(StorageClassInput, BuiltInPrimitiveId, var.self);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
has_primitive_id = true;
break;
default:
break;
}
}
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
if ((need_subgroup_mask || needs_subgroup_invocation_id) && builtin == BuiltInSubgroupLocalInvocationId)
{
builtin_subgroup_invocation_id_id = var.self;
MSL: Deal with cases where builtin is implicitly needed, declared, but unused. We need to make sure any builtins which are declared and unused are emitted as active variables.
2020-04-03 10:50:21 +00:00
mark_implicit_builtin(StorageClassInput, BuiltInSubgroupLocalInvocationId, var.self);
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
has_subgroup_invocation_id = true;
}
if (need_subgroup_ge_mask && builtin == BuiltInSubgroupSize)
{
builtin_subgroup_size_id = var.self;
MSL: Deal with cases where builtin is implicitly needed, declared, but unused. We need to make sure any builtins which are declared and unused are emitted as active variables.
2020-04-03 10:50:21 +00:00
mark_implicit_builtin(StorageClassInput, BuiltInSubgroupSize, var.self);
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
has_subgroup_size = true;
}
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
if (need_multiview)
{
Fixed false-positive optimization of builtin variables (may happen when 'spvOut' is emitted).
2019-09-19 18:44:30 +00:00
switch (builtin)
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
{
Fixed false-positive optimization of builtin variables (may happen when 'spvOut' is emitted).
2019-09-19 18:44:30 +00:00
case BuiltInInstanceIndex:
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
// The view index here is derived from the instance index.
builtin_instance_idx_id = var.self;
MSL: Deal with cases where builtin is implicitly needed, declared, but unused. We need to make sure any builtins which are declared and unused are emitted as active variables.
2020-04-03 10:50:21 +00:00
mark_implicit_builtin(StorageClassInput, BuiltInInstanceIndex, var.self);
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
has_instance_idx = true;
Fixed false-positive optimization of builtin variables (may happen when 'spvOut' is emitted).
2019-09-19 18:44:30 +00:00
break;
MSL: Fix multiview view index calculation with a non-zero base instance. Account for a non-zero base instance when calculating the view index and the "real" instance index. Before, it was likely broken with a non-zero base instance, since the calculated instance index could be less than the base instance.
2020-08-07 22:46:28 +00:00
case BuiltInBaseInstance:
// If a non-zero base instance is used, we need to adjust for it when calculating the view index.
builtin_base_instance_id = var.self;
mark_implicit_builtin(StorageClassInput, BuiltInBaseInstance, var.self);
has_base_instance = true;
break;
Fixed false-positive optimization of builtin variables (may happen when 'spvOut' is emitted).
2019-09-19 18:44:30 +00:00
case BuiltInViewIndex:
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
builtin_view_idx_id = var.self;
MSL: Deal with cases where builtin is implicitly needed, declared, but unused. We need to make sure any builtins which are declared and unused are emitted as active variables.
2020-04-03 10:50:21 +00:00
mark_implicit_builtin(StorageClassInput, BuiltInViewIndex, var.self);
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
has_view_idx = true;
Fixed false-positive optimization of builtin variables (may happen when 'spvOut' is emitted).
2019-09-19 18:44:30 +00:00
break;
default:
break;
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
}
}
MSL: Adjust BuiltInWorkgroupId for vkCmdDispatchBase(). This command allows the caller to set the base value of `BuiltInWorkgroupId`, and thus of `BuiltInGlobalInvocationId`. Metal provides no direct support for this... but it does provide a builtin, `[[grid_origin]]`, normally used to pass the base values for the stage input region, which we will now abuse to pass the dispatch base and avoid burning a buffer binding. `[[grid_origin]]`, as part of Metal's support for compute stage input, requires MSL 1.2. For 1.0 and 1.1, we're forced to provide a buffer. (Curiously, this builtin was undocumented until the MSL 2.2 release. Go figure.)
2019-07-22 18:08:04 +00:00
// The base workgroup needs to have the same type and vector size
// as the workgroup or invocation ID, so keep track of the type that
// was used.
if (need_dispatch_base && workgroup_id_type == 0 &&
(builtin == BuiltInWorkgroupId || builtin == BuiltInGlobalInvocationId))
workgroup_id_type = var.basetype;
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
});
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Use Metal's native frame-buffer fetch API for subpass inputs.
MSL: Support layered input attachments. These need to use arrayed texture types, or Metal will complain when binding the resource. The target layer is addressed relative to the Layer output by the vertex pipeline, or to the ViewIndex if in a multiview pipeline. Unlike with the s/t coordinates, Vulkan does not forbid non-zero layer coordinates here, though this cannot be expressed in Vulkan GLSL. Supporting 3D textures will require additional work. Part of the problem is that Metal does not allow texture views to subset a 3D texture, so we need some way to pass the base depth to the shader.
2020-08-28 00:24:20 +00:00
if ((!has_frag_coord || (msl_options.multiview && !has_view_idx) ||
(msl_options.arrayed_subpass_input && !msl_options.multiview && !has_layer)) &&
(!msl_options.is_ios() || !msl_options.ios_use_framebuffer_fetch_subpasses) && need_subpass_input)
{
if (!has_frag_coord)
{
uint32_t offset = ir.increase_bound_by(3);
uint32_t type_id = offset;
uint32_t type_ptr_id = offset + 1;
uint32_t var_id = offset + 2;
// Create gl_FragCoord.
SPIRType vec4_type;
vec4_type.basetype = SPIRType::Float;
vec4_type.width = 32;
vec4_type.vecsize = 4;
set<SPIRType>(type_id, vec4_type);
SPIRType vec4_type_ptr;
vec4_type_ptr = vec4_type;
vec4_type_ptr.pointer = true;
vec4_type_ptr.parent_type = type_id;
vec4_type_ptr.storage = StorageClassInput;
auto &ptr_type = set<SPIRType>(type_ptr_id, vec4_type_ptr);
ptr_type.self = type_id;
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
MSL: Support layered input attachments. These need to use arrayed texture types, or Metal will complain when binding the resource. The target layer is addressed relative to the Layer output by the vertex pipeline, or to the ViewIndex if in a multiview pipeline. Unlike with the s/t coordinates, Vulkan does not forbid non-zero layer coordinates here, though this cannot be expressed in Vulkan GLSL. Supporting 3D textures will require additional work. Part of the problem is that Metal does not allow texture views to subset a 3D texture, so we need some way to pass the base depth to the shader.
2020-08-28 00:24:20 +00:00
set<SPIRVariable>(var_id, type_ptr_id, StorageClassInput);
set_decoration(var_id, DecorationBuiltIn, BuiltInFragCoord);
builtin_frag_coord_id = var_id;
mark_implicit_builtin(StorageClassInput, BuiltInFragCoord, var_id);
}
if (!has_layer && msl_options.arrayed_subpass_input && !msl_options.multiview)
{
uint32_t offset = ir.increase_bound_by(2);
uint32_t type_ptr_id = offset;
uint32_t var_id = offset + 1;
// Create gl_Layer.
SPIRType uint_type_ptr;
uint_type_ptr = get_uint_type();
uint_type_ptr.pointer = true;
uint_type_ptr.parent_type = get_uint_type_id();
uint_type_ptr.storage = StorageClassInput;
auto &ptr_type = set<SPIRType>(type_ptr_id, uint_type_ptr);
ptr_type.self = get_uint_type_id();
set<SPIRVariable>(var_id, type_ptr_id, StorageClassInput);
set_decoration(var_id, DecorationBuiltIn, BuiltInLayer);
builtin_layer_id = var_id;
mark_implicit_builtin(StorageClassInput, BuiltInLayer, var_id);
}
if (!has_view_idx && msl_options.multiview)
{
uint32_t offset = ir.increase_bound_by(2);
uint32_t type_ptr_id = offset;
uint32_t var_id = offset + 1;
// Create gl_ViewIndex.
SPIRType uint_type_ptr;
uint_type_ptr = get_uint_type();
uint_type_ptr.pointer = true;
uint_type_ptr.parent_type = get_uint_type_id();
uint_type_ptr.storage = StorageClassInput;
auto &ptr_type = set<SPIRType>(type_ptr_id, uint_type_ptr);
ptr_type.self = get_uint_type_id();
set<SPIRVariable>(var_id, type_ptr_id, StorageClassInput);
set_decoration(var_id, DecorationBuiltIn, BuiltInViewIndex);
builtin_view_idx_id = var_id;
mark_implicit_builtin(StorageClassInput, BuiltInViewIndex, var_id);
}
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
}
MSL: Handle the SamplePosition builtin. This is somewhat tricky, because in MSL this value is obtained through a function, `get_sample_position()`. Since the call expression is an rvalue, it can't be passed by reference, so functions get a copy instead. This was the last piece preventing us from turning on sample-rate shading support in MoltenVK.
2018-09-12 19:05:52 +00:00
if (!has_sample_id && need_sample_pos)
{
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint32_t offset = ir.increase_bound_by(2);
uint32_t type_ptr_id = offset;
uint32_t var_id = offset + 1;
MSL: Handle the SamplePosition builtin. This is somewhat tricky, because in MSL this value is obtained through a function, `get_sample_position()`. Since the call expression is an rvalue, it can't be passed by reference, so functions get a copy instead. This was the last piece preventing us from turning on sample-rate shading support in MoltenVK.
2018-09-12 19:05:52 +00:00
// Create gl_SampleID.
SPIRType uint_type_ptr;
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint_type_ptr = get_uint_type();
MSL: Handle the SamplePosition builtin. This is somewhat tricky, because in MSL this value is obtained through a function, `get_sample_position()`. Since the call expression is an rvalue, it can't be passed by reference, so functions get a copy instead. This was the last piece preventing us from turning on sample-rate shading support in MoltenVK.
2018-09-12 19:05:52 +00:00
uint_type_ptr.pointer = true;
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint_type_ptr.parent_type = get_uint_type_id();
MSL: Handle the SamplePosition builtin. This is somewhat tricky, because in MSL this value is obtained through a function, `get_sample_position()`. Since the call expression is an rvalue, it can't be passed by reference, so functions get a copy instead. This was the last piece preventing us from turning on sample-rate shading support in MoltenVK.
2018-09-12 19:05:52 +00:00
uint_type_ptr.storage = StorageClassInput;
auto &ptr_type = set<SPIRType>(type_ptr_id, uint_type_ptr);
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
ptr_type.self = get_uint_type_id();
MSL: Handle the SamplePosition builtin. This is somewhat tricky, because in MSL this value is obtained through a function, `get_sample_position()`. Since the call expression is an rvalue, it can't be passed by reference, so functions get a copy instead. This was the last piece preventing us from turning on sample-rate shading support in MoltenVK.
2018-09-12 19:05:52 +00:00
set<SPIRVariable>(var_id, type_ptr_id, StorageClassInput);
set_decoration(var_id, DecorationBuiltIn, BuiltInSampleId);
builtin_sample_id_id = var_id;
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
mark_implicit_builtin(StorageClassInput, BuiltInSampleId, var_id);
MSL: Handle the SamplePosition builtin. This is somewhat tricky, because in MSL this value is obtained through a function, `get_sample_position()`. Since the call expression is an rvalue, it can't be passed by reference, so functions get a copy instead. This was the last piece preventing us from turning on sample-rate shading support in MoltenVK.
2018-09-12 19:05:52 +00:00
}
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
if ((need_vertex_params && (!has_vertex_idx || !has_base_vertex || !has_instance_idx || !has_base_instance)) ||
MSL: Fix multiview view index calculation with a non-zero base instance. Account for a non-zero base instance when calculating the view index and the "real" instance index. Before, it was likely broken with a non-zero base instance, since the calculated instance index could be less than the base instance.
2020-08-07 22:46:28 +00:00
(need_multiview && (!has_instance_idx || !has_base_instance || !has_view_idx)))
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
{
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint32_t type_ptr_id = ir.increase_bound_by(1);
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
SPIRType uint_type_ptr;
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint_type_ptr = get_uint_type();
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
uint_type_ptr.pointer = true;
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint_type_ptr.parent_type = get_uint_type_id();
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
uint_type_ptr.storage = StorageClassInput;
auto &ptr_type = set<SPIRType>(type_ptr_id, uint_type_ptr);
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
ptr_type.self = get_uint_type_id();
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
if (need_vertex_params && !has_vertex_idx)
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
{
uint32_t var_id = ir.increase_bound_by(1);
// Create gl_VertexIndex.
set<SPIRVariable>(var_id, type_ptr_id, StorageClassInput);
set_decoration(var_id, DecorationBuiltIn, BuiltInVertexIndex);
builtin_vertex_idx_id = var_id;
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
mark_implicit_builtin(StorageClassInput, BuiltInVertexIndex, var_id);
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
}
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
if (need_vertex_params && !has_base_vertex)
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
{
uint32_t var_id = ir.increase_bound_by(1);
// Create gl_BaseVertex.
set<SPIRVariable>(var_id, type_ptr_id, StorageClassInput);
set_decoration(var_id, DecorationBuiltIn, BuiltInBaseVertex);
builtin_base_vertex_id = var_id;
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
mark_implicit_builtin(StorageClassInput, BuiltInBaseVertex, var_id);
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
}
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
if (!has_instance_idx) // Needed by both multiview and tessellation
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
{
uint32_t var_id = ir.increase_bound_by(1);
// Create gl_InstanceIndex.
set<SPIRVariable>(var_id, type_ptr_id, StorageClassInput);
set_decoration(var_id, DecorationBuiltIn, BuiltInInstanceIndex);
builtin_instance_idx_id = var_id;
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
mark_implicit_builtin(StorageClassInput, BuiltInInstanceIndex, var_id);
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
}
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
MSL: Fix multiview view index calculation with a non-zero base instance. Account for a non-zero base instance when calculating the view index and the "real" instance index. Before, it was likely broken with a non-zero base instance, since the calculated instance index could be less than the base instance.
2020-08-07 22:46:28 +00:00
if (!has_base_instance) // Needed by both multiview and tessellation
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
{
uint32_t var_id = ir.increase_bound_by(1);
// Create gl_BaseInstance.
set<SPIRVariable>(var_id, type_ptr_id, StorageClassInput);
set_decoration(var_id, DecorationBuiltIn, BuiltInBaseInstance);
builtin_base_instance_id = var_id;
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
mark_implicit_builtin(StorageClassInput, BuiltInBaseInstance, var_id);
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
}
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
Support the SPV_KHR_device_group extension. The only piece added by this extension is the `DeviceIndex` builtin, which tells the shader which device in a grouped logical device it is running on. Metal's pipeline state objects are owned by the `MTLDevice` that created them. Since Metal doesn't support logical grouping of devices the way Vulkan does, we'll thus have to create a pipeline state for each device in a grouped logical device. The upcoming peer group support in Metal 3 will not change this. For this reason, for Metal, the device index is supplied as a constant at pipeline compile time. There's an interaction between `VK_KHR_device_group` and `VK_KHR_multiview` in the `VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT`, which defines the view index to be the same as the device index. The new `view_index_from_device_index` MSL option supports this functionality.
2019-07-13 02:50:50 +00:00
if (need_multiview)
{
// Multiview shaders are not allowed to write to gl_Layer, ostensibly because
// it is implicitly written from gl_ViewIndex, but we have to do that explicitly.
// Note that we can't just abuse gl_ViewIndex for this purpose: it's an input, but
// gl_Layer is an output in vertex-pipeline shaders.
uint32_t type_ptr_out_id = ir.increase_bound_by(2);
SPIRType uint_type_ptr_out;
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint_type_ptr_out = get_uint_type();
Support the SPV_KHR_device_group extension. The only piece added by this extension is the `DeviceIndex` builtin, which tells the shader which device in a grouped logical device it is running on. Metal's pipeline state objects are owned by the `MTLDevice` that created them. Since Metal doesn't support logical grouping of devices the way Vulkan does, we'll thus have to create a pipeline state for each device in a grouped logical device. The upcoming peer group support in Metal 3 will not change this. For this reason, for Metal, the device index is supplied as a constant at pipeline compile time. There's an interaction between `VK_KHR_device_group` and `VK_KHR_multiview` in the `VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT`, which defines the view index to be the same as the device index. The new `view_index_from_device_index` MSL option supports this functionality.
2019-07-13 02:50:50 +00:00
uint_type_ptr_out.pointer = true;
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint_type_ptr_out.parent_type = get_uint_type_id();
Support the SPV_KHR_device_group extension. The only piece added by this extension is the `DeviceIndex` builtin, which tells the shader which device in a grouped logical device it is running on. Metal's pipeline state objects are owned by the `MTLDevice` that created them. Since Metal doesn't support logical grouping of devices the way Vulkan does, we'll thus have to create a pipeline state for each device in a grouped logical device. The upcoming peer group support in Metal 3 will not change this. For this reason, for Metal, the device index is supplied as a constant at pipeline compile time. There's an interaction between `VK_KHR_device_group` and `VK_KHR_multiview` in the `VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT`, which defines the view index to be the same as the device index. The new `view_index_from_device_index` MSL option supports this functionality.
2019-07-13 02:50:50 +00:00
uint_type_ptr_out.storage = StorageClassOutput;
auto &ptr_out_type = set<SPIRType>(type_ptr_out_id, uint_type_ptr_out);
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
ptr_out_type.self = get_uint_type_id();
Support the SPV_KHR_device_group extension. The only piece added by this extension is the `DeviceIndex` builtin, which tells the shader which device in a grouped logical device it is running on. Metal's pipeline state objects are owned by the `MTLDevice` that created them. Since Metal doesn't support logical grouping of devices the way Vulkan does, we'll thus have to create a pipeline state for each device in a grouped logical device. The upcoming peer group support in Metal 3 will not change this. For this reason, for Metal, the device index is supplied as a constant at pipeline compile time. There's an interaction between `VK_KHR_device_group` and `VK_KHR_multiview` in the `VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT`, which defines the view index to be the same as the device index. The new `view_index_from_device_index` MSL option supports this functionality.
2019-07-13 02:50:50 +00:00
uint32_t var_id = type_ptr_out_id + 1;
set<SPIRVariable>(var_id, type_ptr_out_id, StorageClassOutput);
set_decoration(var_id, DecorationBuiltIn, BuiltInLayer);
builtin_layer_id = var_id;
mark_implicit_builtin(StorageClassOutput, BuiltInLayer, var_id);
}
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
if (need_multiview && !has_view_idx)
{
uint32_t var_id = ir.increase_bound_by(1);
// Create gl_ViewIndex.
set<SPIRVariable>(var_id, type_ptr_id, StorageClassInput);
set_decoration(var_id, DecorationBuiltIn, BuiltInViewIndex);
builtin_view_idx_id = var_id;
mark_implicit_builtin(StorageClassInput, BuiltInViewIndex, var_id);
}
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
}
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if ((need_tesc_params && (msl_options.multi_patch_workgroup || !has_invocation_id || !has_primitive_id)) ||
need_grid_params)
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
{
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint32_t type_ptr_id = ir.increase_bound_by(1);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
SPIRType uint_type_ptr;
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint_type_ptr = get_uint_type();
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
uint_type_ptr.pointer = true;
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint_type_ptr.parent_type = get_uint_type_id();
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
uint_type_ptr.storage = StorageClassInput;
auto &ptr_type = set<SPIRType>(type_ptr_id, uint_type_ptr);
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
ptr_type.self = get_uint_type_id();
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (msl_options.multi_patch_workgroup || need_grid_params)
{
uint32_t var_id = ir.increase_bound_by(1);
// Create gl_GlobalInvocationID.
set<SPIRVariable>(var_id, type_ptr_id, StorageClassInput);
set_decoration(var_id, DecorationBuiltIn, BuiltInGlobalInvocationId);
builtin_invocation_id_id = var_id;
mark_implicit_builtin(StorageClassInput, BuiltInGlobalInvocationId, var_id);
}
else if (need_tesc_params && !has_invocation_id)
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
{
uint32_t var_id = ir.increase_bound_by(1);
// Create gl_InvocationID.
set<SPIRVariable>(var_id, type_ptr_id, StorageClassInput);
set_decoration(var_id, DecorationBuiltIn, BuiltInInvocationId);
builtin_invocation_id_id = var_id;
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
mark_implicit_builtin(StorageClassInput, BuiltInInvocationId, var_id);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
}
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (need_tesc_params && !has_primitive_id)
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
{
uint32_t var_id = ir.increase_bound_by(1);
// Create gl_PrimitiveID.
set<SPIRVariable>(var_id, type_ptr_id, StorageClassInput);
set_decoration(var_id, DecorationBuiltIn, BuiltInPrimitiveId);
builtin_primitive_id_id = var_id;
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
mark_implicit_builtin(StorageClassInput, BuiltInPrimitiveId, var_id);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
}
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (need_grid_params)
{
uint32_t var_id = ir.increase_bound_by(1);
set<SPIRVariable>(var_id, build_extended_vector_type(get_uint_type_id(), 3), StorageClassInput);
set_extended_decoration(var_id, SPIRVCrossDecorationBuiltInStageInputSize);
get_entry_point().interface_variables.push_back(var_id);
set_name(var_id, "spvStageInputSize");
builtin_stage_input_size_id = var_id;
}
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
}
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
if (!has_subgroup_invocation_id && (need_subgroup_mask || needs_subgroup_invocation_id))
{
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint32_t offset = ir.increase_bound_by(2);
uint32_t type_ptr_id = offset;
uint32_t var_id = offset + 1;
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
// Create gl_SubgroupInvocationID.
SPIRType uint_type_ptr;
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint_type_ptr = get_uint_type();
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
uint_type_ptr.pointer = true;
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint_type_ptr.parent_type = get_uint_type_id();
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
uint_type_ptr.storage = StorageClassInput;
auto &ptr_type = set<SPIRType>(type_ptr_id, uint_type_ptr);
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
ptr_type.self = get_uint_type_id();
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
set<SPIRVariable>(var_id, type_ptr_id, StorageClassInput);
set_decoration(var_id, DecorationBuiltIn, BuiltInSubgroupLocalInvocationId);
builtin_subgroup_invocation_id_id = var_id;
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
mark_implicit_builtin(StorageClassInput, BuiltInSubgroupLocalInvocationId, var_id);
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
}
if (!has_subgroup_size && need_subgroup_ge_mask)
{
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint32_t offset = ir.increase_bound_by(2);
uint32_t type_ptr_id = offset;
uint32_t var_id = offset + 1;
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
// Create gl_SubgroupSize.
SPIRType uint_type_ptr;
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint_type_ptr = get_uint_type();
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
uint_type_ptr.pointer = true;
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint_type_ptr.parent_type = get_uint_type_id();
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
uint_type_ptr.storage = StorageClassInput;
auto &ptr_type = set<SPIRType>(type_ptr_id, uint_type_ptr);
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
ptr_type.self = get_uint_type_id();
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
set<SPIRVariable>(var_id, type_ptr_id, StorageClassInput);
set_decoration(var_id, DecorationBuiltIn, BuiltInSubgroupSize);
builtin_subgroup_size_id = var_id;
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
mark_implicit_builtin(StorageClassInput, BuiltInSubgroupSize, var_id);
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
}
MSL: Adjust BuiltInWorkgroupId for vkCmdDispatchBase(). This command allows the caller to set the base value of `BuiltInWorkgroupId`, and thus of `BuiltInGlobalInvocationId`. Metal provides no direct support for this... but it does provide a builtin, `[[grid_origin]]`, normally used to pass the base values for the stage input region, which we will now abuse to pass the dispatch base and avoid burning a buffer binding. `[[grid_origin]]`, as part of Metal's support for compute stage input, requires MSL 1.2. For 1.0 and 1.1, we're forced to provide a buffer. (Curiously, this builtin was undocumented until the MSL 2.2 release. Go figure.)
2019-07-22 18:08:04 +00:00
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (need_dispatch_base || need_vertex_base_params)
MSL: Adjust BuiltInWorkgroupId for vkCmdDispatchBase(). This command allows the caller to set the base value of `BuiltInWorkgroupId`, and thus of `BuiltInGlobalInvocationId`. Metal provides no direct support for this... but it does provide a builtin, `[[grid_origin]]`, normally used to pass the base values for the stage input region, which we will now abuse to pass the dispatch base and avoid burning a buffer binding. `[[grid_origin]]`, as part of Metal's support for compute stage input, requires MSL 1.2. For 1.0 and 1.1, we're forced to provide a buffer. (Curiously, this builtin was undocumented until the MSL 2.2 release. Go figure.)
2019-07-22 18:08:04 +00:00
{
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (workgroup_id_type == 0)
workgroup_id_type = build_extended_vector_type(get_uint_type_id(), 3);
MSL: Adjust BuiltInWorkgroupId for vkCmdDispatchBase(). This command allows the caller to set the base value of `BuiltInWorkgroupId`, and thus of `BuiltInGlobalInvocationId`. Metal provides no direct support for this... but it does provide a builtin, `[[grid_origin]]`, normally used to pass the base values for the stage input region, which we will now abuse to pass the dispatch base and avoid burning a buffer binding. `[[grid_origin]]`, as part of Metal's support for compute stage input, requires MSL 1.2. For 1.0 and 1.1, we're forced to provide a buffer. (Curiously, this builtin was undocumented until the MSL 2.2 release. Go figure.)
2019-07-22 18:08:04 +00:00
uint32_t var_id;
if (msl_options.supports_msl_version(1, 2))
{
// If we have MSL 1.2, we can (ab)use the [[grid_origin]] builtin
// to convey this information and save a buffer slot.
uint32_t offset = ir.increase_bound_by(1);
var_id = offset;
set<SPIRVariable>(var_id, workgroup_id_type, StorageClassInput);
set_extended_decoration(var_id, SPIRVCrossDecorationBuiltInDispatchBase);
get_entry_point().interface_variables.push_back(var_id);
}
else
{
// Otherwise, we need to fall back to a good ol' fashioned buffer.
uint32_t offset = ir.increase_bound_by(2);
var_id = offset;
uint32_t type_id = offset + 1;
SPIRType var_type = get<SPIRType>(workgroup_id_type);
var_type.storage = StorageClassUniform;
set<SPIRType>(type_id, var_type);
set<SPIRVariable>(var_id, type_id, StorageClassUniform);
// This should never match anything.
set_decoration(var_id, DecorationDescriptorSet, ~(5u));
set_decoration(var_id, DecorationBinding, msl_options.indirect_params_buffer_index);
set_extended_decoration(var_id, SPIRVCrossDecorationResourceIndexPrimary,
msl_options.indirect_params_buffer_index);
}
set_name(var_id, "spvDispatchBase");
builtin_dispatch_base_id = var_id;
}
Enabling setting a fixed sampleMask in Metal fragment shaders. In Metal render pipelines don't have an option to set a sampleMask parameter, the only way to get that functionality is to set the sample_mask output of the fragment shader to this value directly. We also need to take care to combine the fixed sample mask with the one that the shader might possibly output.
2020-07-22 16:37:17 +00:00
if (need_sample_mask && !does_shader_write_sample_mask)
{
uint32_t offset = ir.increase_bound_by(2);
uint32_t var_id = offset + 1;
// Create gl_SampleMask.
SPIRType uint_type_ptr_out;
uint_type_ptr_out = get_uint_type();
uint_type_ptr_out.pointer = true;
uint_type_ptr_out.parent_type = get_uint_type_id();
uint_type_ptr_out.storage = StorageClassOutput;
Overhaul how we deal with reserved identifiers. - Do not silently drop reserved identifiers in the parser. This makes it possible to reflect identifiers which are reserved by the cross-compiler module. - Instead of dropping the name, emit _RESERVED_IDENTIFIER_FIXUP in the source to make it clear that a name has been rewritten. - Document what is reserved and not.
2020-08-21 14:14:13 +00:00
Enabling setting a fixed sampleMask in Metal fragment shaders. In Metal render pipelines don't have an option to set a sampleMask parameter, the only way to get that functionality is to set the sample_mask output of the fragment shader to this value directly. We also need to take care to combine the fixed sample mask with the one that the shader might possibly output.
2020-07-22 16:37:17 +00:00
auto &ptr_out_type = set<SPIRType>(offset, uint_type_ptr_out);
ptr_out_type.self = get_uint_type_id();
set<SPIRVariable>(var_id, offset, StorageClassOutput);
set_decoration(var_id, DecorationBuiltIn, BuiltInSampleMask);
builtin_sample_mask_id = var_id;
mark_implicit_builtin(StorageClassOutput, BuiltInSampleMask, var_id);
}
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
}
Pass the swizzle constants as a buffer. It'll be useful to have an "auxiliary buffer" for other builtins--e.g. `DrawIndex` (which should be easier to implement now), or `ViewIndex` when someone gets around to implementing multiview. Pass this buffer to leaf functions as well. Test that we handle this for integer textures as well.
2018-09-23 00:36:11 +00:00
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
if (needs_swizzle_buffer_def)
Pass the swizzle constants as a buffer. It'll be useful to have an "auxiliary buffer" for other builtins--e.g. `DrawIndex` (which should be easier to implement now), or `ViewIndex` when someone gets around to implementing multiview. Pass this buffer to leaf functions as well. Test that we handle this for integer textures as well.
2018-09-23 00:36:11 +00:00
{
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
uint32_t var_id = build_constant_uint_array_pointer();
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
set_name(var_id, "spvSwizzleConstants");
Pass the swizzle constants as a buffer. It'll be useful to have an "auxiliary buffer" for other builtins--e.g. `DrawIndex` (which should be easier to implement now), or `ViewIndex` when someone gets around to implementing multiview. Pass this buffer to leaf functions as well. Test that we handle this for integer textures as well.
2018-09-23 00:36:11 +00:00
// This should never match anything.
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
set_decoration(var_id, DecorationDescriptorSet, kSwizzleBufferBinding);
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
set_decoration(var_id, DecorationBinding, msl_options.swizzle_buffer_index);
MSL: Rewrite how resource indices are fallback-assigned. We used to use the Binding decoration for this, but this method is hopelessly broken. If no explicit MSL resource remapping exists, we remap automatically in a manner which should always "just work".
2019-06-21 10:44:33 +00:00
set_extended_decoration(var_id, SPIRVCrossDecorationResourceIndexPrimary, msl_options.swizzle_buffer_index);
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
swizzle_buffer_id = var_id;
Pass the swizzle constants as a buffer. It'll be useful to have an "auxiliary buffer" for other builtins--e.g. `DrawIndex` (which should be easier to implement now), or `ViewIndex` when someone gets around to implementing multiview. Pass this buffer to leaf functions as well. Test that we handle this for integer textures as well.
2018-09-23 00:36:11 +00:00
}
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
if (!buffers_requiring_array_length.empty())
{
uint32_t var_id = build_constant_uint_array_pointer();
set_name(var_id, "spvBufferSizeConstants");
// This should never match anything.
set_decoration(var_id, DecorationDescriptorSet, kBufferSizeBufferBinding);
set_decoration(var_id, DecorationBinding, msl_options.buffer_size_buffer_index);
MSL: Rewrite how resource indices are fallback-assigned. We used to use the Binding decoration for this, but this method is hopelessly broken. If no explicit MSL resource remapping exists, we remap automatically in a manner which should always "just work".
2019-06-21 10:44:33 +00:00
set_extended_decoration(var_id, SPIRVCrossDecorationResourceIndexPrimary, msl_options.buffer_size_buffer_index);
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
buffer_size_buffer_id = var_id;
}
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
if (needs_view_mask_buffer())
{
uint32_t var_id = build_constant_uint_array_pointer();
set_name(var_id, "spvViewMask");
// This should never match anything.
set_decoration(var_id, DecorationDescriptorSet, ~(4u));
set_decoration(var_id, DecorationBinding, msl_options.view_mask_buffer_index);
set_extended_decoration(var_id, SPIRVCrossDecorationResourceIndexPrimary, msl_options.view_mask_buffer_index);
view_mask_buffer_id = var_id;
}
MSL: Support dynamic offsets for buffers in argument buffers. Vulkan has two types of buffer descriptors, `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` and `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC`, which allow the client to offset the buffers by an amount given when the descriptor set is bound to a pipeline. Metal provides no direct support for this when the buffer in question is in an argument buffer, so once again we're on our own. These offsets cannot be stored or associated in any way with the argument buffer itself, because they are set at bind time. Different pipelines may have different offsets set. Therefore, we must use a separate buffer, not in any argument buffer, to hold these offsets. Then the shader must manually offset the buffer pointer. This change fully supports arrays, including arrays of arrays, even though Vulkan forbids them. It does not, however, support runtime arrays. Perhaps later.
2019-09-06 04:14:12 +00:00
if (!buffers_requiring_dynamic_offset.empty())
{
uint32_t var_id = build_constant_uint_array_pointer();
set_name(var_id, "spvDynamicOffsets");
// This should never match anything.
set_decoration(var_id, DecorationDescriptorSet, ~(5u));
set_decoration(var_id, DecorationBinding, msl_options.dynamic_offsets_buffer_index);
set_extended_decoration(var_id, SPIRVCrossDecorationResourceIndexPrimary,
msl_options.dynamic_offsets_buffer_index);
dynamic_offsets_buffer_id = var_id;
}
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
}
Fixed false-positive optimization of builtin variables (may happen when 'spvOut' is emitted).
2019-09-19 18:44:30 +00:00
// Checks if the specified builtin variable (e.g. gl_InstanceIndex) is marked as active.
// If not, it marks it as active and forces a recompilation.
// This might be used when the optimization of inactive builtins was too optimistic (e.g. when "spvOut" is emitted).
void CompilerMSL::ensure_builtin(spv::StorageClass storage, spv::BuiltIn builtin)
{
Bitset *active_builtins = nullptr;
switch (storage)
{
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
case StorageClassInput:
active_builtins = &active_input_builtins;
break;
case StorageClassOutput:
active_builtins = &active_output_builtins;
break;
default:
break;
Fixed false-positive optimization of builtin variables (may happen when 'spvOut' is emitted).
2019-09-19 18:44:30 +00:00
}
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Fixed false-positive optimization of builtin variables (may happen when 'spvOut' is emitted).
2019-09-19 18:44:30 +00:00
// At this point, the specified builtin variable must have already been declared in the entry point.
// If not, mark as active and force recompile.
if (active_builtins != nullptr && !active_builtins->get(builtin))
{
active_builtins->set(builtin);
force_recompile();
}
}
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
void CompilerMSL::mark_implicit_builtin(StorageClass storage, BuiltIn builtin, uint32_t id)
{
Bitset *active_builtins = nullptr;
switch (storage)
{
case StorageClassInput:
active_builtins = &active_input_builtins;
break;
case StorageClassOutput:
active_builtins = &active_output_builtins;
break;
default:
break;
}
assert(active_builtins != nullptr);
active_builtins->set(builtin);
MSL: Deal with cases where builtin is implicitly needed, declared, but unused. We need to make sure any builtins which are declared and unused are emitted as active variables.
2020-04-03 10:50:21 +00:00
auto &var = get_entry_point().interface_variables;
if (find(begin(var), end(var), VariableID(id)) == end(var))
var.push_back(id);
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
}
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
uint32_t CompilerMSL::build_constant_uint_array_pointer()
{
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint32_t offset = ir.increase_bound_by(3);
uint32_t type_ptr_id = offset;
uint32_t type_ptr_ptr_id = offset + 1;
uint32_t var_id = offset + 2;
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
// Create a buffer to hold extra data, including the swizzle constants.
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
SPIRType uint_type_pointer = get_uint_type();
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
uint_type_pointer.pointer = true;
uint_type_pointer.pointer_depth = 1;
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint_type_pointer.parent_type = get_uint_type_id();
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
uint_type_pointer.storage = StorageClassUniform;
set<SPIRType>(type_ptr_id, uint_type_pointer);
set_decoration(type_ptr_id, DecorationArrayStride, 4);
SPIRType uint_type_pointer2 = uint_type_pointer;
uint_type_pointer2.pointer_depth++;
uint_type_pointer2.parent_type = type_ptr_id;
set<SPIRType>(type_ptr_ptr_id, uint_type_pointer2);
set<SPIRVariable>(var_id, type_ptr_ptr_id, StorageClassUniformConstant);
return var_id;
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
}
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
static string create_sampler_address(const char *prefix, MSLSamplerAddress addr)
{
switch (addr)
{
case MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE:
return join(prefix, "address::clamp_to_edge");
case MSL_SAMPLER_ADDRESS_CLAMP_TO_ZERO:
return join(prefix, "address::clamp_to_zero");
case MSL_SAMPLER_ADDRESS_CLAMP_TO_BORDER:
return join(prefix, "address::clamp_to_border");
case MSL_SAMPLER_ADDRESS_REPEAT:
return join(prefix, "address::repeat");
case MSL_SAMPLER_ADDRESS_MIRRORED_REPEAT:
return join(prefix, "address::mirrored_repeat");
default:
SPIRV_CROSS_THROW("Invalid sampler addressing mode.");
}
}
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
SPIRType &CompilerMSL::get_stage_in_struct_type()
{
auto &si_var = get<SPIRVariable>(stage_in_var_id);
return get_variable_data_type(si_var);
}
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
SPIRType &CompilerMSL::get_stage_out_struct_type()
{
auto &so_var = get<SPIRVariable>(stage_out_var_id);
return get_variable_data_type(so_var);
}
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
SPIRType &CompilerMSL::get_patch_stage_in_struct_type()
{
auto &si_var = get<SPIRVariable>(patch_stage_in_var_id);
return get_variable_data_type(si_var);
}
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
SPIRType &CompilerMSL::get_patch_stage_out_struct_type()
{
auto &so_var = get<SPIRVariable>(patch_stage_out_var_id);
return get_variable_data_type(so_var);
}
std::string CompilerMSL::get_tess_factor_struct_name()
{
if (get_entry_point().flags.get(ExecutionModeTriangles))
return "MTLTriangleTessellationFactorsHalf";
return "MTLQuadTessellationFactorsHalf";
}
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
SPIRType &CompilerMSL::get_uint_type()
{
return get<SPIRType>(get_uint_type_id());
}
uint32_t CompilerMSL::get_uint_type_id()
{
if (uint_type_id != 0)
return uint_type_id;
uint_type_id = ir.increase_bound_by(1);
SPIRType type;
type.basetype = SPIRType::UInt;
type.width = 32;
set<SPIRType>(uint_type_id, type);
return uint_type_id;
}
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
void CompilerMSL::emit_entry_point_declarations()
{
Complete MSL constexpr samplers. Deal with defaults and avoid verbose declarations.
2018-04-18 14:19:55 +00:00
// FIXME: Get test coverage here ...
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries
In order to use Metal shader libraries properly you have to ensure that you have no duplicated global symbol names for different entities, otherwise 'metallib' won't be able to combine multiple shaders into a single library. This is broken into two parts. 1. Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries. 2. Metal helper functions must be static force-inline otherwise they will cause problems when linked together in a single Metallib.
2019-08-13 22:20:02 +00:00
declare_complex_constant_arrays();
Complete MSL constexpr samplers. Deal with defaults and avoid verbose declarations.
2018-04-18 14:19:55 +00:00
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
// Emit constexpr samplers here.
MSL: Support remapping constexpr samplers by set/binding. Older API was oriented around IDs which are not available unless you're doing full reflection, which is awkward for certain use cases which know their set/bindings up front. Optimize resource bindings to be hashmap rather than doing linear seeks all the time.
2019-06-10 13:41:36 +00:00
for (auto &samp : constexpr_samplers_by_id)
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
{
auto &var = get<SPIRVariable>(samp.first);
auto &type = get<SPIRType>(var.basetype);
if (type.basetype == SPIRType::Sampler)
add_resource_name(samp.first);
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
SmallVector<string> args;
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
auto &s = samp.second;
Complete MSL constexpr samplers. Deal with defaults and avoid verbose declarations.
2018-04-18 14:19:55 +00:00
if (s.coord != MSL_SAMPLER_COORD_NORMALIZED)
args.push_back("coord::pixel");
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
if (s.min_filter == s.mag_filter)
Complete MSL constexpr samplers. Deal with defaults and avoid verbose declarations.
2018-04-18 14:19:55 +00:00
{
if (s.min_filter != MSL_SAMPLER_FILTER_NEAREST)
args.push_back("filter::linear");
}
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
else
{
Complete MSL constexpr samplers. Deal with defaults and avoid verbose declarations.
2018-04-18 14:19:55 +00:00
if (s.min_filter != MSL_SAMPLER_FILTER_NEAREST)
args.push_back("min_filter::linear");
if (s.mag_filter != MSL_SAMPLER_FILTER_NEAREST)
args.push_back("mag_filter::linear");
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
}
switch (s.mip_filter)
{
case MSL_SAMPLER_MIP_FILTER_NONE:
Complete MSL constexpr samplers. Deal with defaults and avoid verbose declarations.
2018-04-18 14:19:55 +00:00
// Default
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
break;
case MSL_SAMPLER_MIP_FILTER_NEAREST:
args.push_back("mip_filter::nearest");
break;
case MSL_SAMPLER_MIP_FILTER_LINEAR:
args.push_back("mip_filter::linear");
break;
default:
SPIRV_CROSS_THROW("Invalid mip filter.");
}
if (s.s_address == s.t_address && s.s_address == s.r_address)
Complete MSL constexpr samplers. Deal with defaults and avoid verbose declarations.
2018-04-18 14:19:55 +00:00
{
if (s.s_address != MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE)
args.push_back(create_sampler_address("", s.s_address));
}
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
else
{
Complete MSL constexpr samplers. Deal with defaults and avoid verbose declarations.
2018-04-18 14:19:55 +00:00
if (s.s_address != MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE)
args.push_back(create_sampler_address("s_", s.s_address));
if (s.t_address != MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE)
args.push_back(create_sampler_address("t_", s.t_address));
if (s.r_address != MSL_SAMPLER_ADDRESS_CLAMP_TO_EDGE)
args.push_back(create_sampler_address("r_", s.r_address));
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
}
if (s.compare_enable)
{
switch (s.compare_func)
{
Complete MSL constexpr samplers. Deal with defaults and avoid verbose declarations.
2018-04-18 14:19:55 +00:00
case MSL_SAMPLER_COMPARE_FUNC_ALWAYS:
args.push_back("compare_func::always");
break;
case MSL_SAMPLER_COMPARE_FUNC_NEVER:
args.push_back("compare_func::never");
break;
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
case MSL_SAMPLER_COMPARE_FUNC_EQUAL:
args.push_back("compare_func::equal");
break;
case MSL_SAMPLER_COMPARE_FUNC_NOT_EQUAL:
args.push_back("compare_func::not_equal");
break;
case MSL_SAMPLER_COMPARE_FUNC_LESS:
args.push_back("compare_func::less");
break;
case MSL_SAMPLER_COMPARE_FUNC_LESS_EQUAL:
args.push_back("compare_func::less_equal");
break;
case MSL_SAMPLER_COMPARE_FUNC_GREATER:
args.push_back("compare_func::greater");
break;
case MSL_SAMPLER_COMPARE_FUNC_GREATER_EQUAL:
args.push_back("compare_func::greater_equal");
break;
default:
SPIRV_CROSS_THROW("Invalid sampler compare function.");
}
}
if (s.s_address == MSL_SAMPLER_ADDRESS_CLAMP_TO_BORDER || s.t_address == MSL_SAMPLER_ADDRESS_CLAMP_TO_BORDER ||
s.r_address == MSL_SAMPLER_ADDRESS_CLAMP_TO_BORDER)
{
switch (s.border_color)
{
case MSL_SAMPLER_BORDER_COLOR_OPAQUE_BLACK:
args.push_back("border_color::opaque_black");
break;
case MSL_SAMPLER_BORDER_COLOR_OPAQUE_WHITE:
args.push_back("border_color::opaque_white");
break;
case MSL_SAMPLER_BORDER_COLOR_TRANSPARENT_BLACK:
args.push_back("border_color::transparent_black");
break;
default:
SPIRV_CROSS_THROW("Invalid sampler border color.");
}
}
if (s.anisotropy_enable)
args.push_back(join("max_anisotropy(", s.max_anisotropy, ")"));
if (s.lod_clamp_enable)
Use convert_to_string for lod clamp.
2018-04-18 14:31:08 +00:00
{
Replace locale handling. We were using std::locale::global() to force a C locale which is not safe when SPIRV-Cross is used in a multi-threaded environment. To fix this, we could tap into various per-platform specific locale handling to get safe thread-local locales, but since locales only affect the decimal point in floats, we simply query the locale instead and do the necessary radix replacement ourselves, without touching the locale. This should be much safer and cleaner than the alternative.
2019-02-28 10:26:26 +00:00
args.push_back(join("lod_clamp(", convert_to_string(s.lod_clamp_min, current_locale_radix_character), ", ",
convert_to_string(s.lod_clamp_max, current_locale_radix_character), ")"));
Use convert_to_string for lod clamp.
2018-04-18 14:31:08 +00:00
}
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
// If we would emit no arguments, then omit the parentheses entirely. Otherwise,
// we'll wind up with a "most vexing parse" situation.
if (args.empty())
statement("constexpr sampler ",
type.basetype == SPIRType::SampledImage ? to_sampler_expression(samp.first) : to_name(samp.first),
";");
else
statement("constexpr sampler ",
type.basetype == SPIRType::SampledImage ? to_sampler_expression(samp.first) : to_name(samp.first),
"(", merge(args), ");");
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
}
MSL: Expand arrays of buffers passed as input. Even as of Metal 2.1, MSL still doesn't support arrays of buffers directly. Therefore, we must manually expand them. In the prologue, we define arrays holding the argument pointers; these arrays are what the transpiled code ends up referencing. We might be able to do similar things for textures and samplers prior to MSL 2.0. Speaking of which, also enable texture arrays on iOS MSL 1.2.
2018-09-27 01:06:05 +00:00
MSL: Support dynamic offsets for buffers in argument buffers. Vulkan has two types of buffer descriptors, `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` and `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC`, which allow the client to offset the buffers by an amount given when the descriptor set is bound to a pipeline. Metal provides no direct support for this when the buffer in question is in an argument buffer, so once again we're on our own. These offsets cannot be stored or associated in any way with the argument buffer itself, because they are set at bind time. Different pipelines may have different offsets set. Therefore, we must use a separate buffer, not in any argument buffer, to hold these offsets. Then the shader must manually offset the buffer pointer. This change fully supports arrays, including arrays of arrays, even though Vulkan forbids them. It does not, however, support runtime arrays. Perhaps later.
2019-09-06 04:14:12 +00:00
// Emit dynamic buffers here.
Fix some issues on certain compilers.
2019-09-06 08:11:18 +00:00
for (auto &dynamic_buffer : buffers_requiring_dynamic_offset)
MSL: Support dynamic offsets for buffers in argument buffers. Vulkan has two types of buffer descriptors, `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` and `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC`, which allow the client to offset the buffers by an amount given when the descriptor set is bound to a pipeline. Metal provides no direct support for this when the buffer in question is in an argument buffer, so once again we're on our own. These offsets cannot be stored or associated in any way with the argument buffer itself, because they are set at bind time. Different pipelines may have different offsets set. Therefore, we must use a separate buffer, not in any argument buffer, to hold these offsets. Then the shader must manually offset the buffer pointer. This change fully supports arrays, including arrays of arrays, even though Vulkan forbids them. It does not, however, support runtime arrays. Perhaps later.
2019-09-06 04:14:12 +00:00
{
Fix some issues on certain compilers.
2019-09-06 08:11:18 +00:00
if (!dynamic_buffer.second.second)
{
// Could happen if no buffer was used at requested binding point.
continue;
}
const auto &var = get<SPIRVariable>(dynamic_buffer.second.second);
MSL: Support dynamic offsets for buffers in argument buffers. Vulkan has two types of buffer descriptors, `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` and `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC`, which allow the client to offset the buffers by an amount given when the descriptor set is bound to a pipeline. Metal provides no direct support for this when the buffer in question is in an argument buffer, so once again we're on our own. These offsets cannot be stored or associated in any way with the argument buffer itself, because they are set at bind time. Different pipelines may have different offsets set. Therefore, we must use a separate buffer, not in any argument buffer, to hold these offsets. Then the shader must manually offset the buffer pointer. This change fully supports arrays, including arrays of arrays, even though Vulkan forbids them. It does not, however, support runtime arrays. Perhaps later.
2019-09-06 04:14:12 +00:00
uint32_t var_id = var.self;
const auto &type = get_variable_data_type(var);
string name = to_name(var.self);
uint32_t desc_set = get_decoration(var.self, DecorationDescriptorSet);
uint32_t arg_id = argument_buffer_ids[desc_set];
Fix some issues on certain compilers.
2019-09-06 08:11:18 +00:00
uint32_t base_index = dynamic_buffer.second.first;
MSL: Support dynamic offsets for buffers in argument buffers. Vulkan has two types of buffer descriptors, `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` and `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC`, which allow the client to offset the buffers by an amount given when the descriptor set is bound to a pipeline. Metal provides no direct support for this when the buffer in question is in an argument buffer, so once again we're on our own. These offsets cannot be stored or associated in any way with the argument buffer itself, because they are set at bind time. Different pipelines may have different offsets set. Therefore, we must use a separate buffer, not in any argument buffer, to hold these offsets. Then the shader must manually offset the buffer pointer. This change fully supports arrays, including arrays of arrays, even though Vulkan forbids them. It does not, however, support runtime arrays. Perhaps later.
2019-09-06 04:14:12 +00:00
if (!type.array.empty())
{
// This is complicated, because we need to support arrays of arrays.
// And it's even worse if the outermost dimension is a runtime array, because now
// all this complicated goop has to go into the shader itself. (FIXME)
if (!type.array[type.array.size() - 1])
SPIRV_CROSS_THROW("Runtime arrays with dynamic offsets are not supported yet.");
else
{
MSL: Add a workaround path to force native arrays for everything.
2020-02-24 11:47:14 +00:00
is_using_builtin_array = true;
MSL: Support dynamic offsets for buffers in argument buffers. Vulkan has two types of buffer descriptors, `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` and `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC`, which allow the client to offset the buffers by an amount given when the descriptor set is bound to a pipeline. Metal provides no direct support for this when the buffer in question is in an argument buffer, so once again we're on our own. These offsets cannot be stored or associated in any way with the argument buffer itself, because they are set at bind time. Different pipelines may have different offsets set. Therefore, we must use a separate buffer, not in any argument buffer, to hold these offsets. Then the shader must manually offset the buffer pointer. This change fully supports arrays, including arrays of arrays, even though Vulkan forbids them. It does not, however, support runtime arrays. Perhaps later.
2019-09-06 04:14:12 +00:00
statement(get_argument_address_space(var), " ", type_to_glsl(type), "* ", to_restrict(var_id), name,
type_to_array_glsl(type), " =");
MSL: Do not declare array of UBO/SSBO as spvUnsafeArray<T>. There is no need for these to be copied, and cuts down on template stamping bloat.
2019-10-24 11:57:05 +00:00
MSL: Support dynamic offsets for buffers in argument buffers. Vulkan has two types of buffer descriptors, `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` and `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC`, which allow the client to offset the buffers by an amount given when the descriptor set is bound to a pipeline. Metal provides no direct support for this when the buffer in question is in an argument buffer, so once again we're on our own. These offsets cannot be stored or associated in any way with the argument buffer itself, because they are set at bind time. Different pipelines may have different offsets set. Therefore, we must use a separate buffer, not in any argument buffer, to hold these offsets. Then the shader must manually offset the buffer pointer. This change fully supports arrays, including arrays of arrays, even though Vulkan forbids them. It does not, however, support runtime arrays. Perhaps later.
2019-09-06 04:14:12 +00:00
uint32_t dim = uint32_t(type.array.size());
uint32_t j = 0;
for (SmallVector<uint32_t> indices(type.array.size());
indices[type.array.size() - 1] < to_array_size_literal(type); j++)
{
while (dim > 0)
{
begin_scope();
--dim;
}
string arrays;
for (uint32_t i = uint32_t(type.array.size()); i; --i)
arrays += join("[", indices[i - 1], "]");
Run format_all.sh.
2019-09-06 12:23:16 +00:00
statement("(", get_argument_address_space(var), " ", type_to_glsl(type), "* ",
to_restrict(var_id, false), ")((", get_argument_address_space(var), " char* ",
to_restrict(var_id, false), ")", to_name(arg_id), ".", ensure_valid_name(name, "m"),
arrays, " + ", to_name(dynamic_offsets_buffer_id), "[", base_index + j, "]),");
MSL: Support dynamic offsets for buffers in argument buffers. Vulkan has two types of buffer descriptors, `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` and `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC`, which allow the client to offset the buffers by an amount given when the descriptor set is bound to a pipeline. Metal provides no direct support for this when the buffer in question is in an argument buffer, so once again we're on our own. These offsets cannot be stored or associated in any way with the argument buffer itself, because they are set at bind time. Different pipelines may have different offsets set. Therefore, we must use a separate buffer, not in any argument buffer, to hold these offsets. Then the shader must manually offset the buffer pointer. This change fully supports arrays, including arrays of arrays, even though Vulkan forbids them. It does not, however, support runtime arrays. Perhaps later.
2019-09-06 04:14:12 +00:00
while (++indices[dim] >= to_array_size_literal(type, dim) && dim < type.array.size() - 1)
{
end_scope(",");
indices[dim++] = 0;
}
}
end_scope_decl();
statement_no_indent("");
MSL: Add a workaround path to force native arrays for everything.
2020-02-24 11:47:14 +00:00
is_using_builtin_array = false;
MSL: Support dynamic offsets for buffers in argument buffers. Vulkan has two types of buffer descriptors, `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` and `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC`, which allow the client to offset the buffers by an amount given when the descriptor set is bound to a pipeline. Metal provides no direct support for this when the buffer in question is in an argument buffer, so once again we're on our own. These offsets cannot be stored or associated in any way with the argument buffer itself, because they are set at bind time. Different pipelines may have different offsets set. Therefore, we must use a separate buffer, not in any argument buffer, to hold these offsets. Then the shader must manually offset the buffer pointer. This change fully supports arrays, including arrays of arrays, even though Vulkan forbids them. It does not, however, support runtime arrays. Perhaps later.
2019-09-06 04:14:12 +00:00
}
}
else
{
statement(get_argument_address_space(var), " auto& ", to_restrict(var_id), name, " = *(",
get_argument_address_space(var), " ", type_to_glsl(type), "* ", to_restrict(var_id, false), ")((",
get_argument_address_space(var), " char* ", to_restrict(var_id, false), ")", to_name(arg_id), ".",
ensure_valid_name(name, "m"), " + ", to_name(dynamic_offsets_buffer_id), "[", base_index, "]);");
}
}
MSL: Expand arrays of buffers passed as input. Even as of Metal 2.1, MSL still doesn't support arrays of buffers directly. Therefore, we must manually expand them. In the prologue, we define arrays holding the argument pointers; these arrays are what the transpiled code ends up referencing. We might be able to do similar things for textures and samplers prior to MSL 2.0. Speaking of which, also enable texture arrays on iOS MSL 1.2.
2018-09-27 01:06:05 +00:00
// Emit buffer arrays here.
for (uint32_t array_id : buffer_arrays)
{
const auto &var = get<SPIRVariable>(array_id);
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
const auto &type = get_variable_data_type(var);
MSL: Do not declare array of UBO/SSBO as spvUnsafeArray<T>. There is no need for these to be copied, and cuts down on template stamping bloat.
2019-10-24 11:57:05 +00:00
const auto &buffer_type = get_variable_element_type(var);
MSL: Emit proper name for optimized UBO/SSBO arrays.
2019-02-25 10:09:00 +00:00
string name = to_name(array_id);
Run format_all.sh.
2019-10-28 11:55:14 +00:00
statement(get_argument_address_space(var), " ", type_to_glsl(buffer_type), "* ", to_restrict(array_id), name,
"[] =");
MSL: Expand arrays of buffers passed as input. Even as of Metal 2.1, MSL still doesn't support arrays of buffers directly. Therefore, we must manually expand them. In the prologue, we define arrays holding the argument pointers; these arrays are what the transpiled code ends up referencing. We might be able to do similar things for textures and samplers prior to MSL 2.0. Speaking of which, also enable texture arrays on iOS MSL 1.2.
2018-09-27 01:06:05 +00:00
begin_scope();
MSL: Support dynamic offsets for buffers in argument buffers. Vulkan has two types of buffer descriptors, `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` and `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC`, which allow the client to offset the buffers by an amount given when the descriptor set is bound to a pipeline. Metal provides no direct support for this when the buffer in question is in an argument buffer, so once again we're on our own. These offsets cannot be stored or associated in any way with the argument buffer itself, because they are set at bind time. Different pipelines may have different offsets set. Therefore, we must use a separate buffer, not in any argument buffer, to hold these offsets. Then the shader must manually offset the buffer pointer. This change fully supports arrays, including arrays of arrays, even though Vulkan forbids them. It does not, however, support runtime arrays. Perhaps later.
2019-09-06 04:14:12 +00:00
for (uint32_t i = 0; i < to_array_size_literal(type); ++i)
statement(name, "_", i, ",");
MSL: Expand arrays of buffers passed as input. Even as of Metal 2.1, MSL still doesn't support arrays of buffers directly. Therefore, we must manually expand them. In the prologue, we define arrays holding the argument pointers; these arrays are what the transpiled code ends up referencing. We might be able to do similar things for textures and samplers prior to MSL 2.0. Speaking of which, also enable texture arrays on iOS MSL 1.2.
2018-09-27 01:06:05 +00:00
end_scope_decl();
Update to latest glslang/SPIRV-Tools. Fix various bugs along the way.
2019-01-30 12:31:17 +00:00
statement_no_indent("");
MSL: Expand arrays of buffers passed as input. Even as of Metal 2.1, MSL still doesn't support arrays of buffers directly. Therefore, we must manually expand them. In the prologue, we define arrays holding the argument pointers; these arrays are what the transpiled code ends up referencing. We might be able to do similar things for textures and samplers prior to MSL 2.0. Speaking of which, also enable texture arrays on iOS MSL 1.2.
2018-09-27 01:06:05 +00:00
}
Minor cleanups. Throw an error for cases we don't support. Add a blank line after each local array declaration.
2018-09-27 16:01:46 +00:00
// For some reason, without this, we end up emitting the arrays twice.
MSL: Expand arrays of buffers passed as input. Even as of Metal 2.1, MSL still doesn't support arrays of buffers directly. Therefore, we must manually expand them. In the prologue, we define arrays holding the argument pointers; these arrays are what the transpiled code ends up referencing. We might be able to do similar things for textures and samplers prior to MSL 2.0. Speaking of which, also enable texture arrays on iOS MSL 1.2.
2018-09-27 01:06:05 +00:00
buffer_arrays.clear();
MSL: Add options to control emission of fragment outputs. Like with `point_size` when not rendering points, Metal complains when writing to a variable using the `[[depth]]` qualifier when no depth buffer be attached. In that case, we must avoid emitting `FragDepth`, just like with `PointSize`. I assume it will also complain if there be no stencil attachment and the shader write to `[[stencil]]`, or it write to `[[color(n)]]` but there be no color attachment at n.
2020-04-10 06:13:33 +00:00
// Emit disabled fragment outputs.
std::sort(disabled_frag_outputs.begin(), disabled_frag_outputs.end());
for (uint32_t var_id : disabled_frag_outputs)
{
auto &var = get<SPIRVariable>(var_id);
add_local_variable_name(var_id);
statement(variable_decl(var), ";");
var.deferred_declaration = false;
}
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
}
CompilerMSL options access and UBO alignment test case. CompilerMSL accesses options using same design pattern as CompilerGLSL and CompilerHLSL. CompilerMSL support setting VA & rez binding specs via either constructor or compile() method overload. CompilerMSL support single UBO packing and padding in single pass. spriv_cross app (main.cpp) supports turning off UBO packing and padding via command line option. Add MSL UBO alignment test shader.
2017-03-12 21:42:51 +00:00
string CompilerMSL::compile()
Clarify CompileMSL config parameters and move to compile() function. CompileMSL supports marking vertex attributes and resource bindings as to whether they are used by the shader, and feeding back to caller.
2016-04-08 01:25:51 +00:00
{
Overhaul how we deal with reserved identifiers. - Do not silently drop reserved identifiers in the parser. This makes it possible to reflect identifiers which are reserved by the cross-compiler module. - Instead of dropping the name, emit _RESERVED_IDENTIFIER_FIXUP in the source to make it clear that a name has been rewritten. - Document what is reserved and not.
2020-08-21 14:14:13 +00:00
ir.fixup_reserved_names();
Fixes from review of PR #373. Code fixes from review. Refactor MSL tests back to using the SPIRV-Tools and glslang loaded by checkout_glslang_spirv_tools.sh.
2018-01-06 04:22:36 +00:00
// Do not deal with GLES-isms like precision, older extensions and such.
Deprecate set_options()/get_options() interface, replace it. Replace with common/hlsl/msl instead. The old interface had some bad interaction with overloading which meant you had to up-cast to base class to be able to use set_options, which was awkward.
2018-03-09 14:25:25 +00:00
options.vulkan_semantics = true;
options.es = false;
options.version = 450;
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
backend.null_pointer_literal = "nullptr";
Fixes from review of PR #373. Code fixes from review. Refactor MSL tests back to using the SPIRV-Tools and glslang loaded by checkout_glslang_spirv_tools.sh.
2018-01-06 04:22:36 +00:00
backend.float_literal_suffix = false;
backend.uint32_t_literal_suffix = true;
Fix crash when backend.int16_t_literal_suffix set to null. The design of backend.int16_t_literal_suffix and backend.uint16_t_literal_suffix allows them to be set to null, but that was not always tested for. I have removed the expectation that they can be null and set backend.int16_t_literal_suffix to "" when no suffix is needed. That has the same effect, and seemed to be a more usable and defensive approach.
2019-03-28 18:23:32 +00:00
backend.int16_t_literal_suffix = "";
MSL: Fix 16-bit integer literals. There is no suffix, so bitcasts failed.
2019-09-19 08:19:51 +00:00
backend.uint16_t_literal_suffix = "";
Fixes from review of PR #373. Code fixes from review. Refactor MSL tests back to using the SPIRV-Tools and glslang loaded by checkout_glslang_spirv_tools.sh.
2018-01-06 04:22:36 +00:00
backend.basic_int_type = "int";
backend.basic_uint_type = "uint";
Add support for 8- and 16-bit types to GLSL and MSL. In GLSL, 8-bit types require GL_EXT_shader_8bit_storage. 16-bit types can use either GL_AMD_gpu_shader_int16/GL_AMD_gpu_shader_half_float or GL_EXT_shader_16bit_storage.
2018-10-31 14:43:03 +00:00
backend.basic_int8_type = "char";
backend.basic_uint8_type = "uchar";
backend.basic_int16_type = "short";
backend.basic_uint16_type = "ushort";
Fixes from review of PR #373. Code fixes from review. Refactor MSL tests back to using the SPIRV-Tools and glslang loaded by checkout_glslang_spirv_tools.sh.
2018-01-06 04:22:36 +00:00
backend.discard_literal = "discard_fragment()";
MSL: Support SPV_EXT_demote_to_helper_invocation for MSL 2.3. MSL 2.3 has everything needed to support this extension on all platforms. The existing `discard_fragment()` function was given demote semantics, similar to Direct3D, and the `simd_is_helper_thread()` function was finally added to iOS. I've left the old test alone. Should I remove it in favor of these?
2020-09-29 04:07:55 +00:00
backend.demote_literal = "discard_fragment()";
MSL: Use the select() function for OpSelect. This significantly improves codegen for vector `OpSelect` in MSL.
2019-07-11 04:46:40 +00:00
backend.boolean_mix_function = "select";
Fixes from review of PR #373. Code fixes from review. Refactor MSL tests back to using the SPIRV-Tools and glslang loaded by checkout_glslang_spirv_tools.sh.
2018-01-06 04:22:36 +00:00
backend.swizzle_is_function = false;
backend.shared_is_implied = false;
Use initializer list for composite initializations if backend.use_initializer_list is on.
2018-01-12 22:19:24 +00:00
backend.use_initializer_list = true;
Fix HLSL regression with struct declaration. It actually worked surprisingly. Fix it properly.
2018-01-23 15:36:20 +00:00
backend.use_typed_initializer_list = true;
Fixes from review of PR #373. Code fixes from review. Refactor MSL tests back to using the SPIRV-Tools and glslang loaded by checkout_glslang_spirv_tools.sh.
2018-01-06 04:22:36 +00:00
backend.native_row_major_matrix = false;
HLSL/MSL: Deal correctly with nonuniformEXT qualifier. MSL does not seem to have a qualifier for this, but HLSL SM 5.1 does. glslangValidator for HLSL does not support this, so skip any validation, but it passes in FXC.
2019-05-13 12:58:27 +00:00
backend.unsized_array_supported = false;
MSL cannot declare inline arrays except in certain cases.
2018-02-08 12:06:29 +00:00
backend.can_declare_arrays_inline = false;
CompilerMSL support gl_SampleMask and convert it to scalar uint from array.
2018-02-13 19:44:40 +00:00
backend.allow_truncated_access_chain = true;
MSL: Fix textures which are sampled and compared against. depth2d in MSL only returns float, not float4, even for normal sampling. We need to conditionally remap-swizzle back to float4.
2019-02-22 11:02:11 +00:00
backend.comparison_image_samples_scalar = true;
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
backend.native_pointers = true;
HLSL/MSL: Deal correctly with nonuniformEXT qualifier. MSL does not seem to have a qualifier for this, but HLSL SM 5.1 does. glslangValidator for HLSL does not support this, so skip any validation, but it passes in FXC.
2019-05-13 12:58:27 +00:00
backend.nonuniform_qualifier = "";
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
backend.support_small_type_sampling_result = true;
Implement constant empty struct correctly on all backends. MSL actually supports empty structs, so enable that path as well.
2019-10-24 15:05:55 +00:00
backend.supports_empty_struct = true;
Fixes from review of PR #373. Code fixes from review. Refactor MSL tests back to using the SPIRV-Tools and glslang loaded by checkout_glslang_spirv_tools.sh.
2018-01-06 04:22:36 +00:00
MSL: Add a workaround path to force native arrays for everything.
2020-02-24 11:47:14 +00:00
// Allow Metal to use the array<T> template unless we force it off.
backend.can_return_array = !msl_options.force_native_arrays;
backend.array_is_value_type = !msl_options.force_native_arrays;
MSL: Improve handling of array types in buffer objects. When loading and storing array types which belong to buffer objects, we need to treat these values as not being value types. Also, need to handle array load/store from/to more address space combinations.
2020-06-18 09:37:24 +00:00
// Arrays which are part of buffer objects are never considered to be native arrays.
backend.buffer_offset_array_is_value_type = false;
MSL: Add a workaround path to force native arrays for everything.
2020-02-24 11:47:14 +00:00
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
capture_output_to_buffer = msl_options.capture_output_to_buffer;
is_rasterization_disabled = msl_options.disable_rasterization || capture_output_to_buffer;
Add CompilerMSL::get_is_rasterization_disabled() to manage rasterization status.
2018-07-26 20:40:32 +00:00
MSVC 2013: Work around another compiler bug with array init.
2019-07-09 13:31:01 +00:00
// Initialize array here rather than constructor, MSVC 2013 workaround.
for (auto &id : next_metal_resource_ids)
id = 0;
MSL: Fix struct declaration order with complex type aliases. MSL generally emits the aliases, which means we cannot always place the master type first, unlike GLSL and HLSL. The logic fix is just to reorder after we have tagged types with packing information, rather than doing it in the parser fixup.
2019-05-23 12:54:04 +00:00
fixup_type_alias();
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
replace_illegal_names();
Hoist out variable scope analysis.
2018-07-05 08:42:05 +00:00
build_function_control_flow_graphs_and_analyze();
Add traversal for active builtin variables. Refactor some ugly type-copying for access chains.
2017-03-06 14:21:00 +00:00
update_active_builtins();
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
analyze_image_and_sampler_usage();
Don't override Compiler::analyze_image_and_sampler_usage(). Just add our own separate function for analyzing sampled image usage.
2018-09-24 17:10:27 +00:00
analyze_sampled_image_usage();
Deal with complex interlock cases in GLSL.
2019-09-04 10:18:04 +00:00
analyze_interlocked_resource_usage();
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
preprocess_op_codes();
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
build_implicit_builtins();
Support emitting SPIR-V type declarations tuned for specified SPIR-V objects. CompilerGLSL type_to_glsl() and image_type_glsl() functions support optional object ID. Add SPIRType::Image::access member to support SPIR-V OpTypeImage access qualifier. Remove SPIRType::Image::is_read and ::is_written members. Use DecorationNonReadable and DecorationNonWritable to mark read/write access for image variables. CompilerMSL emit access qualifiers per image variable, instead of per image type. CompilerGLSL and CompilerHLSL behaviour is unchanged.
2017-05-30 00:45:05 +00:00
fixup_image_load_store_access();
Add traversal for active builtin variables. Refactor some ugly type-copying for access chains.
2017-03-06 14:21:00 +00:00
CompilerMSL enhancements. Support BuiltInFragDepth. Emit interface block for StorageClassUniformConstant. Throw exception when output or fragment input structs contain matrix or array. Dynamically created interface structs sorted by location number instead of alphabetically. Add Compiler::is_array() function.
2017-06-30 23:10:46 +00:00
set_enabled_interface_variables(get_active_interface_variables());
MSL: Add support for force-activating IAB resources. Important for ABI compatibility on MSL in certain cases.
2020-01-16 10:07:30 +00:00
if (msl_options.force_active_argument_buffer_resources)
activate_argument_buffer_resources();
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
if (swizzle_buffer_id)
active_interface_variables.insert(swizzle_buffer_id);
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
if (buffer_size_buffer_id)
active_interface_variables.insert(buffer_size_buffer_id);
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
if (view_mask_buffer_id)
active_interface_variables.insert(view_mask_buffer_id);
MSL: Support dynamic offsets for buffers in argument buffers. Vulkan has two types of buffer descriptors, `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` and `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC`, which allow the client to offset the buffers by an amount given when the descriptor set is bound to a pipeline. Metal provides no direct support for this when the buffer in question is in an argument buffer, so once again we're on our own. These offsets cannot be stored or associated in any way with the argument buffer itself, because they are set at bind time. Different pipelines may have different offsets set. Therefore, we must use a separate buffer, not in any argument buffer, to hold these offsets. Then the shader must manually offset the buffer pointer. This change fully supports arrays, including arrays of arrays, even though Vulkan forbids them. It does not, however, support runtime arrays. Perhaps later.
2019-09-06 04:14:12 +00:00
if (dynamic_offsets_buffer_id)
active_interface_variables.insert(dynamic_offsets_buffer_id);
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
if (builtin_layer_id)
active_interface_variables.insert(builtin_layer_id);
MSL: Adjust BuiltInWorkgroupId for vkCmdDispatchBase(). This command allows the caller to set the base value of `BuiltInWorkgroupId`, and thus of `BuiltInGlobalInvocationId`. Metal provides no direct support for this... but it does provide a builtin, `[[grid_origin]]`, normally used to pass the base values for the stage input region, which we will now abuse to pass the dispatch base and avoid burning a buffer binding. `[[grid_origin]]`, as part of Metal's support for compute stage input, requires MSL 1.2. For 1.0 and 1.1, we're forced to provide a buffer. (Curiously, this builtin was undocumented until the MSL 2.2 release. Go figure.)
2019-07-22 18:08:04 +00:00
if (builtin_dispatch_base_id && !msl_options.supports_msl_version(1, 2))
active_interface_variables.insert(builtin_dispatch_base_id);
Enabling setting a fixed sampleMask in Metal fragment shaders. In Metal render pipelines don't have an option to set a sampleMask parameter, the only way to get that functionality is to set the sample_mask output of the fragment shader to this value directly. We also need to take care to combine the fixed sample mask with the one that the shader might possibly output.
2020-07-22 16:37:17 +00:00
if (builtin_sample_mask_id)
active_interface_variables.insert(builtin_sample_mask_id);
CompilerMSL enhancements. Support BuiltInFragDepth. Emit interface block for StorageClassUniformConstant. Throw exception when output or fragment input structs contain matrix or array. Dynamically created interface structs sorted by location number instead of alphabetically. Add Compiler::is_array() function.
2017-06-30 23:10:46 +00:00
CompilerMSL support matrices & arrays in stage-in & stage-out. Support flattening StorageOutput & StorageInput matrices and arrays. No longer move matrix & array inputs to separate buffer. Add separate SPIRFunction::fixup_statements_in & SPIRFunction::fixup_statements_out instead of just SPIRFunction::fixup_statements. Emit SPIRFunction::fixup_statements at beginning of functions. CompilerMSL track vars_needing_early_declaration. Pass global output variables as variables to functions that access them. Sort input structs by location, same as output structs. Emit struct declarations in order output, input, uniforms. Regenerate reference shaders to new formats defined by above.
2018-06-12 15:41:35 +00:00
// Create structs to hold input, output and uniform variables.
// Do output first to ensure out. is declared at top of entry function.
CompilerMSL refactored to simplify handling of vertex attributes. Combine all vertex attributes into a single stage_in structure. Remove unneeded structure members from MSLConfiguration, MSLVertexAttr and Meta::Decoration. Remove unneeded CompilerMSL functions that supported struct offsets and padding.
2017-01-01 19:43:20 +00:00
qual_pos_var_name = "";
stage_out_var_id = add_interface_block(StorageClassOutput);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
patch_stage_out_var_id = add_interface_block(StorageClassOutput, true);
CompilerMSL support matrices & arrays in stage-in & stage-out. Support flattening StorageOutput & StorageInput matrices and arrays. No longer move matrix & array inputs to separate buffer. Add separate SPIRFunction::fixup_statements_in & SPIRFunction::fixup_statements_out instead of just SPIRFunction::fixup_statements. Emit SPIRFunction::fixup_statements at beginning of functions. CompilerMSL track vars_needing_early_declaration. Pass global output variables as variables to functions that access them. Sort input structs by location, same as output structs. Emit struct declarations in order output, input, uniforms. Regenerate reference shaders to new formats defined by above.
2018-06-12 15:41:35 +00:00
stage_in_var_id = add_interface_block(StorageClassInput);
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
if (get_execution_model() == ExecutionModelTessellationEvaluation)
patch_stage_in_var_id = add_interface_block(StorageClassInput, true);
CompilerMSL refactored to simplify handling of vertex attributes. Combine all vertex attributes into a single stage_in structure. Remove unneeded structure members from MSLConfiguration, MSLVertexAttr and Meta::Decoration. Remove unneeded CompilerMSL functions that supported struct offsets and padding.
2017-01-01 19:43:20 +00:00
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
if (get_execution_model() == ExecutionModelTessellationControl)
stage_out_ptr_var_id = add_interface_block_pointer(stage_out_var_id, StorageClassOutput);
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
if (is_tessellation_shader())
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
stage_in_ptr_var_id = add_interface_block_pointer(stage_in_var_id, StorageClassInput);
CompilerMSL vertex entry point return void when rasterization disabled. Add CompilerMSL::Options::disable_rasterization input/output API flag. Disable rasterization via API flag or when writing to textures. Disable rasterization when shader declares no output. Add test shaders for vertex no output and write texture forcing void output.
2018-07-26 04:50:33 +00:00
// Metal vertex functions that define no output must disable rasterization and return void.
Add CompilerMSL::get_is_rasterization_disabled() to manage rasterization status.
2018-07-26 20:40:32 +00:00
if (!stage_out_var_id)
is_rasterization_disabled = true;
CompilerMSL vertex entry point return void when rasterization disabled. Add CompilerMSL::Options::disable_rasterization input/output API flag. Disable rasterization via API flag or when writing to textures. Disable rasterization when shader declares no output. Add test shaders for vertex no output and write texture forcing void output.
2018-07-26 04:50:33 +00:00
CompilerMSL refactored to simplify handling of vertex attributes. Combine all vertex attributes into a single stage_in structure. Remove unneeded structure members from MSLConfiguration, MSLVertexAttr and Meta::Decoration. Remove unneeded CompilerMSL functions that supported struct offsets and padding.
2017-01-01 19:43:20 +00:00
// Convert the use of global variables to recursively-passed function parameters
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
localize_global_variables();
Run clang-format.
2016-10-24 13:24:24 +00:00
extract_global_variables_from_functions();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
// Mark any non-stage-in structs to be tightly packed.
mark_packable_structs();
MSL: Fix struct declaration order with complex type aliases. MSL generally emits the aliases, which means we cannot always place the master type first, unlike GLSL and HLSL. The logic fix is just to reorder after we have tagged types with packing information, rather than doing it in the parser fixup.
2019-05-23 12:54:04 +00:00
reorder_type_alias();
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
MSL: Hoist fixup hooks in entry_point_args() out of the compile loop. Otherwise, in the event of a forced recompile, we could end up adding them twice.
2019-01-16 23:52:53 +00:00
// Add fixup hooks required by shader inputs and outputs. This needs to happen before
// the loop, so the hooks aren't added multiple times.
fix_up_shader_inputs_outputs();
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
// If we are using argument buffers, we create argument buffer structures for them here.
// These buffers will be used in the entry point, not the individual resources.
if (msl_options.argument_buffers)
{
if (!msl_options.supports_msl_version(2, 0))
SPIRV_CROSS_THROW("Argument buffers can only be used with MSL 2.0 and up.");
analyze_argument_buffers();
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
uint32_t pass_count = 0;
do
{
if (pass_count >= 3)
Fixes from review #2 of PR 321.
2017-11-08 18:54:28 +00:00
SPIRV_CROSS_THROW("Over 3 compilation loops detected. Must be a bug!");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
reset();
Add a stable C API for SPIRV-Cross. This adds a new C API for SPIRV-Cross which is intended to be stable, both API and ABI wise. The C++ API has been refactored a bit to make the C wrapper easier and cleaner to write. Especially the vertex attribute / resource interfaces for MSL has been rewritten to avoid taking mutable pointers into the interface. This would be very annoying to wrap and it didn't fit well with the rest of the C++ API to begin with. While doing this, I went ahead and removed all the old deprecated interfaces. The CMake build system has also seen an overhaul. It is now possible to build static/shared/CLI separately with -D options. The shared library only exposes the C API, as it is the only ABI-stable API. pkg-configs as well as CMake modules are exported and installed for the shared library configuration.
2019-02-12 10:11:29 +00:00
// Start bindings at zero.
next_metal_resource_index_buffer = 0;
next_metal_resource_index_texture = 0;
next_metal_resource_index_sampler = 0;
MSL: Rewrite how resource indices are fallback-assigned. We used to use the Binding decoration for this, but this method is hopelessly broken. If no explicit MSL resource remapping exists, we remap automatically in a manner which should always "just work".
2019-06-21 10:44:33 +00:00
for (auto &id : next_metal_resource_ids)
id = 0;
Run format.sh.
2016-09-17 16:46:10 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Move constructor for this type is broken on GCC 4.9 ...
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
buffer.reset();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
emit_header();
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
emit_custom_templates();
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
emit_specialization_constants_and_structs();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
emit_resources();
CompilerMSL support emitting custom functions for SPIR-V ops. CompilerMSL use custom mod() function instead of Metal's fmod() function.
2016-12-19 02:42:10 +00:00
emit_custom_functions();
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
emit_function(get<SPIRFunction>(ir.default_entry_point), Bitset());
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
pass_count++;
Detect invalid DoWhileLoop early. We had a bug where error conditions in DoWhileLoop emit path would not detect that statements were being emitted due to the masking behavior which happens when force_recompile is true. Fix this. Also, refactor force_recompile into member functions so we can properly break on any situation where this is set, without having to rely on watchpoints in debuggers.
2019-04-05 10:06:10 +00:00
} while (is_forcing_recompilation());
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
return buffer.str();
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
CompilerMSL support emitting custom functions for SPIR-V ops. CompilerMSL use custom mod() function instead of Metal's fmod() function.
2016-12-19 02:42:10 +00:00
// Register the need to output any custom functions.
Remove emission of function prototypes in MSL. Do not emit function prototypes. If secondary functions are used, suppress compiler -Wmissing-prototypes warnings. Refactor Compiler::emit_function_prototype() functions to simplify. Rename Compiler_msl::CustomFunctionHandler to OpCodePreprocessor, and Compiler_msl::register_custom_functions() to preprocess_op_codes() to perform more generic preprocessing. Add space between dynamic header lines and fixed header lines.
2017-01-20 16:24:44 +00:00
void CompilerMSL::preprocess_op_codes()
Run clang-format.
2016-10-24 13:24:24 +00:00
{
Run style formatter.
2017-01-20 16:33:59 +00:00
OpCodePreprocessor preproc(*this);
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
traverse_all_reachable_opcodes(get<SPIRFunction>(ir.default_entry_point), preproc);
Remove emission of function prototypes in MSL. Do not emit function prototypes. If secondary functions are used, suppress compiler -Wmissing-prototypes warnings. Refactor Compiler::emit_function_prototype() functions to simplify. Rename Compiler_msl::CustomFunctionHandler to OpCodePreprocessor, and Compiler_msl::register_custom_functions() to preprocess_op_codes() to perform more generic preprocessing. Add space between dynamic header lines and fixed header lines.
2017-01-20 16:24:44 +00:00
Deal with case where we need to emit SpvImplArrayCopy late. We cannot deduce if OpLoad needs ArrayCopy templates early since it's heavily context dependent, and we might only know on 3rd iteration of the compile loop.
2019-04-09 10:28:46 +00:00
suppress_missing_prototypes = preproc.suppress_missing_prototypes;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
if (preproc.uses_atomics)
{
add_header_line("#include <metal_atomic>");
add_pragma_line("#pragma clang diagnostic ignored \"-Wunused-variable\"");
}
CompilerMSL vertex entry point return void when rasterization disabled. Add CompilerMSL::Options::disable_rasterization input/output API flag. Disable rasterization via API flag or when writing to textures. Disable rasterization when shader declares no output. Add test shaders for vertex no output and write texture forcing void output.
2018-07-26 04:50:33 +00:00
CompilerMSL disable rasterization on buffer writes in vertex shader.
2018-07-27 20:53:36 +00:00
// Metal vertex functions that write to resources must disable rasterization and return void.
if (preproc.uses_resource_write)
Add CompilerMSL::get_is_rasterization_disabled() to manage rasterization status.
2018-07-26 20:40:32 +00:00
is_rasterization_disabled = true;
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
// Tessellation control shaders are run as compute functions in Metal, and so
// must capture their output to a buffer.
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (get_execution_model() == ExecutionModelTessellationControl ||
(get_execution_model() == ExecutionModelVertex && msl_options.vertex_for_tessellation))
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
{
is_rasterization_disabled = true;
capture_output_to_buffer = true;
}
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
if (preproc.needs_subgroup_invocation_id)
needs_subgroup_invocation_id = true;
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
// Move the Private and Workgroup global variables to the entry function.
CompilerMSL move Private global variables to entry-point function variables. CompilerMSL add support for texture read() without sampler for OpImageFetch.
2016-04-27 17:54:33 +00:00
// Non-constant variables cannot have global scope in Metal.
void CompilerMSL::localize_global_variables()
{
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
auto &entry_func = get<SPIRFunction>(ir.default_entry_point);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto iter = global_variables.begin();
while (iter != global_variables.end())
{
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
uint32_t v_id = *iter;
auto &var = get<SPIRVariable>(v_id);
if (var.storage == StorageClassPrivate || var.storage == StorageClassWorkgroup)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Support LUTs in single-function CFGs on Private storage class. Fairly common pattern in unoptimized SPIR-V. Support this case as well.
2019-02-06 09:38:18 +00:00
if (!variable_is_lut(var))
entry_func.add_local_variable(v_id);
Add vars declared in the main to the functions
2017-01-16 08:44:40 +00:00
iter = global_variables.erase(iter);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
else
iter++;
}
For MSL, extract global var refs from within functions and convert them to function args.
2016-07-06 20:55:45 +00:00
}
// For any global variable accessed directly by a function,
// extract that variable and add it as an argument to that function.
void CompilerMSL::extract_global_variables_from_functions()
{
Run clang-format.
2016-10-24 13:24:24 +00:00
// Uniforms
MSL fixes from review of PR 134. Remove unnecessary use of std:: prefix in spirv_msl.cpp. Use typedef instead of #define. spirv-cross deprecate --metal CLI option and replace with --msl option.
2017-03-20 01:06:21 +00:00
unordered_set<uint32_t> global_var_ids;
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
ir.for_each_typed_id<SPIRVariable>([&](uint32_t, SPIRVariable &var) {
if (var.storage == StorageClassInput || var.storage == StorageClassOutput ||
var.storage == StorageClassUniform || var.storage == StorageClassUniformConstant ||
var.storage == StorageClassPushConstant || var.storage == StorageClassStorageBuffer)
Run clang-format.
2016-10-24 13:24:24 +00:00
{
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
global_var_ids.insert(var.self);
Run clang-format.
2016-10-24 13:24:24 +00:00
}
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
});
Format code
2017-01-26 09:20:42 +00:00
Deal with scoping for Private variables.
2018-05-16 08:49:30 +00:00
// Local vars that are declared in the main function and accessed directly by a function
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
auto &entry_func = get<SPIRFunction>(ir.default_entry_point);
Improved loop
2017-01-26 19:05:43 +00:00
for (auto &var : entry_func.local_variables)
Deal with scoping for Private variables.
2018-05-16 08:49:30 +00:00
if (get<SPIRVariable>(var).storage != StorageClassFunction)
global_var_ids.insert(var);
Run clang-format.
2016-10-24 13:24:24 +00:00
CompilerMSL uses std::set where order matters for consistent regression testing.
2017-01-31 16:02:44 +00:00
std::set<uint32_t> added_arg_ids;
MSL fixes from review of PR 134. Remove unnecessary use of std:: prefix in spirv_msl.cpp. Use typedef instead of #define. spirv-cross deprecate --metal CLI option and replace with --msl option.
2017-03-20 01:06:21 +00:00
unordered_set<uint32_t> processed_func_ids;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
extract_global_variables_from_function(ir.default_entry_point, added_arg_ids, global_var_ids, processed_func_ids);
For MSL, extract global var refs from within functions and convert them to function args.
2016-07-06 20:55:45 +00:00
}
// MSL does not support the use of global variables for shader input content.
// For any global variable accessed directly by the specified function, extract that variable,
// add it as an argument to that function, and the arg to the added_arg_ids collection.
CompilerMSL uses std::set where order matters for consistent regression testing.
2017-01-31 16:02:44 +00:00
void CompilerMSL::extract_global_variables_from_function(uint32_t func_id, std::set<uint32_t> &added_arg_ids,
MSL fixes from review of PR 134. Remove unnecessary use of std:: prefix in spirv_msl.cpp. Use typedef instead of #define. spirv-cross deprecate --metal CLI option and replace with --msl option.
2017-03-20 01:06:21 +00:00
unordered_set<uint32_t> &global_var_ids,
unordered_set<uint32_t> &processed_func_ids)
For MSL, extract global var refs from within functions and convert them to function args.
2016-07-06 20:55:45 +00:00
{
Run clang-format.
2016-10-24 13:24:24 +00:00
// Avoid processing a function more than once
Format code
2017-01-15 15:39:03 +00:00
if (processed_func_ids.find(func_id) != processed_func_ids.end())
{
Add function global variables
2017-01-09 15:23:58 +00:00
// Return function global variables
added_arg_ids = function_global_vars[func_id];
Run clang-format.
2016-10-24 13:24:24 +00:00
return;
Add function global variables
2017-01-09 15:23:58 +00:00
}
Run clang-format.
2016-10-24 13:24:24 +00:00
processed_func_ids.insert(func_id);
auto &func = get<SPIRFunction>(func_id);
// Recursively establish global args added to functions on which we depend.
for (auto block : func.blocks)
{
auto &b = get<SPIRBlock>(block);
for (auto &i : b.ops)
{
auto ops = stream(i);
auto op = static_cast<Op>(i.op);
switch (op)
{
case OpLoad:
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
case OpInBoundsAccessChain:
Run clang-format.
2016-10-24 13:24:24 +00:00
case OpAccessChain:
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
case OpPtrAccessChain:
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
case OpArrayLength:
Run clang-format.
2016-10-24 13:24:24 +00:00
{
uint32_t base_id = ops[2];
if (global_var_ids.find(base_id) != global_var_ids.end())
added_arg_ids.insert(base_id);
Format code
2017-01-15 15:39:03 +00:00
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Use Metal's native frame-buffer fetch API for subpass inputs.
Support passing implicit frag_coord arguments down to functions.
2018-02-09 11:13:33 +00:00
auto &type = get<SPIRType>(ops[0]);
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
if (type.basetype == SPIRType::Image && type.image.dim == DimSubpassData &&
(!msl_options.is_ios() || !msl_options.ios_use_framebuffer_fetch_subpasses))
Support passing implicit frag_coord arguments down to functions.
2018-02-09 11:13:33 +00:00
{
// Implicitly reads gl_FragCoord.
assert(builtin_frag_coord_id != 0);
added_arg_ids.insert(builtin_frag_coord_id);
MSL: Support layered input attachments. These need to use arrayed texture types, or Metal will complain when binding the resource. The target layer is addressed relative to the Layer output by the vertex pipeline, or to the ViewIndex if in a multiview pipeline. Unlike with the s/t coordinates, Vulkan does not forbid non-zero layer coordinates here, though this cannot be expressed in Vulkan GLSL. Supporting 3D textures will require additional work. Part of the problem is that Metal does not allow texture views to subset a 3D texture, so we need some way to pass the base depth to the shader.
2020-08-28 00:24:20 +00:00
if (msl_options.multiview)
{
// Implicitly reads gl_ViewIndex.
assert(builtin_view_idx_id != 0);
added_arg_ids.insert(builtin_view_idx_id);
}
else if (msl_options.arrayed_subpass_input)
{
// Implicitly reads gl_Layer.
assert(builtin_layer_id != 0);
added_arg_ids.insert(builtin_layer_id);
}
Support passing implicit frag_coord arguments down to functions.
2018-02-09 11:13:33 +00:00
}
Run clang-format.
2016-10-24 13:24:24 +00:00
break;
}
Deal with scoping for Private variables.
2018-05-16 08:49:30 +00:00
Run clang-format.
2016-10-24 13:24:24 +00:00
case OpFunctionCall:
{
CompilerMSL enhancements to nested function use of globals. Allow function calls to include globals as arguments. Allow function calls to include built-ins as arguments. Include all meta info when creating function args from globals. Do not manufacture a sampler for Buffer-type sampled images. Add code option to test_shaders.py to preserve SPIR-V code for interactive debugging.
2017-12-26 21:32:45 +00:00
// First see if any of the function call args are globals
for (uint32_t arg_idx = 3; arg_idx < i.length; arg_idx++)
{
uint32_t arg_id = ops[arg_idx];
if (global_var_ids.find(arg_id) != global_var_ids.end())
added_arg_ids.insert(arg_id);
}
// Then recurse into the function itself to extract globals used internally in the function
Run clang-format.
2016-10-24 13:24:24 +00:00
uint32_t inner_func_id = ops[2];
CompilerMSL uses std::set where order matters for consistent regression testing.
2017-01-31 16:02:44 +00:00
std::set<uint32_t> inner_func_args;
Run clang-format.
2016-10-24 13:24:24 +00:00
extract_global_variables_from_function(inner_func_id, inner_func_args, global_var_ids,
processed_func_ids);
added_arg_ids.insert(inner_func_args.begin(), inner_func_args.end());
break;
}
Deal with scoping for Private variables.
2018-05-16 08:49:30 +00:00
case OpStore:
{
uint32_t base_id = ops[0];
if (global_var_ids.find(base_id) != global_var_ids.end())
added_arg_ids.insert(base_id);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
uint32_t rvalue_id = ops[1];
if (global_var_ids.find(rvalue_id) != global_var_ids.end())
added_arg_ids.insert(rvalue_id);
Deal with scoping for Private variables.
2018-05-16 08:49:30 +00:00
break;
}
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
case OpSelect:
{
uint32_t base_id = ops[3];
if (global_var_ids.find(base_id) != global_var_ids.end())
added_arg_ids.insert(base_id);
base_id = ops[4];
if (global_var_ids.find(base_id) != global_var_ids.end())
added_arg_ids.insert(base_id);
Add missing break.
2019-01-08 18:48:40 +00:00
break;
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
}
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Emulate texture2D atomic operations
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
case OpImageTexelPointer:
{
// When using the pointer, we need to know which variable it is actually loaded from.
uint32_t base_id = ops[2];
auto *var = maybe_get_backing_variable(base_id);
MSL: Minor cleanups for texture atomic emulation. Storing pointers to internal objects is generally not done, IDs are preferred.
2019-10-24 09:30:20 +00:00
if (var && atomic_image_vars.count(var->self))
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
{
if (global_var_ids.find(base_id) != global_var_ids.end())
added_arg_ids.insert(base_id);
}
break;
}
Run clang-format.
2016-10-24 13:24:24 +00:00
default:
break;
}
Deal with scoping for Private variables.
2018-05-16 08:49:30 +00:00
// TODO: Add all other operations which can affect memory.
// We should consider a more unified system here to reduce boiler-plate.
// This kind of analysis is done in several places ...
Run clang-format.
2016-10-24 13:24:24 +00:00
}
}
Format code
2017-01-15 15:39:03 +00:00
function_global_vars[func_id] = added_arg_ids;
Run clang-format.
2016-10-24 13:24:24 +00:00
// Add the global variables as arguments to the function
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
if (func_id != ir.default_entry_point)
Run clang-format.
2016-10-24 13:24:24 +00:00
{
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
bool added_in = false;
bool added_out = false;
Run clang-format.
2016-10-24 13:24:24 +00:00
for (uint32_t arg_id : added_arg_ids)
{
CompilerMSL pass builtin struct members into functions. Add and use Compiler::get_non_pointer_type() convenience functions.
2018-06-24 19:06:12 +00:00
auto &var = get<SPIRVariable>(arg_id);
MSL improvements: - pack/unpack nested constant buffer structs - support for write-only textures (only global ones for now) - better rt index support for msl generator
2017-12-06 17:51:23 +00:00
uint32_t type_id = var.basetype;
CompilerMSL pass builtin struct members into functions. Add and use Compiler::get_non_pointer_type() convenience functions.
2018-06-24 19:06:12 +00:00
auto *p_type = &get<SPIRType>(type_id);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
BuiltIn bi_type = BuiltIn(get_decoration(arg_id, DecorationBuiltIn));
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
if (((is_tessellation_shader() && var.storage == StorageClassInput) ||
(get_execution_model() == ExecutionModelTessellationControl && var.storage == StorageClassOutput)) &&
Handle blocks of patch I/O. In this case, each member of the block will be decorated with `DecorationPatch`, rather than the block variable having the decoration.
2019-02-15 23:21:38 +00:00
!(has_decoration(arg_id, DecorationPatch) || is_patch_block(*p_type)) &&
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
(!is_builtin_variable(var) || bi_type == BuiltInPosition || bi_type == BuiltInPointSize ||
bi_type == BuiltInClipDistance || bi_type == BuiltInCullDistance ||
p_type->basetype == SPIRType::Struct))
{
// Tessellation control shaders see inputs and per-vertex outputs as arrays.
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
// Similarly, tessellation evaluation shaders see per-vertex inputs as arrays.
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
// We collected them into a structure; we must pass the array of this
// structure to the function.
std::string name;
if (var.storage == StorageClassInput)
{
if (added_in)
continue;
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
name = "gl_in";
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
arg_id = stage_in_ptr_var_id;
added_in = true;
}
else if (var.storage == StorageClassOutput)
{
if (added_out)
continue;
name = "gl_out";
arg_id = stage_out_ptr_var_id;
added_out = true;
}
type_id = get<SPIRVariable>(arg_id).basetype;
uint32_t next_id = ir.increase_bound_by(1);
func.add_parameter(type_id, next_id, true);
set<SPIRVariable>(next_id, type_id, StorageClassFunction, 0, arg_id);
CompilerMSL supports promoting unnamed global vars to function args. CompilerMSL use correct MSL type name for 3D textures.
2016-11-27 20:00:06 +00:00
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
set_name(next_id, name);
}
else if (is_builtin_variable(var) && p_type->basetype == SPIRType::Struct)
CompilerMSL pass builtin struct members into functions. Add and use Compiler::get_non_pointer_type() convenience functions.
2018-06-24 19:06:12 +00:00
{
Rename get_non_pointer_type() methods. This better reflects their purpose now.
2019-01-08 18:54:40 +00:00
// Get the pointee type
type_id = get_pointee_type_id(type_id);
CompilerMSL pass builtin struct members into functions. Add and use Compiler::get_non_pointer_type() convenience functions.
2018-06-24 19:06:12 +00:00
p_type = &get<SPIRType>(type_id);
CompilerMSL supports promoting unnamed global vars to function args. CompilerMSL use correct MSL type name for 3D textures.
2016-11-27 20:00:06 +00:00
CompilerMSL pass builtin struct members into functions. Add and use Compiler::get_non_pointer_type() convenience functions.
2018-06-24 19:06:12 +00:00
uint32_t mbr_idx = 0;
for (auto &mbr_type_id : p_type->member_types)
{
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
BuiltIn builtin = BuiltInMax;
CompilerMSL pass builtin struct members into functions. Add and use Compiler::get_non_pointer_type() convenience functions.
2018-06-24 19:06:12 +00:00
bool is_builtin = is_member_builtin(*p_type, mbr_idx, &builtin);
Fixes from PR 621 code review.
2018-06-25 15:40:20 +00:00
if (is_builtin && has_active_builtin(builtin, var.storage))
CompilerMSL pass builtin struct members into functions. Add and use Compiler::get_non_pointer_type() convenience functions.
2018-06-24 19:06:12 +00:00
{
// Add a arg variable with the same type and decorations as the member
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
uint32_t next_ids = ir.increase_bound_by(2);
MSL: Properly support passing parameters by value. MSL would force thread const& which would not work if the input argument came from a different storage class. Emit proper non-reference arguments for such values.
2018-08-06 13:41:10 +00:00
uint32_t ptr_type_id = next_ids + 0;
uint32_t var_id = next_ids + 1;
// Make sure we have an actual pointer type,
// so that we will get the appropriate address space when declaring these builtins.
auto &ptr = set<SPIRType>(ptr_type_id, get<SPIRType>(mbr_type_id));
ptr.self = mbr_type_id;
ptr.storage = var.storage;
ptr.pointer = true;
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
ptr.parent_type = mbr_type_id;
MSL: Properly support passing parameters by value. MSL would force thread const& which would not work if the input argument came from a different storage class. Emit proper non-reference arguments for such values.
2018-08-06 13:41:10 +00:00
func.add_parameter(mbr_type_id, var_id, true);
set<SPIRVariable>(var_id, ptr_type_id, StorageClassFunction);
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
ir.meta[var_id].decoration = ir.meta[type_id].members[mbr_idx];
CompilerMSL pass builtin struct members into functions. Add and use Compiler::get_non_pointer_type() convenience functions.
2018-06-24 19:06:12 +00:00
}
mbr_idx++;
}
}
else
{
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
uint32_t next_id = ir.increase_bound_by(1);
CompilerMSL pass builtin struct members into functions. Add and use Compiler::get_non_pointer_type() convenience functions.
2018-06-24 19:06:12 +00:00
func.add_parameter(type_id, next_id, true);
set<SPIRVariable>(next_id, type_id, StorageClassFunction, 0, arg_id);
// Ensure the existing variable has a valid name and the new variable has all the same meta info
set_name(arg_id, ensure_valid_name(to_name(arg_id), "v"));
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
ir.meta[next_id] = ir.meta[arg_id];
CompilerMSL pass builtin struct members into functions. Add and use Compiler::get_non_pointer_type() convenience functions.
2018-06-24 19:06:12 +00:00
}
Run clang-format.
2016-10-24 13:24:24 +00:00
}
}
CompilerMSL move Private global variables to entry-point function variables. CompilerMSL add support for texture read() without sampler for OpImageFetch.
2016-04-27 17:54:33 +00:00
}
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
// For all variables that are some form of non-input-output interface block, mark that all the structs
// that are recursively contained within the type referenced by that variable should be packed tightly.
void CompilerMSL::mark_packable_structs()
{
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
ir.for_each_typed_id<SPIRVariable>([&](uint32_t, SPIRVariable &var) {
if (var.storage != StorageClassFunction && !is_hidden_variable(var))
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
{
Workaround bugs on MSVC. Bug: https://developercommunity.visualstudio.com/content/problem/303996/c-error-c2668-ambiguous-overloaded-in-lambda-with.html
2019-01-11 08:29:28 +00:00
auto &type = this->get<SPIRType>(var.basetype);
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
if (type.pointer &&
(type.storage == StorageClassUniform || type.storage == StorageClassUniformConstant ||
type.storage == StorageClassPushConstant || type.storage == StorageClassStorageBuffer) &&
(has_decoration(type.self, DecorationBlock) || has_decoration(type.self, DecorationBufferBlock)))
mark_as_packable(type);
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
}
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
});
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
}
// If the specified type is a struct, it and any nested structs
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
// are marked as packable with the SPIRVCrossDecorationBufferBlockRepacked decoration,
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
void CompilerMSL::mark_as_packable(SPIRType &type)
{
// If this is not the base type (eg. it's a pointer or array), tunnel down
if (type.parent_type)
{
mark_as_packable(get<SPIRType>(type.parent_type));
return;
}
if (type.basetype == SPIRType::Struct)
{
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
set_extended_decoration(type.self, SPIRVCrossDecorationBufferBlockRepacked);
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
// Recurse
Fix some warnings when building in MoltenVK.
2019-07-23 14:39:13 +00:00
uint32_t mbr_cnt = uint32_t(type.member_types.size());
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
for (uint32_t mbr_idx = 0; mbr_idx < mbr_cnt; mbr_idx++)
{
uint32_t mbr_type_id = type.member_types[mbr_idx];
auto &mbr_type = get<SPIRType>(mbr_type_id);
mark_as_packable(mbr_type);
Fix type aliasing on MSL. Be careful about who gets to be the alias master, and don't alias types when we have packed types in play.
2018-03-05 15:27:04 +00:00
if (mbr_type.type_alias)
{
auto &mbr_type_alias = get<SPIRType>(mbr_type.type_alias);
mark_as_packable(mbr_type_alias);
}
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
}
}
}
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
// If a shader input exists at the location, it is marked as being used by this shader
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
void CompilerMSL::mark_location_as_used_by_shader(uint32_t location, const SPIRType &type, StorageClass storage)
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
{
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (storage != StorageClassInput)
return;
if (is_array(type))
{
uint32_t dim = 1;
for (uint32_t i = 0; i < type.array.size(); i++)
dim *= to_array_size_literal(type, i);
for (uint32_t i = 0; i < dim; i++)
{
if (is_matrix(type))
{
for (uint32_t j = 0; j < type.columns; j++)
inputs_in_use.insert(location++);
}
else
inputs_in_use.insert(location++);
}
}
else if (is_matrix(type))
{
for (uint32_t i = 0; i < type.columns; i++)
inputs_in_use.insert(location + i);
}
else
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
inputs_in_use.insert(location);
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
MSL: Add option to pad fragment outputs. If not enough components are provided in the shader, the shader MSL compiler throws an error rather than make components undefined. This hurts portability, so we need to add explicit padding here.
2019-01-14 13:53:47 +00:00
uint32_t CompilerMSL::get_target_components_for_fragment_location(uint32_t location) const
{
auto itr = fragment_output_components.find(location);
if (itr == end(fragment_output_components))
return 4;
else
return itr->second;
}
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
uint32_t CompilerMSL::build_extended_vector_type(uint32_t type_id, uint32_t components, SPIRType::BaseType basetype)
MSL: Add option to pad fragment outputs. If not enough components are provided in the shader, the shader MSL compiler throws an error rather than make components undefined. This hurts portability, so we need to add explicit padding here.
2019-01-14 13:53:47 +00:00
{
uint32_t new_type_id = ir.increase_bound_by(1);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
auto &old_type = get<SPIRType>(type_id);
auto *type = &set<SPIRType>(new_type_id, old_type);
type->vecsize = components;
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
if (basetype != SPIRType::Unknown)
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
type->basetype = basetype;
type->self = new_type_id;
type->parent_type = type_id;
type->array.clear();
type->array_size_literal.clear();
type->pointer = false;
if (is_array(old_type))
{
uint32_t array_type_id = ir.increase_bound_by(1);
type = &set<SPIRType>(array_type_id, *type);
type->parent_type = new_type_id;
type->array = old_type.array;
type->array_size_literal = old_type.array_size_literal;
new_type_id = array_type_id;
}
if (old_type.pointer)
{
uint32_t ptr_type_id = ir.increase_bound_by(1);
type = &set<SPIRType>(ptr_type_id, *type);
type->self = new_type_id;
type->parent_type = new_type_id;
type->storage = old_type.storage;
type->pointer = true;
new_type_id = ptr_type_id;
}
MSL: Add option to pad fragment outputs. If not enough components are provided in the shader, the shader MSL compiler throws an error rather than make components undefined. This hurts portability, so we need to add explicit padding here.
2019-01-14 13:53:47 +00:00
return new_type_id;
}
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
void CompilerMSL::add_plain_variable_to_interface_block(StorageClass storage, const string &ib_var_ref,
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
SPIRType &ib_type, SPIRVariable &var, InterfaceBlockMeta &meta)
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
{
bool is_builtin = is_builtin_variable(var);
BuiltIn builtin = BuiltIn(get_decoration(var.self, DecorationBuiltIn));
bool is_flat = has_decoration(var.self, DecorationFlat);
bool is_noperspective = has_decoration(var.self, DecorationNoPerspective);
bool is_centroid = has_decoration(var.self, DecorationCentroid);
bool is_sample = has_decoration(var.self, DecorationSample);
// Add a reference to the variable type to the interface struct.
uint32_t ib_mbr_idx = uint32_t(ib_type.member_types.size());
uint32_t type_id = ensure_correct_builtin_type(var.basetype, builtin);
var.basetype = type_id;
MSL: Add option to pad fragment outputs. If not enough components are provided in the shader, the shader MSL compiler throws an error rather than make components undefined. This hurts portability, so we need to add explicit padding here.
2019-01-14 13:53:47 +00:00
Never flatten outputs when capturing them. There's no need to do so, since these are not stage-out structs being returned, but regular structures being written to a buffer. This also neatly avoids issues writing to composite (e.g. arrayed) per-patch outputs from a tessellation control shader.
2019-02-11 23:18:54 +00:00
type_id = get_pointee_type_id(var.basetype);
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
if (meta.strip_array && is_array(get<SPIRType>(type_id)))
Never flatten outputs when capturing them. There's no need to do so, since these are not stage-out structs being returned, but regular structures being written to a buffer. This also neatly avoids issues writing to composite (e.g. arrayed) per-patch outputs from a tessellation control shader.
2019-02-11 23:18:54 +00:00
type_id = get<SPIRType>(type_id).parent_type;
auto &type = get<SPIRType>(type_id);
MSL: Add option to pad fragment outputs. If not enough components are provided in the shader, the shader MSL compiler throws an error rather than make components undefined. This hurts portability, so we need to add explicit padding here.
2019-01-14 13:53:47 +00:00
uint32_t target_components = 0;
uint32_t type_components = type.vecsize;
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
MSL: Add option to pad fragment outputs. If not enough components are provided in the shader, the shader MSL compiler throws an error rather than make components undefined. This hurts portability, so we need to add explicit padding here.
2019-01-14 13:53:47 +00:00
bool padded_output = false;
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
bool padded_input = false;
uint32_t start_component = 0;
auto &entry_func = get<SPIRFunction>(ir.default_entry_point);
// Deal with Component decorations.
InterfaceBlockMeta::LocationMeta *location_meta = nullptr;
if (has_decoration(var.self, DecorationLocation))
{
auto location_meta_itr = meta.location_meta.find(get_decoration(var.self, DecorationLocation));
if (location_meta_itr != end(meta.location_meta))
location_meta = &location_meta_itr->second;
}
MSL: Add option to pad fragment outputs. If not enough components are provided in the shader, the shader MSL compiler throws an error rather than make components undefined. This hurts portability, so we need to add explicit padding here.
2019-01-14 13:53:47 +00:00
Run format_all.sh.
2020-01-08 09:48:30 +00:00
bool pad_fragment_output = has_decoration(var.self, DecorationLocation) &&
msl_options.pad_fragment_output_components &&
MSL: Deal with padded fragment output + Component decoration.
2020-01-07 16:02:12 +00:00
get_entry_point().model == ExecutionModelFragment && storage == StorageClassOutput;
MSL: Add option to pad fragment outputs. If not enough components are provided in the shader, the shader MSL compiler throws an error rather than make components undefined. This hurts portability, so we need to add explicit padding here.
2019-01-14 13:53:47 +00:00
MSL: Deal with padded fragment output + Component decoration.
2020-01-07 16:02:12 +00:00
// Check if we need to pad fragment output to match a certain number of components.
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
if (location_meta)
{
start_component = get_decoration(var.self, DecorationComponent);
uint32_t num_components = location_meta->num_components;
MSL: Deal with padded fragment output + Component decoration.
2020-01-07 16:02:12 +00:00
if (pad_fragment_output)
{
uint32_t locn = get_decoration(var.self, DecorationLocation);
num_components = std::max(num_components, get_target_components_for_fragment_location(locn));
}
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
if (location_meta->ib_index != ~0u)
{
// We have already declared the variable. Just emit an early-declared variable and fixup as needed.
entry_func.add_local_variable(var.self);
vars_needing_early_declaration.push_back(var.self);
if (var.storage == StorageClassInput)
{
uint32_t ib_index = location_meta->ib_index;
entry_func.fixup_hooks_in.push_back([=, &var]() {
statement(to_name(var.self), " = ", ib_var_ref, ".", to_member_name(ib_type, ib_index),
vector_swizzle(type_components, start_component), ";");
});
}
else
{
uint32_t ib_index = location_meta->ib_index;
entry_func.fixup_hooks_out.push_back([=, &var]() {
statement(ib_var_ref, ".", to_member_name(ib_type, ib_index),
Run format_all.sh.
2020-01-08 09:48:30 +00:00
vector_swizzle(type_components, start_component), " = ", to_name(var.self), ";");
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
});
}
return;
}
else
{
location_meta->ib_index = uint32_t(ib_type.member_types.size());
type_id = build_extended_vector_type(type_id, num_components);
if (var.storage == StorageClassInput)
padded_input = true;
else
padded_output = true;
}
}
MSL: Deal with padded fragment output + Component decoration.
2020-01-07 16:02:12 +00:00
else if (pad_fragment_output)
{
uint32_t locn = get_decoration(var.self, DecorationLocation);
target_components = get_target_components_for_fragment_location(locn);
if (type_components < target_components)
{
// Make a new type here.
type_id = build_extended_vector_type(type_id, target_components);
padded_output = true;
}
}
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
ib_type.member_types.push_back(type_id);
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
// Give the member a name
string mbr_name = ensure_valid_name(to_expression(var.self), "m");
set_member_name(ib_type.self, ib_mbr_idx, mbr_name);
// Update the original variable reference to include the structure reference
string qual_var_name = ib_var_ref + "." + mbr_name;
MSL: Add option to pad fragment outputs. If not enough components are provided in the shader, the shader MSL compiler throws an error rather than make components undefined. This hurts portability, so we need to add explicit padding here.
2019-01-14 13:53:47 +00:00
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
if (padded_output || padded_input)
MSL: Add option to pad fragment outputs. If not enough components are provided in the shader, the shader MSL compiler throws an error rather than make components undefined. This hurts portability, so we need to add explicit padding here.
2019-01-14 13:53:47 +00:00
{
entry_func.add_local_variable(var.self);
vars_needing_early_declaration.push_back(var.self);
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
if (padded_output)
{
Run format_all.sh.
2020-01-08 09:48:30 +00:00
entry_func.fixup_hooks_out.push_back([=, &var]() {
statement(qual_var_name, vector_swizzle(type_components, start_component), " = ", to_name(var.self),
";");
});
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
}
else
{
entry_func.fixup_hooks_in.push_back([=, &var]() {
Run format_all.sh.
2020-01-08 09:48:30 +00:00
statement(to_name(var.self), " = ", qual_var_name, vector_swizzle(type_components, start_component),
";");
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
});
}
MSL: Add option to pad fragment outputs. If not enough components are provided in the shader, the shader MSL compiler throws an error rather than make components undefined. This hurts portability, so we need to add explicit padding here.
2019-01-14 13:53:47 +00:00
}
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
else if (!meta.strip_array)
MSL: Add option to pad fragment outputs. If not enough components are provided in the shader, the shader MSL compiler throws an error rather than make components undefined. This hurts portability, so we need to add explicit padding here.
2019-01-14 13:53:47 +00:00
ir.meta[var.self].decoration.qualified_alias = qual_var_name;
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
if (var.storage == StorageClassOutput && var.initializer != ID(0))
Support initializers on StorageClassOutput.
2019-01-30 09:29:08 +00:00
{
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
if (padded_output || padded_input)
{
entry_func.fixup_hooks_in.push_back(
Run format_all.sh.
2020-01-08 09:48:30 +00:00
[=, &var]() { statement(to_name(var.self), " = ", to_expression(var.initializer), ";"); });
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
}
else
{
entry_func.fixup_hooks_in.push_back(
Run format_all.sh.
2020-01-08 09:48:30 +00:00
[=, &var]() { statement(qual_var_name, " = ", to_expression(var.initializer), ";"); });
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
}
Support initializers on StorageClassOutput.
2019-01-30 09:29:08 +00:00
}
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
// Copy the variable location from the original variable to the member
if (get_decoration_bitset(var.self).get(DecorationLocation))
{
uint32_t locn = get_decoration(var.self, DecorationLocation);
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
if (storage == StorageClassInput)
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
{
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
type_id = ensure_correct_input_type(var.basetype, locn, location_meta ? location_meta->num_components : 0);
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
if (!location_meta)
var.basetype = type_id;
Pass the original pointer type to ensure_correct_attribute_type(). This prevents us from overwriting the variable's type with a non-pointer type.
2019-02-11 22:07:43 +00:00
type_id = get_pointee_type_id(type_id);
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
if (meta.strip_array && is_array(get<SPIRType>(type_id)))
Pass the original pointer type to ensure_correct_attribute_type(). This prevents us from overwriting the variable's type with a non-pointer type.
2019-02-11 22:07:43 +00:00
type_id = get<SPIRType>(type_id).parent_type;
ib_type.member_types[ib_mbr_idx] = type_id;
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
}
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
mark_location_as_used_by_shader(locn, get<SPIRType>(type_id), storage);
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
}
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
else if (is_builtin && is_tessellation_shader() && inputs_by_builtin.count(builtin))
MSL: Set location of builtins based on client input. Builtin attributes in SPIR-V aren't linked by location, but by their built-in-ness. This poses a problem for MSL, since builtin inputs in the vertex pipeline are just regular attributes. We must then assign them locations so that they can be matched up to the attributes in the stage input descriptor--and also to avoid duplicate attribute numbers in tessellation evaluation shaders, where there are two different stage-in structs, so the member index therein is no longer unique!
2019-02-21 04:10:59 +00:00
{
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
uint32_t locn = inputs_by_builtin[builtin].location;
MSL: Set location of builtins based on client input. Builtin attributes in SPIR-V aren't linked by location, but by their built-in-ness. This poses a problem for MSL, since builtin inputs in the vertex pipeline are just regular attributes. We must then assign them locations so that they can be matched up to the attributes in the stage input descriptor--and also to avoid duplicate attribute numbers in tessellation evaluation shaders, where there are two different stage-in structs, so the member index therein is no longer unique!
2019-02-21 04:10:59 +00:00
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
mark_location_as_used_by_shader(locn, type, storage);
MSL: Set location of builtins based on client input. Builtin attributes in SPIR-V aren't linked by location, but by their built-in-ness. This poses a problem for MSL, since builtin inputs in the vertex pipeline are just regular attributes. We must then assign them locations so that they can be matched up to the attributes in the stage input descriptor--and also to avoid duplicate attribute numbers in tessellation evaluation shaders, where there are two different stage-in structs, so the member index therein is no longer unique!
2019-02-21 04:10:59 +00:00
}
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
if (!location_meta)
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
{
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
if (get_decoration_bitset(var.self).get(DecorationComponent))
{
uint32_t component = get_decoration(var.self, DecorationComponent);
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationComponent, component);
}
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
}
if (get_decoration_bitset(var.self).get(DecorationIndex))
{
uint32_t index = get_decoration(var.self, DecorationIndex);
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationIndex, index);
}
// Mark the member as builtin if needed
if (is_builtin)
{
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationBuiltIn, builtin);
MSL: Make sure we fix up the output position. If a stage takes the position as both an input and an output (i.e. a tessellation shader or a geometry shader), then we could wind up fixing up the input position by mistake. Ensure that doesn't happen, by only setting the `qual_pos_var_name` variable from the output position.
2019-02-22 21:26:00 +00:00
if (builtin == BuiltInPosition && storage == StorageClassOutput)
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
qual_pos_var_name = qual_var_name;
}
// Copy interpolation decorations if needed
if (is_flat)
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationFlat);
if (is_noperspective)
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationNoPerspective);
if (is_centroid)
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationCentroid);
if (is_sample)
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationSample);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
MSL: Don't set OrigID when emitting component packed vectors. There is no unique OrigID, so we shouldn't ever need to look at this value.
2020-01-07 13:57:19 +00:00
// If we have location meta, there is no unique OrigID. We won't need it, since we flatten/unflatten
// the variable to stack anyways here.
if (!location_meta)
set_extended_member_decoration(ib_type.self, ib_mbr_idx, SPIRVCrossDecorationInterfaceOrigID, var.self);
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
}
void CompilerMSL::add_composite_variable_to_interface_block(StorageClass storage, const string &ib_var_ref,
Run format_all.sh.
2020-01-08 09:48:30 +00:00
SPIRType &ib_type, SPIRVariable &var,
InterfaceBlockMeta &meta)
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
{
auto &entry_func = get<SPIRFunction>(ir.default_entry_point);
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
auto &var_type = meta.strip_array ? get_variable_element_type(var) : get_variable_data_type(var);
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
uint32_t elem_cnt = 0;
if (is_matrix(var_type))
{
if (is_array(var_type))
SPIRV_CROSS_THROW("MSL cannot emit arrays-of-matrices in input and output variables.");
elem_cnt = var_type.columns;
}
else if (is_array(var_type))
{
if (var_type.array.size() != 1)
SPIRV_CROSS_THROW("MSL cannot emit arrays-of-arrays in input and output variables.");
elem_cnt = to_array_size_literal(var_type);
}
MSL: Set location of builtins based on client input. Builtin attributes in SPIR-V aren't linked by location, but by their built-in-ness. This poses a problem for MSL, since builtin inputs in the vertex pipeline are just regular attributes. We must then assign them locations so that they can be matched up to the attributes in the stage input descriptor--and also to avoid duplicate attribute numbers in tessellation evaluation shaders, where there are two different stage-in structs, so the member index therein is no longer unique!
2019-02-21 04:10:59 +00:00
bool is_builtin = is_builtin_variable(var);
BuiltIn builtin = BuiltIn(get_decoration(var.self, DecorationBuiltIn));
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
bool is_flat = has_decoration(var.self, DecorationFlat);
bool is_noperspective = has_decoration(var.self, DecorationNoPerspective);
bool is_centroid = has_decoration(var.self, DecorationCentroid);
bool is_sample = has_decoration(var.self, DecorationSample);
auto *usable_type = &var_type;
if (usable_type->pointer)
usable_type = &get<SPIRType>(usable_type->parent_type);
while (is_array(*usable_type) || is_matrix(*usable_type))
usable_type = &get<SPIRType>(usable_type->parent_type);
MSL: Force unnamed array builtin attributes to have a name. That way, when we refer to them, they'll have the name that we're expecting.
2019-02-21 02:23:02 +00:00
// If a builtin, force it to have the proper name.
MSL: Set location of builtins based on client input. Builtin attributes in SPIR-V aren't linked by location, but by their built-in-ness. This poses a problem for MSL, since builtin inputs in the vertex pipeline are just regular attributes. We must then assign them locations so that they can be matched up to the attributes in the stage input descriptor--and also to avoid duplicate attribute numbers in tessellation evaluation shaders, where there are two different stage-in structs, so the member index therein is no longer unique!
2019-02-21 04:10:59 +00:00
if (is_builtin)
MSL: Force unnamed array builtin attributes to have a name. That way, when we refer to them, they'll have the name that we're expecting.
2019-02-21 02:23:02 +00:00
set_name(var.self, builtin_to_glsl(builtin, StorageClassFunction));
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
bool flatten_from_ib_var = false;
Deal with illegal names in types as well. - Fixes issue with clip_distance flattening in MSL where member to flatten from would come from to_member_name, where it should have used the builtin name directly. This member name was modified by this patch and broke clip distance test shaders. - Some cleanups with ir.meta, use ir.find_meta instead to not create unnecessary hashmap nodes.
2020-01-16 09:28:54 +00:00
string flatten_from_ib_mbr_name;
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
Fix uninitialized memory issue. Seen on Travis with MSVC Win32 Release builds only.
2019-12-02 14:52:00 +00:00
if (storage == StorageClassOutput && is_builtin && builtin == BuiltInClipDistance)
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
{
// Also declare [[clip_distance]] attribute here.
uint32_t clip_array_mbr_idx = uint32_t(ib_type.member_types.size());
ib_type.member_types.push_back(get_variable_data_type_id(var));
set_member_decoration(ib_type.self, clip_array_mbr_idx, DecorationBuiltIn, BuiltInClipDistance);
Deal with illegal names in types as well. - Fixes issue with clip_distance flattening in MSL where member to flatten from would come from to_member_name, where it should have used the builtin name directly. This member name was modified by this patch and broke clip distance test shaders. - Some cleanups with ir.meta, use ir.find_meta instead to not create unnecessary hashmap nodes.
2020-01-16 09:28:54 +00:00
flatten_from_ib_mbr_name = builtin_to_glsl(BuiltInClipDistance, StorageClassOutput);
set_member_name(ib_type.self, clip_array_mbr_idx, flatten_from_ib_mbr_name);
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
// When we flatten, we flatten directly from the "out" struct,
// not from a function variable.
flatten_from_ib_var = true;
MSL: Allow removing clip distance user varyings. Only safe if user knows that subsequent shader stage will not read clip distance.
2020-04-20 07:48:20 +00:00
if (!msl_options.enable_clip_distance_user_varying)
return;
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
}
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
else if (!meta.strip_array)
MSL: Do not declare variables which will not be unflattened. Non-patch arrays of IO variables in tesc/tese have their array index stripped, and access chains are specially handled, we shouldn't attempt to create "normal" arrays of these.
2019-10-25 11:54:38 +00:00
{
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
// Only flatten/unflatten IO composites for non-tessellation cases where arrays are not stripped.
MSL: Do not declare variables which will not be unflattened. Non-patch arrays of IO variables in tesc/tese have their array index stripped, and access chains are specially handled, we shouldn't attempt to create "normal" arrays of these.
2019-10-25 11:54:38 +00:00
entry_func.add_local_variable(var.self);
// We need to declare the variable early and at entry-point scope.
vars_needing_early_declaration.push_back(var.self);
}
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
for (uint32_t i = 0; i < elem_cnt; i++)
{
// Add a reference to the variable type to the interface struct.
uint32_t ib_mbr_idx = uint32_t(ib_type.member_types.size());
MSL: Add option to pad fragment outputs. If not enough components are provided in the shader, the shader MSL compiler throws an error rather than make components undefined. This hurts portability, so we need to add explicit padding here.
2019-01-14 13:53:47 +00:00
uint32_t target_components = 0;
bool padded_output = false;
uint32_t type_id = usable_type->self;
// Check if we need to pad fragment output to match a certain number of components.
if (get_decoration_bitset(var.self).get(DecorationLocation) && msl_options.pad_fragment_output_components &&
get_entry_point().model == ExecutionModelFragment && storage == StorageClassOutput)
{
uint32_t locn = get_decoration(var.self, DecorationLocation) + i;
target_components = get_target_components_for_fragment_location(locn);
if (usable_type->vecsize < target_components)
{
// Make a new type here.
type_id = build_extended_vector_type(usable_type->self, target_components);
padded_output = true;
}
}
ib_type.member_types.push_back(get_pointee_type_id(type_id));
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
// Give the member a name
string mbr_name = ensure_valid_name(join(to_expression(var.self), "_", i), "m");
set_member_name(ib_type.self, ib_mbr_idx, mbr_name);
// There is no qualified alias since we need to flatten the internal array on return.
if (get_decoration_bitset(var.self).get(DecorationLocation))
{
uint32_t locn = get_decoration(var.self, DecorationLocation) + i;
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
if (storage == StorageClassInput)
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
{
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
var.basetype = ensure_correct_input_type(var.basetype, locn);
uint32_t mbr_type_id = ensure_correct_input_type(usable_type->self, locn);
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
ib_type.member_types[ib_mbr_idx] = mbr_type_id;
}
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
mark_location_as_used_by_shader(locn, *usable_type, storage);
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
}
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
else if (is_builtin && is_tessellation_shader() && inputs_by_builtin.count(builtin))
MSL: Set location of builtins based on client input. Builtin attributes in SPIR-V aren't linked by location, but by their built-in-ness. This poses a problem for MSL, since builtin inputs in the vertex pipeline are just regular attributes. We must then assign them locations so that they can be matched up to the attributes in the stage input descriptor--and also to avoid duplicate attribute numbers in tessellation evaluation shaders, where there are two different stage-in structs, so the member index therein is no longer unique!
2019-02-21 04:10:59 +00:00
{
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
uint32_t locn = inputs_by_builtin[builtin].location + i;
MSL: Set location of builtins based on client input. Builtin attributes in SPIR-V aren't linked by location, but by their built-in-ness. This poses a problem for MSL, since builtin inputs in the vertex pipeline are just regular attributes. We must then assign them locations so that they can be matched up to the attributes in the stage input descriptor--and also to avoid duplicate attribute numbers in tessellation evaluation shaders, where there are two different stage-in structs, so the member index therein is no longer unique!
2019-02-21 04:10:59 +00:00
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
mark_location_as_used_by_shader(locn, *usable_type, storage);
MSL: Set location of builtins based on client input. Builtin attributes in SPIR-V aren't linked by location, but by their built-in-ness. This poses a problem for MSL, since builtin inputs in the vertex pipeline are just regular attributes. We must then assign them locations so that they can be matched up to the attributes in the stage input descriptor--and also to avoid duplicate attribute numbers in tessellation evaluation shaders, where there are two different stage-in structs, so the member index therein is no longer unique!
2019-02-21 04:10:59 +00:00
}
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
else if (is_builtin && builtin == BuiltInClipDistance)
{
// Declare the ClipDistance as [[user(clipN)]].
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationBuiltIn, BuiltInClipDistance);
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, i);
}
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
if (get_decoration_bitset(var.self).get(DecorationIndex))
{
uint32_t index = get_decoration(var.self, DecorationIndex);
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationIndex, index);
}
// Copy interpolation decorations if needed
if (is_flat)
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationFlat);
if (is_noperspective)
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationNoPerspective);
if (is_centroid)
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationCentroid);
if (is_sample)
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationSample);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
set_extended_member_decoration(ib_type.self, ib_mbr_idx, SPIRVCrossDecorationInterfaceOrigID, var.self);
MSL: Do not declare variables which will not be unflattened. Non-patch arrays of IO variables in tesc/tese have their array index stripped, and access chains are specially handled, we shouldn't attempt to create "normal" arrays of these.
2019-10-25 11:54:38 +00:00
// Only flatten/unflatten IO composites for non-tessellation cases where arrays are not stripped.
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
if (!meta.strip_array)
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
{
Don't set any aliases or do any flattening for arrayed per-vertex I/O. We already handle all that specially.
2019-02-15 23:22:37 +00:00
switch (storage)
{
case StorageClassInput:
entry_func.fixup_hooks_in.push_back(
[=, &var]() { statement(to_name(var.self), "[", i, "] = ", ib_var_ref, ".", mbr_name, ";"); });
break;
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
Don't set any aliases or do any flattening for arrayed per-vertex I/O. We already handle all that specially.
2019-02-15 23:22:37 +00:00
case StorageClassOutput:
entry_func.fixup_hooks_out.push_back([=, &var]() {
if (padded_output)
{
auto &padded_type = this->get<SPIRType>(type_id);
statement(
ib_var_ref, ".", mbr_name, " = ",
remap_swizzle(padded_type, usable_type->vecsize, join(to_name(var.self), "[", i, "]")),
";");
}
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
else if (flatten_from_ib_var)
Run format_all.sh.
2020-01-16 14:20:59 +00:00
statement(ib_var_ref, ".", mbr_name, " = ", ib_var_ref, ".", flatten_from_ib_mbr_name, "[", i,
"];");
Don't set any aliases or do any flattening for arrayed per-vertex I/O. We already handle all that specially.
2019-02-15 23:22:37 +00:00
else
statement(ib_var_ref, ".", mbr_name, " = ", to_name(var.self), "[", i, "];");
});
break;
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
Don't set any aliases or do any flattening for arrayed per-vertex I/O. We already handle all that specially.
2019-02-15 23:22:37 +00:00
default:
break;
}
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
}
}
}
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
uint32_t CompilerMSL::get_accumulated_member_location(const SPIRVariable &var, uint32_t mbr_idx, bool strip_array)
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
{
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
auto &type = strip_array ? get_variable_element_type(var) : get_variable_data_type(var);
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
uint32_t location = get_decoration(var.self, DecorationLocation);
for (uint32_t i = 0; i < mbr_idx; i++)
{
auto &mbr_type = get<SPIRType>(type.member_types[i]);
// Start counting from any place we have a new location decoration.
if (has_member_decoration(type.self, mbr_idx, DecorationLocation))
location = get_member_decoration(type.self, mbr_idx, DecorationLocation);
uint32_t location_count = 1;
if (mbr_type.columns > 1)
location_count = mbr_type.columns;
if (!mbr_type.array.empty())
for (uint32_t j = 0; j < uint32_t(mbr_type.array.size()); j++)
location_count *= to_array_size_literal(mbr_type, j);
location += location_count;
}
return location;
}
void CompilerMSL::add_composite_member_variable_to_interface_block(StorageClass storage, const string &ib_var_ref,
SPIRType &ib_type, SPIRVariable &var,
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
uint32_t mbr_idx, InterfaceBlockMeta &meta)
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
{
auto &entry_func = get<SPIRFunction>(ir.default_entry_point);
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
auto &var_type = meta.strip_array ? get_variable_element_type(var) : get_variable_data_type(var);
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
Fix uninitialized memory issue. Seen on Travis with MSVC Win32 Release builds only.
2019-12-02 14:52:00 +00:00
BuiltIn builtin = BuiltInMax;
MSL: Set location of builtins based on client input. Builtin attributes in SPIR-V aren't linked by location, but by their built-in-ness. This poses a problem for MSL, since builtin inputs in the vertex pipeline are just regular attributes. We must then assign them locations so that they can be matched up to the attributes in the stage input descriptor--and also to avoid duplicate attribute numbers in tessellation evaluation shaders, where there are two different stage-in structs, so the member index therein is no longer unique!
2019-02-21 04:10:59 +00:00
bool is_builtin = is_member_builtin(var_type, mbr_idx, &builtin);
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
bool is_flat =
has_member_decoration(var_type.self, mbr_idx, DecorationFlat) || has_decoration(var.self, DecorationFlat);
bool is_noperspective = has_member_decoration(var_type.self, mbr_idx, DecorationNoPerspective) ||
has_decoration(var.self, DecorationNoPerspective);
bool is_centroid = has_member_decoration(var_type.self, mbr_idx, DecorationCentroid) ||
has_decoration(var.self, DecorationCentroid);
bool is_sample =
has_member_decoration(var_type.self, mbr_idx, DecorationSample) || has_decoration(var.self, DecorationSample);
uint32_t mbr_type_id = var_type.member_types[mbr_idx];
auto &mbr_type = get<SPIRType>(mbr_type_id);
uint32_t elem_cnt = 0;
if (is_matrix(mbr_type))
{
if (is_array(mbr_type))
SPIRV_CROSS_THROW("MSL cannot emit arrays-of-matrices in input and output variables.");
elem_cnt = mbr_type.columns;
}
else if (is_array(mbr_type))
{
if (mbr_type.array.size() != 1)
SPIRV_CROSS_THROW("MSL cannot emit arrays-of-arrays in input and output variables.");
elem_cnt = to_array_size_literal(mbr_type);
}
auto *usable_type = &mbr_type;
if (usable_type->pointer)
usable_type = &get<SPIRType>(usable_type->parent_type);
while (is_array(*usable_type) || is_matrix(*usable_type))
usable_type = &get<SPIRType>(usable_type->parent_type);
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
bool flatten_from_ib_var = false;
Deal with illegal names in types as well. - Fixes issue with clip_distance flattening in MSL where member to flatten from would come from to_member_name, where it should have used the builtin name directly. This member name was modified by this patch and broke clip distance test shaders. - Some cleanups with ir.meta, use ir.find_meta instead to not create unnecessary hashmap nodes.
2020-01-16 09:28:54 +00:00
string flatten_from_ib_mbr_name;
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
Fix uninitialized memory issue. Seen on Travis with MSVC Win32 Release builds only.
2019-12-02 14:52:00 +00:00
if (storage == StorageClassOutput && is_builtin && builtin == BuiltInClipDistance)
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
{
// Also declare [[clip_distance]] attribute here.
uint32_t clip_array_mbr_idx = uint32_t(ib_type.member_types.size());
ib_type.member_types.push_back(mbr_type_id);
set_member_decoration(ib_type.self, clip_array_mbr_idx, DecorationBuiltIn, BuiltInClipDistance);
Deal with illegal names in types as well. - Fixes issue with clip_distance flattening in MSL where member to flatten from would come from to_member_name, where it should have used the builtin name directly. This member name was modified by this patch and broke clip distance test shaders. - Some cleanups with ir.meta, use ir.find_meta instead to not create unnecessary hashmap nodes.
2020-01-16 09:28:54 +00:00
flatten_from_ib_mbr_name = builtin_to_glsl(BuiltInClipDistance, StorageClassOutput);
set_member_name(ib_type.self, clip_array_mbr_idx, flatten_from_ib_mbr_name);
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
// When we flatten, we flatten directly from the "out" struct,
// not from a function variable.
flatten_from_ib_var = true;
MSL: Allow removing clip distance user varyings. Only safe if user knows that subsequent shader stage will not read clip distance.
2020-04-20 07:48:20 +00:00
if (!msl_options.enable_clip_distance_user_varying)
return;
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
}
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
for (uint32_t i = 0; i < elem_cnt; i++)
{
// Add a reference to the variable type to the interface struct.
uint32_t ib_mbr_idx = uint32_t(ib_type.member_types.size());
ib_type.member_types.push_back(usable_type->self);
// Give the member a name
string mbr_name = ensure_valid_name(join(to_qualified_member_name(var_type, mbr_idx), "_", i), "m");
set_member_name(ib_type.self, ib_mbr_idx, mbr_name);
if (has_member_decoration(var_type.self, mbr_idx, DecorationLocation))
{
uint32_t locn = get_member_decoration(var_type.self, mbr_idx, DecorationLocation) + i;
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
mark_location_as_used_by_shader(locn, *usable_type, storage);
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
}
else if (has_decoration(var.self, DecorationLocation))
{
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
uint32_t locn = get_accumulated_member_location(var, mbr_idx, meta.strip_array) + i;
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
mark_location_as_used_by_shader(locn, *usable_type, storage);
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
}
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
else if (is_builtin && is_tessellation_shader() && inputs_by_builtin.count(builtin))
MSL: Set location of builtins based on client input. Builtin attributes in SPIR-V aren't linked by location, but by their built-in-ness. This poses a problem for MSL, since builtin inputs in the vertex pipeline are just regular attributes. We must then assign them locations so that they can be matched up to the attributes in the stage input descriptor--and also to avoid duplicate attribute numbers in tessellation evaluation shaders, where there are two different stage-in structs, so the member index therein is no longer unique!
2019-02-21 04:10:59 +00:00
{
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
uint32_t locn = inputs_by_builtin[builtin].location + i;
MSL: Set location of builtins based on client input. Builtin attributes in SPIR-V aren't linked by location, but by their built-in-ness. This poses a problem for MSL, since builtin inputs in the vertex pipeline are just regular attributes. We must then assign them locations so that they can be matched up to the attributes in the stage input descriptor--and also to avoid duplicate attribute numbers in tessellation evaluation shaders, where there are two different stage-in structs, so the member index therein is no longer unique!
2019-02-21 04:10:59 +00:00
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
mark_location_as_used_by_shader(locn, *usable_type, storage);
MSL: Set location of builtins based on client input. Builtin attributes in SPIR-V aren't linked by location, but by their built-in-ness. This poses a problem for MSL, since builtin inputs in the vertex pipeline are just regular attributes. We must then assign them locations so that they can be matched up to the attributes in the stage input descriptor--and also to avoid duplicate attribute numbers in tessellation evaluation shaders, where there are two different stage-in structs, so the member index therein is no longer unique!
2019-02-21 04:10:59 +00:00
}
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
else if (is_builtin && builtin == BuiltInClipDistance)
{
// Declare the ClipDistance as [[user(clipN)]].
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationBuiltIn, BuiltInClipDistance);
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, i);
}
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
if (has_member_decoration(var_type.self, mbr_idx, DecorationComponent))
SPIRV_CROSS_THROW("DecorationComponent on matrices and arrays make little sense.");
// Copy interpolation decorations if needed
if (is_flat)
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationFlat);
if (is_noperspective)
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationNoPerspective);
if (is_centroid)
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationCentroid);
if (is_sample)
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationSample);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
set_extended_member_decoration(ib_type.self, ib_mbr_idx, SPIRVCrossDecorationInterfaceOrigID, var.self);
set_extended_member_decoration(ib_type.self, ib_mbr_idx, SPIRVCrossDecorationInterfaceMemberIndex, mbr_idx);
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
// Unflatten or flatten from [[stage_in]] or [[stage_out]] as appropriate.
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
if (!meta.strip_array)
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
{
Don't set any aliases or do any flattening for arrayed per-vertex I/O. We already handle all that specially.
2019-02-15 23:22:37 +00:00
switch (storage)
{
case StorageClassInput:
entry_func.fixup_hooks_in.push_back([=, &var, &var_type]() {
statement(to_name(var.self), ".", to_member_name(var_type, mbr_idx), "[", i, "] = ", ib_var_ref,
".", mbr_name, ";");
});
break;
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
Don't set any aliases or do any flattening for arrayed per-vertex I/O. We already handle all that specially.
2019-02-15 23:22:37 +00:00
case StorageClassOutput:
entry_func.fixup_hooks_out.push_back([=, &var, &var_type]() {
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
if (flatten_from_ib_var)
{
Run format_all.sh.
2020-01-16 14:20:59 +00:00
statement(ib_var_ref, ".", mbr_name, " = ", ib_var_ref, ".", flatten_from_ib_mbr_name, "[", i,
"];");
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
}
else
{
statement(ib_var_ref, ".", mbr_name, " = ", to_name(var.self), ".",
to_member_name(var_type, mbr_idx), "[", i, "];");
}
Don't set any aliases or do any flattening for arrayed per-vertex I/O. We already handle all that specially.
2019-02-15 23:22:37 +00:00
});
break;
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
Don't set any aliases or do any flattening for arrayed per-vertex I/O. We already handle all that specially.
2019-02-15 23:22:37 +00:00
default:
break;
}
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
}
}
}
void CompilerMSL::add_plain_member_variable_to_interface_block(StorageClass storage, const string &ib_var_ref,
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
SPIRType &ib_type, SPIRVariable &var, uint32_t mbr_idx,
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
InterfaceBlockMeta &meta)
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
{
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
auto &var_type = meta.strip_array ? get_variable_element_type(var) : get_variable_data_type(var);
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
auto &entry_func = get<SPIRFunction>(ir.default_entry_point);
BuiltIn builtin = BuiltInMax;
bool is_builtin = is_member_builtin(var_type, mbr_idx, &builtin);
bool is_flat =
has_member_decoration(var_type.self, mbr_idx, DecorationFlat) || has_decoration(var.self, DecorationFlat);
bool is_noperspective = has_member_decoration(var_type.self, mbr_idx, DecorationNoPerspective) ||
has_decoration(var.self, DecorationNoPerspective);
bool is_centroid = has_member_decoration(var_type.self, mbr_idx, DecorationCentroid) ||
has_decoration(var.self, DecorationCentroid);
bool is_sample =
has_member_decoration(var_type.self, mbr_idx, DecorationSample) || has_decoration(var.self, DecorationSample);
// Add a reference to the member to the interface struct.
uint32_t mbr_type_id = var_type.member_types[mbr_idx];
uint32_t ib_mbr_idx = uint32_t(ib_type.member_types.size());
mbr_type_id = ensure_correct_builtin_type(mbr_type_id, builtin);
var_type.member_types[mbr_idx] = mbr_type_id;
ib_type.member_types.push_back(mbr_type_id);
// Give the member a name
string mbr_name = ensure_valid_name(to_qualified_member_name(var_type, mbr_idx), "m");
set_member_name(ib_type.self, ib_mbr_idx, mbr_name);
// Update the original variable reference to include the structure reference
string qual_var_name = ib_var_ref + "." + mbr_name;
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
if (is_builtin && !meta.strip_array)
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
{
// For the builtin gl_PerVertex, we cannot treat it as a block anyways,
// so redirect to qualified name.
set_member_qualified_name(var_type.self, mbr_idx, qual_var_name);
}
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
else if (!meta.strip_array)
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
{
// Unflatten or flatten from [[stage_in]] or [[stage_out]] as appropriate.
switch (storage)
{
case StorageClassInput:
MSL: Add option to pad fragment outputs. If not enough components are provided in the shader, the shader MSL compiler throws an error rather than make components undefined. This hurts portability, so we need to add explicit padding here.
2019-01-14 13:53:47 +00:00
entry_func.fixup_hooks_in.push_back([=, &var, &var_type]() {
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
statement(to_name(var.self), ".", to_member_name(var_type, mbr_idx), " = ", qual_var_name, ";");
});
break;
case StorageClassOutput:
MSL: Add option to pad fragment outputs. If not enough components are provided in the shader, the shader MSL compiler throws an error rather than make components undefined. This hurts portability, so we need to add explicit padding here.
2019-01-14 13:53:47 +00:00
entry_func.fixup_hooks_out.push_back([=, &var, &var_type]() {
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
statement(qual_var_name, " = ", to_name(var.self), ".", to_member_name(var_type, mbr_idx), ";");
});
break;
default:
break;
}
}
// Copy the variable location from the original variable to the member
if (has_member_decoration(var_type.self, mbr_idx, DecorationLocation))
{
uint32_t locn = get_member_decoration(var_type.self, mbr_idx, DecorationLocation);
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
if (storage == StorageClassInput)
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
{
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
mbr_type_id = ensure_correct_input_type(mbr_type_id, locn);
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
var_type.member_types[mbr_idx] = mbr_type_id;
ib_type.member_types[ib_mbr_idx] = mbr_type_id;
}
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
mark_location_as_used_by_shader(locn, get<SPIRType>(mbr_type_id), storage);
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
}
else if (has_decoration(var.self, DecorationLocation))
{
// The block itself might have a location and in this case, all members of the block
// receive incrementing locations.
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
uint32_t locn = get_accumulated_member_location(var, mbr_idx, meta.strip_array);
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
if (storage == StorageClassInput)
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
{
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
mbr_type_id = ensure_correct_input_type(mbr_type_id, locn);
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
var_type.member_types[mbr_idx] = mbr_type_id;
ib_type.member_types[ib_mbr_idx] = mbr_type_id;
}
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
mark_location_as_used_by_shader(locn, get<SPIRType>(mbr_type_id), storage);
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
}
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
else if (is_builtin && is_tessellation_shader() && inputs_by_builtin.count(builtin))
MSL: Set location of builtins based on client input. Builtin attributes in SPIR-V aren't linked by location, but by their built-in-ness. This poses a problem for MSL, since builtin inputs in the vertex pipeline are just regular attributes. We must then assign them locations so that they can be matched up to the attributes in the stage input descriptor--and also to avoid duplicate attribute numbers in tessellation evaluation shaders, where there are two different stage-in structs, so the member index therein is no longer unique!
2019-02-21 04:10:59 +00:00
{
Add a stable C API for SPIRV-Cross. This adds a new C API for SPIRV-Cross which is intended to be stable, both API and ABI wise. The C++ API has been refactored a bit to make the C wrapper easier and cleaner to write. Especially the vertex attribute / resource interfaces for MSL has been rewritten to avoid taking mutable pointers into the interface. This would be very annoying to wrap and it didn't fit well with the rest of the C++ API to begin with. While doing this, I went ahead and removed all the old deprecated interfaces. The CMake build system has also seen an overhaul. It is now possible to build static/shared/CLI separately with -D options. The shared library only exposes the C API, as it is the only ABI-stable API. pkg-configs as well as CMake modules are exported and installed for the shared library configuration.
2019-02-12 10:11:29 +00:00
uint32_t locn = 0;
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
auto builtin_itr = inputs_by_builtin.find(builtin);
if (builtin_itr != end(inputs_by_builtin))
Add a stable C API for SPIRV-Cross. This adds a new C API for SPIRV-Cross which is intended to be stable, both API and ABI wise. The C++ API has been refactored a bit to make the C wrapper easier and cleaner to write. Especially the vertex attribute / resource interfaces for MSL has been rewritten to avoid taking mutable pointers into the interface. This would be very annoying to wrap and it didn't fit well with the rest of the C++ API to begin with. While doing this, I went ahead and removed all the old deprecated interfaces. The CMake build system has also seen an overhaul. It is now possible to build static/shared/CLI separately with -D options. The shared library only exposes the C API, as it is the only ABI-stable API. pkg-configs as well as CMake modules are exported and installed for the shared library configuration.
2019-02-12 10:11:29 +00:00
locn = builtin_itr->second.location;
MSL: Set location of builtins based on client input. Builtin attributes in SPIR-V aren't linked by location, but by their built-in-ness. This poses a problem for MSL, since builtin inputs in the vertex pipeline are just regular attributes. We must then assign them locations so that they can be matched up to the attributes in the stage input descriptor--and also to avoid duplicate attribute numbers in tessellation evaluation shaders, where there are two different stage-in structs, so the member index therein is no longer unique!
2019-02-21 04:10:59 +00:00
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
mark_location_as_used_by_shader(locn, get<SPIRType>(mbr_type_id), storage);
MSL: Set location of builtins based on client input. Builtin attributes in SPIR-V aren't linked by location, but by their built-in-ness. This poses a problem for MSL, since builtin inputs in the vertex pipeline are just regular attributes. We must then assign them locations so that they can be matched up to the attributes in the stage input descriptor--and also to avoid duplicate attribute numbers in tessellation evaluation shaders, where there are two different stage-in structs, so the member index therein is no longer unique!
2019-02-21 04:10:59 +00:00
}
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
// Copy the component location, if present.
if (has_member_decoration(var_type.self, mbr_idx, DecorationComponent))
{
uint32_t comp = get_member_decoration(var_type.self, mbr_idx, DecorationComponent);
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationComponent, comp);
}
// Mark the member as builtin if needed
if (is_builtin)
{
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationBuiltIn, builtin);
MSL: Make sure we fix up the output position. If a stage takes the position as both an input and an output (i.e. a tessellation shader or a geometry shader), then we could wind up fixing up the input position by mistake. Ensure that doesn't happen, by only setting the `qual_pos_var_name` variable from the output position.
2019-02-22 21:26:00 +00:00
if (builtin == BuiltInPosition && storage == StorageClassOutput)
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
qual_pos_var_name = qual_var_name;
}
// Copy interpolation decorations if needed
if (is_flat)
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationFlat);
if (is_noperspective)
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationNoPerspective);
if (is_centroid)
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationCentroid);
if (is_sample)
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationSample);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
set_extended_member_decoration(ib_type.self, ib_mbr_idx, SPIRVCrossDecorationInterfaceOrigID, var.self);
set_extended_member_decoration(ib_type.self, ib_mbr_idx, SPIRVCrossDecorationInterfaceMemberIndex, mbr_idx);
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
}
MSL: Use vectors for the tessellation level builtins in tese shaders. The tessellation levels in Metal are stored as a densely-packed array of half-precision floating point values. But, stage-in attributes in Metal have to have offsets and strides aligned to a multiple of four, so we can't add them individually. Luckily for us, the arrays have lengths less than 4. So, let's use vectors for them! Triangles get a single attribute with a `float4`, where the outer levels are in `.xyz` and the inner levels are in `.w`. The arrays are unpacked as though we had added the elements individually. Quads get two: a `float4` with the outer levels and a `float2` with the inner levels. Further, since vectors can be indexed as arrays, there's no need to unpack them in this case. This also saves on precious vertex attributes. Before, we were using up to 6 of them. Now we need two at most.
2019-02-22 18:11:17 +00:00
// In Metal, the tessellation levels are stored as tightly packed half-precision floating point values.
// But, stage-in attribute offsets and strides must be multiples of four, so we can't pass the levels
// individually. Therefore, we must pass them as vectors. Triangles get a single float4, with the outer
// levels in 'xyz' and the inner level in 'w'. Quads get a float4 containing the outer levels and a
// float2 containing the inner levels.
void CompilerMSL::add_tess_level_input_to_interface_block(const std::string &ib_var_ref, SPIRType &ib_type,
SPIRVariable &var)
{
auto &entry_func = get<SPIRFunction>(ir.default_entry_point);
auto &var_type = get_variable_element_type(var);
BuiltIn builtin = BuiltIn(get_decoration(var.self, DecorationBuiltIn));
// Force the variable to have the proper name.
set_name(var.self, builtin_to_glsl(builtin, StorageClassFunction));
if (get_entry_point().flags.get(ExecutionModeTriangles))
{
// Triangles are tricky, because we want only one member in the struct.
// We need to declare the variable early and at entry-point scope.
entry_func.add_local_variable(var.self);
vars_needing_early_declaration.push_back(var.self);
string mbr_name = "gl_TessLevel";
// If we already added the other one, we can skip this step.
if (!added_builtin_tess_level)
{
// Add a reference to the variable type to the interface struct.
uint32_t ib_mbr_idx = uint32_t(ib_type.member_types.size());
uint32_t type_id = build_extended_vector_type(var_type.self, 4);
ib_type.member_types.push_back(type_id);
// Give the member a name
set_member_name(ib_type.self, ib_mbr_idx, mbr_name);
// There is no qualified alias since we need to flatten the internal array on return.
if (get_decoration_bitset(var.self).get(DecorationLocation))
{
uint32_t locn = get_decoration(var.self, DecorationLocation);
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
mark_location_as_used_by_shader(locn, var_type, StorageClassInput);
MSL: Use vectors for the tessellation level builtins in tese shaders. The tessellation levels in Metal are stored as a densely-packed array of half-precision floating point values. But, stage-in attributes in Metal have to have offsets and strides aligned to a multiple of four, so we can't add them individually. Luckily for us, the arrays have lengths less than 4. So, let's use vectors for them! Triangles get a single attribute with a `float4`, where the outer levels are in `.xyz` and the inner levels are in `.w`. The arrays are unpacked as though we had added the elements individually. Quads get two: a `float4` with the outer levels and a `float2` with the inner levels. Further, since vectors can be indexed as arrays, there's no need to unpack them in this case. This also saves on precious vertex attributes. Before, we were using up to 6 of them. Now we need two at most.
2019-02-22 18:11:17 +00:00
}
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
else if (inputs_by_builtin.count(builtin))
MSL: Use vectors for the tessellation level builtins in tese shaders. The tessellation levels in Metal are stored as a densely-packed array of half-precision floating point values. But, stage-in attributes in Metal have to have offsets and strides aligned to a multiple of four, so we can't add them individually. Luckily for us, the arrays have lengths less than 4. So, let's use vectors for them! Triangles get a single attribute with a `float4`, where the outer levels are in `.xyz` and the inner levels are in `.w`. The arrays are unpacked as though we had added the elements individually. Quads get two: a `float4` with the outer levels and a `float2` with the inner levels. Further, since vectors can be indexed as arrays, there's no need to unpack them in this case. This also saves on precious vertex attributes. Before, we were using up to 6 of them. Now we need two at most.
2019-02-22 18:11:17 +00:00
{
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
uint32_t locn = inputs_by_builtin[builtin].location;
MSL: Use vectors for the tessellation level builtins in tese shaders. The tessellation levels in Metal are stored as a densely-packed array of half-precision floating point values. But, stage-in attributes in Metal have to have offsets and strides aligned to a multiple of four, so we can't add them individually. Luckily for us, the arrays have lengths less than 4. So, let's use vectors for them! Triangles get a single attribute with a `float4`, where the outer levels are in `.xyz` and the inner levels are in `.w`. The arrays are unpacked as though we had added the elements individually. Quads get two: a `float4` with the outer levels and a `float2` with the inner levels. Further, since vectors can be indexed as arrays, there's no need to unpack them in this case. This also saves on precious vertex attributes. Before, we were using up to 6 of them. Now we need two at most.
2019-02-22 18:11:17 +00:00
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
mark_location_as_used_by_shader(locn, var_type, StorageClassInput);
MSL: Use vectors for the tessellation level builtins in tese shaders. The tessellation levels in Metal are stored as a densely-packed array of half-precision floating point values. But, stage-in attributes in Metal have to have offsets and strides aligned to a multiple of four, so we can't add them individually. Luckily for us, the arrays have lengths less than 4. So, let's use vectors for them! Triangles get a single attribute with a `float4`, where the outer levels are in `.xyz` and the inner levels are in `.w`. The arrays are unpacked as though we had added the elements individually. Quads get two: a `float4` with the outer levels and a `float2` with the inner levels. Further, since vectors can be indexed as arrays, there's no need to unpack them in this case. This also saves on precious vertex attributes. Before, we were using up to 6 of them. Now we need two at most.
2019-02-22 18:11:17 +00:00
}
added_builtin_tess_level = true;
}
switch (builtin)
{
case BuiltInTessLevelOuter:
entry_func.fixup_hooks_in.push_back([=, &var]() {
statement(to_name(var.self), "[0] = ", ib_var_ref, ".", mbr_name, ".x;");
statement(to_name(var.self), "[1] = ", ib_var_ref, ".", mbr_name, ".y;");
statement(to_name(var.self), "[2] = ", ib_var_ref, ".", mbr_name, ".z;");
});
break;
case BuiltInTessLevelInner:
entry_func.fixup_hooks_in.push_back(
[=, &var]() { statement(to_name(var.self), "[0] = ", ib_var_ref, ".", mbr_name, ".w;"); });
break;
default:
assert(false);
break;
}
}
else
{
// Add a reference to the variable type to the interface struct.
uint32_t ib_mbr_idx = uint32_t(ib_type.member_types.size());
uint32_t type_id = build_extended_vector_type(var_type.self, builtin == BuiltInTessLevelOuter ? 4 : 2);
// Change the type of the variable, too.
uint32_t ptr_type_id = ir.increase_bound_by(1);
auto &new_var_type = set<SPIRType>(ptr_type_id, get<SPIRType>(type_id));
new_var_type.pointer = true;
new_var_type.storage = StorageClassInput;
new_var_type.parent_type = type_id;
var.basetype = ptr_type_id;
ib_type.member_types.push_back(type_id);
// Give the member a name
string mbr_name = to_expression(var.self);
set_member_name(ib_type.self, ib_mbr_idx, mbr_name);
// Since vectors can be indexed like arrays, there is no need to unpack this. We can
// just refer to the vector directly. So give it a qualified alias.
string qual_var_name = ib_var_ref + "." + mbr_name;
ir.meta[var.self].decoration.qualified_alias = qual_var_name;
if (get_decoration_bitset(var.self).get(DecorationLocation))
{
uint32_t locn = get_decoration(var.self, DecorationLocation);
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
mark_location_as_used_by_shader(locn, new_var_type, StorageClassInput);
MSL: Use vectors for the tessellation level builtins in tese shaders. The tessellation levels in Metal are stored as a densely-packed array of half-precision floating point values. But, stage-in attributes in Metal have to have offsets and strides aligned to a multiple of four, so we can't add them individually. Luckily for us, the arrays have lengths less than 4. So, let's use vectors for them! Triangles get a single attribute with a `float4`, where the outer levels are in `.xyz` and the inner levels are in `.w`. The arrays are unpacked as though we had added the elements individually. Quads get two: a `float4` with the outer levels and a `float2` with the inner levels. Further, since vectors can be indexed as arrays, there's no need to unpack them in this case. This also saves on precious vertex attributes. Before, we were using up to 6 of them. Now we need two at most.
2019-02-22 18:11:17 +00:00
}
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
else if (inputs_by_builtin.count(builtin))
MSL: Use vectors for the tessellation level builtins in tese shaders. The tessellation levels in Metal are stored as a densely-packed array of half-precision floating point values. But, stage-in attributes in Metal have to have offsets and strides aligned to a multiple of four, so we can't add them individually. Luckily for us, the arrays have lengths less than 4. So, let's use vectors for them! Triangles get a single attribute with a `float4`, where the outer levels are in `.xyz` and the inner levels are in `.w`. The arrays are unpacked as though we had added the elements individually. Quads get two: a `float4` with the outer levels and a `float2` with the inner levels. Further, since vectors can be indexed as arrays, there's no need to unpack them in this case. This also saves on precious vertex attributes. Before, we were using up to 6 of them. Now we need two at most.
2019-02-22 18:11:17 +00:00
{
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
uint32_t locn = inputs_by_builtin[builtin].location;
MSL: Use vectors for the tessellation level builtins in tese shaders. The tessellation levels in Metal are stored as a densely-packed array of half-precision floating point values. But, stage-in attributes in Metal have to have offsets and strides aligned to a multiple of four, so we can't add them individually. Luckily for us, the arrays have lengths less than 4. So, let's use vectors for them! Triangles get a single attribute with a `float4`, where the outer levels are in `.xyz` and the inner levels are in `.w`. The arrays are unpacked as though we had added the elements individually. Quads get two: a `float4` with the outer levels and a `float2` with the inner levels. Further, since vectors can be indexed as arrays, there's no need to unpack them in this case. This also saves on precious vertex attributes. Before, we were using up to 6 of them. Now we need two at most.
2019-02-22 18:11:17 +00:00
set_member_decoration(ib_type.self, ib_mbr_idx, DecorationLocation, locn);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
mark_location_as_used_by_shader(locn, new_var_type, StorageClassInput);
MSL: Use vectors for the tessellation level builtins in tese shaders. The tessellation levels in Metal are stored as a densely-packed array of half-precision floating point values. But, stage-in attributes in Metal have to have offsets and strides aligned to a multiple of four, so we can't add them individually. Luckily for us, the arrays have lengths less than 4. So, let's use vectors for them! Triangles get a single attribute with a `float4`, where the outer levels are in `.xyz` and the inner levels are in `.w`. The arrays are unpacked as though we had added the elements individually. Quads get two: a `float4` with the outer levels and a `float2` with the inner levels. Further, since vectors can be indexed as arrays, there's no need to unpack them in this case. This also saves on precious vertex attributes. Before, we were using up to 6 of them. Now we need two at most.
2019-02-22 18:11:17 +00:00
}
}
}
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
void CompilerMSL::add_variable_to_interface_block(StorageClass storage, const string &ib_var_ref, SPIRType &ib_type,
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
SPIRVariable &var, InterfaceBlockMeta &meta)
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
{
auto &entry_func = get<SPIRFunction>(ir.default_entry_point);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
// Tessellation control I/O variables and tessellation evaluation per-point inputs are
// usually declared as arrays. In these cases, we want to add the element type to the
// interface block, since in Metal it's the interface block itself which is arrayed.
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
auto &var_type = meta.strip_array ? get_variable_element_type(var) : get_variable_data_type(var);
MSL: Use vectors for the tessellation level builtins in tese shaders. The tessellation levels in Metal are stored as a densely-packed array of half-precision floating point values. But, stage-in attributes in Metal have to have offsets and strides aligned to a multiple of four, so we can't add them individually. Luckily for us, the arrays have lengths less than 4. So, let's use vectors for them! Triangles get a single attribute with a `float4`, where the outer levels are in `.xyz` and the inner levels are in `.w`. The arrays are unpacked as though we had added the elements individually. Quads get two: a `float4` with the outer levels and a `float2` with the inner levels. Further, since vectors can be indexed as arrays, there's no need to unpack them in this case. This also saves on precious vertex attributes. Before, we were using up to 6 of them. Now we need two at most.
2019-02-22 18:11:17 +00:00
bool is_builtin = is_builtin_variable(var);
auto builtin = BuiltIn(get_decoration(var.self, DecorationBuiltIn));
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
if (var_type.basetype == SPIRType::Struct)
{
Run format_all.sh.
2020-01-08 09:48:30 +00:00
if (!is_builtin_type(var_type) && (!capture_output_to_buffer || storage == StorageClassInput) &&
!meta.strip_array)
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
{
// For I/O blocks or structs, we will need to pass the block itself around
// to functions if they are used globally in leaf functions.
// Rather than passing down member by member,
// we unflatten I/O blocks while running the shader,
// and pass the actual struct type down to leaf functions.
// We then unflatten inputs, and flatten outputs in the "fixup" stages.
entry_func.add_local_variable(var.self);
vars_needing_early_declaration.push_back(var.self);
}
Never flatten outputs when capturing them. There's no need to do so, since these are not stage-out structs being returned, but regular structures being written to a buffer. This also neatly avoids issues writing to composite (e.g. arrayed) per-patch outputs from a tessellation control shader.
2019-02-11 23:18:54 +00:00
if (capture_output_to_buffer && storage != StorageClassInput && !has_decoration(var_type.self, DecorationBlock))
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
{
Never flatten outputs when capturing them. There's no need to do so, since these are not stage-out structs being returned, but regular structures being written to a buffer. This also neatly avoids issues writing to composite (e.g. arrayed) per-patch outputs from a tessellation control shader.
2019-02-11 23:18:54 +00:00
// In Metal tessellation shaders, the interface block itself is arrayed. This makes things
// very complicated, since stage-in structures in MSL don't support nested structures.
// Luckily, for stage-out when capturing output, we can avoid this and just add
// composite members directly, because the stage-out structure is stored to a buffer,
// not returned.
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
add_plain_variable_to_interface_block(storage, ib_var_ref, ib_type, var, meta);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
}
else
{
// Flatten the struct members into the interface struct
for (uint32_t mbr_idx = 0; mbr_idx < uint32_t(var_type.member_types.size()); mbr_idx++)
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
{
MSL: Use vectors for the tessellation level builtins in tese shaders. The tessellation levels in Metal are stored as a densely-packed array of half-precision floating point values. But, stage-in attributes in Metal have to have offsets and strides aligned to a multiple of four, so we can't add them individually. Luckily for us, the arrays have lengths less than 4. So, let's use vectors for them! Triangles get a single attribute with a `float4`, where the outer levels are in `.xyz` and the inner levels are in `.w`. The arrays are unpacked as though we had added the elements individually. Quads get two: a `float4` with the outer levels and a `float2` with the inner levels. Further, since vectors can be indexed as arrays, there's no need to unpack them in this case. This also saves on precious vertex attributes. Before, we were using up to 6 of them. Now we need two at most.
2019-02-22 18:11:17 +00:00
builtin = BuiltInMax;
is_builtin = is_member_builtin(var_type, mbr_idx, &builtin);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
auto &mbr_type = get<SPIRType>(var_type.member_types[mbr_idx]);
if (!is_builtin || has_active_builtin(builtin, storage))
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
{
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
bool is_composite_type = is_matrix(mbr_type) || is_array(mbr_type);
Run format_all.sh.
2020-01-08 09:48:30 +00:00
bool attribute_load_store =
storage == StorageClassInput && get_execution_model() != ExecutionModelFragment;
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
bool storage_is_stage_io =
(storage == StorageClassInput && !(get_execution_model() == ExecutionModelTessellationControl &&
msl_options.multi_patch_workgroup)) ||
storage == StorageClassOutput;
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
// ClipDistance always needs to be declared as user attributes.
if (builtin == BuiltInClipDistance)
is_builtin = false;
if ((!is_builtin || attribute_load_store) && storage_is_stage_io && is_composite_type)
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
{
add_composite_member_variable_to_interface_block(storage, ib_var_ref, ib_type, var, mbr_idx,
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
meta);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
}
else
{
Run format_all.sh.
2020-01-08 09:48:30 +00:00
add_plain_member_variable_to_interface_block(storage, ib_var_ref, ib_type, var, mbr_idx, meta);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
}
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
}
}
}
}
MSL: Use vectors for the tessellation level builtins in tese shaders. The tessellation levels in Metal are stored as a densely-packed array of half-precision floating point values. But, stage-in attributes in Metal have to have offsets and strides aligned to a multiple of four, so we can't add them individually. Luckily for us, the arrays have lengths less than 4. So, let's use vectors for them! Triangles get a single attribute with a `float4`, where the outer levels are in `.xyz` and the inner levels are in `.w`. The arrays are unpacked as though we had added the elements individually. Quads get two: a `float4` with the outer levels and a `float2` with the inner levels. Further, since vectors can be indexed as arrays, there's no need to unpack them in this case. This also saves on precious vertex attributes. Before, we were using up to 6 of them. Now we need two at most.
2019-02-22 18:11:17 +00:00
else if (get_execution_model() == ExecutionModelTessellationEvaluation && storage == StorageClassInput &&
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
!meta.strip_array && is_builtin && (builtin == BuiltInTessLevelOuter || builtin == BuiltInTessLevelInner))
MSL: Use vectors for the tessellation level builtins in tese shaders. The tessellation levels in Metal are stored as a densely-packed array of half-precision floating point values. But, stage-in attributes in Metal have to have offsets and strides aligned to a multiple of four, so we can't add them individually. Luckily for us, the arrays have lengths less than 4. So, let's use vectors for them! Triangles get a single attribute with a `float4`, where the outer levels are in `.xyz` and the inner levels are in `.w`. The arrays are unpacked as though we had added the elements individually. Quads get two: a `float4` with the outer levels and a `float2` with the inner levels. Further, since vectors can be indexed as arrays, there's no need to unpack them in this case. This also saves on precious vertex attributes. Before, we were using up to 6 of them. Now we need two at most.
2019-02-22 18:11:17 +00:00
{
add_tess_level_input_to_interface_block(ib_var_ref, ib_type, var);
}
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
else if (var_type.basetype == SPIRType::Boolean || var_type.basetype == SPIRType::Char ||
type_is_integral(var_type) || type_is_floating_point(var_type) || var_type.basetype == SPIRType::Boolean)
{
if (!is_builtin || has_active_builtin(builtin, storage))
{
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
bool is_composite_type = is_matrix(var_type) || is_array(var_type);
bool storage_is_stage_io =
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
(storage == StorageClassInput &&
!(get_execution_model() == ExecutionModelTessellationControl && msl_options.multi_patch_workgroup)) ||
(storage == StorageClassOutput && !capture_output_to_buffer);
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
bool attribute_load_store = storage == StorageClassInput && get_execution_model() != ExecutionModelFragment;
// ClipDistance always needs to be declared as user attributes.
if (builtin == BuiltInClipDistance)
is_builtin = false;
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
// MSL does not allow matrices or arrays in input or output variables, so need to handle it specially.
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
if ((!is_builtin || attribute_load_store) && storage_is_stage_io && is_composite_type)
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
{
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
add_composite_variable_to_interface_block(storage, ib_var_ref, ib_type, var, meta);
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
}
else
{
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
add_plain_variable_to_interface_block(storage, ib_var_ref, ib_type, var, meta);
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
}
}
}
}
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
// Fix up the mapping of variables to interface member indices, which is used to compile access chains
// for per-vertex variables in a tessellation control shader.
void CompilerMSL::fix_up_interface_member_indices(StorageClass storage, uint32_t ib_type_id)
{
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
// Only needed for tessellation shaders.
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
// Need to redirect interface indices back to variables themselves.
// For structs, each member of the struct need a separate instance.
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
if (get_execution_model() != ExecutionModelTessellationControl &&
!(get_execution_model() == ExecutionModelTessellationEvaluation && storage == StorageClassInput))
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
return;
MSL: Fix integer cast.
2019-10-26 18:30:24 +00:00
auto mbr_cnt = uint32_t(ir.meta[ib_type_id].members.size());
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
for (uint32_t i = 0; i < mbr_cnt; i++)
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
{
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
uint32_t var_id = get_extended_member_decoration(ib_type_id, i, SPIRVCrossDecorationInterfaceOrigID);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
if (!var_id)
continue;
auto &var = get<SPIRVariable>(var_id);
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
auto &type = get_variable_element_type(var);
if (storage == StorageClassInput && type.basetype == SPIRType::Struct)
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
{
Run format_all.sh.
2019-10-28 11:55:14 +00:00
uint32_t mbr_idx = get_extended_member_decoration(ib_type_id, i, SPIRVCrossDecorationInterfaceMemberIndex);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
// Only set the lowest InterfaceMemberIndex for each variable member.
// IB struct members will be emitted in-order w.r.t. interface member index.
if (!has_extended_member_decoration(var_id, mbr_idx, SPIRVCrossDecorationInterfaceMemberIndex))
set_extended_member_decoration(var_id, mbr_idx, SPIRVCrossDecorationInterfaceMemberIndex, i);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
}
else
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
{
// Only set the lowest InterfaceMemberIndex for each variable.
// IB struct members will be emitted in-order w.r.t. interface member index.
if (!has_extended_decoration(var_id, SPIRVCrossDecorationInterfaceMemberIndex))
set_extended_decoration(var_id, SPIRVCrossDecorationInterfaceMemberIndex, i);
}
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
}
}
CompilerMSL refactored to simplify handling of vertex attributes. Combine all vertex attributes into a single stage_in structure. Remove unneeded structure members from MSLConfiguration, MSLVertexAttr and Meta::Decoration. Remove unneeded CompilerMSL functions that supported struct offsets and padding.
2017-01-01 19:43:20 +00:00
// Add an interface structure for the type of storage, which is either StorageClassInput or StorageClassOutput.
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
// Returns the ID of the newly added variable, or zero if no variable was added.
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
uint32_t CompilerMSL::add_interface_block(StorageClass storage, bool patch)
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
{
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
// Accumulate the variables that should appear in the interface struct.
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
SmallVector<SPIRVariable *> vars;
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
bool incl_builtins = storage == StorageClassOutput || is_tessellation_shader();
MSL: Support PrimitiveID in fragment and barycentrics.
2019-06-13 09:33:40 +00:00
bool has_seen_barycentric = false;
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
InterfaceBlockMeta meta;
// Varying interfaces between stages which use "user()" attribute can be dealt with
// without explicit packing and unpacking of components. For any variables which link against the runtime
// in some way (vertex attributes, fragment output, etc), we'll need to deal with it somehow.
bool pack_components =
Run format_all.sh.
2020-01-08 09:48:30 +00:00
(storage == StorageClassInput && get_execution_model() == ExecutionModelVertex) ||
(storage == StorageClassOutput && get_execution_model() == ExecutionModelFragment) ||
(storage == StorageClassOutput && get_execution_model() == ExecutionModelVertex && capture_output_to_buffer);
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
ir.for_each_typed_id<SPIRVariable>([&](uint32_t var_id, SPIRVariable &var) {
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
if (var.storage != storage)
return;
Workaround bugs on MSVC. Bug: https://developercommunity.visualstudio.com/content/problem/303996/c-error-c2668-ambiguous-overloaded-in-lambda-with.html
2019-01-11 08:29:28 +00:00
auto &type = this->get<SPIRType>(var.basetype);
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
bool is_builtin = is_builtin_variable(var);
auto bi_type = BuiltIn(get_decoration(var_id, DecorationBuiltIn));
MSL: Add options to control emission of fragment outputs. Like with `point_size` when not rendering points, Metal complains when writing to a variable using the `[[depth]]` qualifier when no depth buffer be attached. In that case, we must avoid emitting `FragDepth`, just like with `PointSize`. I assume it will also complain if there be no stencil attachment and the shader write to `[[stencil]]`, or it write to `[[color(n)]]` but there be no color attachment at n.
2020-04-10 06:13:33 +00:00
uint32_t location = get_decoration(var_id, DecorationLocation);
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
// These builtins are part of the stage in/out structs.
bool is_interface_block_builtin =
(bi_type == BuiltInPosition || bi_type == BuiltInPointSize || bi_type == BuiltInClipDistance ||
bi_type == BuiltInCullDistance || bi_type == BuiltInLayer || bi_type == BuiltInViewportIndex ||
Run format_all.sh.
2019-06-21 14:02:22 +00:00
bi_type == BuiltInBaryCoordNV || bi_type == BuiltInBaryCoordNoPerspNV || bi_type == BuiltInFragDepth ||
bi_type == BuiltInFragStencilRefEXT || bi_type == BuiltInSampleMask) ||
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
(get_execution_model() == ExecutionModelTessellationEvaluation &&
(bi_type == BuiltInTessLevelOuter || bi_type == BuiltInTessLevelInner));
bool is_active = interface_variable_exists_in_entry_point(var.self);
if (is_builtin && is_active)
{
// Only emit the builtin if it's active in this entry point. Interface variable list might lie.
is_active = has_active_builtin(bi_type, storage);
}
bool filter_patch_decoration = (has_decoration(var_id, DecorationPatch) || is_patch_block(type)) == patch;
MSL: Support PrimitiveID in fragment and barycentrics.
2019-06-13 09:33:40 +00:00
bool hidden = is_hidden_variable(var, incl_builtins);
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
// ClipDistance is never hidden, we need to emulate it when used as an input.
if (bi_type == BuiltInClipDistance)
hidden = false;
MSL: Add options to control emission of fragment outputs. Like with `point_size` when not rendering points, Metal complains when writing to a variable using the `[[depth]]` qualifier when no depth buffer be attached. In that case, we must avoid emitting `FragDepth`, just like with `PointSize`. I assume it will also complain if there be no stencil attachment and the shader write to `[[stencil]]`, or it write to `[[color(n)]]` but there be no color attachment at n.
2020-04-10 06:13:33 +00:00
// It's not enough to simply avoid marking fragment outputs if the pipeline won't
// accept them. We can't put them in the struct at all, or otherwise the compiler
// complains that the outputs weren't explicitly marked.
MSL: Only disable output variables in fragment shaders. Forgot to do this in #1319. Fixes #1322.
2020-04-15 17:13:25 +00:00
if (get_execution_model() == ExecutionModelFragment && storage == StorageClassOutput && !patch &&
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
((is_builtin && ((bi_type == BuiltInFragDepth && !msl_options.enable_frag_depth_builtin) ||
(bi_type == BuiltInFragStencilRefEXT && !msl_options.enable_frag_stencil_ref_builtin))) ||
MSL: Add options to control emission of fragment outputs. Like with `point_size` when not rendering points, Metal complains when writing to a variable using the `[[depth]]` qualifier when no depth buffer be attached. In that case, we must avoid emitting `FragDepth`, just like with `PointSize`. I assume it will also complain if there be no stencil attachment and the shader write to `[[stencil]]`, or it write to `[[color(n)]]` but there be no color attachment at n.
2020-04-10 06:13:33 +00:00
(!is_builtin && !(msl_options.enable_frag_output_mask & (1 << location)))))
{
hidden = true;
disabled_frag_outputs.push_back(var_id);
MSL: Force disabled fragment builtins to have the right name. DXVK emits SPIR-V where fragment shader builtins have names derived from DXBC assembly, e.g. `oDepth` for `FragDepth`. When we declared the disabled output, we used this name, but when referencing it, we continued to use the GLSL name. This breaks compilation.
2020-04-16 00:22:16 +00:00
// If a builtin, force it to have the proper name.
if (is_builtin)
set_name(var_id, builtin_to_glsl(bi_type, StorageClassFunction));
MSL: Add options to control emission of fragment outputs. Like with `point_size` when not rendering points, Metal complains when writing to a variable using the `[[depth]]` qualifier when no depth buffer be attached. In that case, we must avoid emitting `FragDepth`, just like with `PointSize`. I assume it will also complain if there be no stencil attachment and the shader write to `[[stencil]]`, or it write to `[[color(n)]]` but there be no color attachment at n.
2020-04-10 06:13:33 +00:00
}
MSL: Support PrimitiveID in fragment and barycentrics.
2019-06-13 09:33:40 +00:00
// Barycentric inputs must be emitted in stage-in, because they can have interpolation arguments.
if (is_active && (bi_type == BuiltInBaryCoordNV || bi_type == BuiltInBaryCoordNoPerspNV))
{
if (has_seen_barycentric)
SPIRV_CROSS_THROW("Cannot declare both BaryCoordNV and BaryCoordNoPerspNV in same shader in MSL.");
has_seen_barycentric = true;
hidden = false;
}
if (is_active && !hidden && type.pointer && filter_patch_decoration &&
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
(!is_builtin || is_interface_block_builtin))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
vars.push_back(&var);
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
MSL: Explicitly don't support component packing for tessellation.
2020-01-07 15:49:19 +00:00
if (!is_builtin)
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
{
// Need to deal specially with DecorationComponent.
// Multiple variables can alias the same Location, and try to make sure each location is declared only once.
// We will swizzle data in and out to make this work.
// We only need to consider plain variables here, not composites.
MSL: Explicitly don't support component packing for tessellation.
2020-01-07 15:49:19 +00:00
// This is only relevant for vertex inputs and fragment outputs.
// Technically tessellation as well, but it is too complicated to support.
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
uint32_t component = get_decoration(var_id, DecorationComponent);
if (component != 0)
{
MSL: Explicitly don't support component packing for tessellation.
2020-01-07 15:49:19 +00:00
if (is_tessellation_shader())
SPIRV_CROSS_THROW("Component decoration is not supported in tessellation shaders.");
else if (pack_components)
{
auto &location_meta = meta.location_meta[location];
location_meta.num_components = std::max(location_meta.num_components, component + type.vecsize);
}
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
}
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
});
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
// If no variables qualify, leave.
// For patch input in a tessellation evaluation shader, the per-vertex stage inputs
// are included in a special patch control point array.
if (vars.empty() && !(storage == StorageClassInput && patch && stage_in_var_id))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return 0;
// Add a new typed variable for this interface structure.
// The initializer expression is allocated here, but populated when the function
// declaraion is emitted, because it is cleared after each compilation pass.
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
uint32_t next_id = ir.increase_bound_by(3);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
uint32_t ib_type_id = next_id++;
auto &ib_type = set<SPIRType>(ib_type_id);
ib_type.basetype = SPIRType::Struct;
ib_type.storage = storage;
CompilerMSL enhancements to handling of in/out variables. CompilerMSL sort in/out attributes by attribute number (location). Sort inputs in reverse order. CompilerMSL propagate incoming vertex attribute offset values. CompilerMSL elide unused in/out variables. CompilerMSL replace use of sets with unordered_sets.
2016-12-18 23:48:15 +00:00
set_decoration(ib_type_id, DecorationBlock);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
uint32_t ib_var_id = next_id++;
auto &var = set<SPIRVariable>(ib_var_id, ib_type_id, storage, 0);
var.initializer = next_id++;
string ib_var_ref;
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
auto &entry_func = get<SPIRFunction>(ir.default_entry_point);
CompilerMSL refactored to simplify handling of vertex attributes. Combine all vertex attributes into a single stage_in structure. Remove unneeded structure members from MSLConfiguration, MSLVertexAttr and Meta::Decoration. Remove unneeded CompilerMSL functions that supported struct offsets and padding.
2017-01-01 19:43:20 +00:00
switch (storage)
MSL sort interface struct members by offset instead of location. MSL support OpFMod as fmod() function. Remove SPIRType::is_packed member.
2016-12-04 17:32:58 +00:00
{
CompilerMSL refactored to simplify handling of vertex attributes. Combine all vertex attributes into a single stage_in structure. Remove unneeded structure members from MSLConfiguration, MSLVertexAttr and Meta::Decoration. Remove unneeded CompilerMSL functions that supported struct offsets and padding.
2017-01-01 19:43:20 +00:00
case StorageClassInput:
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
ib_var_ref = patch ? patch_stage_in_var_name : stage_in_var_name;
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
if (get_execution_model() == ExecutionModelTessellationControl)
{
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
// Add a hook to populate the shared workgroup memory containing the gl_in array.
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
entry_func.fixup_hooks_in.push_back([=]() {
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
// Can't use PatchVertices, PrimitiveId, or InvocationId yet; the hooks for those may not have run yet.
if (msl_options.multi_patch_workgroup)
{
// n.b. builtin_invocation_id_id here is the dispatch global invocation ID,
// not the TC invocation ID.
statement("device ", to_name(ir.default_entry_point), "_", ib_var_ref, "* gl_in = &",
input_buffer_var_name, "[min(", to_expression(builtin_invocation_id_id), ".x / ",
get_entry_point().output_vertices,
Run format_all.sh.
2020-08-24 09:02:49 +00:00
", spvIndirectParams[1] - 1) * spvIndirectParams[0]];");
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
}
else
{
// It's safe to use InvocationId here because it's directly mapped to a
// Metal builtin, and therefore doesn't need a hook.
statement("if (", to_expression(builtin_invocation_id_id), " < spvIndirectParams[0])");
statement(" ", input_wg_var_name, "[", to_expression(builtin_invocation_id_id),
"] = ", ib_var_ref, ";");
statement("threadgroup_barrier(mem_flags::mem_threadgroup);");
statement("if (", to_expression(builtin_invocation_id_id),
" >= ", get_entry_point().output_vertices, ")");
statement(" return;");
}
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
});
}
CompilerMSL refactored to simplify handling of vertex attributes. Combine all vertex attributes into a single stage_in structure. Remove unneeded structure members from MSLConfiguration, MSLVertexAttr and Meta::Decoration. Remove unneeded CompilerMSL functions that supported struct offsets and padding.
2017-01-01 19:43:20 +00:00
break;
MSL sort interface struct members by offset instead of location. MSL support OpFMod as fmod() function. Remove SPIRType::is_packed member.
2016-12-04 17:32:58 +00:00
CompilerMSL refactored to simplify handling of vertex attributes. Combine all vertex attributes into a single stage_in structure. Remove unneeded structure members from MSLConfiguration, MSLVertexAttr and Meta::Decoration. Remove unneeded CompilerMSL functions that supported struct offsets and padding.
2017-01-01 19:43:20 +00:00
case StorageClassOutput:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
ib_var_ref = patch ? patch_stage_out_var_name : stage_out_var_name;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
CompilerMSL vertex entry point return void when rasterization disabled. Add CompilerMSL::Options::disable_rasterization input/output API flag. Disable rasterization via API flag or when writing to textures. Disable rasterization when shader declares no output. Add test shaders for vertex no output and write texture forcing void output.
2018-07-26 04:50:33 +00:00
// Add the output interface struct as a local variable to the entry function.
// If the entry point should return the output struct, set the entry function
// to return the output interface struct, otherwise to return nothing.
// Indicate the output var requires early initialization.
Add CompilerMSL::get_is_rasterization_disabled() to manage rasterization status.
2018-07-26 20:40:32 +00:00
bool ep_should_return_output = !get_is_rasterization_disabled();
CompilerMSL vertex entry point return void when rasterization disabled. Add CompilerMSL::Options::disable_rasterization input/output API flag. Disable rasterization via API flag or when writing to textures. Disable rasterization when shader declares no output. Add test shaders for vertex no output and write texture forcing void output.
2018-07-26 04:50:33 +00:00
uint32_t rtn_id = ep_should_return_output ? ib_var_id : 0;
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
if (!capture_output_to_buffer)
{
entry_func.add_local_variable(ib_var_id);
for (auto &blk_id : entry_func.blocks)
{
auto &blk = get<SPIRBlock>(blk_id);
if (blk.terminator == SPIRBlock::Return)
blk.return_value = rtn_id;
}
vars_needing_early_declaration.push_back(ib_var_id);
}
else
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
switch (get_execution_model())
{
case ExecutionModelVertex:
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
case ExecutionModelTessellationEvaluation:
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
// Instead of declaring a struct variable to hold the output and then
// copying that to the output buffer, we'll declare the output variable
// as a reference to the final output element in the buffer. Then we can
// avoid the extra copy.
entry_func.fixup_hooks_in.push_back([=]() {
if (stage_out_var_id)
{
// The first member of the indirect buffer is always the number of vertices
// to draw.
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (get_execution_model() == ExecutionModelVertex && msl_options.vertex_for_tessellation)
{
statement("device ", to_name(ir.default_entry_point), "_", ib_var_ref, "& ", ib_var_ref,
" = ", output_buffer_var_name, "[", to_expression(builtin_invocation_id_id),
".y * ", to_expression(builtin_stage_input_size_id), ".x + ",
to_expression(builtin_invocation_id_id), ".x];");
}
else if (msl_options.enable_base_index_zero)
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
{
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
statement("device ", to_name(ir.default_entry_point), "_", ib_var_ref, "& ", ib_var_ref,
" = ", output_buffer_var_name, "[", to_expression(builtin_instance_idx_id),
" * spvIndirectParams[0] + ", to_expression(builtin_vertex_idx_id), "];");
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
}
else
{
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
statement("device ", to_name(ir.default_entry_point), "_", ib_var_ref, "& ", ib_var_ref,
" = ", output_buffer_var_name, "[(", to_expression(builtin_instance_idx_id),
" - ", to_expression(builtin_base_instance_id), ") * spvIndirectParams[0] + ",
to_expression(builtin_vertex_idx_id), " - ",
to_expression(builtin_base_vertex_id), "];");
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
}
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
}
});
break;
case ExecutionModelTessellationControl:
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (msl_options.multi_patch_workgroup)
{
// We cannot use PrimitiveId here, because the hook may not have run yet.
if (patch)
{
entry_func.fixup_hooks_in.push_back([=]() {
statement("device ", to_name(ir.default_entry_point), "_", ib_var_ref, "& ", ib_var_ref,
" = ", patch_output_buffer_var_name, "[", to_expression(builtin_invocation_id_id),
".x / ", get_entry_point().output_vertices, "];");
});
}
else
{
entry_func.fixup_hooks_in.push_back([=]() {
statement("device ", to_name(ir.default_entry_point), "_", ib_var_ref, "* gl_out = &",
output_buffer_var_name, "[", to_expression(builtin_invocation_id_id), ".x - ",
to_expression(builtin_invocation_id_id), ".x % ",
get_entry_point().output_vertices, "];");
});
}
}
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
else
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
{
if (patch)
{
entry_func.fixup_hooks_in.push_back([=]() {
statement("device ", to_name(ir.default_entry_point), "_", ib_var_ref, "& ", ib_var_ref,
" = ", patch_output_buffer_var_name, "[", to_expression(builtin_primitive_id_id),
"];");
});
}
else
{
entry_func.fixup_hooks_in.push_back([=]() {
statement("device ", to_name(ir.default_entry_point), "_", ib_var_ref, "* gl_out = &",
output_buffer_var_name, "[", to_expression(builtin_primitive_id_id), " * ",
get_entry_point().output_vertices, "];");
});
}
}
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
break;
default:
break;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
CompilerMSL refactored to simplify handling of vertex attributes. Combine all vertex attributes into a single stage_in structure. Remove unneeded structure members from MSLConfiguration, MSLVertexAttr and Meta::Decoration. Remove unneeded CompilerMSL functions that supported struct offsets and padding.
2017-01-01 19:43:20 +00:00
break;
}
Format code
2017-01-15 15:39:03 +00:00
CompilerMSL refactored to simplify handling of vertex attributes. Combine all vertex attributes into a single stage_in structure. Remove unneeded structure members from MSLConfiguration, MSLVertexAttr and Meta::Decoration. Remove unneeded CompilerMSL functions that supported struct offsets and padding.
2017-01-01 19:43:20 +00:00
default:
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
set_name(ib_type_id, to_name(ir.default_entry_point) + "_" + ib_var_ref);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
set_name(ib_var_id, ib_var_ref);
MSL: Support stencil export.
2019-06-12 08:06:59 +00:00
for (auto *p_var : vars)
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
{
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
bool strip_array =
(get_execution_model() == ExecutionModelTessellationControl ||
(get_execution_model() == ExecutionModelTessellationEvaluation && storage == StorageClassInput)) &&
!patch;
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
meta.strip_array = strip_array;
add_variable_to_interface_block(storage, ib_var_ref, ib_type, *p_var, meta);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (get_execution_model() == ExecutionModelTessellationControl && msl_options.multi_patch_workgroup &&
storage == StorageClassInput)
{
// For tessellation control inputs, add all outputs from the vertex shader to ensure
// the struct containing them is the correct size and layout.
for (auto &input : inputs_by_location)
{
if (is_msl_shader_input_used(input.first))
continue;
// Create a fake variable to put at the location.
uint32_t offset = ir.increase_bound_by(4);
uint32_t type_id = offset;
uint32_t array_type_id = offset + 1;
uint32_t ptr_type_id = offset + 2;
uint32_t var_id = offset + 3;
SPIRType type;
switch (input.second.format)
{
case MSL_SHADER_INPUT_FORMAT_UINT16:
case MSL_SHADER_INPUT_FORMAT_ANY16:
type.basetype = SPIRType::UShort;
type.width = 16;
break;
case MSL_SHADER_INPUT_FORMAT_ANY32:
default:
type.basetype = SPIRType::UInt;
type.width = 32;
break;
}
type.vecsize = input.second.vecsize;
set<SPIRType>(type_id, type);
type.array.push_back(0);
type.array_size_literal.push_back(true);
type.parent_type = type_id;
set<SPIRType>(array_type_id, type);
type.pointer = true;
type.parent_type = array_type_id;
type.storage = storage;
auto &ptr_type = set<SPIRType>(ptr_type_id, type);
ptr_type.self = array_type_id;
auto &fake_var = set<SPIRVariable>(var_id, ptr_type_id, storage);
set_decoration(var_id, DecorationLocation, input.first);
meta.strip_array = true;
add_variable_to_interface_block(storage, ib_var_ref, ib_type, fake_var, meta);
}
}
CompilerMSL enhancements. Support BuiltInFragDepth. Emit interface block for StorageClassUniformConstant. Throw exception when output or fragment input structs contain matrix or array. Dynamically created interface structs sorted by location number instead of alphabetically. Add Compiler::is_array() function.
2017-06-30 23:10:46 +00:00
// Sort the members of the structure by their locations.
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
MemberSorter member_sorter(ib_type, ir.meta[ib_type_id], MemberSorter::Location);
Fix Wshadow warning.
2017-01-28 07:58:25 +00:00
member_sorter.sort();
Format code
2017-01-15 15:39:03 +00:00
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
// The member indices were saved to the original variables, but after the members
// were sorted, those indices are now likely incorrect. Fix those up now.
if (!patch)
fix_up_interface_member_indices(storage, ib_type_id);
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
// For patch inputs, add one more member, holding the array of control point data.
if (get_execution_model() == ExecutionModelTessellationEvaluation && storage == StorageClassInput && patch &&
stage_in_var_id)
{
uint32_t pcp_type_id = ir.increase_bound_by(1);
auto &pcp_type = set<SPIRType>(pcp_type_id, ib_type);
pcp_type.basetype = SPIRType::ControlPointArray;
pcp_type.parent_type = pcp_type.type_alias = get_stage_in_struct_type().self;
pcp_type.storage = storage;
ir.meta[pcp_type_id] = ir.meta[ib_type.self];
Quiesce truncation warnings.
2019-02-21 21:11:45 +00:00
uint32_t mbr_idx = uint32_t(ib_type.member_types.size());
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
ib_type.member_types.push_back(pcp_type_id);
set_member_name(ib_type.self, mbr_idx, "gl_in");
}
CompilerMSL enhancements. Support BuiltInFragDepth. Emit interface block for StorageClassUniformConstant. Throw exception when output or fragment input structs contain matrix or array. Dynamically created interface structs sorted by location number instead of alphabetically. Add Compiler::is_array() function.
2017-06-30 23:10:46 +00:00
return ib_var_id;
}
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
uint32_t CompilerMSL::add_interface_block_pointer(uint32_t ib_var_id, StorageClass storage)
{
if (!ib_var_id)
return 0;
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
uint32_t ib_ptr_var_id;
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
uint32_t next_id = ir.increase_bound_by(3);
auto &ib_type = expression_type(ib_var_id);
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
if (get_execution_model() == ExecutionModelTessellationControl)
{
// Tessellation control per-vertex I/O is presented as an array, so we must
// do the same with our struct here.
uint32_t ib_ptr_type_id = next_id++;
auto &ib_ptr_type = set<SPIRType>(ib_ptr_type_id, ib_type);
ib_ptr_type.parent_type = ib_ptr_type.type_alias = ib_type.self;
ib_ptr_type.pointer = true;
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
ib_ptr_type.storage =
storage == StorageClassInput ?
(msl_options.multi_patch_workgroup ? StorageClassStorageBuffer : StorageClassWorkgroup) :
StorageClassStorageBuffer;
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
ir.meta[ib_ptr_type_id] = ir.meta[ib_type.self];
// To ensure that get_variable_data_type() doesn't strip off the pointer,
// which we need, use another pointer.
uint32_t ib_ptr_ptr_type_id = next_id++;
auto &ib_ptr_ptr_type = set<SPIRType>(ib_ptr_ptr_type_id, ib_ptr_type);
ib_ptr_ptr_type.parent_type = ib_ptr_type_id;
ib_ptr_ptr_type.type_alias = ib_type.self;
ib_ptr_ptr_type.storage = StorageClassFunction;
ir.meta[ib_ptr_ptr_type_id] = ir.meta[ib_type.self];
ib_ptr_var_id = next_id;
set<SPIRVariable>(ib_ptr_var_id, ib_ptr_ptr_type_id, StorageClassFunction, 0);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
set_name(ib_ptr_var_id, storage == StorageClassInput ? "gl_in" : "gl_out");
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
}
else
{
// Tessellation evaluation per-vertex inputs are also presented as arrays.
// But, in Metal, this array uses a very special type, 'patch_control_point<T>',
// which is a container that can be used to access the control point data.
// To represent this, a special 'ControlPointArray' type has been added to the
// SPIRV-Cross type system. It should only be generated by and seen in the MSL
// backend (i.e. this one).
uint32_t pcp_type_id = next_id++;
auto &pcp_type = set<SPIRType>(pcp_type_id, ib_type);
pcp_type.basetype = SPIRType::ControlPointArray;
pcp_type.parent_type = pcp_type.type_alias = ib_type.self;
pcp_type.storage = storage;
ir.meta[pcp_type_id] = ir.meta[ib_type.self];
ib_ptr_var_id = next_id;
set<SPIRVariable>(ib_ptr_var_id, pcp_type_id, storage, 0);
set_name(ib_ptr_var_id, "gl_in");
ir.meta[ib_ptr_var_id].decoration.qualified_alias = join(patch_stage_in_var_name, ".gl_in");
}
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
return ib_ptr_var_id;
}
CompilerMSL support gl_SampleMask and convert it to scalar uint from array.
2018-02-13 19:44:40 +00:00
// Ensure that the type is compatible with the builtin.
// If it is, simply return the given type ID.
// Otherwise, create a new type, and return it's ID.
uint32_t CompilerMSL::ensure_correct_builtin_type(uint32_t type_id, BuiltIn builtin)
{
auto &type = get<SPIRType>(type_id);
MSL: Handle the ViewportIndex builtin. This requires MSL 2.0+. Also, force `ViewportIndex` and `Layer` to be defined as the correct type, which is always `uint` in MSL. Since Metal doesn't yet have geometry shaders, the vertex shader (or tessellation evaluation shader == "post-tessellation vertex shader" in Metal jargon) is the only kind of shader that can set this output. This currently requires an extension to Vulkan, which causes validation of the SPIR-V binaries for the test cases to fail. Therefore, the test cases are marked "invalid", even though they're actually perfectly valid SPIR-V--they just won't work without the `SPV_EXT_shader_viewport_index_layer` extension.
2018-09-12 23:00:17 +00:00
if ((builtin == BuiltInSampleMask && is_array(type)) ||
MSL: Support stencil export.
2019-06-12 08:06:59 +00:00
((builtin == BuiltInLayer || builtin == BuiltInViewportIndex || builtin == BuiltInFragStencilRefEXT) &&
type.basetype != SPIRType::UInt))
CompilerMSL support gl_SampleMask and convert it to scalar uint from array.
2018-02-13 19:44:40 +00:00
{
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
uint32_t next_id = ir.increase_bound_by(type.pointer ? 2 : 1);
CompilerMSL support gl_SampleMask and convert it to scalar uint from array.
2018-02-13 19:44:40 +00:00
uint32_t base_type_id = next_id++;
auto &base_type = set<SPIRType>(base_type_id);
base_type.basetype = SPIRType::UInt;
base_type.width = 32;
if (!type.pointer)
return base_type_id;
uint32_t ptr_type_id = next_id++;
auto &ptr_type = set<SPIRType>(ptr_type_id);
ptr_type = base_type;
ptr_type.pointer = true;
ptr_type.storage = type.storage;
ptr_type.parent_type = base_type_id;
return ptr_type_id;
}
return type_id;
}
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
// Ensure that the type is compatible with the shader input.
MSL: Force signedness of shader vertex attributes to match the host. Based on a patch by Stefan Dösinger. Metal cannot do signedness conversion on vertex attributes, and for good reason. Putting a `uint4` into an `int4`, or a `char4` into a `uint4`, would lose those values that are outside the range of the target type. But putting a `uchar4` into a `short4` or an `int4`, or a `ushort4` into an `int4`, should work. In that case, force the signedness in the shader to match the declared type of the host. Unfortunately, I don't really know how to automatically test this. This remapping is done based on input parameters normally supplied by MoltenVK. I'm not sure how we'd set this up for the command-line `spirv-cross` tool.
2018-11-28 22:26:45 +00:00
// If it is, simply return the given type ID.
// Otherwise, create a new type, and return its ID.
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
uint32_t CompilerMSL::ensure_correct_input_type(uint32_t type_id, uint32_t location, uint32_t num_components)
MSL: Force signedness of shader vertex attributes to match the host. Based on a patch by Stefan Dösinger. Metal cannot do signedness conversion on vertex attributes, and for good reason. Putting a `uint4` into an `int4`, or a `char4` into a `uint4`, would lose those values that are outside the range of the target type. But putting a `uchar4` into a `short4` or an `int4`, or a `ushort4` into an `int4`, should work. In that case, force the signedness in the shader to match the declared type of the host. Unfortunately, I don't really know how to automatically test this. This remapping is done based on input parameters normally supplied by MoltenVK. I'm not sure how we'd set this up for the command-line `spirv-cross` tool.
2018-11-28 22:26:45 +00:00
{
auto &type = get<SPIRType>(type_id);
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
auto p_va = inputs_by_location.find(location);
if (p_va == end(inputs_by_location))
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
{
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
if (num_components > type.vecsize)
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
return build_extended_vector_type(type_id, num_components);
else
return type_id;
}
MSL: Force signedness of shader vertex attributes to match the host. Based on a patch by Stefan Dösinger. Metal cannot do signedness conversion on vertex attributes, and for good reason. Putting a `uint4` into an `int4`, or a `char4` into a `uint4`, would lose those values that are outside the range of the target type. But putting a `uchar4` into a `short4` or an `int4`, or a `ushort4` into an `int4`, should work. In that case, force the signedness in the shader to match the declared type of the host. Unfortunately, I don't really know how to automatically test this. This remapping is done based on input parameters normally supplied by MoltenVK. I'm not sure how we'd set this up for the command-line `spirv-cross` tool.
2018-11-28 22:26:45 +00:00
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
if (num_components == 0)
num_components = p_va->second.vecsize;
Add a stable C API for SPIRV-Cross. This adds a new C API for SPIRV-Cross which is intended to be stable, both API and ABI wise. The C++ API has been refactored a bit to make the C wrapper easier and cleaner to write. Especially the vertex attribute / resource interfaces for MSL has been rewritten to avoid taking mutable pointers into the interface. This would be very annoying to wrap and it didn't fit well with the rest of the C++ API to begin with. While doing this, I went ahead and removed all the old deprecated interfaces. The CMake build system has also seen an overhaul. It is now possible to build static/shared/CLI separately with -D options. The shared library only exposes the C API, as it is the only ABI-stable API. pkg-configs as well as CMake modules are exported and installed for the shared library configuration.
2019-02-12 10:11:29 +00:00
switch (p_va->second.format)
MSL: Use an enum instead of two mutually exclusive booleans. NFCI.
2018-12-04 19:54:29 +00:00
{
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
case MSL_SHADER_INPUT_FORMAT_UINT8:
MSL: Force signedness of shader vertex attributes to match the host. Based on a patch by Stefan Dösinger. Metal cannot do signedness conversion on vertex attributes, and for good reason. Putting a `uint4` into an `int4`, or a `char4` into a `uint4`, would lose those values that are outside the range of the target type. But putting a `uchar4` into a `short4` or an `int4`, or a `ushort4` into an `int4`, should work. In that case, force the signedness in the shader to match the declared type of the host. Unfortunately, I don't really know how to automatically test this. This remapping is done based on input parameters normally supplied by MoltenVK. I'm not sure how we'd set this up for the command-line `spirv-cross` tool.
2018-11-28 22:26:45 +00:00
{
switch (type.basetype)
{
case SPIRType::UByte:
case SPIRType::UShort:
case SPIRType::UInt:
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
if (num_components > type.vecsize)
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
return build_extended_vector_type(type_id, num_components);
else
return type_id;
MSL: Force signedness of shader vertex attributes to match the host. Based on a patch by Stefan Dösinger. Metal cannot do signedness conversion on vertex attributes, and for good reason. Putting a `uint4` into an `int4`, or a `char4` into a `uint4`, would lose those values that are outside the range of the target type. But putting a `uchar4` into a `short4` or an `int4`, or a `ushort4` into an `int4`, should work. In that case, force the signedness in the shader to match the declared type of the host. Unfortunately, I don't really know how to automatically test this. This remapping is done based on input parameters normally supplied by MoltenVK. I'm not sure how we'd set this up for the command-line `spirv-cross` tool.
2018-11-28 22:26:45 +00:00
case SPIRType::Short:
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
return build_extended_vector_type(type_id, num_components > type.vecsize ? num_components : type.vecsize,
SPIRType::UShort);
MSL: Force signedness of shader vertex attributes to match the host. Based on a patch by Stefan Dösinger. Metal cannot do signedness conversion on vertex attributes, and for good reason. Putting a `uint4` into an `int4`, or a `char4` into a `uint4`, would lose those values that are outside the range of the target type. But putting a `uchar4` into a `short4` or an `int4`, or a `ushort4` into an `int4`, should work. In that case, force the signedness in the shader to match the declared type of the host. Unfortunately, I don't really know how to automatically test this. This remapping is done based on input parameters normally supplied by MoltenVK. I'm not sure how we'd set this up for the command-line `spirv-cross` tool.
2018-11-28 22:26:45 +00:00
case SPIRType::Int:
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
return build_extended_vector_type(type_id, num_components > type.vecsize ? num_components : type.vecsize,
SPIRType::UInt);
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
MSL: Force signedness of shader vertex attributes to match the host. Based on a patch by Stefan Dösinger. Metal cannot do signedness conversion on vertex attributes, and for good reason. Putting a `uint4` into an `int4`, or a `char4` into a `uint4`, would lose those values that are outside the range of the target type. But putting a `uchar4` into a `short4` or an `int4`, or a `ushort4` into an `int4`, should work. In that case, force the signedness in the shader to match the declared type of the host. Unfortunately, I don't really know how to automatically test this. This remapping is done based on input parameters normally supplied by MoltenVK. I'm not sure how we'd set this up for the command-line `spirv-cross` tool.
2018-11-28 22:26:45 +00:00
default:
SPIRV_CROSS_THROW("Vertex attribute type mismatch between host and shader");
}
}
Add a stable C API for SPIRV-Cross. This adds a new C API for SPIRV-Cross which is intended to be stable, both API and ABI wise. The C++ API has been refactored a bit to make the C wrapper easier and cleaner to write. Especially the vertex attribute / resource interfaces for MSL has been rewritten to avoid taking mutable pointers into the interface. This would be very annoying to wrap and it didn't fit well with the rest of the C++ API to begin with. While doing this, I went ahead and removed all the old deprecated interfaces. The CMake build system has also seen an overhaul. It is now possible to build static/shared/CLI separately with -D options. The shared library only exposes the C API, as it is the only ABI-stable API. pkg-configs as well as CMake modules are exported and installed for the shared library configuration.
2019-02-12 10:11:29 +00:00
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
case MSL_SHADER_INPUT_FORMAT_UINT16:
MSL: Force signedness of shader vertex attributes to match the host. Based on a patch by Stefan Dösinger. Metal cannot do signedness conversion on vertex attributes, and for good reason. Putting a `uint4` into an `int4`, or a `char4` into a `uint4`, would lose those values that are outside the range of the target type. But putting a `uchar4` into a `short4` or an `int4`, or a `ushort4` into an `int4`, should work. In that case, force the signedness in the shader to match the declared type of the host. Unfortunately, I don't really know how to automatically test this. This remapping is done based on input parameters normally supplied by MoltenVK. I'm not sure how we'd set this up for the command-line `spirv-cross` tool.
2018-11-28 22:26:45 +00:00
{
switch (type.basetype)
{
case SPIRType::UShort:
case SPIRType::UInt:
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
if (num_components > type.vecsize)
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
return build_extended_vector_type(type_id, num_components);
else
return type_id;
MSL: Force signedness of shader vertex attributes to match the host. Based on a patch by Stefan Dösinger. Metal cannot do signedness conversion on vertex attributes, and for good reason. Putting a `uint4` into an `int4`, or a `char4` into a `uint4`, would lose those values that are outside the range of the target type. But putting a `uchar4` into a `short4` or an `int4`, or a `ushort4` into an `int4`, should work. In that case, force the signedness in the shader to match the declared type of the host. Unfortunately, I don't really know how to automatically test this. This remapping is done based on input parameters normally supplied by MoltenVK. I'm not sure how we'd set this up for the command-line `spirv-cross` tool.
2018-11-28 22:26:45 +00:00
case SPIRType::Int:
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
return build_extended_vector_type(type_id, num_components > type.vecsize ? num_components : type.vecsize,
SPIRType::UInt);
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
MSL: Force signedness of shader vertex attributes to match the host. Based on a patch by Stefan Dösinger. Metal cannot do signedness conversion on vertex attributes, and for good reason. Putting a `uint4` into an `int4`, or a `char4` into a `uint4`, would lose those values that are outside the range of the target type. But putting a `uchar4` into a `short4` or an `int4`, or a `ushort4` into an `int4`, should work. In that case, force the signedness in the shader to match the declared type of the host. Unfortunately, I don't really know how to automatically test this. This remapping is done based on input parameters normally supplied by MoltenVK. I'm not sure how we'd set this up for the command-line `spirv-cross` tool.
2018-11-28 22:26:45 +00:00
default:
SPIRV_CROSS_THROW("Vertex attribute type mismatch between host and shader");
}
}
Add a stable C API for SPIRV-Cross. This adds a new C API for SPIRV-Cross which is intended to be stable, both API and ABI wise. The C++ API has been refactored a bit to make the C wrapper easier and cleaner to write. Especially the vertex attribute / resource interfaces for MSL has been rewritten to avoid taking mutable pointers into the interface. This would be very annoying to wrap and it didn't fit well with the rest of the C++ API to begin with. While doing this, I went ahead and removed all the old deprecated interfaces. The CMake build system has also seen an overhaul. It is now possible to build static/shared/CLI separately with -D options. The shared library only exposes the C API, as it is the only ABI-stable API. pkg-configs as well as CMake modules are exported and installed for the shared library configuration.
2019-02-12 10:11:29 +00:00
default:
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
if (num_components > type.vecsize)
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
type_id = build_extended_vector_type(type_id, num_components);
MSL: Use an enum instead of two mutually exclusive booleans. NFCI.
2018-12-04 19:54:29 +00:00
break;
}
MSL: Force signedness of shader vertex attributes to match the host. Based on a patch by Stefan Dösinger. Metal cannot do signedness conversion on vertex attributes, and for good reason. Putting a `uint4` into an `int4`, or a `char4` into a `uint4`, would lose those values that are outside the range of the target type. But putting a `uchar4` into a `short4` or an `int4`, or a `ushort4` into an `int4`, should work. In that case, force the signedness in the shader to match the declared type of the host. Unfortunately, I don't really know how to automatically test this. This remapping is done based on input parameters normally supplied by MoltenVK. I'm not sure how we'd set this up for the command-line `spirv-cross` tool.
2018-11-28 22:26:45 +00:00
return type_id;
}
Recursively pack struct types when we find scalar packed structs.
2019-07-23 13:24:53 +00:00
void CompilerMSL::mark_struct_members_packed(const SPIRType &type)
{
set_extended_decoration(type.self, SPIRVCrossDecorationPhysicalTypePacked);
// Problem case! Struct needs to be placed at an awkward alignment.
// Mark every member of the child struct as packed.
Fix some warnings when building in MoltenVK.
2019-07-23 14:39:13 +00:00
uint32_t mbr_cnt = uint32_t(type.member_types.size());
Recursively pack struct types when we find scalar packed structs.
2019-07-23 13:24:53 +00:00
for (uint32_t i = 0; i < mbr_cnt; i++)
{
auto &mbr_type = get<SPIRType>(type.member_types[i]);
if (mbr_type.basetype == SPIRType::Struct)
{
// Recursively mark structs as packed.
auto *struct_type = &mbr_type;
while (!struct_type->array.empty())
struct_type = &get<SPIRType>(struct_type->parent_type);
mark_struct_members_packed(*struct_type);
}
Do not attempt to pack types which are already scalar.
2019-07-24 09:52:28 +00:00
else if (!is_scalar(mbr_type))
Recursively pack struct types when we find scalar packed structs.
2019-07-23 13:24:53 +00:00
set_extended_member_decoration(type.self, i, SPIRVCrossDecorationPhysicalTypePacked);
}
}
Deal with scalar layout of entire structs. Mark all candidate struct types.
2019-07-19 12:18:14 +00:00
void CompilerMSL::mark_scalar_layout_structs(const SPIRType &type)
{
Fix some warnings when building in MoltenVK.
2019-07-23 14:39:13 +00:00
uint32_t mbr_cnt = uint32_t(type.member_types.size());
Deal with scalar layout of entire structs. Mark all candidate struct types.
2019-07-19 12:18:14 +00:00
for (uint32_t i = 0; i < mbr_cnt; i++)
{
auto &mbr_type = get<SPIRType>(type.member_types[i]);
if (mbr_type.basetype == SPIRType::Struct)
{
Traverse correct types when checking scalar layout.
2019-07-19 12:43:42 +00:00
auto *struct_type = &mbr_type;
while (!struct_type->array.empty())
struct_type = &get<SPIRType>(struct_type->parent_type);
if (has_extended_decoration(struct_type->self, SPIRVCrossDecorationPhysicalTypePacked))
Deal with scalar layout of entire structs. Mark all candidate struct types.
2019-07-19 12:18:14 +00:00
continue;
uint32_t msl_alignment = get_declared_struct_member_alignment_msl(type, i);
uint32_t msl_size = get_declared_struct_member_size_msl(type, i);
uint32_t spirv_offset = type_struct_member_offset(type, i);
uint32_t spirv_offset_next;
if (i + 1 < mbr_cnt)
spirv_offset_next = type_struct_member_offset(type, i + 1);
else
spirv_offset_next = spirv_offset + msl_size;
// Both are complicated cases. In scalar layout, a struct of float3 might just consume 12 bytes,
// and the next member will be placed at offset 12.
bool struct_is_misaligned = (spirv_offset % msl_alignment) != 0;
bool struct_is_too_large = spirv_offset + msl_size > spirv_offset_next;
Tests run clean.
2019-07-22 08:23:39 +00:00
uint32_t array_stride = 0;
bool struct_needs_explicit_padding = false;
// Verify that if a struct is used as an array that ArrayStride matches the effective size of the struct.
if (!mbr_type.array.empty())
{
array_stride = type_struct_member_array_stride(type, i);
Fix some warnings when building in MoltenVK.
2019-07-23 14:39:13 +00:00
uint32_t dimensions = uint32_t(mbr_type.array.size() - 1);
Add struct size padding tests.
2019-07-23 08:30:37 +00:00
for (uint32_t dim = 0; dim < dimensions; dim++)
Tests run clean.
2019-07-22 08:23:39 +00:00
{
Add struct size padding tests.
2019-07-23 08:30:37 +00:00
uint32_t array_size = to_array_size_literal(mbr_type, dim);
Tests run clean.
2019-07-22 08:23:39 +00:00
array_stride /= max(array_size, 1u);
}
// Set expected struct size based on ArrayStride.
struct_needs_explicit_padding = true;
// If struct size is larger than array stride, we might be able to fit, if we tightly pack.
if (get_declared_struct_size_msl(*struct_type) > array_stride)
struct_is_too_large = true;
}
Deal with scalar layout of entire structs. Mark all candidate struct types.
2019-07-19 12:18:14 +00:00
if (struct_is_misaligned || struct_is_too_large)
Recursively pack struct types when we find scalar packed structs.
2019-07-23 13:24:53 +00:00
mark_struct_members_packed(*struct_type);
Traverse correct types when checking scalar layout.
2019-07-19 12:43:42 +00:00
mark_scalar_layout_structs(*struct_type);
Tests run clean.
2019-07-22 08:23:39 +00:00
if (struct_needs_explicit_padding)
{
msl_size = get_declared_struct_size_msl(*struct_type, true, true);
if (array_stride < msl_size)
{
SPIRV_CROSS_THROW("Cannot express an array stride smaller than size of struct type.");
}
else
{
if (has_extended_decoration(struct_type->self, SPIRVCrossDecorationPaddingTarget))
{
Run format_all.sh.
2019-07-23 10:23:41 +00:00
if (array_stride !=
get_extended_decoration(struct_type->self, SPIRVCrossDecorationPaddingTarget))
SPIRV_CROSS_THROW(
"A struct is used with different array strides. Cannot express this in MSL.");
Tests run clean.
2019-07-22 08:23:39 +00:00
}
else
set_extended_decoration(struct_type->self, SPIRVCrossDecorationPaddingTarget, array_stride);
}
}
Deal with scalar layout of entire structs. Mark all candidate struct types.
2019-07-19 12:18:14 +00:00
}
}
}
CompilerMSL options access and UBO alignment test case. CompilerMSL accesses options using same design pattern as CompilerGLSL and CompilerHLSL. CompilerMSL support setting VA & rez binding specs via either constructor or compile() method overload. CompilerMSL support single UBO packing and padding in single pass. spriv_cross app (main.cpp) supports turning off UBO packing and padding via command line option. Add MSL UBO alignment test shader.
2017-03-12 21:42:51 +00:00
// Sort the members of the struct type by offset, and pack and then pad members where needed
// to align MSL members with SPIR-V offsets. The struct members are iterated twice. Packing
// occurs first, followed by padding, because packing a member reduces both its size and its
// natural alignment, possibly requiring a padding member to be added ahead of it.
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
void CompilerMSL::align_struct(SPIRType &ib_type, unordered_set<uint32_t> &aligned_structs)
CompilerMSL support separate indexed MTLBuffers for stage_in containing matrices. Add DecorationBinding to Compiler::get_member_decoration()/set_member_decoration().
2017-01-29 18:28:20 +00:00
{
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
// We align structs recursively, so stop any redundant work.
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
ID &ib_type_id = ib_type.self;
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
if (aligned_structs.count(ib_type_id))
return;
aligned_structs.insert(ib_type_id);
CompilerMSL support separate indexed MTLBuffers for stage_in containing matrices. Add DecorationBinding to Compiler::get_member_decoration()/set_member_decoration().
2017-01-29 18:28:20 +00:00
// Sort the members of the interface structure by their offset.
spirv_msl auto-alignment of members of MSL uniform structs. spirv_msl optionally add padding and packing to allow MSL struct members to align with SPIR-V struct alignments. spirv_cross add convenience methods for testing Decorations. spirv_glsl replace member_decl() function with new emit_stuct_member(). Allow struct member types to be marked as packed via DecorationCPacked decoration.
2017-03-01 02:44:36 +00:00
// They should already be sorted per SPIR-V spec anyway.
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
MemberSorter member_sorter(ib_type, ir.meta[ib_type_id], MemberSorter::Offset);
CompilerMSL support separate indexed MTLBuffers for stage_in containing matrices. Add DecorationBinding to Compiler::get_member_decoration()/set_member_decoration().
2017-01-29 18:28:20 +00:00
member_sorter.sort();
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
auto mbr_cnt = uint32_t(ib_type.member_types.size());
for (uint32_t mbr_idx = 0; mbr_idx < mbr_cnt; mbr_idx++)
{
// Pack any dependent struct types before we pack a parent struct.
auto &mbr_type = get<SPIRType>(ib_type.member_types[mbr_idx]);
if (mbr_type.basetype == SPIRType::Struct)
align_struct(mbr_type, aligned_structs);
}
CompilerMSL options access and UBO alignment test case. CompilerMSL accesses options using same design pattern as CompilerGLSL and CompilerHLSL. CompilerMSL support setting VA & rez binding specs via either constructor or compile() method overload. CompilerMSL support single UBO packing and padding in single pass. spriv_cross app (main.cpp) supports turning off UBO packing and padding via command line option. Add MSL UBO alignment test shader.
2017-03-12 21:42:51 +00:00
// Test the alignment of each member, and if a member should be closer to the previous
// member than the default spacing expects, it is likely that the previous member is in
// a packed format. If so, and the previous member is packable, pack it.
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
// For example ... this applies to any 3-element vector that is followed by a scalar.
uint32_t msl_offset = 0;
CompilerMSL options access and UBO alignment test case. CompilerMSL accesses options using same design pattern as CompilerGLSL and CompilerHLSL. CompilerMSL support setting VA & rez binding specs via either constructor or compile() method overload. CompilerMSL support single UBO packing and padding in single pass. spriv_cross app (main.cpp) supports turning off UBO packing and padding via command line option. Add MSL UBO alignment test shader.
2017-03-12 21:42:51 +00:00
for (uint32_t mbr_idx = 0; mbr_idx < mbr_cnt; mbr_idx++)
{
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
// This checks the member in isolation, if the member needs some kind of type remapping to conform to SPIR-V
// offsets, array strides and matrix strides.
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
ensure_member_packing_rules_msl(ib_type, mbr_idx);
CompilerMSL options access and UBO alignment test case. CompilerMSL accesses options using same design pattern as CompilerGLSL and CompilerHLSL. CompilerMSL support setting VA & rez binding specs via either constructor or compile() method overload. CompilerMSL support single UBO packing and padding in single pass. spriv_cross app (main.cpp) supports turning off UBO packing and padding via command line option. Add MSL UBO alignment test shader.
2017-03-12 21:42:51 +00:00
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
// Align current offset to the current member's default alignment. If the member was packed, it will observe
// the updated alignment here.
Fix some warnings when building in MoltenVK.
2019-07-23 14:39:13 +00:00
uint32_t msl_align_mask = get_declared_struct_member_alignment_msl(ib_type, mbr_idx) - 1;
Reintroduce struct_member_* MSL queries. Need to remap to physical type + packed qualifier, and this is handy to do in a helper function.
2019-07-18 11:48:27 +00:00
uint32_t aligned_msl_offset = (msl_offset + msl_align_mask) & ~msl_align_mask;
spirv_msl only add padding structure members if required by member alignment.
2017-03-06 16:00:23 +00:00
CompilerMSL options access and UBO alignment test case. CompilerMSL accesses options using same design pattern as CompilerGLSL and CompilerHLSL. CompilerMSL support setting VA & rez binding specs via either constructor or compile() method overload. CompilerMSL support single UBO packing and padding in single pass. spriv_cross app (main.cpp) supports turning off UBO packing and padding via command line option. Add MSL UBO alignment test shader.
2017-03-12 21:42:51 +00:00
// Fetch the member offset as declared in the SPIRV.
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
uint32_t spirv_mbr_offset = get_member_decoration(ib_type_id, mbr_idx, DecorationOffset);
if (spirv_mbr_offset > aligned_msl_offset)
CompilerMSL support separate indexed MTLBuffers for stage_in containing matrices. Add DecorationBinding to Compiler::get_member_decoration()/set_member_decoration().
2017-01-29 18:28:20 +00:00
{
spirv_msl pack MSL uniform struct members only when size warrants.
2017-03-03 01:57:26 +00:00
// Since MSL and SPIR-V have slightly different struct member alignment and
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
// size rules, we'll pad to standard C-packing rules with a char[] array. If the member is farther
spirv_msl pack MSL uniform struct members only when size warrants.
2017-03-03 01:57:26 +00:00
// away than C-packing, expects, add an inert padding member before the the member.
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
uint32_t padding_bytes = spirv_mbr_offset - aligned_msl_offset;
Tests run clean.
2019-07-22 08:23:39 +00:00
set_extended_member_decoration(ib_type_id, mbr_idx, SPIRVCrossDecorationPaddingTarget, padding_bytes);
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
// Re-align as a sanity check that aligning post-padding matches up.
msl_offset += padding_bytes;
Reintroduce struct_member_* MSL queries. Need to remap to physical type + packed qualifier, and this is handy to do in a helper function.
2019-07-18 11:48:27 +00:00
aligned_msl_offset = (msl_offset + msl_align_mask) & ~msl_align_mask;
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
}
else if (spirv_mbr_offset < aligned_msl_offset)
{
// This should not happen, but deal with unexpected scenarios.
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
// It *might* happen if a sub-struct has a larger alignment requirement in MSL than SPIR-V.
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
SPIRV_CROSS_THROW("Cannot represent buffer block correctly in MSL.");
spirv_msl pack MSL uniform struct members only when size warrants.
2017-03-03 01:57:26 +00:00
}
spirv_msl auto-alignment of members of MSL uniform structs. spirv_msl optionally add padding and packing to allow MSL struct members to align with SPIR-V struct alignments. spirv_cross add convenience methods for testing Decorations. spirv_glsl replace member_decl() function with new emit_stuct_member(). Allow struct member types to be marked as packed via DecorationCPacked decoration.
2017-03-01 02:44:36 +00:00
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
assert(aligned_msl_offset == spirv_mbr_offset);
CompilerMSL options access and UBO alignment test case. CompilerMSL accesses options using same design pattern as CompilerGLSL and CompilerHLSL. CompilerMSL support setting VA & rez binding specs via either constructor or compile() method overload. CompilerMSL support single UBO packing and padding in single pass. spriv_cross app (main.cpp) supports turning off UBO packing and padding via command line option. Add MSL UBO alignment test shader.
2017-03-12 21:42:51 +00:00
// Increment the current offset to be positioned immediately after the current member.
Deal with OpSpecConstantOp used as array size. When trying to validate buffer sizes, we usually need to bail out when using SpecConstantOps, but for some very specific cases where we allow unsized arrays currently, we can safely allow "unknown" sized arrays as well. This is probably the best we can do, when we have even more difficult cases than this, we throw a more sensible error message.
2018-11-01 13:56:25 +00:00
// Don't do this for the last member since it can be unsized, and it is not relevant for padding purposes here.
if (mbr_idx + 1 < mbr_cnt)
Reintroduce struct_member_* MSL queries. Need to remap to physical type + packed qualifier, and this is handy to do in a helper function.
2019-07-18 11:48:27 +00:00
msl_offset = aligned_msl_offset + get_declared_struct_member_size_msl(ib_type, mbr_idx);
CompilerMSL support separate indexed MTLBuffers for stage_in containing matrices. Add DecorationBinding to Compiler::get_member_decoration()/set_member_decoration().
2017-01-29 18:28:20 +00:00
}
}
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
bool CompilerMSL::validate_member_packing_rules_msl(const SPIRType &type, uint32_t index) const
spirv_msl pack MSL uniform struct members only when size warrants.
2017-03-03 01:57:26 +00:00
{
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
auto &mbr_type = get<SPIRType>(type.member_types[index]);
uint32_t spirv_offset = get_member_decoration(type.self, index, DecorationOffset);
MSL: Start considering float[] and float2[] in std140 layout.
2019-01-16 15:16:39 +00:00
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
if (index + 1 < type.member_types.size())
MSL: Start considering float[] and float2[] in std140 layout.
2019-01-16 15:16:39 +00:00
{
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
// First, we will check offsets. If SPIR-V offset + MSL size > SPIR-V offset of next member,
// we *must* perform some kind of remapping, no way getting around it.
// We can always pad after this member if necessary, so that case is fine.
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
uint32_t spirv_offset_next = get_member_decoration(type.self, index + 1, DecorationOffset);
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
assert(spirv_offset_next >= spirv_offset);
uint32_t maximum_size = spirv_offset_next - spirv_offset;
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
uint32_t msl_mbr_size = get_declared_struct_member_size_msl(type, index);
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
if (msl_mbr_size > maximum_size)
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
return false;
MSL: Start considering float[] and float2[] in std140 layout.
2019-01-16 15:16:39 +00:00
}
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
if (!mbr_type.array.empty())
MSL: Add a preliminary check for bad arrays of structs. ArrayStride can be larger than the declared struct size. We have no obvious solution for now, but warn about it in the MSL output for the time being.
2019-01-28 10:32:06 +00:00
{
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
// If we have an array type, array stride must match exactly with SPIR-V.
MSL: Support edge case with DX layout in scalar block layout. DX may emit ArrayStride and MatrixStride of 16, but the size of the object does not align with that and expect to pack other members inside its last member. The workaround is to emit array size/col/row one less than we expect and rely on padding to carve out a "dead zone" for the last member.
2020-04-20 09:02:20 +00:00
MSL: Avoid packed arrays in more cases. Extend the array stride relaxation to non-packed arrays as well, as long as the array in question contains a single array element.
2020-05-06 08:19:09 +00:00
// An exception to this requirement is if we have one array element.
MSL: Support edge case with DX layout in scalar block layout. DX may emit ArrayStride and MatrixStride of 16, but the size of the object does not align with that and expect to pack other members inside its last member. The workaround is to emit array size/col/row one less than we expect and rely on padding to carve out a "dead zone" for the last member.
2020-04-20 09:02:20 +00:00
// This comes from DX scalar layout workaround.
// If app tries to be cheeky and access the member out of bounds, this will not work, but this is the best we can do.
MSL: Avoid packed arrays in more cases. Extend the array stride relaxation to non-packed arrays as well, as long as the array in question contains a single array element.
2020-05-06 08:19:09 +00:00
// In OpAccessChain with logical memory models, access chains must be in-bounds in SPIR-V specification.
bool relax_array_stride = mbr_type.array.back() == 1 && mbr_type.array_size_literal.back();
MSL: Support edge case with DX layout in scalar block layout. DX may emit ArrayStride and MatrixStride of 16, but the size of the object does not align with that and expect to pack other members inside its last member. The workaround is to emit array size/col/row one less than we expect and rely on padding to carve out a "dead zone" for the last member.
2020-04-20 09:02:20 +00:00
if (!relax_array_stride)
{
uint32_t spirv_array_stride = type_struct_member_array_stride(type, index);
uint32_t msl_array_stride = get_declared_struct_member_array_stride_msl(type, index);
if (spirv_array_stride != msl_array_stride)
return false;
}
MSL: Add a preliminary check for bad arrays of structs. ArrayStride can be larger than the declared struct size. We have no obvious solution for now, but warn about it in the MSL output for the time being.
2019-01-28 10:32:06 +00:00
}
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
if (is_matrix(mbr_type))
{
// Need to check MatrixStride as well.
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
uint32_t spirv_matrix_stride = type_struct_member_matrix_stride(type, index);
uint32_t msl_matrix_stride = get_declared_struct_member_matrix_stride_msl(type, index);
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
if (spirv_matrix_stride != msl_matrix_stride)
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
return false;
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
}
CompilerMSL support smaller offsets for 3-row row-major matrices. Support MSL typedefs to declare 3-row row-major matrices as 3-column matrices. Allow those matrices to be decorated as packed. Support transposing those matrices when used. Modify how member alignments are calculated.
2018-02-11 21:52:57 +00:00
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
// Now, we check alignment.
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
uint32_t msl_alignment = get_declared_struct_member_alignment_msl(type, index);
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
if ((spirv_offset % msl_alignment) != 0)
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
return false;
CompilerMSL support smaller offsets for 3-row row-major matrices. Support MSL typedefs to declare 3-row row-major matrices as 3-column matrices. Allow those matrices to be decorated as packed. Support transposing those matrices when used. Modify how member alignments are calculated.
2018-02-11 21:52:57 +00:00
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
// We're in the clear.
return true;
}
// Here we need to verify that the member type we declare conforms to Offset, ArrayStride or MatrixStride restrictions.
// If there is a mismatch, we need to emit remapped types, either normal types, or "packed_X" types.
// In odd cases we need to emit packed and remapped types, for e.g. weird matrices or arrays with weird array strides.
void CompilerMSL::ensure_member_packing_rules_msl(SPIRType &ib_type, uint32_t index)
{
if (validate_member_packing_rules_msl(ib_type, index))
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
return;
CompilerMSL support smaller offsets for 3-row row-major matrices. Support MSL typedefs to declare 3-row row-major matrices as 3-column matrices. Allow those matrices to be decorated as packed. Support transposing those matrices when used. Modify how member alignments are calculated.
2018-02-11 21:52:57 +00:00
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
// We failed validation.
// This case will be nightmare-ish to deal with. This could possibly happen if struct alignment does not quite
// match up with what we want. Scalar block layout comes to mind here where we might have to work around the rule
// that struct alignment == max alignment of all members and struct size depends on this alignment.
auto &mbr_type = get<SPIRType>(ib_type.member_types[index]);
if (mbr_type.basetype == SPIRType::Struct)
SPIRV_CROSS_THROW("Cannot perform any repacking for structs when it is used as a member of another struct.");
Reintroduce struct_member_* MSL queries. Need to remap to physical type + packed qualifier, and this is handy to do in a helper function.
2019-07-18 11:48:27 +00:00
// Perform remapping here.
MSL: Avoid packed arrays in more cases. Extend the array stride relaxation to non-packed arrays as well, as long as the array in question contains a single array element.
2020-05-06 08:19:09 +00:00
// There is nothing to be gained by using packed scalars, so don't attempt it.
if (!is_scalar(ib_type))
set_extended_member_decoration(ib_type.self, index, SPIRVCrossDecorationPhysicalTypePacked);
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
// Try validating again, now with packed.
if (validate_member_packing_rules_msl(ib_type, index))
return;
// We're in deep trouble, and we need to create a new PhysicalType which matches up with what we expect.
// A lot of work goes here ...
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
// We will need remapping on Load and Store to translate the types between Logical and Physical.
Start considering how to emit physical type ID.
2019-07-18 15:05:28 +00:00
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
// First, we check if we have small vector std140 array.
// We detect this if we have an array of vectors, and array stride is greater than number of elements.
if (!mbr_type.array.empty() && !is_matrix(mbr_type))
{
uint32_t array_stride = type_struct_member_array_stride(ib_type, index);
spirv_msl pack MSL uniform struct members only when size warrants.
2017-03-03 01:57:26 +00:00
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
// Hack off array-of-arrays until we find the array stride per element we must have to make it work.
Fix some warnings when building in MoltenVK.
2019-07-23 14:39:13 +00:00
uint32_t dimensions = uint32_t(mbr_type.array.size() - 1);
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
for (uint32_t dim = 0; dim < dimensions; dim++)
array_stride /= max(to_array_size_literal(mbr_type, dim), 1u);
uint32_t elems_per_stride = array_stride / (mbr_type.width / 8);
Deal with scalar layout of entire structs. Mark all candidate struct types.
2019-07-19 12:18:14 +00:00
if (elems_per_stride == 3)
SPIRV_CROSS_THROW("Cannot use ArrayStride of 3 elements in remapping scenarios.");
else if (elems_per_stride > 4)
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
SPIRV_CROSS_THROW("Cannot represent vectors with more than 4 elements in MSL.");
auto physical_type = mbr_type;
physical_type.vecsize = elems_per_stride;
physical_type.parent_type = 0;
uint32_t type_id = ir.increase_bound_by(1);
set<SPIRType>(type_id, physical_type);
set_extended_member_decoration(ib_type.self, index, SPIRVCrossDecorationPhysicalTypeID, type_id);
set_decoration(type_id, DecorationArrayStride, array_stride);
// Remove packed_ for vectors of size 1, 2 and 4.
Deal with scalar layout of entire structs. Mark all candidate struct types.
2019-07-19 12:18:14 +00:00
if (has_extended_decoration(ib_type.self, SPIRVCrossDecorationPhysicalTypePacked))
Run format_all.sh.
2019-07-23 10:23:41 +00:00
SPIRV_CROSS_THROW("Unable to remove packed decoration as entire struct must be fully packed. Do not mix "
"scalar and std140 layout rules.");
Deal with scalar layout of entire structs. Mark all candidate struct types.
2019-07-19 12:18:14 +00:00
else
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
unset_extended_member_decoration(ib_type.self, index, SPIRVCrossDecorationPhysicalTypePacked);
}
else if (is_matrix(mbr_type))
{
// MatrixStride might be std140-esque.
uint32_t matrix_stride = type_struct_member_matrix_stride(ib_type, index);
uint32_t elems_per_stride = matrix_stride / (mbr_type.width / 8);
Deal with scalar layout of entire structs. Mark all candidate struct types.
2019-07-19 12:18:14 +00:00
if (elems_per_stride == 3)
SPIRV_CROSS_THROW("Cannot use ArrayStride of 3 elements in remapping scenarios.");
else if (elems_per_stride > 4)
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
SPIRV_CROSS_THROW("Cannot represent vectors with more than 4 elements in MSL.");
bool row_major = has_member_decoration(ib_type.self, index, DecorationRowMajor);
auto physical_type = mbr_type;
physical_type.parent_type = 0;
if (row_major)
physical_type.columns = elems_per_stride;
else
physical_type.vecsize = elems_per_stride;
uint32_t type_id = ir.increase_bound_by(1);
set<SPIRType>(type_id, physical_type);
set_extended_member_decoration(ib_type.self, index, SPIRVCrossDecorationPhysicalTypeID, type_id);
// Remove packed_ for vectors of size 1, 2 and 4.
Deal with scalar layout of entire structs. Mark all candidate struct types.
2019-07-19 12:18:14 +00:00
if (has_extended_decoration(ib_type.self, SPIRVCrossDecorationPhysicalTypePacked))
Run format_all.sh.
2019-07-23 10:23:41 +00:00
SPIRV_CROSS_THROW("Unable to remove packed decoration as entire struct must be fully packed. Do not mix "
"scalar and std140 layout rules.");
Deal with scalar layout of entire structs. Mark all candidate struct types.
2019-07-19 12:18:14 +00:00
else
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
unset_extended_member_decoration(ib_type.self, index, SPIRVCrossDecorationPhysicalTypePacked);
}
MSL: Support edge case with DX layout in scalar block layout. DX may emit ArrayStride and MatrixStride of 16, but the size of the object does not align with that and expect to pack other members inside its last member. The workaround is to emit array size/col/row one less than we expect and rely on padding to carve out a "dead zone" for the last member.
2020-04-20 09:02:20 +00:00
else
SPIRV_CROSS_THROW("Found a buffer packing case which we cannot represent in MSL.");
// Try validating again, now with physical type remapping.
if (validate_member_packing_rules_msl(ib_type, index))
return;
// We might have a particular odd scalar layout case where the last element of an array
// does not take up as much space as the ArrayStride or MatrixStride. This can happen with DX cbuffers.
// The "proper" workaround for this is extremely painful and essentially impossible in the edge case of float3[],
// so we hack around it by declaring the offending array or matrix with one less array size/col/row,
// and rely on padding to get the correct value. We will technically access arrays out of bounds into the padding region,
// but it should spill over gracefully without too much trouble. We rely on behavior like this for unsized arrays anyways.
// E.g. we might observe a physical layout of:
// { float2 a[2]; float b; } in cbuffer layout where ArrayStride of a is 16, but offset of b is 24, packed right after a[1] ...
uint32_t type_id = get_extended_member_decoration(ib_type.self, index, SPIRVCrossDecorationPhysicalTypeID);
auto &type = get<SPIRType>(type_id);
// Modify the physical type in-place. This is safe since each physical type workaround is a copy.
if (is_array(type))
{
if (type.array.back() > 1)
{
if (!type.array_size_literal.back())
SPIRV_CROSS_THROW("Cannot apply scalar layout workaround with spec constant array size.");
type.array.back() -= 1;
}
else
{
// We have an array of size 1, so we cannot decrement that. Our only option now is to
// force a packed layout instead, and drop the physical type remap since ArrayStride is meaningless now.
unset_extended_member_decoration(ib_type.self, index, SPIRVCrossDecorationPhysicalTypeID);
set_extended_member_decoration(ib_type.self, index, SPIRVCrossDecorationPhysicalTypePacked);
}
}
else if (is_matrix(type))
{
bool row_major = has_member_decoration(ib_type.self, index, DecorationRowMajor);
if (!row_major)
{
// Slice off one column. If we only have 2 columns, this might turn the matrix into a vector with one array element instead.
if (type.columns > 2)
{
type.columns--;
}
else if (type.columns == 2)
{
type.columns = 1;
assert(type.array.empty());
type.array.push_back(1);
type.array_size_literal.push_back(true);
}
}
else
{
// Slice off one row. If we only have 2 rows, this might turn the matrix into a vector with one array element instead.
if (type.vecsize > 2)
{
type.vecsize--;
}
else if (type.vecsize == 2)
{
type.vecsize = type.columns;
type.columns = 1;
assert(type.array.empty());
type.array.push_back(1);
type.array_size_literal.push_back(true);
}
}
}
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
// This better validate now, or we must fail gracefully.
if (!validate_member_packing_rules_msl(ib_type, index))
SPIRV_CROSS_THROW("Found a buffer packing case which we cannot represent in MSL.");
MSL: Handle packed matrices. The old method of using a different unpacked matrix type doesn't work for scalar alignment. It certainly wouldn't have any effect for a square matrix, since the number of columns and rows are the same. So now we'll store them as arrays of packed vectors.
2019-07-10 23:37:31 +00:00
}
Avoid unintentional name conflict with HLSL backend.
2019-01-17 11:21:16 +00:00
void CompilerMSL::emit_store_statement(uint32_t lhs_expression, uint32_t rhs_expression)
Deal with packing/unpacking on store. Still a bit buggy, since we cannot deduce between float2[] and packed_float2. Need a deeper refactor to plumb this through ...
2019-01-17 09:06:23 +00:00
{
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
auto &type = expression_type(rhs_expression);
bool lhs_remapped_type = has_extended_decoration(lhs_expression, SPIRVCrossDecorationPhysicalTypeID);
bool lhs_packed_type = has_extended_decoration(lhs_expression, SPIRVCrossDecorationPhysicalTypePacked);
auto *lhs_e = maybe_get<SPIRExpression>(lhs_expression);
auto *rhs_e = maybe_get<SPIRExpression>(rhs_expression);
Fix some row-major column store cases.
2019-07-22 10:56:14 +00:00
bool transpose = lhs_e && lhs_e->need_transpose;
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
// No physical type remapping, and no packed type, so can just emit a store directly.
if (!lhs_remapped_type && !lhs_packed_type)
{
// We might not be dealing with remapped physical types or packed types,
// but we might be doing a clean store to a row-major matrix.
// In this case, we just flip transpose states, and emit the store, a transpose must be in the RHS expression, if any.
if (is_matrix(type) && lhs_e && lhs_e->need_transpose)
{
if (!rhs_e)
Run format_all.sh.
2019-07-23 10:23:41 +00:00
SPIRV_CROSS_THROW("Need to transpose right-side expression of a store to row-major matrix, but it is "
"not a SPIRExpression.");
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
lhs_e->need_transpose = false;
Deal correctly with complete stores to row_major matrices.
2019-07-22 13:49:17 +00:00
if (rhs_e && rhs_e->need_transpose)
{
// Direct copy, but might need to unpack RHS.
// Skip the transpose, as we will transpose when writing to LHS and transpose(transpose(T)) == T.
rhs_e->need_transpose = false;
Run format_all.sh.
2019-07-23 10:23:41 +00:00
statement(to_expression(lhs_expression), " = ", to_unpacked_row_major_matrix_expression(rhs_expression),
";");
Deal correctly with complete stores to row_major matrices.
2019-07-22 13:49:17 +00:00
rhs_e->need_transpose = true;
}
else
Only transpose unpacked expressions.
2019-07-22 14:06:09 +00:00
statement(to_expression(lhs_expression), " = transpose(", to_unpacked_expression(rhs_expression), ");");
Deal correctly with complete stores to row_major matrices.
2019-07-22 13:49:17 +00:00
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
lhs_e->need_transpose = true;
Deal correctly with complete stores to row_major matrices.
2019-07-22 13:49:17 +00:00
register_write(lhs_expression);
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
}
MSL: Support storing to row-major column. Defer transposes to actual Load or Store.
2019-07-22 09:13:44 +00:00
else if (lhs_e && lhs_e->need_transpose)
{
lhs_e->need_transpose = false;
// Storing a column to a row-major matrix. Unroll the write.
for (uint32_t c = 0; c < type.vecsize; c++)
{
auto lhs_expr = to_dereferenced_expression(lhs_expression);
auto column_index = lhs_expr.find_last_of('[');
if (column_index != string::npos)
{
statement(lhs_expr.insert(column_index, join('[', c, ']')), " = ",
to_extract_component_expression(rhs_expression, c), ";");
}
}
lhs_e->need_transpose = true;
Don't forget to register a write to LHS expression in certain case.
2019-07-22 11:06:30 +00:00
register_write(lhs_expression);
MSL: Support storing to row-major column. Defer transposes to actual Load or Store.
2019-07-22 09:13:44 +00:00
}
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
else
CompilerGLSL::emit_store_statement(lhs_expression, rhs_expression);
}
Fix some row-major column store cases.
2019-07-22 10:56:14 +00:00
else if (!lhs_remapped_type && !is_matrix(type) && !transpose)
Refactor out packed expressions to extended decorations. Can't safely just cast to the original enum without lots of hacks.
2019-01-17 10:22:24 +00:00
{
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
// Even if the target type is packed, we can directly store to it. We cannot store to packed matrices directly,
// since they are declared as array of vectors instead, and we need the fallback path below.
Avoid unintentional name conflict with HLSL backend.
2019-01-17 11:21:16 +00:00
CompilerGLSL::emit_store_statement(lhs_expression, rhs_expression);
Refactor out packed expressions to extended decorations. Can't safely just cast to the original enum without lots of hacks.
2019-01-17 10:22:24 +00:00
}
Deal with packing/unpacking on store. Still a bit buggy, since we cannot deduce between float2[] and packed_float2. Need a deeper refactor to plumb this through ...
2019-01-17 09:06:23 +00:00
else
{
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
// Special handling when storing to a remapped physical type.
// This is mostly to deal with std140 padded matrices or vectors.
Deal with packing/unpacking on store. Still a bit buggy, since we cannot deduce between float2[] and packed_float2. Need a deeper refactor to plumb this through ...
2019-01-17 09:06:23 +00:00
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
TypeID physical_type_id = lhs_remapped_type ?
ID(get_extended_decoration(lhs_expression, SPIRVCrossDecorationPhysicalTypeID)) :
type.self;
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
auto &physical_type = get<SPIRType>(physical_type_id);
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
Fix some row-major column store cases.
2019-07-22 10:56:14 +00:00
if (is_matrix(type))
MSL: Handle packed matrices. The old method of using a different unpacked matrix type doesn't work for scalar alignment. It certainly wouldn't have any effect for a square matrix, since the number of columns and rows are the same. So now we'll store them as arrays of packed vectors.
2019-07-10 23:37:31 +00:00
{
MSL: Do not emit swizzled writes in packing fixups. Similar to scalar access chain fix, this causes a read-modify-write on memory we're not supposed to write to.
2020-07-01 12:13:10 +00:00
const char *packed_pfx = lhs_packed_type ? "packed_" : "";
MSL: Handle packed matrices. The old method of using a different unpacked matrix type doesn't work for scalar alignment. It certainly wouldn't have any effect for a square matrix, since the number of columns and rows are the same. So now we'll store them as arrays of packed vectors.
2019-07-10 23:37:31 +00:00
// Packed matrices are stored as arrays of packed vectors, so we need
// to assign the vectors one at a time.
// For row-major matrices, we need to transpose the *right-hand* side,
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
// not the left-hand side.
// Lots of cases to cover here ...
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
bool rhs_transpose = rhs_e && rhs_e->need_transpose;
MSL: Do not emit swizzled writes in packing fixups. Similar to scalar access chain fix, this causes a read-modify-write on memory we're not supposed to write to.
2020-07-01 12:13:10 +00:00
SPIRType write_type = type;
string cast_expr;
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
// We're dealing with transpose manually.
if (rhs_transpose)
rhs_e->need_transpose = false;
MSL: Handle packed matrices. The old method of using a different unpacked matrix type doesn't work for scalar alignment. It certainly wouldn't have any effect for a square matrix, since the number of columns and rows are the same. So now we'll store them as arrays of packed vectors.
2019-07-10 23:37:31 +00:00
if (transpose)
{
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
// We're dealing with transpose manually.
MSL: Handle packed matrices. The old method of using a different unpacked matrix type doesn't work for scalar alignment. It certainly wouldn't have any effect for a square matrix, since the number of columns and rows are the same. So now we'll store them as arrays of packed vectors.
2019-07-10 23:37:31 +00:00
lhs_e->need_transpose = false;
MSL: Do not emit swizzled writes in packing fixups. Similar to scalar access chain fix, this causes a read-modify-write on memory we're not supposed to write to.
2020-07-01 12:13:10 +00:00
write_type.vecsize = type.columns;
write_type.columns = 1;
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
if (physical_type.columns != type.columns)
MSL: Do not emit swizzled writes in packing fixups. Similar to scalar access chain fix, this causes a read-modify-write on memory we're not supposed to write to.
2020-07-01 12:13:10 +00:00
cast_expr = join("(device ", packed_pfx, type_to_glsl(write_type), "&)");
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
if (rhs_transpose)
{
// If RHS is also transposed, we can just copy row by row.
for (uint32_t i = 0; i < type.vecsize; i++)
{
MSL: Do not emit swizzled writes in packing fixups. Similar to scalar access chain fix, this causes a read-modify-write on memory we're not supposed to write to.
2020-07-01 12:13:10 +00:00
statement(cast_expr, to_enclosed_expression(lhs_expression), "[", i, "]", " = ",
Run format_all.sh.
2019-07-23 10:23:41 +00:00
to_unpacked_row_major_matrix_expression(rhs_expression), "[", i, "];");
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
}
}
else
{
auto vector_type = expression_type(rhs_expression);
vector_type.vecsize = vector_type.columns;
vector_type.columns = 1;
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
// Transpose on the fly. Emitting a lot of full transpose() ops and extracting lanes seems very bad,
// so pick out individual components instead.
for (uint32_t i = 0; i < type.vecsize; i++)
{
string rhs_row = type_to_glsl_constructor(vector_type) + "(";
for (uint32_t j = 0; j < vector_type.vecsize; j++)
{
Declare correct matrix type when unpacking.
2019-07-22 11:25:45 +00:00
rhs_row += join(to_enclosed_unpacked_expression(rhs_expression), "[", j, "][", i, "]");
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
if (j + 1 < vector_type.vecsize)
rhs_row += ", ";
}
rhs_row += ")";
MSL: Do not emit swizzled writes in packing fixups. Similar to scalar access chain fix, this causes a read-modify-write on memory we're not supposed to write to.
2020-07-01 12:13:10 +00:00
statement(cast_expr, to_enclosed_expression(lhs_expression), "[", i, "]", " = ", rhs_row, ";");
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
}
}
// We're dealing with transpose manually.
MSL: Handle packed matrices. The old method of using a different unpacked matrix type doesn't work for scalar alignment. It certainly wouldn't have any effect for a square matrix, since the number of columns and rows are the same. So now we'll store them as arrays of packed vectors.
2019-07-10 23:37:31 +00:00
lhs_e->need_transpose = true;
}
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
else
{
MSL: Do not emit swizzled writes in packing fixups. Similar to scalar access chain fix, this causes a read-modify-write on memory we're not supposed to write to.
2020-07-01 12:13:10 +00:00
write_type.columns = 1;
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
if (physical_type.vecsize != type.vecsize)
MSL: Do not emit swizzled writes in packing fixups. Similar to scalar access chain fix, this causes a read-modify-write on memory we're not supposed to write to.
2020-07-01 12:13:10 +00:00
cast_expr = join("(device ", packed_pfx, type_to_glsl(write_type), "&)");
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
if (rhs_transpose)
{
auto vector_type = expression_type(rhs_expression);
vector_type.columns = 1;
// Transpose on the fly. Emitting a lot of full transpose() ops and extracting lanes seems very bad,
// so pick out individual components instead.
for (uint32_t i = 0; i < type.columns; i++)
{
string rhs_row = type_to_glsl_constructor(vector_type) + "(";
for (uint32_t j = 0; j < vector_type.vecsize; j++)
{
Correctly unpack row-major matrices when storing to LHS.
2019-07-22 10:03:12 +00:00
// Need to explicitly unpack expression since we've mucked with transpose state.
Use to_unpacked_row_major_expression to unify row-major in MSL/GLSL.
2019-07-23 09:36:54 +00:00
auto unpacked_expr = to_unpacked_row_major_matrix_expression(rhs_expression);
Correctly unpack row-major matrices when storing to LHS.
2019-07-22 10:03:12 +00:00
rhs_row += join(unpacked_expr, "[", j, "][", i, "]");
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
if (j + 1 < vector_type.vecsize)
rhs_row += ", ";
}
rhs_row += ")";
MSL: Do not emit swizzled writes in packing fixups. Similar to scalar access chain fix, this causes a read-modify-write on memory we're not supposed to write to.
2020-07-01 12:13:10 +00:00
statement(cast_expr, to_enclosed_expression(lhs_expression), "[", i, "]", " = ", rhs_row, ";");
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
}
}
else
{
// Copy column-by-column.
for (uint32_t i = 0; i < type.columns; i++)
{
MSL: Do not emit swizzled writes in packing fixups. Similar to scalar access chain fix, this causes a read-modify-write on memory we're not supposed to write to.
2020-07-01 12:13:10 +00:00
statement(cast_expr, to_enclosed_expression(lhs_expression), "[", i, "]", " = ",
Run format_all.sh.
2019-07-23 10:23:41 +00:00
to_enclosed_unpacked_expression(rhs_expression), "[", i, "];");
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
}
}
}
// We're dealing with transpose manually.
if (rhs_transpose)
rhs_e->need_transpose = true;
MSL: Handle packed matrices. The old method of using a different unpacked matrix type doesn't work for scalar alignment. It certainly wouldn't have any effect for a square matrix, since the number of columns and rows are the same. So now we'll store them as arrays of packed vectors.
2019-07-10 23:37:31 +00:00
}
MSL: Support storing to row-major column. Defer transposes to actual Load or Store.
2019-07-22 09:13:44 +00:00
else if (transpose)
{
lhs_e->need_transpose = false;
MSL: Do not emit swizzled writes in packing fixups. Similar to scalar access chain fix, this causes a read-modify-write on memory we're not supposed to write to.
2020-07-01 12:13:10 +00:00
SPIRType write_type = type;
write_type.vecsize = 1;
write_type.columns = 1;
MSL: Support storing to row-major column. Defer transposes to actual Load or Store.
2019-07-22 09:13:44 +00:00
// Storing a column to a row-major matrix. Unroll the write.
for (uint32_t c = 0; c < type.vecsize; c++)
{
Fix some row-major column store cases.
2019-07-22 10:56:14 +00:00
auto lhs_expr = to_enclosed_expression(lhs_expression);
MSL: Support storing to row-major column. Defer transposes to actual Load or Store.
2019-07-22 09:13:44 +00:00
auto column_index = lhs_expr.find_last_of('[');
if (column_index != string::npos)
{
MSL: Do not emit swizzled writes in packing fixups. Similar to scalar access chain fix, this causes a read-modify-write on memory we're not supposed to write to.
2020-07-01 12:13:10 +00:00
statement("((device ", type_to_glsl(write_type), "*)&",
lhs_expr.insert(column_index, join('[', c, ']', ")")), " = ",
MSL: Support storing to row-major column. Defer transposes to actual Load or Store.
2019-07-22 09:13:44 +00:00
to_extract_component_expression(rhs_expression, c), ";");
}
}
lhs_e->need_transpose = true;
}
Deal with swizzled stores to std140 matrices.
2019-07-22 11:05:23 +00:00
else if ((is_matrix(physical_type) || is_array(physical_type)) && physical_type.vecsize > type.vecsize)
MSL: Support scalar block layout. Relaxed block layout relaxed the restrictions on vector alignment, allowing them to be aligned on scalar boundaries. Scalar block layout relaxes this further, allowing *any* member to be aligned on a scalar boundary. The requirement that a vector not improperly straddle a 16-byte boundary is also relaxed. I've also added a test showing that `std430` layout works with UBOs. I'm troubled by the dual meaning of the `Packed` extended decoration. In some instances (struct, `float[]`, and `vec2[]` members), it actually means the exact opposite, that the member needs extra padding. This is especially problematic for `vec2[]`, because now we need to distinguish the two cases by checking the array stride. I wonder if this should actually be split into two decorations.
2019-07-10 01:28:02 +00:00
{
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
assert(type.vecsize >= 1 && type.vecsize <= 3);
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
// If we have packed types, we cannot use swizzled stores.
// We could technically unroll the store for each element if needed.
// When remapping to a std140 physical type, we always get float4,
// and the packed decoration should always be removed.
assert(!lhs_packed_type);
Fix some row-major column store cases.
2019-07-22 10:56:14 +00:00
string lhs = to_dereferenced_expression(lhs_expression);
string rhs = to_pointer_expression(rhs_expression);
MSL: Support scalar block layout. Relaxed block layout relaxed the restrictions on vector alignment, allowing them to be aligned on scalar boundaries. Scalar block layout relaxes this further, allowing *any* member to be aligned on a scalar boundary. The requirement that a vector not improperly straddle a 16-byte boundary is also relaxed. I've also added a test showing that `std430` layout works with UBOs. I'm troubled by the dual meaning of the `Packed` extended decoration. In some instances (struct, `float[]`, and `vec2[]` members), it actually means the exact opposite, that the member needs extra padding. This is especially problematic for `vec2[]`, because now we need to distinguish the two cases by checking the array stride. I wonder if this should actually be split into two decorations.
2019-07-10 01:28:02 +00:00
// Unpack the expression so we can store to it with a float or float2.
// It's still an l-value, so it's fine. Most other unpacking of expressions turn them into r-values instead.
MSL: Do not emit swizzled writes in packing fixups. Similar to scalar access chain fix, this causes a read-modify-write on memory we're not supposed to write to.
2020-07-01 12:13:10 +00:00
lhs = join("(device ", type_to_glsl(type), "&)", enclose_expression(lhs));
Fix some row-major column store cases.
2019-07-22 10:56:14 +00:00
if (!optimize_read_modify_write(expression_type(rhs_expression), lhs, rhs))
statement(lhs, " = ", rhs, ";");
MSL: Support scalar block layout. Relaxed block layout relaxed the restrictions on vector alignment, allowing them to be aligned on scalar boundaries. Scalar block layout relaxes this further, allowing *any* member to be aligned on a scalar boundary. The requirement that a vector not improperly straddle a 16-byte boundary is also relaxed. I've also added a test showing that `std430` layout works with UBOs. I'm troubled by the dual meaning of the `Packed` extended decoration. In some instances (struct, `float[]`, and `vec2[]` members), it actually means the exact opposite, that the member needs extra padding. This is especially problematic for `vec2[]`, because now we need to distinguish the two cases by checking the array stride. I wonder if this should actually be split into two decorations.
2019-07-10 01:28:02 +00:00
}
Fix some row-major column store cases.
2019-07-22 10:56:14 +00:00
else if (!is_matrix(type))
MSL: Handle packed matrices. The old method of using a different unpacked matrix type doesn't work for scalar alignment. It certainly wouldn't have any effect for a square matrix, since the number of columns and rows are the same. So now we'll store them as arrays of packed vectors.
2019-07-10 23:37:31 +00:00
{
Fix some row-major column store cases.
2019-07-22 10:56:14 +00:00
string lhs = to_dereferenced_expression(lhs_expression);
string rhs = to_pointer_expression(rhs_expression);
MSL: Handle packed matrices. The old method of using a different unpacked matrix type doesn't work for scalar alignment. It certainly wouldn't have any effect for a square matrix, since the number of columns and rows are the same. So now we'll store them as arrays of packed vectors.
2019-07-10 23:37:31 +00:00
if (!optimize_read_modify_write(expression_type(rhs_expression), lhs, rhs))
statement(lhs, " = ", rhs, ";");
}
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
Deal with packing/unpacking on store. Still a bit buggy, since we cannot deduce between float2[] and packed_float2. Need a deeper refactor to plumb this through ...
2019-01-17 09:06:23 +00:00
register_write(lhs_expression);
}
}
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
static bool expression_ends_with(const string &expr_str, const std::string &ending)
When compiling from HLSL which pads and aligns float[]/float2[] within structures to float4[] we need to unpack the original type in Metal from the float4.
2019-08-14 14:57:23 +00:00
{
if (expr_str.length() >= ending.length())
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
return (expr_str.compare(expr_str.length() - ending.length(), ending.length(), ending) == 0);
When compiling from HLSL which pads and aligns float[]/float2[] within structures to float4[] we need to unpack the original type in Metal from the float4.
2019-08-14 14:57:23 +00:00
else
return false;
}
spirv_msl unpack packed MSL uniform struct members. spirv_glsl add member_is_packed_type() and unpack_expression_type() functions.
2017-03-01 18:07:40 +00:00
// Converts the format of the current expression from packed to unpacked,
// by wrapping the expression in a constructor of the appropriate type.
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
// Also, handle special physical ID remapping scenarios, similar to emit_store_statement().
Pass down row-major state to unpacking functions.
2019-07-19 11:03:08 +00:00
string CompilerMSL::unpack_expression_type(string expr_str, const SPIRType &type, uint32_t physical_type_id,
bool packed, bool row_major)
spirv_msl unpack packed MSL uniform struct members. spirv_glsl add member_is_packed_type() and unpack_expression_type() functions.
2017-03-01 18:07:40 +00:00
{
Deal correctly with complete stores to row_major matrices.
2019-07-22 13:49:17 +00:00
// Trivial case, nothing to do.
if (physical_type_id == 0 && !packed)
return expr_str;
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
const SPIRType *physical_type = nullptr;
if (physical_type_id)
physical_type = &get<SPIRType>(physical_type_id);
static const char *swizzle_lut[] = {
".x",
".xy",
".xyz",
};
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
if (physical_type && is_vector(*physical_type) && is_array(*physical_type) &&
physical_type->vecsize > type.vecsize && !expression_ends_with(expr_str, swizzle_lut[type.vecsize - 1]))
MSL: Support scalar block layout. Relaxed block layout relaxed the restrictions on vector alignment, allowing them to be aligned on scalar boundaries. Scalar block layout relaxes this further, allowing *any* member to be aligned on a scalar boundary. The requirement that a vector not improperly straddle a 16-byte boundary is also relaxed. I've also added a test showing that `std430` layout works with UBOs. I'm troubled by the dual meaning of the `Packed` extended decoration. In some instances (struct, `float[]`, and `vec2[]` members), it actually means the exact opposite, that the member needs extra padding. This is especially problematic for `vec2[]`, because now we need to distinguish the two cases by checking the array stride. I wonder if this should actually be split into two decorations.
2019-07-10 01:28:02 +00:00
{
MSL: Fix unpack_expression from column of padded matrix.
2019-11-07 10:29:40 +00:00
// std140 array cases for vectors.
assert(type.vecsize >= 1 && type.vecsize <= 3);
return enclose_expression(expr_str) + swizzle_lut[type.vecsize - 1];
}
Run format_all.sh.
2020-01-08 09:48:30 +00:00
else if (physical_type && is_matrix(*physical_type) && is_vector(type) && physical_type->vecsize > type.vecsize)
MSL: Fix unpack_expression from column of padded matrix.
2019-11-07 10:29:40 +00:00
{
// Extract column from padded matrix.
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
assert(type.vecsize >= 1 && type.vecsize <= 3);
return enclose_expression(expr_str) + swizzle_lut[type.vecsize - 1];
MSL: Support scalar block layout. Relaxed block layout relaxed the restrictions on vector alignment, allowing them to be aligned on scalar boundaries. Scalar block layout relaxes this further, allowing *any* member to be aligned on a scalar boundary. The requirement that a vector not improperly straddle a 16-byte boundary is also relaxed. I've also added a test showing that `std430` layout works with UBOs. I'm troubled by the dual meaning of the `Packed` extended decoration. In some instances (struct, `float[]`, and `vec2[]` members), it actually means the exact opposite, that the member needs extra padding. This is especially problematic for `vec2[]`, because now we need to distinguish the two cases by checking the array stride. I wonder if this should actually be split into two decorations.
2019-07-10 01:28:02 +00:00
}
MSL: Handle packed matrices. The old method of using a different unpacked matrix type doesn't work for scalar alignment. It certainly wouldn't have any effect for a square matrix, since the number of columns and rows are the same. So now we'll store them as arrays of packed vectors.
2019-07-10 23:37:31 +00:00
else if (is_matrix(type))
{
// Packed matrices are stored as arrays of packed vectors. Unfortunately,
// we can't just pass the array straight to the matrix constructor. We have to
// pass each vector individually, so that they can be unpacked to normal vectors.
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
if (!physical_type)
physical_type = &type;
Pass down row-major state to unpacking functions.
2019-07-19 11:03:08 +00:00
uint32_t vecsize = type.vecsize;
uint32_t columns = type.columns;
if (row_major)
swap(vecsize, columns);
uint32_t physical_vecsize = row_major ? physical_type->columns : physical_type->vecsize;
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
const char *base_type = type.width == 16 ? "half" : "float";
Declare correct matrix type when unpacking.
2019-07-22 11:25:45 +00:00
string unpack_expr = join(base_type, columns, "x", vecsize, "(");
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
const char *load_swiz = "";
Pass down row-major state to unpacking functions.
2019-07-19 11:03:08 +00:00
if (physical_vecsize != vecsize)
load_swiz = swizzle_lut[vecsize - 1];
for (uint32_t i = 0; i < columns; i++)
MSL: Handle packed matrices. The old method of using a different unpacked matrix type doesn't work for scalar alignment. It certainly wouldn't have any effect for a square matrix, since the number of columns and rows are the same. So now we'll store them as arrays of packed vectors.
2019-07-10 23:37:31 +00:00
{
if (i > 0)
unpack_expr += ", ";
Pass down row-major state to unpacking functions.
2019-07-19 11:03:08 +00:00
if (packed)
unpack_expr += join(base_type, physical_vecsize, "(", expr_str, "[", i, "]", ")", load_swiz);
else
unpack_expr += join(expr_str, "[", i, "]", load_swiz);
MSL: Handle packed matrices. The old method of using a different unpacked matrix type doesn't work for scalar alignment. It certainly wouldn't have any effect for a square matrix, since the number of columns and rows are the same. So now we'll store them as arrays of packed vectors.
2019-07-10 23:37:31 +00:00
}
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
MSL: Handle packed matrices. The old method of using a different unpacked matrix type doesn't work for scalar alignment. It certainly wouldn't have any effect for a square matrix, since the number of columns and rows are the same. So now we'll store them as arrays of packed vectors.
2019-07-10 23:37:31 +00:00
unpack_expr += ")";
return unpack_expr;
}
MSL: Start considering float[] and float2[] in std140 layout.
2019-01-16 15:16:39 +00:00
else
Disabled spvUnsafeArray<> type for packed vectors and added test cases for those arrays.
2019-10-09 21:59:47 +00:00
{
MSL: Remove dubious workaround code in unpack_expression. From UE4 review, does not cause any changes in test output, and should only change output if we were unpacking arrays or something like that, which we don't support.
2019-11-07 10:33:00 +00:00
return join(type_to_glsl(type), "(", expr_str, ")");
Disabled spvUnsafeArray<> type for packed vectors and added test cases for those arrays.
2019-10-09 21:59:47 +00:00
}
spirv_msl unpack packed MSL uniform struct members. spirv_glsl add member_is_packed_type() and unpack_expression_type() functions.
2017-03-01 18:07:40 +00:00
}
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
// Emits the file header info
void CompilerMSL::emit_header()
{
Deal with case where we need to emit SpvImplArrayCopy late. We cannot deduce if OpLoad needs ArrayCopy templates early since it's heavily context dependent, and we might only know on 3rd iteration of the compile loop.
2019-04-09 10:28:46 +00:00
// This particular line can be overridden during compilation, so make it a flag and not a pragma line.
if (suppress_missing_prototypes)
statement("#pragma clang diagnostic ignored \"-Wmissing-prototypes\"");
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
// Disable warning about missing braces for array<T> template to make arrays a value type
if (spv_function_implementations.count(SPVFuncImplUnsafeArray) != 0)
statement("#pragma clang diagnostic ignored \"-Wmissing-braces\"");
CompilerMSL emit no-warning pragma when emitting spvConvertFromRowMajorCxR functions.
2018-01-06 05:51:25 +00:00
for (auto &pragma : pragma_lines)
statement(pragma);
Remove emission of function prototypes in MSL. Do not emit function prototypes. If secondary functions are used, suppress compiler -Wmissing-prototypes warnings. Refactor Compiler::emit_function_prototype() functions to simplify. Rename Compiler_msl::CustomFunctionHandler to OpCodePreprocessor, and Compiler_msl::register_custom_functions() to preprocess_op_codes() to perform more generic preprocessing. Add space between dynamic header lines and fixed header lines.
2017-01-20 16:24:44 +00:00
Deal with case where we need to emit SpvImplArrayCopy late. We cannot deduce if OpLoad needs ArrayCopy templates early since it's heavily context dependent, and we might only know on 3rd iteration of the compile loop.
2019-04-09 10:28:46 +00:00
if (!pragma_lines.empty() || suppress_missing_prototypes)
Run style formatter.
2017-01-20 16:33:59 +00:00
statement("");
Emit header_lines for MSL also
2016-09-17 03:21:37 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
statement("#include <metal_stdlib>");
statement("#include <simd/simd.h>");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
for (auto &header : header_lines)
statement(header);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
statement("");
statement("using namespace metal;");
statement("");
CompilerMSL support smaller offsets for 3-row row-major matrices. Support MSL typedefs to declare 3-row row-major matrices as 3-column matrices. Allow those matrices to be decorated as packed. Support transposing those matrices when used. Modify how member alignments are calculated.
2018-02-11 21:52:57 +00:00
for (auto &td : typedef_lines)
statement(td);
if (!typedef_lines.empty())
statement("");
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
void CompilerMSL::add_pragma_line(const string &line)
{
CompilerMSL support smaller offsets for 3-row row-major matrices. Support MSL typedefs to declare 3-row row-major matrices as 3-column matrices. Allow those matrices to be decorated as packed. Support transposing those matrices when used. Modify how member alignments are calculated.
2018-02-11 21:52:57 +00:00
auto rslt = pragma_lines.insert(line);
if (rslt.second)
Detect invalid DoWhileLoop early. We had a bug where error conditions in DoWhileLoop emit path would not detect that statements were being emitted due to the masking behavior which happens when force_recompile is true. Fix this. Also, refactor force_recompile into member functions so we can properly break on any situation where this is set, without having to rely on watchpoints in debuggers.
2019-04-05 10:06:10 +00:00
force_recompile();
CompilerMSL support smaller offsets for 3-row row-major matrices. Support MSL typedefs to declare 3-row row-major matrices as 3-column matrices. Allow those matrices to be decorated as packed. Support transposing those matrices when used. Modify how member alignments are calculated.
2018-02-11 21:52:57 +00:00
}
void CompilerMSL::add_typedef_line(const string &line)
{
auto rslt = typedef_lines.insert(line);
if (rslt.second)
Detect invalid DoWhileLoop early. We had a bug where error conditions in DoWhileLoop emit path would not detect that statements were being emitted due to the masking behavior which happens when force_recompile is true. Fix this. Also, refactor force_recompile into member functions so we can properly break on any situation where this is set, without having to rely on watchpoints in debuggers.
2019-04-05 10:06:10 +00:00
force_recompile();
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
}
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Template struct like spvUnsafeArray<> need to be declared *before* any resources are declared
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
void CompilerMSL::emit_custom_templates()
{
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
for (const auto &spv_func : spv_function_implementations)
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
{
switch (spv_func)
{
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
case SPVFuncImplUnsafeArray:
statement("template<typename T, size_t Num>");
statement("struct spvUnsafeArray");
begin_scope();
statement("T elements[Num ? Num : 1];");
statement("");
statement("thread T& operator [] (size_t pos) thread");
begin_scope();
statement("return elements[pos];");
end_scope();
statement("constexpr const thread T& operator [] (size_t pos) const thread");
begin_scope();
statement("return elements[pos];");
end_scope();
statement("");
statement("device T& operator [] (size_t pos) device");
begin_scope();
statement("return elements[pos];");
end_scope();
statement("constexpr const device T& operator [] (size_t pos) const device");
begin_scope();
statement("return elements[pos];");
end_scope();
statement("");
statement("constexpr const constant T& operator [] (size_t pos) const constant");
begin_scope();
statement("return elements[pos];");
end_scope();
statement("");
statement("threadgroup T& operator [] (size_t pos) threadgroup");
begin_scope();
statement("return elements[pos];");
end_scope();
statement("constexpr const threadgroup T& operator [] (size_t pos) const threadgroup");
begin_scope();
statement("return elements[pos];");
end_scope();
end_scope_decl();
statement("");
break;
default:
break;
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
}
}
}
CompilerMSL support emitting custom functions for SPIR-V ops. CompilerMSL use custom mod() function instead of Metal's fmod() function.
2016-12-19 02:42:10 +00:00
// Emits any needed custom function bodies.
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Metal helper functions must be static force-inline, i.e. static inline __attribute__((always_inline))
// otherwise they will cause problems when linked together in a single Metallib.
CompilerMSL support emitting custom functions for SPIR-V ops. CompilerMSL use custom mod() function instead of Metal's fmod() function.
2016-12-19 02:42:10 +00:00
void CompilerMSL::emit_custom_functions()
{
Fix -Wduplicate-enum and -Wrange-for-analysis.
2020-09-04 08:04:25 +00:00
for (uint32_t i = kArrayCopyMultidimMax; i >= 2; i--)
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
if (spv_function_implementations.count(static_cast<SPVFuncImpl>(SPVFuncImplArrayCopyMultidimBase + i)))
spv_function_implementations.insert(static_cast<SPVFuncImpl>(SPVFuncImplArrayCopyMultidimBase + i - 1));
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
if (spv_function_implementations.count(SPVFuncImplDynamicImageSampler))
{
// Unfortunately, this one needs a lot of the other functions to compile OK.
if (!msl_options.supports_msl_version(2))
SPIRV_CROSS_THROW(
"spvDynamicImageSampler requires default-constructible texture objects, which require MSL 2.0.");
spv_function_implementations.insert(SPVFuncImplForwardArgs);
spv_function_implementations.insert(SPVFuncImplTextureSwizzle);
if (msl_options.swizzle_texture_samples)
spv_function_implementations.insert(SPVFuncImplGatherSwizzle);
for (uint32_t i = SPVFuncImplChromaReconstructNearest2Plane;
i <= SPVFuncImplChromaReconstructLinear420XMidpointYMidpoint3Plane; i++)
spv_function_implementations.insert(static_cast<SPVFuncImpl>(i));
spv_function_implementations.insert(SPVFuncImplExpandITUFullRange);
spv_function_implementations.insert(SPVFuncImplExpandITUNarrowRange);
spv_function_implementations.insert(SPVFuncImplConvertYCbCrBT709);
spv_function_implementations.insert(SPVFuncImplConvertYCbCrBT601);
spv_function_implementations.insert(SPVFuncImplConvertYCbCrBT2020);
}
for (uint32_t i = SPVFuncImplChromaReconstructNearest2Plane;
i <= SPVFuncImplChromaReconstructLinear420XMidpointYMidpoint3Plane; i++)
if (spv_function_implementations.count(static_cast<SPVFuncImpl>(i)))
spv_function_implementations.insert(SPVFuncImplForwardArgs);
if (spv_function_implementations.count(SPVFuncImplTextureSwizzle) ||
spv_function_implementations.count(SPVFuncImplGatherSwizzle) ||
spv_function_implementations.count(SPVFuncImplGatherCompareSwizzle))
{
spv_function_implementations.insert(SPVFuncImplForwardArgs);
spv_function_implementations.insert(SPVFuncImplGetSwizzle);
}
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
for (const auto &spv_func : spv_function_implementations)
CompilerMSL support emitting custom functions for SPIR-V ops. CompilerMSL use custom mod() function instead of Metal's fmod() function.
2016-12-19 02:42:10 +00:00
{
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
switch (spv_func)
CompilerMSL support emitting custom functions for SPIR-V ops. CompilerMSL use custom mod() function instead of Metal's fmod() function.
2016-12-19 02:42:10 +00:00
{
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case SPVFuncImplMod:
statement("// Implementation of the GLSL mod() function, which is slightly different than Metal fmod()");
CompilerMSL support emitting custom functions for SPIR-V ops. CompilerMSL use custom mod() function instead of Metal's fmod() function.
2016-12-19 02:42:10 +00:00
statement("template<typename Tx, typename Ty>");
MSL: inline all emitted functions # Conflicts: # spirv_msl.cpp
2019-06-09 23:55:39 +00:00
statement("inline Tx mod(Tx x, Ty y)");
CompilerMSL support emitting custom functions for SPIR-V ops. CompilerMSL use custom mod() function instead of Metal's fmod() function.
2016-12-19 02:42:10 +00:00
begin_scope();
statement("return x - y * floor(x / y);");
end_scope();
statement("");
break;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case SPVFuncImplRadians:
statement("// Implementation of the GLSL radians() function");
statement("template<typename T>");
MSL: inline all emitted functions # Conflicts: # spirv_msl.cpp
2019-06-09 23:55:39 +00:00
statement("inline T radians(T d)");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
begin_scope();
Add FP16 test for MSL as well.
2018-03-07 09:24:21 +00:00
statement("return d * T(0.01745329251);");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
end_scope();
statement("");
break;
case SPVFuncImplDegrees:
statement("// Implementation of the GLSL degrees() function");
statement("template<typename T>");
MSL: inline all emitted functions # Conflicts: # spirv_msl.cpp
2019-06-09 23:55:39 +00:00
statement("inline T degrees(T r)");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
begin_scope();
Add FP16 test for MSL as well.
2018-03-07 09:24:21 +00:00
statement("return r * T(57.2957795131);");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
end_scope();
statement("");
break;
case SPVFuncImplFindILsb:
statement("// Implementation of the GLSL findLSB() function");
statement("template<typename T>");
MSL: inline all emitted functions # Conflicts: # spirv_msl.cpp
2019-06-09 23:55:39 +00:00
statement("inline T spvFindLSB(T x)");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
begin_scope();
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
statement("return select(ctz(x), T(-1), x == T(0));");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
end_scope();
statement("");
break;
case SPVFuncImplFindUMsb:
statement("// Implementation of the unsigned GLSL findMSB() function");
statement("template<typename T>");
MSL: inline all emitted functions # Conflicts: # spirv_msl.cpp
2019-06-09 23:55:39 +00:00
statement("inline T spvFindUMSB(T x)");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
begin_scope();
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
statement("return select(clz(T(0)) - (clz(x) + T(1)), T(-1), x == T(0));");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
end_scope();
statement("");
break;
case SPVFuncImplFindSMsb:
statement("// Implementation of the signed GLSL findMSB() function");
statement("template<typename T>");
MSL: inline all emitted functions # Conflicts: # spirv_msl.cpp
2019-06-09 23:55:39 +00:00
statement("inline T spvFindSMSB(T x)");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
begin_scope();
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
statement("T v = select(x, T(-1) - x, x < T(0));");
statement("return select(clz(T(0)) - (clz(v) + T(1)), T(-1), v == T(0));");
end_scope();
statement("");
break;
MSL: Emit wrapper for SSign (sign() for int types) Metal does not define the sign() function for integer types, only floating-point types.
2018-11-07 12:24:21 +00:00
case SPVFuncImplSSign:
statement("// Implementation of the GLSL sign() function for integer types");
statement("template<typename T, typename E = typename enable_if<is_integral<T>::value>::type>");
MSL: inline all emitted functions # Conflicts: # spirv_msl.cpp
2019-06-09 23:55:39 +00:00
statement("inline T sign(T x)");
MSL: Emit wrapper for SSign (sign() for int types) Metal does not define the sign() function for integer types, only floating-point types.
2018-11-07 12:24:21 +00:00
begin_scope();
statement("return select(select(select(x, T(0), x == T(0)), T(1), x > T(0)), T(-1), x < T(0));");
end_scope();
statement("");
break;
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
case SPVFuncImplArrayCopy:
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
case SPVFuncImplArrayOfArrayCopy2Dim:
case SPVFuncImplArrayOfArrayCopy3Dim:
case SPVFuncImplArrayOfArrayCopy4Dim:
case SPVFuncImplArrayOfArrayCopy5Dim:
case SPVFuncImplArrayOfArrayCopy6Dim:
{
MSL: Deal with array copies from and to threadgroup.
2019-08-27 11:16:16 +00:00
// Unfortunately we cannot template on the address space, so combinatorial explosion it is.
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
static const char *function_name_tags[] = {
Run format_all.sh.
2020-07-01 09:42:58 +00:00
"FromConstantToStack", "FromConstantToThreadGroup", "FromStackToStack",
"FromStackToThreadGroup", "FromThreadGroupToStack", "FromThreadGroupToThreadGroup",
"FromDeviceToDevice", "FromConstantToDevice", "FromStackToDevice",
"FromThreadGroupToDevice", "FromDeviceToStack", "FromDeviceToThreadGroup",
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
};
static const char *src_address_space[] = {
Run format_all.sh.
2020-07-01 09:42:58 +00:00
"constant", "constant", "thread const", "thread const",
"threadgroup const", "threadgroup const", "device const", "constant",
"thread const", "threadgroup const", "device const", "device const",
MSL: Deal with array copies from and to threadgroup.
2019-08-27 11:16:16 +00:00
};
static const char *dst_address_space[] = {
Run format_all.sh.
2019-08-28 12:25:26 +00:00
"thread", "threadgroup", "thread", "threadgroup", "thread", "threadgroup",
Run format_all.sh.
2020-07-01 09:42:58 +00:00
"device", "device", "device", "device", "thread", "threadgroup",
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
};
MSL: Improve handling of array types in buffer objects. When loading and storing array types which belong to buffer objects, we need to treat these values as not being value types. Also, need to handle array load/store from/to more address space combinations.
2020-06-18 09:37:24 +00:00
for (uint32_t variant = 0; variant < 12; variant++)
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
{
uint32_t dimensions = spv_func - SPVFuncImplArrayCopyMultidimBase;
string tmp = "template<typename T";
Fix integer precision warnings on assignments.
2018-09-20 20:10:42 +00:00
for (uint8_t i = 0; i < dimensions; i++)
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
{
tmp += ", uint ";
tmp += 'A' + i;
}
tmp += ">";
statement(tmp);
string array_arg;
Fix integer precision warnings on assignments.
2018-09-20 20:10:42 +00:00
for (uint8_t i = 0; i < dimensions; i++)
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
{
array_arg += "[";
array_arg += 'A' + i;
array_arg += "]";
}
Clang-format changes
2019-08-30 08:25:40 +00:00
statement("inline void spvArrayCopy", function_name_tags[variant], dimensions, "(",
dst_address_space[variant], " T (&dst)", array_arg, ", ", src_address_space[variant],
" T (&src)", array_arg, ")");
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
begin_scope();
statement("for (uint i = 0; i < A; i++)");
begin_scope();
MSL: Deal with array copies from and to threadgroup.
2019-08-27 11:16:16 +00:00
if (dimensions == 1)
statement("dst[i] = src[i];");
else
statement("spvArrayCopy", function_name_tags[variant], dimensions - 1, "(dst[i], src[i]);");
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
end_scope();
end_scope();
statement("");
}
break;
}
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Support for Metal 2.1's new texture_buffer type.
CompilerMSL support larger texel buffers by using 2D Metal textures. Add CompilerMSL::Options::texture_width_max. Emit and use spvTexelBufferCoord() function to convert 1D texel buffer coordinates to 2D Metal texture coordinates.
2018-06-26 21:30:21 +00:00
case SPVFuncImplTexelBufferCoords:
{
Support Metal 2.1's texture_buffer type which is the equivalent to HLSL's Buffer/RWBuffer, so doesn't require modifying buffer sizes to match alignments.
2019-08-14 14:43:04 +00:00
if (msl_options.texel_buffer_texture_width > 0)
{
Adjustments after rebase of ue4_dev branch.
2019-09-13 18:03:02 +00:00
string tex_width_str = convert_to_string(msl_options.texel_buffer_texture_width);
statement("// Returns 2D texture coords corresponding to 1D texel buffer coords");
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
statement(force_inline);
Adjustments after rebase of ue4_dev branch.
2019-09-13 18:03:02 +00:00
statement("uint2 spvTexelBufferCoord(uint tc)");
begin_scope();
statement(join("return uint2(tc % ", tex_width_str, ", tc / ", tex_width_str, ");"));
end_scope();
statement("");
Support Metal 2.1's texture_buffer type which is the equivalent to HLSL's Buffer/RWBuffer, so doesn't require modifying buffer sizes to match alignments.
2019-08-14 14:43:04 +00:00
}
else
{
statement("// Returns 2D texture coords corresponding to 1D texel buffer coords");
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
statement(
"#define spvTexelBufferCoord(tc, tex) uint2((tc) % (tex).get_width(), (tc) / (tex).get_width())");
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
statement("");
Support Metal 2.1's texture_buffer type which is the equivalent to HLSL's Buffer/RWBuffer, so doesn't require modifying buffer sizes to match alignments.
2019-08-14 14:43:04 +00:00
}
CompilerMSL support larger texel buffers by using 2D Metal textures. Add CompilerMSL::Options::texture_width_max. Emit and use spvTexelBufferCoord() function to convert 1D texel buffer coordinates to 2D Metal texture coordinates.
2018-06-26 21:30:21 +00:00
break;
}
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Emulate texture2D atomic operations
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
case SPVFuncImplImage2DAtomicCoords:
{
MSL: Fix calculation of atomic image buffer address. Fix reversed coordinates: `y` should be used to calculate the row address. Align row address to the row stride. I've made the row alignment a function constant; this makes it possible to override it at pipeline compile time. Honestly, I don't know how this worked at all for Epic. It definitely didn't work in the CTS prior to this.
2020-10-13 18:20:49 +00:00
if (msl_options.supports_msl_version(1, 2))
{
statement("// The required alignment of a linear texture of R32Uint format.");
statement("constant uint spvLinearTextureAlignmentOverride [[function_constant(",
msl_options.r32ui_alignment_constant_id, ")]];");
statement("constant uint spvLinearTextureAlignment = ",
"is_function_constant_defined(spvLinearTextureAlignmentOverride) ? ",
"spvLinearTextureAlignmentOverride : ", msl_options.r32ui_linear_texture_alignment, ";");
}
else
{
statement("// The required alignment of a linear texture of R32Uint format.");
statement("constant uint spvLinearTextureAlignment = ", msl_options.r32ui_linear_texture_alignment,
";");
}
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
statement("// Returns buffer coords corresponding to 2D texture coords for emulating 2D texture atomics");
MSL: Fix calculation of atomic image buffer address. Fix reversed coordinates: `y` should be used to calculate the row address. Align row address to the row stride. I've made the row alignment a function constant; this makes it possible to override it at pipeline compile time. Honestly, I don't know how this worked at all for Epic. It definitely didn't work in the CTS prior to this.
2020-10-13 18:20:49 +00:00
statement("#define spvImage2DAtomicCoord(tc, tex) (((((tex).get_width() + ",
" spvLinearTextureAlignment / 4 - 1) & ~(",
" spvLinearTextureAlignment / 4 - 1)) * (tc).y) + (tc).x)");
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
statement("");
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
break;
}
Adjustments after rebase of ue4_dev branch.
2019-09-13 18:03:02 +00:00
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// "fadd" intrinsic support
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
case SPVFuncImplFAdd:
statement("template<typename T>");
statement("T spvFAdd(T l, T r)");
CompilerMSL support larger texel buffers by using 2D Metal textures. Add CompilerMSL::Options::texture_width_max. Emit and use spvTexelBufferCoord() function to convert 1D texel buffer coordinates to 2D Metal texture coordinates.
2018-06-26 21:30:21 +00:00
begin_scope();
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
statement("return fma(T(1), l, r);");
end_scope();
statement("");
break;
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// "fmul' intrinsic support
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
case SPVFuncImplFMul:
statement("template<typename T>");
statement("T spvFMul(T l, T r)");
begin_scope();
statement("return fma(l, r, T(0));");
end_scope();
statement("");
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Added '--msl-invariant-float-math' option and new test case for it.
2019-10-09 15:22:25 +00:00
statement("template<typename T, int Cols, int Rows>");
statement("vec<T, Cols> spvFMulVectorMatrix(vec<T, Rows> v, matrix<T, Cols, Rows> m)");
begin_scope();
statement("vec<T, Cols> res = vec<T, Cols>(0);");
statement("for (uint i = Rows; i > 0; --i)");
begin_scope();
statement("vec<T, Cols> tmp(0);");
statement("for (uint j = 0; j < Cols; ++j)");
begin_scope();
statement("tmp[j] = m[j][i - 1];");
end_scope();
statement("res = fma(tmp, vec<T, Cols>(v[i - 1]), res);");
end_scope();
statement("return res;");
end_scope();
statement("");
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
statement("template<typename T, int Cols, int Rows>");
Removed reference specifiers in 'spvFMul*' functions to avoid address specifiers.
2019-09-17 19:49:10 +00:00
statement("vec<T, Rows> spvFMulMatrixVector(matrix<T, Cols, Rows> m, vec<T, Cols> v)");
begin_scope();
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
statement("vec<T, Rows> res = vec<T, Rows>(0);");
statement("for (uint i = Cols; i > 0; --i)");
Removed reference specifiers in 'spvFMul*' functions to avoid address specifiers.
2019-09-17 19:49:10 +00:00
begin_scope();
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
statement("res = fma(m[i - 1], vec<T, Rows>(v[i - 1]), res);");
Removed reference specifiers in 'spvFMul*' functions to avoid address specifiers.
2019-09-17 19:49:10 +00:00
end_scope();
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
statement("return res;");
Removed reference specifiers in 'spvFMul*' functions to avoid address specifiers.
2019-09-17 19:49:10 +00:00
end_scope();
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
statement("");
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
statement("template<typename T, int LCols, int LRows, int RCols, int RRows>");
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
statement(
"matrix<T, RCols, LRows> spvFMulMatrixMatrix(matrix<T, LCols, LRows> l, matrix<T, RCols, RRows> r)");
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
begin_scope();
statement("matrix<T, RCols, LRows> res;");
statement("for (uint i = 0; i < RCols; i++)");
begin_scope();
statement("vec<T, RCols> tmp(0);");
statement("for (uint j = 0; j < LCols; j++)");
begin_scope();
statement("tmp = fma(vec<T, RCols>(r[i][j]), l[j], tmp);");
end_scope();
statement("res[i] = tmp;");
end_scope();
statement("return res;");
end_scope();
statement("");
break;
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Emulate texturecube_array with texture2d_array for iOS where this type is not available
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
case SPVFuncImplCubemapTo2DArrayFace:
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
statement(force_inline);
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
statement("float3 spvCubemapTo2DArrayFace(float3 P)");
begin_scope();
statement("float3 Coords = abs(P.xyz);");
statement("float CubeFace = 0;");
statement("float ProjectionAxis = 0;");
statement("float u = 0;");
statement("float v = 0;");
statement("if (Coords.x >= Coords.y && Coords.x >= Coords.z)");
begin_scope();
statement("CubeFace = P.x >= 0 ? 0 : 1;");
statement("ProjectionAxis = Coords.x;");
statement("u = P.x >= 0 ? -P.z : P.z;");
statement("v = -P.y;");
end_scope();
statement("else if (Coords.y >= Coords.x && Coords.y >= Coords.z)");
begin_scope();
statement("CubeFace = P.y >= 0 ? 2 : 3;");
statement("ProjectionAxis = Coords.y;");
statement("u = P.x;");
statement("v = P.y >= 0 ? P.z : -P.z;");
end_scope();
statement("else");
begin_scope();
statement("CubeFace = P.z >= 0 ? 4 : 5;");
statement("ProjectionAxis = Coords.z;");
statement("u = P.z >= 0 ? P.x : -P.x;");
statement("v = -P.y;");
end_scope();
statement("u = 0.5 * (u/ProjectionAxis + 1);");
statement("v = 0.5 * (v/ProjectionAxis + 1);");
statement("return float3(u, v, CubeFace);");
CompilerMSL support larger texel buffers by using 2D Metal textures. Add CompilerMSL::Options::texture_width_max. Emit and use spvTexelBufferCoord() function to convert 1D texel buffer coordinates to 2D Metal texture coordinates.
2018-06-26 21:30:21 +00:00
end_scope();
statement("");
break;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case SPVFuncImplInverse4x4:
statement("// Returns the determinant of a 2x2 matrix.");
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
statement(force_inline);
In order to use Metal shader libraries properly you have to ensure that you have no duplicated global symbol names for different entities, otherwise 'metallib' won't be able to combine multiple shaders into a single library. This is broken into two parts. 1. Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries. 2. Metal helper functions must be static force-inline otherwise they will cause problems when linked together in a single Metallib.
2019-08-13 22:20:02 +00:00
statement("float spvDet2x2(float a1, float a2, float b1, float b2)");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
begin_scope();
statement("return a1 * b2 - b1 * a2;");
end_scope();
statement("");
Fix multiple declaration of spvDet2x2 on MSL.
2018-02-23 15:48:16 +00:00
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
statement("// Returns the determinant of a 3x3 matrix.");
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
statement(force_inline);
In order to use Metal shader libraries properly you have to ensure that you have no duplicated global symbol names for different entities, otherwise 'metallib' won't be able to combine multiple shaders into a single library. This is broken into two parts. 1. Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries. 2. Metal helper functions must be static force-inline otherwise they will cause problems when linked together in a single Metallib.
2019-08-13 22:20:02 +00:00
statement("float spvDet3x3(float a1, float a2, float a3, float b1, float b2, float b3, float c1, "
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
"float c2, float c3)");
begin_scope();
statement("return a1 * spvDet2x2(b2, b3, c2, c3) - b1 * spvDet2x2(a2, a3, c2, c3) + c1 * spvDet2x2(a2, a3, "
"b2, b3);");
end_scope();
statement("");
statement("// Returns the inverse of a matrix, by using the algorithm of calculating the classical");
statement("// adjoint and dividing by the determinant. The contents of the matrix are changed.");
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
statement(force_inline);
In order to use Metal shader libraries properly you have to ensure that you have no duplicated global symbol names for different entities, otherwise 'metallib' won't be able to combine multiple shaders into a single library. This is broken into two parts. 1. Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries. 2. Metal helper functions must be static force-inline otherwise they will cause problems when linked together in a single Metallib.
2019-08-13 22:20:02 +00:00
statement("float4x4 spvInverse4x4(float4x4 m)");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
begin_scope();
statement("float4x4 adj; // The adjoint matrix (inverse after dividing by determinant)");
Fix multiple declaration of spvDet2x2 on MSL.
2018-02-23 15:48:16 +00:00
statement_no_indent("");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
statement("// Create the transpose of the cofactors, as the classical adjoint of the matrix.");
statement("adj[0][0] = spvDet3x3(m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], "
"m[3][3]);");
statement("adj[0][1] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[2][1], m[2][2], m[2][3], m[3][1], m[3][2], "
"m[3][3]);");
statement("adj[0][2] = spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[3][1], m[3][2], "
"m[3][3]);");
statement("adj[0][3] = -spvDet3x3(m[0][1], m[0][2], m[0][3], m[1][1], m[1][2], m[1][3], m[2][1], m[2][2], "
"m[2][3]);");
Fix multiple declaration of spvDet2x2 on MSL.
2018-02-23 15:48:16 +00:00
statement_no_indent("");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
statement("adj[1][0] = -spvDet3x3(m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], "
"m[3][3]);");
statement("adj[1][1] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[2][0], m[2][2], m[2][3], m[3][0], m[3][2], "
"m[3][3]);");
statement("adj[1][2] = -spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[3][0], m[3][2], "
"m[3][3]);");
statement("adj[1][3] = spvDet3x3(m[0][0], m[0][2], m[0][3], m[1][0], m[1][2], m[1][3], m[2][0], m[2][2], "
"m[2][3]);");
Fix multiple declaration of spvDet2x2 on MSL.
2018-02-23 15:48:16 +00:00
statement_no_indent("");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
statement("adj[2][0] = spvDet3x3(m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], "
"m[3][3]);");
statement("adj[2][1] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[2][0], m[2][1], m[2][3], m[3][0], m[3][1], "
"m[3][3]);");
statement("adj[2][2] = spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[3][0], m[3][1], "
"m[3][3]);");
statement("adj[2][3] = -spvDet3x3(m[0][0], m[0][1], m[0][3], m[1][0], m[1][1], m[1][3], m[2][0], m[2][1], "
"m[2][3]);");
Fix multiple declaration of spvDet2x2 on MSL.
2018-02-23 15:48:16 +00:00
statement_no_indent("");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
statement("adj[3][0] = -spvDet3x3(m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], "
"m[3][2]);");
statement("adj[3][1] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[2][0], m[2][1], m[2][2], m[3][0], m[3][1], "
"m[3][2]);");
statement("adj[3][2] = -spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[3][0], m[3][1], "
"m[3][2]);");
statement("adj[3][3] = spvDet3x3(m[0][0], m[0][1], m[0][2], m[1][0], m[1][1], m[1][2], m[2][0], m[2][1], "
"m[2][2]);");
Fix multiple declaration of spvDet2x2 on MSL.
2018-02-23 15:48:16 +00:00
statement_no_indent("");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
statement("// Calculate the determinant as a combination of the cofactors of the first row.");
statement("float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]) + (adj[0][3] "
"* m[3][0]);");
Fix multiple declaration of spvDet2x2 on MSL.
2018-02-23 15:48:16 +00:00
statement_no_indent("");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
statement("// Divide the classical adjoint matrix by the determinant.");
statement("// If determinant is zero, matrix is not invertable, so leave it unchanged.");
statement("return (det != 0.0f) ? (adj * (1.0f / det)) : m;");
end_scope();
statement("");
break;
case SPVFuncImplInverse3x3:
Fix multiple declaration of spvDet2x2 on MSL.
2018-02-23 15:48:16 +00:00
if (spv_function_implementations.count(SPVFuncImplInverse4x4) == 0)
{
statement("// Returns the determinant of a 2x2 matrix.");
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
statement(force_inline);
In order to use Metal shader libraries properly you have to ensure that you have no duplicated global symbol names for different entities, otherwise 'metallib' won't be able to combine multiple shaders into a single library. This is broken into two parts. 1. Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries. 2. Metal helper functions must be static force-inline otherwise they will cause problems when linked together in a single Metallib.
2019-08-13 22:20:02 +00:00
statement("float spvDet2x2(float a1, float a2, float b1, float b2)");
Fix multiple declaration of spvDet2x2 on MSL.
2018-02-23 15:48:16 +00:00
begin_scope();
statement("return a1 * b2 - b1 * a2;");
end_scope();
statement("");
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
statement("// Returns the inverse of a matrix, by using the algorithm of calculating the classical");
statement("// adjoint and dividing by the determinant. The contents of the matrix are changed.");
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
statement(force_inline);
In order to use Metal shader libraries properly you have to ensure that you have no duplicated global symbol names for different entities, otherwise 'metallib' won't be able to combine multiple shaders into a single library. This is broken into two parts. 1. Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries. 2. Metal helper functions must be static force-inline otherwise they will cause problems when linked together in a single Metallib.
2019-08-13 22:20:02 +00:00
statement("float3x3 spvInverse3x3(float3x3 m)");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
begin_scope();
statement("float3x3 adj; // The adjoint matrix (inverse after dividing by determinant)");
Fix multiple declaration of spvDet2x2 on MSL.
2018-02-23 15:48:16 +00:00
statement_no_indent("");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
statement("// Create the transpose of the cofactors, as the classical adjoint of the matrix.");
statement("adj[0][0] = spvDet2x2(m[1][1], m[1][2], m[2][1], m[2][2]);");
statement("adj[0][1] = -spvDet2x2(m[0][1], m[0][2], m[2][1], m[2][2]);");
statement("adj[0][2] = spvDet2x2(m[0][1], m[0][2], m[1][1], m[1][2]);");
Fix multiple declaration of spvDet2x2 on MSL.
2018-02-23 15:48:16 +00:00
statement_no_indent("");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
statement("adj[1][0] = -spvDet2x2(m[1][0], m[1][2], m[2][0], m[2][2]);");
statement("adj[1][1] = spvDet2x2(m[0][0], m[0][2], m[2][0], m[2][2]);");
statement("adj[1][2] = -spvDet2x2(m[0][0], m[0][2], m[1][0], m[1][2]);");
Fix multiple declaration of spvDet2x2 on MSL.
2018-02-23 15:48:16 +00:00
statement_no_indent("");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
statement("adj[2][0] = spvDet2x2(m[1][0], m[1][1], m[2][0], m[2][1]);");
statement("adj[2][1] = -spvDet2x2(m[0][0], m[0][1], m[2][0], m[2][1]);");
statement("adj[2][2] = spvDet2x2(m[0][0], m[0][1], m[1][0], m[1][1]);");
Fix multiple declaration of spvDet2x2 on MSL.
2018-02-23 15:48:16 +00:00
statement_no_indent("");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
statement("// Calculate the determinant as a combination of the cofactors of the first row.");
statement("float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]) + (adj[0][2] * m[2][0]);");
Fix multiple declaration of spvDet2x2 on MSL.
2018-02-23 15:48:16 +00:00
statement_no_indent("");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
statement("// Divide the classical adjoint matrix by the determinant.");
statement("// If determinant is zero, matrix is not invertable, so leave it unchanged.");
statement("return (det != 0.0f) ? (adj * (1.0f / det)) : m;");
end_scope();
statement("");
break;
case SPVFuncImplInverse2x2:
statement("// Returns the inverse of a matrix, by using the algorithm of calculating the classical");
statement("// adjoint and dividing by the determinant. The contents of the matrix are changed.");
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
statement(force_inline);
In order to use Metal shader libraries properly you have to ensure that you have no duplicated global symbol names for different entities, otherwise 'metallib' won't be able to combine multiple shaders into a single library. This is broken into two parts. 1. Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries. 2. Metal helper functions must be static force-inline otherwise they will cause problems when linked together in a single Metallib.
2019-08-13 22:20:02 +00:00
statement("float2x2 spvInverse2x2(float2x2 m)");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
begin_scope();
statement("float2x2 adj; // The adjoint matrix (inverse after dividing by determinant)");
Fix multiple declaration of spvDet2x2 on MSL.
2018-02-23 15:48:16 +00:00
statement_no_indent("");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
statement("// Create the transpose of the cofactors, as the classical adjoint of the matrix.");
statement("adj[0][0] = m[1][1];");
statement("adj[0][1] = -m[0][1];");
Fix multiple declaration of spvDet2x2 on MSL.
2018-02-23 15:48:16 +00:00
statement_no_indent("");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
statement("adj[1][0] = -m[1][0];");
statement("adj[1][1] = m[0][0];");
Fix multiple declaration of spvDet2x2 on MSL.
2018-02-23 15:48:16 +00:00
statement_no_indent("");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
statement("// Calculate the determinant as a combination of the cofactors of the first row.");
statement("float det = (adj[0][0] * m[0][0]) + (adj[0][1] * m[1][0]);");
Fix multiple declaration of spvDet2x2 on MSL.
2018-02-23 15:48:16 +00:00
statement_no_indent("");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
statement("// Divide the classical adjoint matrix by the determinant.");
statement("// If determinant is zero, matrix is not invertable, so leave it unchanged.");
statement("return (det != 0.0f) ? (adj * (1.0f / det)) : m;");
end_scope();
statement("");
break;
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
case SPVFuncImplForwardArgs:
MSL: Add an option to insert texture swizzles into generated shaders. It's intended to be used with MoltenVK to support arbitrary `VkComponentMapping` settings. The idea is that MoltenVK will pass a buffer (which it set to some buffer index that isn't being used) containing packed versions of the `VkComponentMapping` struct, one for each sampled image. Yes, this is horribly ugly. It is unfortunately necessary. Much of the ugliness is to support swizzling gather operations, where we need to alter the component that the gather operates on--something complicated by the `gather()` method requiring the passed-in component to be a constant expression. It doesn't even support swizzling gathers on depth textures, though I could add that if it turns out we need it.
2018-09-20 01:36:33 +00:00
statement("template<typename T> struct spvRemoveReference { typedef T type; };");
statement("template<typename T> struct spvRemoveReference<thread T&> { typedef T type; };");
statement("template<typename T> struct spvRemoveReference<thread T&&> { typedef T type; };");
statement("template<typename T> inline constexpr thread T&& spvForward(thread typename "
"spvRemoveReference<T>::type& x)");
begin_scope();
statement("return static_cast<thread T&&>(x);");
end_scope();
statement("template<typename T> inline constexpr thread T&& spvForward(thread typename "
"spvRemoveReference<T>::type&& x)");
begin_scope();
statement("return static_cast<thread T&&>(x);");
end_scope();
statement("");
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
break;
case SPVFuncImplGetSwizzle:
statement("enum class spvSwizzle : uint");
begin_scope();
statement("none = 0,");
statement("zero,");
statement("one,");
statement("red,");
statement("green,");
statement("blue,");
statement("alpha");
end_scope_decl();
statement("");
MSL: Add an option to insert texture swizzles into generated shaders. It's intended to be used with MoltenVK to support arbitrary `VkComponentMapping` settings. The idea is that MoltenVK will pass a buffer (which it set to some buffer index that isn't being used) containing packed versions of the `VkComponentMapping` struct, one for each sampled image. Yes, this is horribly ugly. It is unfortunately necessary. Much of the ugliness is to support swizzling gather operations, where we need to alter the component that the gather operates on--something complicated by the `gather()` method requiring the passed-in component to be a constant expression. It doesn't even support swizzling gathers on depth textures, though I could add that if it turns out we need it.
2018-09-20 01:36:33 +00:00
statement("template<typename T>");
MSL: Fix mapping of identity-swizzled components. Before, if any component was not identity-mapped, those components that were still identity-mapped were set to 0. Now we properly leave them alone.
2019-01-07 17:17:12 +00:00
statement("inline T spvGetSwizzle(vec<T, 4> x, T c, spvSwizzle s)");
MSL: Add an option to insert texture swizzles into generated shaders. It's intended to be used with MoltenVK to support arbitrary `VkComponentMapping` settings. The idea is that MoltenVK will pass a buffer (which it set to some buffer index that isn't being used) containing packed versions of the `VkComponentMapping` struct, one for each sampled image. Yes, this is horribly ugly. It is unfortunately necessary. Much of the ugliness is to support swizzling gather operations, where we need to alter the component that the gather operates on--something complicated by the `gather()` method requiring the passed-in component to be a constant expression. It doesn't even support swizzling gathers on depth textures, though I could add that if it turns out we need it.
2018-09-20 01:36:33 +00:00
begin_scope();
statement("switch (s)");
begin_scope();
MSL: Fix mapping of identity-swizzled components. Before, if any component was not identity-mapped, those components that were still identity-mapped were set to 0. Now we properly leave them alone.
2019-01-07 17:17:12 +00:00
statement("case spvSwizzle::none:");
statement(" return c;");
MSL: Add an option to insert texture swizzles into generated shaders. It's intended to be used with MoltenVK to support arbitrary `VkComponentMapping` settings. The idea is that MoltenVK will pass a buffer (which it set to some buffer index that isn't being used) containing packed versions of the `VkComponentMapping` struct, one for each sampled image. Yes, this is horribly ugly. It is unfortunately necessary. Much of the ugliness is to support swizzling gather operations, where we need to alter the component that the gather operates on--something complicated by the `gather()` method requiring the passed-in component to be a constant expression. It doesn't even support swizzling gathers on depth textures, though I could add that if it turns out we need it.
2018-09-20 01:36:33 +00:00
statement("case spvSwizzle::zero:");
statement(" return 0;");
statement("case spvSwizzle::one:");
statement(" return 1;");
statement("case spvSwizzle::red:");
statement(" return x.r;");
statement("case spvSwizzle::green:");
statement(" return x.g;");
statement("case spvSwizzle::blue:");
statement(" return x.b;");
statement("case spvSwizzle::alpha:");
statement(" return x.a;");
end_scope();
end_scope();
statement("");
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
break;
case SPVFuncImplTextureSwizzle:
MSL: Add an option to insert texture swizzles into generated shaders. It's intended to be used with MoltenVK to support arbitrary `VkComponentMapping` settings. The idea is that MoltenVK will pass a buffer (which it set to some buffer index that isn't being used) containing packed versions of the `VkComponentMapping` struct, one for each sampled image. Yes, this is horribly ugly. It is unfortunately necessary. Much of the ugliness is to support swizzling gather operations, where we need to alter the component that the gather operates on--something complicated by the `gather()` method requiring the passed-in component to be a constant expression. It doesn't even support swizzling gathers on depth textures, though I could add that if it turns out we need it.
2018-09-20 01:36:33 +00:00
statement("// Wrapper function that swizzles texture samples and fetches.");
statement("template<typename T>");
statement("inline vec<T, 4> spvTextureSwizzle(vec<T, 4> x, uint s)");
begin_scope();
statement("if (!s)");
statement(" return x;");
MSL: Fix mapping of identity-swizzled components. Before, if any component was not identity-mapped, those components that were still identity-mapped were set to 0. Now we properly leave them alone.
2019-01-07 17:17:12 +00:00
statement("return vec<T, 4>(spvGetSwizzle(x, x.r, spvSwizzle((s >> 0) & 0xFF)), "
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
"spvGetSwizzle(x, x.g, spvSwizzle((s >> 8) & 0xFF)), spvGetSwizzle(x, x.b, spvSwizzle((s >> 16) "
"& 0xFF)), "
MSL: Fix mapping of identity-swizzled components. Before, if any component was not identity-mapped, those components that were still identity-mapped were set to 0. Now we properly leave them alone.
2019-01-07 17:17:12 +00:00
"spvGetSwizzle(x, x.a, spvSwizzle((s >> 24) & 0xFF)));");
MSL: Add an option to insert texture swizzles into generated shaders. It's intended to be used with MoltenVK to support arbitrary `VkComponentMapping` settings. The idea is that MoltenVK will pass a buffer (which it set to some buffer index that isn't being used) containing packed versions of the `VkComponentMapping` struct, one for each sampled image. Yes, this is horribly ugly. It is unfortunately necessary. Much of the ugliness is to support swizzling gather operations, where we need to alter the component that the gather operates on--something complicated by the `gather()` method requiring the passed-in component to be a constant expression. It doesn't even support swizzling gathers on depth textures, though I could add that if it turns out we need it.
2018-09-20 01:36:33 +00:00
end_scope();
statement("");
statement("template<typename T>");
statement("inline T spvTextureSwizzle(T x, uint s)");
begin_scope();
statement("return spvTextureSwizzle(vec<T, 4>(x, 0, 0, 1), s).x;");
end_scope();
statement("");
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
break;
case SPVFuncImplGatherSwizzle:
MSL: Add an option to insert texture swizzles into generated shaders. It's intended to be used with MoltenVK to support arbitrary `VkComponentMapping` settings. The idea is that MoltenVK will pass a buffer (which it set to some buffer index that isn't being used) containing packed versions of the `VkComponentMapping` struct, one for each sampled image. Yes, this is horribly ugly. It is unfortunately necessary. Much of the ugliness is to support swizzling gather operations, where we need to alter the component that the gather operates on--something complicated by the `gather()` method requiring the passed-in component to be a constant expression. It doesn't even support swizzling gathers on depth textures, though I could add that if it turns out we need it.
2018-09-20 01:36:33 +00:00
statement("// Wrapper function that swizzles texture gathers.");
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
statement("template<typename T, template<typename, access = access::sample, typename = void> class Tex, "
"typename... Ts>");
statement("inline vec<T, 4> spvGatherSwizzle(const thread Tex<T>& t, sampler s, "
"uint sw, component c, Ts... params) METAL_CONST_ARG(c)");
MSL: Add an option to insert texture swizzles into generated shaders. It's intended to be used with MoltenVK to support arbitrary `VkComponentMapping` settings. The idea is that MoltenVK will pass a buffer (which it set to some buffer index that isn't being used) containing packed versions of the `VkComponentMapping` struct, one for each sampled image. Yes, this is horribly ugly. It is unfortunately necessary. Much of the ugliness is to support swizzling gather operations, where we need to alter the component that the gather operates on--something complicated by the `gather()` method requiring the passed-in component to be a constant expression. It doesn't even support swizzling gathers on depth textures, though I could add that if it turns out we need it.
2018-09-20 01:36:33 +00:00
begin_scope();
statement("if (sw)");
begin_scope();
Pack texture component swizzles by bytes.
2018-09-22 03:50:29 +00:00
statement("switch (spvSwizzle((sw >> (uint(c) * 8)) & 0xFF))");
MSL: Add an option to insert texture swizzles into generated shaders. It's intended to be used with MoltenVK to support arbitrary `VkComponentMapping` settings. The idea is that MoltenVK will pass a buffer (which it set to some buffer index that isn't being used) containing packed versions of the `VkComponentMapping` struct, one for each sampled image. Yes, this is horribly ugly. It is unfortunately necessary. Much of the ugliness is to support swizzling gather operations, where we need to alter the component that the gather operates on--something complicated by the `gather()` method requiring the passed-in component to be a constant expression. It doesn't even support swizzling gathers on depth textures, though I could add that if it turns out we need it.
2018-09-20 01:36:33 +00:00
begin_scope();
statement("case spvSwizzle::none:");
statement(" break;");
statement("case spvSwizzle::zero:");
statement(" return vec<T, 4>(0, 0, 0, 0);");
statement("case spvSwizzle::one:");
statement(" return vec<T, 4>(1, 1, 1, 1);");
statement("case spvSwizzle::red:");
statement(" return t.gather(s, spvForward<Ts>(params)..., component::x);");
statement("case spvSwizzle::green:");
statement(" return t.gather(s, spvForward<Ts>(params)..., component::y);");
statement("case spvSwizzle::blue:");
statement(" return t.gather(s, spvForward<Ts>(params)..., component::z);");
statement("case spvSwizzle::alpha:");
statement(" return t.gather(s, spvForward<Ts>(params)..., component::w);");
end_scope();
end_scope();
// texture::gather insists on its component parameter being a constant
// expression, so we need this silly workaround just to compile the shader.
statement("switch (c)");
begin_scope();
statement("case component::x:");
statement(" return t.gather(s, spvForward<Ts>(params)..., component::x);");
statement("case component::y:");
statement(" return t.gather(s, spvForward<Ts>(params)..., component::y);");
statement("case component::z:");
statement(" return t.gather(s, spvForward<Ts>(params)..., component::z);");
statement("case component::w:");
statement(" return t.gather(s, spvForward<Ts>(params)..., component::w);");
end_scope();
end_scope();
statement("");
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
break;
case SPVFuncImplGatherCompareSwizzle:
MSL: Swizzle gathers on depth textures as well. Might as well.
2018-09-29 14:52:26 +00:00
statement("// Wrapper function that swizzles depth texture gathers.");
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
statement("template<typename T, template<typename, access = access::sample, typename = void> class Tex, "
"typename... Ts>");
statement("inline vec<T, 4> spvGatherCompareSwizzle(const thread Tex<T>& t, sampler "
"s, uint sw, Ts... params) ");
MSL: Swizzle gathers on depth textures as well. Might as well.
2018-09-29 14:52:26 +00:00
begin_scope();
statement("if (sw)");
begin_scope();
statement("switch (spvSwizzle(sw & 0xFF))");
begin_scope();
statement("case spvSwizzle::none:");
statement("case spvSwizzle::red:");
statement(" break;");
statement("case spvSwizzle::zero:");
statement("case spvSwizzle::green:");
statement("case spvSwizzle::blue:");
statement("case spvSwizzle::alpha:");
statement(" return vec<T, 4>(0, 0, 0, 0);");
statement("case spvSwizzle::one:");
statement(" return vec<T, 4>(1, 1, 1, 1);");
end_scope();
end_scope();
statement("return t.gather_compare(s, spvForward<Ts>(params)...);");
end_scope();
statement("");
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
break;
case SPVFuncImplSubgroupBallot:
statement("inline uint4 spvSubgroupBallot(bool value)");
begin_scope();
statement("simd_vote vote = simd_ballot(value);");
statement("// simd_ballot() returns a 64-bit integer-like object, but");
statement("// SPIR-V callers expect a uint4. We must convert.");
statement("// FIXME: This won't include higher bits if Apple ever supports");
statement("// 128 lanes in an SIMD-group.");
statement("return uint4((uint)((simd_vote::vote_t)vote & 0xFFFFFFFF), (uint)(((simd_vote::vote_t)vote >> "
"32) & 0xFFFFFFFF), 0, 0);");
end_scope();
statement("");
break;
case SPVFuncImplSubgroupBallotBitExtract:
statement("inline bool spvSubgroupBallotBitExtract(uint4 ballot, uint bit)");
begin_scope();
statement("return !!extract_bits(ballot[bit / 32], bit % 32, 1);");
end_scope();
statement("");
break;
case SPVFuncImplSubgroupBallotFindLSB:
statement("inline uint spvSubgroupBallotFindLSB(uint4 ballot)");
begin_scope();
statement("return select(ctz(ballot.x), select(32 + ctz(ballot.y), select(64 + ctz(ballot.z), select(96 + "
"ctz(ballot.w), uint(-1), ballot.w == 0), ballot.z == 0), ballot.y == 0), ballot.x == 0);");
end_scope();
statement("");
break;
case SPVFuncImplSubgroupBallotFindMSB:
statement("inline uint spvSubgroupBallotFindMSB(uint4 ballot)");
begin_scope();
statement("return select(128 - (clz(ballot.w) + 1), select(96 - (clz(ballot.z) + 1), select(64 - "
"(clz(ballot.y) + 1), select(32 - (clz(ballot.x) + 1), uint(-1), ballot.x == 0), ballot.y == 0), "
"ballot.z == 0), ballot.w == 0);");
end_scope();
statement("");
break;
case SPVFuncImplSubgroupBallotBitCount:
statement("inline uint spvSubgroupBallotBitCount(uint4 ballot)");
begin_scope();
statement("return popcount(ballot.x) + popcount(ballot.y) + popcount(ballot.z) + popcount(ballot.w);");
end_scope();
statement("");
statement("inline uint spvSubgroupBallotInclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID)");
begin_scope();
statement("uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID + 1, 32u)), "
"extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID + 1 - 32, 0)), "
"uint2(0));");
statement("return spvSubgroupBallotBitCount(ballot & mask);");
end_scope();
statement("");
statement("inline uint spvSubgroupBallotExclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID)");
begin_scope();
statement("uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID, 32u)), "
"extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID - 32, 0)), uint2(0));");
statement("return spvSubgroupBallotBitCount(ballot & mask);");
end_scope();
statement("");
break;
case SPVFuncImplSubgroupAllEqual:
// Metal doesn't provide a function to evaluate this directly. But, we can
// implement this by comparing every thread's value to one thread's value
// (in this case, the value of the first active thread). Then, by the transitive
// property of equality, if all comparisons return true, then they are all equal.
statement("template<typename T>");
statement("inline bool spvSubgroupAllEqual(T value)");
begin_scope();
statement("return simd_all(value == simd_broadcast_first(value));");
end_scope();
statement("");
statement("template<>");
statement("inline bool spvSubgroupAllEqual(bool value)");
begin_scope();
statement("return simd_all(value) || !simd_any(value);");
end_scope();
statement("");
break;
MSL: Add an option to insert texture swizzles into generated shaders. It's intended to be used with MoltenVK to support arbitrary `VkComponentMapping` settings. The idea is that MoltenVK will pass a buffer (which it set to some buffer index that isn't being used) containing packed versions of the `VkComponentMapping` struct, one for each sampled image. Yes, this is horribly ugly. It is unfortunately necessary. Much of the ugliness is to support swizzling gather operations, where we need to alter the component that the gather operates on--something complicated by the `gather()` method requiring the passed-in component to be a constant expression. It doesn't even support swizzling gathers on depth textures, though I could add that if it turns out we need it.
2018-09-20 01:36:33 +00:00
MSL/HLSL: Support scalar reflect and refract.
2019-07-03 10:24:58 +00:00
case SPVFuncImplReflectScalar:
// Metal does not support scalar versions of these functions.
statement("template<typename T>");
statement("inline T spvReflect(T i, T n)");
begin_scope();
Don't use scalar dot().
2019-07-03 12:32:06 +00:00
statement("return i - T(2) * i * n * n;");
MSL/HLSL: Support scalar reflect and refract.
2019-07-03 10:24:58 +00:00
end_scope();
statement("");
break;
case SPVFuncImplRefractScalar:
// Metal does not support scalar versions of these functions.
statement("template<typename T>");
statement("inline T spvRefract(T i, T n, T eta)");
begin_scope();
Don't use scalar dot().
2019-07-03 12:32:06 +00:00
statement("T NoI = n * i;");
statement("T NoI2 = NoI * NoI;");
statement("T k = T(1) - eta * eta * (T(1) - NoI2);");
MSL/HLSL: Support scalar reflect and refract.
2019-07-03 10:24:58 +00:00
statement("if (k < T(0))");
begin_scope();
statement("return T(0);");
end_scope();
statement("else");
begin_scope();
Don't use scalar dot().
2019-07-03 12:32:06 +00:00
statement("return eta * i - (eta * NoI + sqrt(k)) * n;");
MSL/HLSL: Support scalar reflect and refract.
2019-07-03 10:24:58 +00:00
end_scope();
end_scope();
statement("");
break;
Test glsl.std450 more exhaustively. Make sure to test everything with scalar as well to catch any weird edge cases. Not all opcodes are covered here, just the arithmetic ones. FP64 packing is also ignored.
2019-07-17 09:24:31 +00:00
case SPVFuncImplFaceForwardScalar:
// Metal does not support scalar versions of these functions.
statement("template<typename T>");
statement("inline T spvFaceForward(T n, T i, T nref)");
begin_scope();
statement("return i * nref < T(0) ? n : -n;");
end_scope();
statement("");
break;
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
case SPVFuncImplChromaReconstructNearest2Plane:
statement("template<typename T, typename... LodOptions>");
statement("inline vec<T, 4> spvChromaReconstructNearest(texture2d<T> plane0, texture2d<T> plane1, sampler "
"samp, float2 coord, LodOptions... options)");
begin_scope();
statement("vec<T, 4> ycbcr = vec<T, 4>(0, 0, 0, 1);");
statement("ycbcr.g = plane0.sample(samp, coord, spvForward<LodOptions>(options)...).r;");
statement("ycbcr.br = plane1.sample(samp, coord, spvForward<LodOptions>(options)...).rg;");
statement("return ycbcr;");
end_scope();
statement("");
break;
case SPVFuncImplChromaReconstructNearest3Plane:
statement("template<typename T, typename... LodOptions>");
statement("inline vec<T, 4> spvChromaReconstructNearest(texture2d<T> plane0, texture2d<T> plane1, "
"texture2d<T> plane2, sampler samp, float2 coord, LodOptions... options)");
begin_scope();
statement("vec<T, 4> ycbcr = vec<T, 4>(0, 0, 0, 1);");
statement("ycbcr.g = plane0.sample(samp, coord, spvForward<LodOptions>(options)...).r;");
statement("ycbcr.b = plane1.sample(samp, coord, spvForward<LodOptions>(options)...).r;");
statement("ycbcr.r = plane2.sample(samp, coord, spvForward<LodOptions>(options)...).r;");
statement("return ycbcr;");
end_scope();
statement("");
break;
case SPVFuncImplChromaReconstructLinear422CositedEven2Plane:
statement("template<typename T, typename... LodOptions>");
statement("inline vec<T, 4> spvChromaReconstructLinear422CositedEven(texture2d<T> plane0, texture2d<T> "
"plane1, sampler samp, float2 coord, LodOptions... options)");
begin_scope();
statement("vec<T, 4> ycbcr = vec<T, 4>(0, 0, 0, 1);");
statement("ycbcr.g = plane0.sample(samp, coord, spvForward<LodOptions>(options)...).r;");
statement("if (fract(coord.x * plane1.get_width()) != 0.0)");
begin_scope();
statement("ycbcr.br = vec<T, 2>(mix(plane1.sample(samp, coord, spvForward<LodOptions>(options)...), "
"plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 0)), 0.5).rg);");
end_scope();
statement("else");
begin_scope();
statement("ycbcr.br = plane1.sample(samp, coord, spvForward<LodOptions>(options)...).rg;");
end_scope();
statement("return ycbcr;");
end_scope();
statement("");
break;
case SPVFuncImplChromaReconstructLinear422CositedEven3Plane:
statement("template<typename T, typename... LodOptions>");
statement("inline vec<T, 4> spvChromaReconstructLinear422CositedEven(texture2d<T> plane0, texture2d<T> "
"plane1, texture2d<T> plane2, sampler samp, float2 coord, LodOptions... options)");
begin_scope();
statement("vec<T, 4> ycbcr = vec<T, 4>(0, 0, 0, 1);");
statement("ycbcr.g = plane0.sample(samp, coord, spvForward<LodOptions>(options)...).r;");
statement("if (fract(coord.x * plane1.get_width()) != 0.0)");
begin_scope();
statement("ycbcr.b = T(mix(plane1.sample(samp, coord, spvForward<LodOptions>(options)...), "
"plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 0)), 0.5).r);");
statement("ycbcr.r = T(mix(plane2.sample(samp, coord, spvForward<LodOptions>(options)...), "
"plane2.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 0)), 0.5).r);");
end_scope();
statement("else");
begin_scope();
statement("ycbcr.b = plane1.sample(samp, coord, spvForward<LodOptions>(options)...).r;");
statement("ycbcr.r = plane2.sample(samp, coord, spvForward<LodOptions>(options)...).r;");
end_scope();
statement("return ycbcr;");
end_scope();
statement("");
break;
case SPVFuncImplChromaReconstructLinear422Midpoint2Plane:
statement("template<typename T, typename... LodOptions>");
statement("inline vec<T, 4> spvChromaReconstructLinear422Midpoint(texture2d<T> plane0, texture2d<T> "
"plane1, sampler samp, float2 coord, LodOptions... options)");
begin_scope();
statement("vec<T, 4> ycbcr = vec<T, 4>(0, 0, 0, 1);");
statement("ycbcr.g = plane0.sample(samp, coord, spvForward<LodOptions>(options)...).r;");
statement("int2 offs = int2(fract(coord.x * plane1.get_width()) != 0.0 ? 1 : -1, 0);");
statement("ycbcr.br = vec<T, 2>(mix(plane1.sample(samp, coord, spvForward<LodOptions>(options)...), "
"plane1.sample(samp, coord, spvForward<LodOptions>(options)..., offs), 0.25).rg);");
statement("return ycbcr;");
end_scope();
statement("");
break;
case SPVFuncImplChromaReconstructLinear422Midpoint3Plane:
statement("template<typename T, typename... LodOptions>");
statement("inline vec<T, 4> spvChromaReconstructLinear422Midpoint(texture2d<T> plane0, texture2d<T> "
"plane1, texture2d<T> plane2, sampler samp, float2 coord, LodOptions... options)");
begin_scope();
statement("vec<T, 4> ycbcr = vec<T, 4>(0, 0, 0, 1);");
statement("ycbcr.g = plane0.sample(samp, coord, spvForward<LodOptions>(options)...).r;");
statement("int2 offs = int2(fract(coord.x * plane1.get_width()) != 0.0 ? 1 : -1, 0);");
statement("ycbcr.b = T(mix(plane1.sample(samp, coord, spvForward<LodOptions>(options)...), "
"plane1.sample(samp, coord, spvForward<LodOptions>(options)..., offs), 0.25).r);");
statement("ycbcr.r = T(mix(plane2.sample(samp, coord, spvForward<LodOptions>(options)...), "
"plane2.sample(samp, coord, spvForward<LodOptions>(options)..., offs), 0.25).r);");
statement("return ycbcr;");
end_scope();
statement("");
break;
case SPVFuncImplChromaReconstructLinear420XCositedEvenYCositedEven2Plane:
statement("template<typename T, typename... LodOptions>");
statement("inline vec<T, 4> spvChromaReconstructLinear420XCositedEvenYCositedEven(texture2d<T> plane0, "
"texture2d<T> plane1, sampler samp, float2 coord, LodOptions... options)");
begin_scope();
statement("vec<T, 4> ycbcr = vec<T, 4>(0, 0, 0, 1);");
statement("ycbcr.g = plane0.sample(samp, coord, spvForward<LodOptions>(options)...).r;");
statement("float2 ab = fract(round(coord * float2(plane0.get_width(), plane0.get_height())) * 0.5);");
statement("ycbcr.br = vec<T, 2>(mix(mix(plane1.sample(samp, coord, spvForward<LodOptions>(options)...), "
"plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 0)), ab.x), "
"mix(plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(0, 1)), "
"plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 1)), ab.x), ab.y).rg);");
statement("return ycbcr;");
end_scope();
statement("");
break;
case SPVFuncImplChromaReconstructLinear420XCositedEvenYCositedEven3Plane:
statement("template<typename T, typename... LodOptions>");
statement("inline vec<T, 4> spvChromaReconstructLinear420XCositedEvenYCositedEven(texture2d<T> plane0, "
"texture2d<T> plane1, texture2d<T> plane2, sampler samp, float2 coord, LodOptions... options)");
begin_scope();
statement("vec<T, 4> ycbcr = vec<T, 4>(0, 0, 0, 1);");
statement("ycbcr.g = plane0.sample(samp, coord, spvForward<LodOptions>(options)...).r;");
statement("float2 ab = fract(round(coord * float2(plane0.get_width(), plane0.get_height())) * 0.5);");
statement("ycbcr.b = T(mix(mix(plane1.sample(samp, coord, spvForward<LodOptions>(options)...), "
"plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 0)), ab.x), "
"mix(plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(0, 1)), "
"plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 1)), ab.x), ab.y).r);");
statement("ycbcr.r = T(mix(mix(plane2.sample(samp, coord, spvForward<LodOptions>(options)...), "
"plane2.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 0)), ab.x), "
"mix(plane2.sample(samp, coord, spvForward<LodOptions>(options)..., int2(0, 1)), "
"plane2.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 1)), ab.x), ab.y).r);");
statement("return ycbcr;");
end_scope();
statement("");
break;
case SPVFuncImplChromaReconstructLinear420XMidpointYCositedEven2Plane:
statement("template<typename T, typename... LodOptions>");
statement("inline vec<T, 4> spvChromaReconstructLinear420XMidpointYCositedEven(texture2d<T> plane0, "
"texture2d<T> plane1, sampler samp, float2 coord, LodOptions... options)");
begin_scope();
statement("vec<T, 4> ycbcr = vec<T, 4>(0, 0, 0, 1);");
statement("ycbcr.g = plane0.sample(samp, coord, spvForward<LodOptions>(options)...).r;");
statement("float2 ab = fract((round(coord * float2(plane0.get_width(), plane0.get_height())) - float2(0.5, "
"0)) * 0.5);");
statement("ycbcr.br = vec<T, 2>(mix(mix(plane1.sample(samp, coord, spvForward<LodOptions>(options)...), "
"plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 0)), ab.x), "
"mix(plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(0, 1)), "
"plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 1)), ab.x), ab.y).rg);");
statement("return ycbcr;");
end_scope();
statement("");
break;
case SPVFuncImplChromaReconstructLinear420XMidpointYCositedEven3Plane:
statement("template<typename T, typename... LodOptions>");
statement("inline vec<T, 4> spvChromaReconstructLinear420XMidpointYCositedEven(texture2d<T> plane0, "
"texture2d<T> plane1, texture2d<T> plane2, sampler samp, float2 coord, LodOptions... options)");
begin_scope();
statement("vec<T, 4> ycbcr = vec<T, 4>(0, 0, 0, 1);");
statement("ycbcr.g = plane0.sample(samp, coord, spvForward<LodOptions>(options)...).r;");
statement("float2 ab = fract((round(coord * float2(plane0.get_width(), plane0.get_height())) - float2(0.5, "
"0)) * 0.5);");
statement("ycbcr.b = T(mix(mix(plane1.sample(samp, coord, spvForward<LodOptions>(options)...), "
"plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 0)), ab.x), "
"mix(plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(0, 1)), "
"plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 1)), ab.x), ab.y).r);");
statement("ycbcr.r = T(mix(mix(plane2.sample(samp, coord, spvForward<LodOptions>(options)...), "
"plane2.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 0)), ab.x), "
"mix(plane2.sample(samp, coord, spvForward<LodOptions>(options)..., int2(0, 1)), "
"plane2.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 1)), ab.x), ab.y).r);");
statement("return ycbcr;");
end_scope();
statement("");
break;
case SPVFuncImplChromaReconstructLinear420XCositedEvenYMidpoint2Plane:
statement("template<typename T, typename... LodOptions>");
statement("inline vec<T, 4> spvChromaReconstructLinear420XCositedEvenYMidpoint(texture2d<T> plane0, "
"texture2d<T> plane1, sampler samp, float2 coord, LodOptions... options)");
begin_scope();
statement("vec<T, 4> ycbcr = vec<T, 4>(0, 0, 0, 1);");
statement("ycbcr.g = plane0.sample(samp, coord, spvForward<LodOptions>(options)...).r;");
statement("float2 ab = fract((round(coord * float2(plane0.get_width(), plane0.get_height())) - float2(0, "
"0.5)) * 0.5);");
statement("ycbcr.br = vec<T, 2>(mix(mix(plane1.sample(samp, coord, spvForward<LodOptions>(options)...), "
"plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 0)), ab.x), "
"mix(plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(0, 1)), "
"plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 1)), ab.x), ab.y).rg);");
statement("return ycbcr;");
end_scope();
statement("");
break;
case SPVFuncImplChromaReconstructLinear420XCositedEvenYMidpoint3Plane:
statement("template<typename T, typename... LodOptions>");
statement("inline vec<T, 4> spvChromaReconstructLinear420XCositedEvenYMidpoint(texture2d<T> plane0, "
"texture2d<T> plane1, texture2d<T> plane2, sampler samp, float2 coord, LodOptions... options)");
begin_scope();
statement("vec<T, 4> ycbcr = vec<T, 4>(0, 0, 0, 1);");
statement("ycbcr.g = plane0.sample(samp, coord, spvForward<LodOptions>(options)...).r;");
statement("float2 ab = fract((round(coord * float2(plane0.get_width(), plane0.get_height())) - float2(0, "
"0.5)) * 0.5);");
statement("ycbcr.b = T(mix(mix(plane1.sample(samp, coord, spvForward<LodOptions>(options)...), "
"plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 0)), ab.x), "
"mix(plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(0, 1)), "
"plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 1)), ab.x), ab.y).r);");
statement("ycbcr.r = T(mix(mix(plane2.sample(samp, coord, spvForward<LodOptions>(options)...), "
"plane2.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 0)), ab.x), "
"mix(plane2.sample(samp, coord, spvForward<LodOptions>(options)..., int2(0, 1)), "
"plane2.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 1)), ab.x), ab.y).r);");
statement("return ycbcr;");
end_scope();
statement("");
break;
case SPVFuncImplChromaReconstructLinear420XMidpointYMidpoint2Plane:
statement("template<typename T, typename... LodOptions>");
statement("inline vec<T, 4> spvChromaReconstructLinear420XMidpointYMidpoint(texture2d<T> plane0, "
"texture2d<T> plane1, sampler samp, float2 coord, LodOptions... options)");
begin_scope();
statement("vec<T, 4> ycbcr = vec<T, 4>(0, 0, 0, 1);");
statement("ycbcr.g = plane0.sample(samp, coord, spvForward<LodOptions>(options)...).r;");
statement("float2 ab = fract((round(coord * float2(plane0.get_width(), plane0.get_height())) - float2(0.5, "
"0.5)) * 0.5);");
statement("ycbcr.br = vec<T, 2>(mix(mix(plane1.sample(samp, coord, spvForward<LodOptions>(options)...), "
"plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 0)), ab.x), "
"mix(plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(0, 1)), "
"plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 1)), ab.x), ab.y).rg);");
statement("return ycbcr;");
end_scope();
statement("");
break;
case SPVFuncImplChromaReconstructLinear420XMidpointYMidpoint3Plane:
statement("template<typename T, typename... LodOptions>");
statement("inline vec<T, 4> spvChromaReconstructLinear420XMidpointYMidpoint(texture2d<T> plane0, "
"texture2d<T> plane1, texture2d<T> plane2, sampler samp, float2 coord, LodOptions... options)");
begin_scope();
statement("vec<T, 4> ycbcr = vec<T, 4>(0, 0, 0, 1);");
statement("ycbcr.g = plane0.sample(samp, coord, spvForward<LodOptions>(options)...).r;");
statement("float2 ab = fract((round(coord * float2(plane0.get_width(), plane0.get_height())) - float2(0.5, "
"0.5)) * 0.5);");
statement("ycbcr.b = T(mix(mix(plane1.sample(samp, coord, spvForward<LodOptions>(options)...), "
"plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 0)), ab.x), "
"mix(plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(0, 1)), "
"plane1.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 1)), ab.x), ab.y).r);");
statement("ycbcr.r = T(mix(mix(plane2.sample(samp, coord, spvForward<LodOptions>(options)...), "
"plane2.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 0)), ab.x), "
"mix(plane2.sample(samp, coord, spvForward<LodOptions>(options)..., int2(0, 1)), "
"plane2.sample(samp, coord, spvForward<LodOptions>(options)..., int2(1, 1)), ab.x), ab.y).r);");
statement("return ycbcr;");
end_scope();
statement("");
break;
case SPVFuncImplExpandITUFullRange:
statement("template<typename T>");
statement("inline vec<T, 4> spvExpandITUFullRange(vec<T, 4> ycbcr, int n)");
begin_scope();
statement("ycbcr.br -= exp2(T(n-1))/(exp2(T(n))-1);");
statement("return ycbcr;");
end_scope();
statement("");
break;
case SPVFuncImplExpandITUNarrowRange:
statement("template<typename T>");
statement("inline vec<T, 4> spvExpandITUNarrowRange(vec<T, 4> ycbcr, int n)");
begin_scope();
statement("ycbcr.g = (ycbcr.g * (exp2(T(n)) - 1) - ldexp(T(16), n - 8))/ldexp(T(219), n - 8);");
statement("ycbcr.br = (ycbcr.br * (exp2(T(n)) - 1) - ldexp(T(128), n - 8))/ldexp(T(224), n - 8);");
statement("return ycbcr;");
end_scope();
statement("");
break;
case SPVFuncImplConvertYCbCrBT709:
statement("// cf. Khronos Data Format Specification, section 15.1.1");
statement("constant float3x3 spvBT709Factors = {{1, 1, 1}, {0, -0.13397432/0.7152, 1.8556}, {1.5748, "
"-0.33480248/0.7152, 0}};");
statement("");
statement("template<typename T>");
statement("inline vec<T, 4> spvConvertYCbCrBT709(vec<T, 4> ycbcr)");
begin_scope();
statement("vec<T, 4> rgba;");
statement("rgba.rgb = vec<T, 3>(spvBT709Factors * ycbcr.gbr);");
statement("rgba.a = ycbcr.a;");
statement("return rgba;");
end_scope();
statement("");
break;
case SPVFuncImplConvertYCbCrBT601:
statement("// cf. Khronos Data Format Specification, section 15.1.2");
statement("constant float3x3 spvBT601Factors = {{1, 1, 1}, {0, -0.202008/0.587, 1.772}, {1.402, "
"-0.419198/0.587, 0}};");
statement("");
statement("template<typename T>");
statement("inline vec<T, 4> spvConvertYCbCrBT601(vec<T, 4> ycbcr)");
begin_scope();
statement("vec<T, 4> rgba;");
statement("rgba.rgb = vec<T, 3>(spvBT601Factors * ycbcr.gbr);");
statement("rgba.a = ycbcr.a;");
statement("return rgba;");
end_scope();
statement("");
break;
case SPVFuncImplConvertYCbCrBT2020:
statement("// cf. Khronos Data Format Specification, section 15.1.3");
statement("constant float3x3 spvBT2020Factors = {{1, 1, 1}, {0, -0.11156702/0.6780, 1.8814}, {1.4746, "
"-0.38737742/0.6780, 0}};");
statement("");
statement("template<typename T>");
statement("inline vec<T, 4> spvConvertYCbCrBT2020(vec<T, 4> ycbcr)");
begin_scope();
statement("vec<T, 4> rgba;");
statement("rgba.rgb = vec<T, 3>(spvBT2020Factors * ycbcr.gbr);");
statement("rgba.a = ycbcr.a;");
statement("return rgba;");
end_scope();
statement("");
break;
case SPVFuncImplDynamicImageSampler:
statement("enum class spvFormatResolution");
begin_scope();
statement("_444 = 0,");
statement("_422,");
statement("_420");
end_scope_decl();
statement("");
statement("enum class spvChromaFilter");
begin_scope();
statement("nearest = 0,");
statement("linear");
end_scope_decl();
statement("");
statement("enum class spvXChromaLocation");
begin_scope();
statement("cosited_even = 0,");
statement("midpoint");
end_scope_decl();
statement("");
statement("enum class spvYChromaLocation");
begin_scope();
statement("cosited_even = 0,");
statement("midpoint");
end_scope_decl();
statement("");
statement("enum class spvYCbCrModelConversion");
begin_scope();
statement("rgb_identity = 0,");
statement("ycbcr_identity,");
statement("ycbcr_bt_709,");
statement("ycbcr_bt_601,");
statement("ycbcr_bt_2020");
end_scope_decl();
statement("");
statement("enum class spvYCbCrRange");
begin_scope();
statement("itu_full = 0,");
statement("itu_narrow");
end_scope_decl();
statement("");
statement("struct spvComponentBits");
begin_scope();
statement("constexpr explicit spvComponentBits(int v) thread : value(v) {}");
statement("uchar value : 6;");
end_scope_decl();
statement("// A class corresponding to metal::sampler which holds sampler");
statement("// Y'CbCr conversion info.");
statement("struct spvYCbCrSampler");
begin_scope();
statement("constexpr spvYCbCrSampler() thread : val(build()) {}");
statement("template<typename... Ts>");
statement("constexpr spvYCbCrSampler(Ts... t) thread : val(build(t...)) {}");
statement("constexpr spvYCbCrSampler(const thread spvYCbCrSampler& s) thread = default;");
statement("");
statement("spvFormatResolution get_resolution() const thread");
begin_scope();
statement("return spvFormatResolution((val & resolution_mask) >> resolution_base);");
end_scope();
statement("spvChromaFilter get_chroma_filter() const thread");
begin_scope();
statement("return spvChromaFilter((val & chroma_filter_mask) >> chroma_filter_base);");
end_scope();
statement("spvXChromaLocation get_x_chroma_offset() const thread");
begin_scope();
statement("return spvXChromaLocation((val & x_chroma_off_mask) >> x_chroma_off_base);");
end_scope();
statement("spvYChromaLocation get_y_chroma_offset() const thread");
begin_scope();
statement("return spvYChromaLocation((val & y_chroma_off_mask) >> y_chroma_off_base);");
end_scope();
statement("spvYCbCrModelConversion get_ycbcr_model() const thread");
begin_scope();
statement("return spvYCbCrModelConversion((val & ycbcr_model_mask) >> ycbcr_model_base);");
end_scope();
statement("spvYCbCrRange get_ycbcr_range() const thread");
begin_scope();
statement("return spvYCbCrRange((val & ycbcr_range_mask) >> ycbcr_range_base);");
end_scope();
statement("int get_bpc() const thread { return (val & bpc_mask) >> bpc_base; }");
statement("");
statement("private:");
statement("ushort val;");
statement("");
statement("constexpr static constant ushort resolution_bits = 2;");
statement("constexpr static constant ushort chroma_filter_bits = 2;");
statement("constexpr static constant ushort x_chroma_off_bit = 1;");
statement("constexpr static constant ushort y_chroma_off_bit = 1;");
statement("constexpr static constant ushort ycbcr_model_bits = 3;");
statement("constexpr static constant ushort ycbcr_range_bit = 1;");
statement("constexpr static constant ushort bpc_bits = 6;");
statement("");
statement("constexpr static constant ushort resolution_base = 0;");
statement("constexpr static constant ushort chroma_filter_base = 2;");
statement("constexpr static constant ushort x_chroma_off_base = 4;");
statement("constexpr static constant ushort y_chroma_off_base = 5;");
statement("constexpr static constant ushort ycbcr_model_base = 6;");
statement("constexpr static constant ushort ycbcr_range_base = 9;");
statement("constexpr static constant ushort bpc_base = 10;");
statement("");
statement(
"constexpr static constant ushort resolution_mask = ((1 << resolution_bits) - 1) << resolution_base;");
statement("constexpr static constant ushort chroma_filter_mask = ((1 << chroma_filter_bits) - 1) << "
"chroma_filter_base;");
statement("constexpr static constant ushort x_chroma_off_mask = ((1 << x_chroma_off_bit) - 1) << "
"x_chroma_off_base;");
statement("constexpr static constant ushort y_chroma_off_mask = ((1 << y_chroma_off_bit) - 1) << "
"y_chroma_off_base;");
statement("constexpr static constant ushort ycbcr_model_mask = ((1 << ycbcr_model_bits) - 1) << "
"ycbcr_model_base;");
statement("constexpr static constant ushort ycbcr_range_mask = ((1 << ycbcr_range_bit) - 1) << "
"ycbcr_range_base;");
statement("constexpr static constant ushort bpc_mask = ((1 << bpc_bits) - 1) << bpc_base;");
statement("");
statement("static constexpr ushort build()");
begin_scope();
statement("return 0;");
end_scope();
statement("");
statement("template<typename... Ts>");
statement("static constexpr ushort build(spvFormatResolution res, Ts... t)");
begin_scope();
statement("return (ushort(res) << resolution_base) | (build(t...) & ~resolution_mask);");
end_scope();
statement("");
statement("template<typename... Ts>");
statement("static constexpr ushort build(spvChromaFilter filt, Ts... t)");
begin_scope();
statement("return (ushort(filt) << chroma_filter_base) | (build(t...) & ~chroma_filter_mask);");
end_scope();
statement("");
statement("template<typename... Ts>");
statement("static constexpr ushort build(spvXChromaLocation loc, Ts... t)");
begin_scope();
statement("return (ushort(loc) << x_chroma_off_base) | (build(t...) & ~x_chroma_off_mask);");
end_scope();
statement("");
statement("template<typename... Ts>");
statement("static constexpr ushort build(spvYChromaLocation loc, Ts... t)");
begin_scope();
statement("return (ushort(loc) << y_chroma_off_base) | (build(t...) & ~y_chroma_off_mask);");
end_scope();
statement("");
statement("template<typename... Ts>");
statement("static constexpr ushort build(spvYCbCrModelConversion model, Ts... t)");
begin_scope();
statement("return (ushort(model) << ycbcr_model_base) | (build(t...) & ~ycbcr_model_mask);");
end_scope();
statement("");
statement("template<typename... Ts>");
statement("static constexpr ushort build(spvYCbCrRange range, Ts... t)");
begin_scope();
statement("return (ushort(range) << ycbcr_range_base) | (build(t...) & ~ycbcr_range_mask);");
end_scope();
statement("");
statement("template<typename... Ts>");
statement("static constexpr ushort build(spvComponentBits bpc, Ts... t)");
begin_scope();
statement("return (ushort(bpc.value) << bpc_base) | (build(t...) & ~bpc_mask);");
end_scope();
end_scope_decl();
statement("");
statement("// A class which can hold up to three textures and a sampler, including");
statement("// Y'CbCr conversion info, used to pass combined image-samplers");
statement("// dynamically to functions.");
statement("template<typename T>");
statement("struct spvDynamicImageSampler");
begin_scope();
statement("texture2d<T> plane0;");
statement("texture2d<T> plane1;");
statement("texture2d<T> plane2;");
statement("sampler samp;");
statement("spvYCbCrSampler ycbcr_samp;");
statement("uint swizzle = 0;");
statement("");
if (msl_options.swizzle_texture_samples)
{
statement("constexpr spvDynamicImageSampler(texture2d<T> tex, sampler samp, uint sw) thread :");
statement(" plane0(tex), samp(samp), swizzle(sw) {}");
}
else
{
statement("constexpr spvDynamicImageSampler(texture2d<T> tex, sampler samp) thread :");
statement(" plane0(tex), samp(samp) {}");
}
statement("constexpr spvDynamicImageSampler(texture2d<T> tex, sampler samp, spvYCbCrSampler ycbcr_samp, "
"uint sw) thread :");
statement(" plane0(tex), samp(samp), ycbcr_samp(ycbcr_samp), swizzle(sw) {}");
statement("constexpr spvDynamicImageSampler(texture2d<T> plane0, texture2d<T> plane1,");
statement(" sampler samp, spvYCbCrSampler ycbcr_samp, uint sw) thread :");
statement(" plane0(plane0), plane1(plane1), samp(samp), ycbcr_samp(ycbcr_samp), swizzle(sw) {}");
statement(
"constexpr spvDynamicImageSampler(texture2d<T> plane0, texture2d<T> plane1, texture2d<T> plane2,");
statement(" sampler samp, spvYCbCrSampler ycbcr_samp, uint sw) thread :");
statement(" plane0(plane0), plane1(plane1), plane2(plane2), samp(samp), ycbcr_samp(ycbcr_samp), "
"swizzle(sw) {}");
statement("");
// XXX This is really hard to follow... I've left comments to make it a bit easier.
statement("template<typename... LodOptions>");
statement("vec<T, 4> do_sample(float2 coord, LodOptions... options) const thread");
begin_scope();
statement("if (!is_null_texture(plane1))");
begin_scope();
statement("if (ycbcr_samp.get_resolution() == spvFormatResolution::_444 ||");
statement(" ycbcr_samp.get_chroma_filter() == spvChromaFilter::nearest)");
begin_scope();
statement("if (!is_null_texture(plane2))");
statement(" return spvChromaReconstructNearest(plane0, plane1, plane2, samp, coord,");
statement(" spvForward<LodOptions>(options)...);");
statement(
"return spvChromaReconstructNearest(plane0, plane1, samp, coord, spvForward<LodOptions>(options)...);");
end_scope(); // if (resolution == 422 || chroma_filter == nearest)
statement("switch (ycbcr_samp.get_resolution())");
begin_scope();
statement("case spvFormatResolution::_444: break;");
statement("case spvFormatResolution::_422:");
begin_scope();
statement("switch (ycbcr_samp.get_x_chroma_offset())");
begin_scope();
statement("case spvXChromaLocation::cosited_even:");
statement(" if (!is_null_texture(plane2))");
statement(" return spvChromaReconstructLinear422CositedEven(");
statement(" plane0, plane1, plane2, samp,");
statement(" coord, spvForward<LodOptions>(options)...);");
statement(" return spvChromaReconstructLinear422CositedEven(");
statement(" plane0, plane1, samp, coord,");
statement(" spvForward<LodOptions>(options)...);");
statement("case spvXChromaLocation::midpoint:");
statement(" if (!is_null_texture(plane2))");
statement(" return spvChromaReconstructLinear422Midpoint(");
statement(" plane0, plane1, plane2, samp,");
statement(" coord, spvForward<LodOptions>(options)...);");
statement(" return spvChromaReconstructLinear422Midpoint(");
statement(" plane0, plane1, samp, coord,");
statement(" spvForward<LodOptions>(options)...);");
end_scope(); // switch (x_chroma_offset)
end_scope(); // case 422:
statement("case spvFormatResolution::_420:");
begin_scope();
statement("switch (ycbcr_samp.get_x_chroma_offset())");
begin_scope();
statement("case spvXChromaLocation::cosited_even:");
begin_scope();
statement("switch (ycbcr_samp.get_y_chroma_offset())");
begin_scope();
statement("case spvYChromaLocation::cosited_even:");
statement(" if (!is_null_texture(plane2))");
statement(" return spvChromaReconstructLinear420XCositedEvenYCositedEven(");
statement(" plane0, plane1, plane2, samp,");
statement(" coord, spvForward<LodOptions>(options)...);");
statement(" return spvChromaReconstructLinear420XCositedEvenYCositedEven(");
statement(" plane0, plane1, samp, coord,");
statement(" spvForward<LodOptions>(options)...);");
statement("case spvYChromaLocation::midpoint:");
statement(" if (!is_null_texture(plane2))");
statement(" return spvChromaReconstructLinear420XCositedEvenYMidpoint(");
statement(" plane0, plane1, plane2, samp,");
statement(" coord, spvForward<LodOptions>(options)...);");
statement(" return spvChromaReconstructLinear420XCositedEvenYMidpoint(");
statement(" plane0, plane1, samp, coord,");
statement(" spvForward<LodOptions>(options)...);");
end_scope(); // switch (y_chroma_offset)
end_scope(); // case x::cosited_even:
statement("case spvXChromaLocation::midpoint:");
begin_scope();
statement("switch (ycbcr_samp.get_y_chroma_offset())");
begin_scope();
statement("case spvYChromaLocation::cosited_even:");
statement(" if (!is_null_texture(plane2))");
statement(" return spvChromaReconstructLinear420XMidpointYCositedEven(");
statement(" plane0, plane1, plane2, samp,");
statement(" coord, spvForward<LodOptions>(options)...);");
statement(" return spvChromaReconstructLinear420XMidpointYCositedEven(");
statement(" plane0, plane1, samp, coord,");
statement(" spvForward<LodOptions>(options)...);");
statement("case spvYChromaLocation::midpoint:");
statement(" if (!is_null_texture(plane2))");
statement(" return spvChromaReconstructLinear420XMidpointYMidpoint(");
statement(" plane0, plane1, plane2, samp,");
statement(" coord, spvForward<LodOptions>(options)...);");
statement(" return spvChromaReconstructLinear420XMidpointYMidpoint(");
statement(" plane0, plane1, samp, coord,");
statement(" spvForward<LodOptions>(options)...);");
end_scope(); // switch (y_chroma_offset)
end_scope(); // case x::midpoint
end_scope(); // switch (x_chroma_offset)
end_scope(); // case 420:
end_scope(); // switch (resolution)
end_scope(); // if (multiplanar)
statement("return plane0.sample(samp, coord, spvForward<LodOptions>(options)...);");
end_scope(); // do_sample()
statement("template <typename... LodOptions>");
statement("vec<T, 4> sample(float2 coord, LodOptions... options) const thread");
begin_scope();
statement(
"vec<T, 4> s = spvTextureSwizzle(do_sample(coord, spvForward<LodOptions>(options)...), swizzle);");
statement("if (ycbcr_samp.get_ycbcr_model() == spvYCbCrModelConversion::rgb_identity)");
statement(" return s;");
statement("");
statement("switch (ycbcr_samp.get_ycbcr_range())");
begin_scope();
statement("case spvYCbCrRange::itu_full:");
statement(" s = spvExpandITUFullRange(s, ycbcr_samp.get_bpc());");
statement(" break;");
statement("case spvYCbCrRange::itu_narrow:");
statement(" s = spvExpandITUNarrowRange(s, ycbcr_samp.get_bpc());");
statement(" break;");
end_scope();
statement("");
statement("switch (ycbcr_samp.get_ycbcr_model())");
begin_scope();
statement("case spvYCbCrModelConversion::rgb_identity:"); // Silence Clang warning
statement("case spvYCbCrModelConversion::ycbcr_identity:");
statement(" return s;");
statement("case spvYCbCrModelConversion::ycbcr_bt_709:");
statement(" return spvConvertYCbCrBT709(s);");
statement("case spvYCbCrModelConversion::ycbcr_bt_601:");
statement(" return spvConvertYCbCrBT601(s);");
statement("case spvYCbCrModelConversion::ycbcr_bt_2020:");
statement(" return spvConvertYCbCrBT2020(s);");
end_scope();
end_scope();
statement("");
// Sampler Y'CbCr conversion forbids offsets.
statement("vec<T, 4> sample(float2 coord, int2 offset) const thread");
begin_scope();
if (msl_options.swizzle_texture_samples)
statement("return spvTextureSwizzle(plane0.sample(samp, coord, offset), swizzle);");
else
statement("return plane0.sample(samp, coord, offset);");
end_scope();
statement("template<typename lod_options>");
statement("vec<T, 4> sample(float2 coord, lod_options options, int2 offset) const thread");
begin_scope();
if (msl_options.swizzle_texture_samples)
statement("return spvTextureSwizzle(plane0.sample(samp, coord, options, offset), swizzle);");
else
statement("return plane0.sample(samp, coord, options, offset);");
end_scope();
statement("#if __HAVE_MIN_LOD_CLAMP__");
statement("vec<T, 4> sample(float2 coord, bias b, min_lod_clamp min_lod, int2 offset) const thread");
begin_scope();
statement("return plane0.sample(samp, coord, b, min_lod, offset);");
end_scope();
statement(
"vec<T, 4> sample(float2 coord, gradient2d grad, min_lod_clamp min_lod, int2 offset) const thread");
begin_scope();
statement("return plane0.sample(samp, coord, grad, min_lod, offset);");
end_scope();
statement("#endif");
statement("");
// Y'CbCr conversion forbids all operations but sampling.
statement("vec<T, 4> read(uint2 coord, uint lod = 0) const thread");
begin_scope();
statement("return plane0.read(coord, lod);");
end_scope();
statement("");
statement("vec<T, 4> gather(float2 coord, int2 offset = int2(0), component c = component::x) const thread");
begin_scope();
if (msl_options.swizzle_texture_samples)
statement("return spvGatherSwizzle(plane0, samp, swizzle, c, coord, offset);");
else
statement("return plane0.gather(samp, coord, offset, c);");
end_scope();
end_scope_decl();
statement("");
CompilerMSL support emitting custom functions for SPIR-V ops. CompilerMSL use custom mod() function instead of Metal's fmod() function.
2016-12-19 02:42:10 +00:00
default:
break;
}
}
}
CompilerMSL support and tests for OpUndef.
2017-11-16 03:44:42 +00:00
// Undefined global memory is not allowed in MSL.
For MSL, use {} instead of constructors to init OpUndef values.
2017-11-30 20:03:27 +00:00
// Declare constant and init to zeros. Use {}, as global constructors can break Metal.
CompilerMSL support and tests for OpUndef.
2017-11-16 03:44:42 +00:00
void CompilerMSL::declare_undefined_values()
{
bool emitted = false;
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
ir.for_each_typed_id<SPIRUndef>([&](uint32_t, SPIRUndef &undef) {
Workaround bugs on MSVC. Bug: https://developercommunity.visualstudio.com/content/problem/303996/c-error-c2668-ambiguous-overloaded-in-lambda-with.html
2019-01-11 08:29:28 +00:00
auto &type = this->get<SPIRType>(undef.basetype);
Handle OpUndef %void. Apparently this is legal and spirv-opt is starting to emit this kind of code now.
2020-09-04 07:29:44 +00:00
// OpUndef can be void for some reason ...
if (type.basetype == SPIRType::Void)
return;
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
statement("constant ", variable_decl(type, to_name(undef.self), undef.self), " = {};");
emitted = true;
});
CompilerMSL support and tests for OpUndef.
2017-11-16 03:44:42 +00:00
if (emitted)
statement("");
}
MSL cannot declare inline arrays except in certain cases.
2018-02-08 12:06:29 +00:00
void CompilerMSL::declare_constant_arrays()
{
MSL: Do not declare complex composite array in main for non-inlined. Need to consider that complex composite arrays may be used in leaf functions, and avoid the MSL library link fix unless everything is nicely inlined.
2019-10-24 09:12:01 +00:00
bool fully_inlined = ir.ids_for_type[TypeFunction].size() == 1;
MSL cannot declare inline arrays except in certain cases.
2018-02-08 12:06:29 +00:00
// MSL cannot declare arrays inline (except when declaring a variable), so we must move them out to
// global constants directly, so we are able to use constants as variable expressions.
bool emitted = false;
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
ir.for_each_typed_id<SPIRConstant>([&](uint32_t, SPIRConstant &c) {
if (c.specialization)
return;
MSL cannot declare inline arrays except in certain cases.
2018-02-08 12:06:29 +00:00
Workaround bugs on MSVC. Bug: https://developercommunity.visualstudio.com/content/problem/303996/c-error-c2668-ambiguous-overloaded-in-lambda-with.html
2019-01-11 08:29:28 +00:00
auto &type = this->get<SPIRType>(c.constant_type);
MSL: Do not declare complex composite array in main for non-inlined. Need to consider that complex composite arrays may be used in leaf functions, and avoid the MSL library link fix unless everything is nicely inlined.
2019-10-24 09:12:01 +00:00
// Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries.
// FIXME: However, hoisting constants to main() means we need to pass down constant arrays to leaf functions if they are used there.
// If there are multiple functions in the module, drop this case to avoid breaking use cases which do not need to
// link into Metal libraries. This is hacky.
if (!type.array.empty() && (!fully_inlined || is_scalar(type) || is_vector(type)))
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
{
auto name = to_name(c.self);
statement("constant ", variable_decl(type, name), " = ", constant_expression(c), ";");
emitted = true;
MSL cannot declare inline arrays except in certain cases.
2018-02-08 12:06:29 +00:00
}
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
});
MSL cannot declare inline arrays except in certain cases.
2018-02-08 12:06:29 +00:00
if (emitted)
statement("");
}
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries
In order to use Metal shader libraries properly you have to ensure that you have no duplicated global symbol names for different entities, otherwise 'metallib' won't be able to combine multiple shaders into a single library. This is broken into two parts. 1. Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries. 2. Metal helper functions must be static force-inline otherwise they will cause problems when linked together in a single Metallib.
2019-08-13 22:20:02 +00:00
void CompilerMSL::declare_complex_constant_arrays()
{
MSL: Do not declare complex composite array in main for non-inlined. Need to consider that complex composite arrays may be used in leaf functions, and avoid the MSL library link fix unless everything is nicely inlined.
2019-10-24 09:12:01 +00:00
// If we do not have a fully inlined module, we did not opt in to
// declaring constant arrays of complex types. See CompilerMSL::declare_constant_arrays().
bool fully_inlined = ir.ids_for_type[TypeFunction].size() == 1;
if (!fully_inlined)
return;
In order to use Metal shader libraries properly you have to ensure that you have no duplicated global symbol names for different entities, otherwise 'metallib' won't be able to combine multiple shaders into a single library. This is broken into two parts. 1. Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries. 2. Metal helper functions must be static force-inline otherwise they will cause problems when linked together in a single Metallib.
2019-08-13 22:20:02 +00:00
// MSL cannot declare arrays inline (except when declaring a variable), so we must move them out to
// global constants directly, so we are able to use constants as variable expressions.
bool emitted = false;
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
In order to use Metal shader libraries properly you have to ensure that you have no duplicated global symbol names for different entities, otherwise 'metallib' won't be able to combine multiple shaders into a single library. This is broken into two parts. 1. Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries. 2. Metal helper functions must be static force-inline otherwise they will cause problems when linked together in a single Metallib.
2019-08-13 22:20:02 +00:00
ir.for_each_typed_id<SPIRConstant>([&](uint32_t, SPIRConstant &c) {
if (c.specialization)
return;
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
In order to use Metal shader libraries properly you have to ensure that you have no duplicated global symbol names for different entities, otherwise 'metallib' won't be able to combine multiple shaders into a single library. This is broken into two parts. 1. Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries. 2. Metal helper functions must be static force-inline otherwise they will cause problems when linked together in a single Metallib.
2019-08-13 22:20:02 +00:00
auto &type = this->get<SPIRType>(c.constant_type);
if (!type.array.empty() && !(is_scalar(type) || is_vector(type)))
{
auto name = to_name(c.self);
Further updates for pull request #1162; also added two test cases for spvCubemapTo2DArrayFace function and added '--msl-framebuffer-fetch'/ '--msl-emulate-cube-array' compiler options.
2019-09-27 19:49:54 +00:00
statement("", variable_decl(type, name), " = ", constant_expression(c), ";");
In order to use Metal shader libraries properly you have to ensure that you have no duplicated global symbol names for different entities, otherwise 'metallib' won't be able to combine multiple shaders into a single library. This is broken into two parts. 1. Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries. 2. Metal helper functions must be static force-inline otherwise they will cause problems when linked together in a single Metallib.
2019-08-13 22:20:02 +00:00
emitted = true;
}
});
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
In order to use Metal shader libraries properly you have to ensure that you have no duplicated global symbol names for different entities, otherwise 'metallib' won't be able to combine multiple shaders into a single library. This is broken into two parts. 1. Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries. 2. Metal helper functions must be static force-inline otherwise they will cause problems when linked together in a single Metallib.
2019-08-13 22:20:02 +00:00
if (emitted)
statement("");
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
void CompilerMSL::emit_resources()
{
MSL cannot declare inline arrays except in certain cases.
2018-02-08 12:06:29 +00:00
declare_constant_arrays();
CompilerMSL support and tests for OpUndef.
2017-11-16 03:44:42 +00:00
declare_undefined_values();
MSL: Support global I/O block and struct Input/Output usage. Implement this by flattening outputs and unflattening inputs explicitly. This allows us to pass down a single struct instead of dealing with the insanity that would be passing down each flattened member separately. Remove stage_uniforms_var_id. Seems to be dead code. Naked uniforms do not exist in SPIR-V for Vulkan, which this seems to have been intended for. It was also unused elsewhere.
2018-09-13 12:42:05 +00:00
// Emit the special [[stage_in]] and [[stage_out]] interface blocks which we created.
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
emit_interface_block(stage_out_var_id);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
emit_interface_block(patch_stage_out_var_id);
CompilerMSL support matrices & arrays in stage-in & stage-out. Support flattening StorageOutput & StorageInput matrices and arrays. No longer move matrix & array inputs to separate buffer. Add separate SPIRFunction::fixup_statements_in & SPIRFunction::fixup_statements_out instead of just SPIRFunction::fixup_statements. Emit SPIRFunction::fixup_statements at beginning of functions. CompilerMSL track vars_needing_early_declaration. Pass global output variables as variables to functions that access them. Sort input structs by location, same as output structs. Emit struct declarations in order output, input, uniforms. Regenerate reference shaders to new formats defined by above.
2018-06-12 15:41:35 +00:00
emit_interface_block(stage_in_var_id);
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
emit_interface_block(patch_stage_in_var_id);
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
CompilerMSL add support for MSL specialization function constants. CompilerMSL add emit_custom_functions() function. CompilerMSL restrict use of as_type<> cast to necessary conditions. CompilerMSL refactor get_declared_struct_member_size() and get_declared_struct_member_alignment() functions, and remove unnecessary get_declared_type_size() functions. Add test shaders-msl/vulkan/frag/spec-constant.vk.frag.
2017-06-15 19:24:22 +00:00
// Emit declarations for the specialization Metal function constants
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
void CompilerMSL::emit_specialization_constants_and_structs()
CompilerMSL add support for MSL specialization function constants. CompilerMSL add emit_custom_functions() function. CompilerMSL restrict use of as_type<> cast to necessary conditions. CompilerMSL refactor get_declared_struct_member_size() and get_declared_struct_member_alignment() functions, and remove unnecessary get_declared_type_size() functions. Add test shaders-msl/vulkan/frag/spec-constant.vk.frag.
2017-06-15 19:24:22 +00:00
{
Declare work group size constants in HLSL and MSL. Technically not needed, but it does make compute code easier to read compared to magical constants being used for work group size.
2017-09-29 08:13:45 +00:00
SpecializationConstant wg_x, wg_y, wg_z;
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
ID workgroup_size_id = get_work_group_size_specialization_constants(wg_x, wg_y, wg_z);
Declare OpSpecConstantOp up-front on relevant targets. Required, since spec constants can include results from constant ops.
2018-05-15 12:20:16 +00:00
bool emitted = false;
CompilerMSL add support for MSL specialization function constants. CompilerMSL add emit_custom_functions() function. CompilerMSL restrict use of as_type<> cast to necessary conditions. CompilerMSL refactor get_declared_struct_member_size() and get_declared_struct_member_alignment() functions, and remove unnecessary get_declared_type_size() functions. Add test shaders-msl/vulkan/frag/spec-constant.vk.frag.
2017-06-15 19:24:22 +00:00
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
unordered_set<uint32_t> declared_structs;
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
unordered_set<uint32_t> aligned_structs;
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
Deal with scalar layout of entire structs. Mark all candidate struct types.
2019-07-19 12:18:14 +00:00
// First, we need to deal with scalar block layout.
// It is possible that a struct may have to be placed at an alignment which does not match the innate alignment of the struct itself.
// In that case, if such a case exists for a struct, we must force that all elements of the struct become packed_ types.
// This makes the struct alignment as small as physically possible.
// When we actually align the struct later, we can insert padding as necessary to make the packed members behave like normally aligned types.
ir.for_each_typed_id<SPIRType>([&](uint32_t type_id, const SPIRType &type) {
Run format_all.sh.
2019-07-23 10:23:41 +00:00
if (type.basetype == SPIRType::Struct &&
has_extended_decoration(type_id, SPIRVCrossDecorationBufferBlockRepacked))
Deal with scalar layout of entire structs. Mark all candidate struct types.
2019-07-19 12:18:14 +00:00
mark_scalar_layout_structs(type);
});
Start considering how to emit physical type ID.
2019-07-18 15:05:28 +00:00
// Very particular use of the soft loop lock.
// align_struct may need to create custom types on the fly, but we don't care about
// these types for purpose of iterating over them in ir.ids_for_type and friends.
auto loop_lock = ir.create_loop_soft_lock();
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
for (auto &id_ : ir.ids_for_constant_or_type)
CompilerMSL add support for MSL specialization function constants. CompilerMSL add emit_custom_functions() function. CompilerMSL restrict use of as_type<> cast to necessary conditions. CompilerMSL refactor get_declared_struct_member_size() and get_declared_struct_member_alignment() functions, and remove unnecessary get_declared_type_size() functions. Add test shaders-msl/vulkan/frag/spec-constant.vk.frag.
2017-06-15 19:24:22 +00:00
{
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
auto &id = ir.ids[id_];
Declare OpSpecConstantOp up-front on relevant targets. Required, since spec constants can include results from constant ops.
2018-05-15 12:20:16 +00:00
if (id.get_type() == TypeConstant)
{
auto &c = id.get<SPIRConstant>();
Declare work group size constants in HLSL and MSL. Technically not needed, but it does make compute code easier to read compared to magical constants being used for work group size.
2017-09-29 08:13:45 +00:00
Declare OpSpecConstantOp up-front on relevant targets. Required, since spec constants can include results from constant ops.
2018-05-15 12:20:16 +00:00
if (c.self == workgroup_size_id)
{
Update tests.
2018-11-01 10:22:14 +00:00
// TODO: This can be expressed as a [[threads_per_threadgroup]] input semantic, but we need to know
// the work group size at compile time in SPIR-V, and [[threads_per_threadgroup]] would need to be passed around as a global.
// The work group size may be a specialization constant.
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
statement("constant uint3 ", builtin_to_glsl(BuiltInWorkgroupSize, StorageClassWorkgroup),
" [[maybe_unused]] = ", constant_expression(get<SPIRConstant>(workgroup_size_id)), ";");
Update tests.
2018-11-01 10:22:14 +00:00
emitted = true;
Declare OpSpecConstantOp up-front on relevant targets. Required, since spec constants can include results from constant ops.
2018-05-15 12:20:16 +00:00
}
Update tests.
2018-11-01 10:22:14 +00:00
else if (c.specialization)
Declare OpSpecConstantOp up-front on relevant targets. Required, since spec constants can include results from constant ops.
2018-05-15 12:20:16 +00:00
{
Update tests.
2018-11-01 10:22:14 +00:00
auto &type = get<SPIRType>(c.constant_type);
string sc_type_name = type_to_glsl(type);
string sc_name = to_name(c.self);
string sc_tmp_name = sc_name + "_tmp";
// Function constants are only supported in MSL 1.2 and later.
// If we don't support it just declare the "default" directly.
// This "default" value can be overridden to the true specialization constant by the API user.
// Specialization constants which are used as array length expressions cannot be function constants in MSL,
// so just fall back to macros.
Run format_all.sh.
2018-11-01 10:23:33 +00:00
if (msl_options.supports_msl_version(1, 2) && has_decoration(c.self, DecorationSpecId) &&
!c.is_used_as_array_length)
Update tests.
2018-11-01 10:22:14 +00:00
{
uint32_t constant_id = get_decoration(c.self, DecorationSpecId);
// Only scalar, non-composite values can be function constants.
statement("constant ", sc_type_name, " ", sc_tmp_name, " [[function_constant(", constant_id,
")]];");
statement("constant ", sc_type_name, " ", sc_name, " = is_function_constant_defined(", sc_tmp_name,
") ? ", sc_tmp_name, " : ", constant_expression(c), ";");
}
else if (has_decoration(c.self, DecorationSpecId))
{
// Fallback to macro overrides.
c.specialization_constant_macro_name =
Run format_all.sh.
2018-11-01 10:23:33 +00:00
constant_value_macro_name(get_decoration(c.self, DecorationSpecId));
Update tests.
2018-11-01 10:22:14 +00:00
statement("#ifndef ", c.specialization_constant_macro_name);
statement("#define ", c.specialization_constant_macro_name, " ", constant_expression(c));
statement("#endif");
Run format_all.sh.
2018-11-01 10:23:33 +00:00
statement("constant ", sc_type_name, " ", sc_name, " = ", c.specialization_constant_macro_name,
";");
Update tests.
2018-11-01 10:22:14 +00:00
}
else
{
// Composite specialization constants must be built from other specialization constants.
statement("constant ", sc_type_name, " ", sc_name, " = ", constant_expression(c), ";");
}
emitted = true;
Declare OpSpecConstantOp up-front on relevant targets. Required, since spec constants can include results from constant ops.
2018-05-15 12:20:16 +00:00
}
Declare work group size constants in HLSL and MSL. Technically not needed, but it does make compute code easier to read compared to magical constants being used for work group size.
2017-09-29 08:13:45 +00:00
}
Declare OpSpecConstantOp up-front on relevant targets. Required, since spec constants can include results from constant ops.
2018-05-15 12:20:16 +00:00
else if (id.get_type() == TypeConstantOp)
Declare work group size constants in HLSL and MSL. Technically not needed, but it does make compute code easier to read compared to magical constants being used for work group size.
2017-09-29 08:13:45 +00:00
{
Declare OpSpecConstantOp up-front on relevant targets. Required, since spec constants can include results from constant ops.
2018-05-15 12:20:16 +00:00
auto &c = id.get<SPIRConstantOp>();
auto &type = get<SPIRType>(c.basetype);
auto name = to_name(c.self);
statement("constant ", variable_decl(type, name), " = ", constant_op_expression(c), ";");
emitted = true;
Declare work group size constants in HLSL and MSL. Technically not needed, but it does make compute code easier to read compared to magical constants being used for work group size.
2017-09-29 08:13:45 +00:00
}
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
else if (id.get_type() == TypeType)
{
// Output non-builtin interface structs. These include local function structs
// and structs nested within uniform and read-write buffers.
auto &type = id.get<SPIRType>();
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
TypeID type_id = type.self;
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
bool is_struct = (type.basetype == SPIRType::Struct) && type.array.empty() && !type.pointer;
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
bool is_block =
has_decoration(type.self, DecorationBlock) || has_decoration(type.self, DecorationBufferBlock);
bool is_builtin_block = is_block && is_builtin_type(type);
bool is_declarable_struct = is_struct && !is_builtin_block;
// We'll declare this later.
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
if (stage_out_var_id && get_stage_out_struct_type().self == type_id)
is_declarable_struct = false;
if (patch_stage_out_var_id && get_patch_stage_out_struct_type().self == type_id)
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
is_declarable_struct = false;
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
if (stage_in_var_id && get_stage_in_struct_type().self == type_id)
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
is_declarable_struct = false;
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
if (patch_stage_in_var_id && get_patch_stage_in_struct_type().self == type_id)
is_declarable_struct = false;
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
// Align and emit declarable structs...but avoid declaring each more than once.
if (is_declarable_struct && declared_structs.count(type_id) == 0)
{
if (emitted)
statement("");
emitted = false;
declared_structs.insert(type_id);
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
if (has_extended_decoration(type_id, SPIRVCrossDecorationBufferBlockRepacked))
align_struct(type, aligned_structs);
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
// Make sure we declare the underlying struct type, and not the "decorated" type with pointers, etc.
emit_struct(get<SPIRType>(type_id));
}
}
CompilerMSL add support for MSL specialization function constants. CompilerMSL add emit_custom_functions() function. CompilerMSL restrict use of as_type<> cast to necessary conditions. CompilerMSL refactor get_declared_struct_member_size() and get_declared_struct_member_alignment() functions, and remove unnecessary get_declared_type_size() functions. Add test shaders-msl/vulkan/frag/spec-constant.vk.frag.
2017-06-15 19:24:22 +00:00
}
Declare work group size constants in HLSL and MSL. Technically not needed, but it does make compute code easier to read compared to magical constants being used for work group size.
2017-09-29 08:13:45 +00:00
Declare OpSpecConstantOp up-front on relevant targets. Required, since spec constants can include results from constant ops.
2018-05-15 12:20:16 +00:00
if (emitted)
Declare work group size constants in HLSL and MSL. Technically not needed, but it does make compute code easier to read compared to magical constants being used for work group size.
2017-09-29 08:13:45 +00:00
statement("");
CompilerMSL add support for MSL specialization function constants. CompilerMSL add emit_custom_functions() function. CompilerMSL restrict use of as_type<> cast to necessary conditions. CompilerMSL refactor get_declared_struct_member_size() and get_declared_struct_member_alignment() functions, and remove unnecessary get_declared_type_size() functions. Add test shaders-msl/vulkan/frag/spec-constant.vk.frag.
2017-06-15 19:24:22 +00:00
}
MSL: Support unordered relational operators. The SPIR-V spec says that these check if the operands either are unordered or satisfy the given condition. So that's just what we'll do, using Metal's `isunordered()` stdlib function. Apple's optimizers ought to be able to collapse that to a single unordered compare.
2018-08-31 18:46:02 +00:00
void CompilerMSL::emit_binary_unord_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1,
const char *op)
{
bool forward = should_forward(op0) && should_forward(op1);
emit_op(result_type, result_id,
join("(isunordered(", to_enclosed_unpacked_expression(op0), ", ", to_enclosed_unpacked_expression(op1),
") || ", to_enclosed_unpacked_expression(op0), " ", op, " ", to_enclosed_unpacked_expression(op1),
")"),
forward);
inherit_expression_dependencies(result_id, op0);
inherit_expression_dependencies(result_id, op1);
}
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
bool CompilerMSL::emit_tessellation_io_load(uint32_t result_type_id, uint32_t id, uint32_t ptr)
{
auto &ptr_type = expression_type(ptr);
auto &result_type = get<SPIRType>(result_type_id);
if (ptr_type.storage != StorageClassInput && ptr_type.storage != StorageClassOutput)
return false;
if (ptr_type.storage == StorageClassOutput && get_execution_model() == ExecutionModelTessellationEvaluation)
return false;
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
bool multi_patch_tess_ctl = get_execution_model() == ExecutionModelTessellationControl &&
msl_options.multi_patch_workgroup && ptr_type.storage == StorageClassInput;
MSL: Fix handling of matrices and structs in the output control point array. Prior to this point, we were treating them as flattened, as they are in old-style tessellation control shaders, and still are for structs in new-style shaders. This is not true for outputs; output composites are not flattened at all. This semantic mismatch broke a Vulkan CTS test. It should now pass.
2020-08-03 05:53:42 +00:00
bool flat_matrix = is_matrix(result_type) && ptr_type.storage == StorageClassInput && !multi_patch_tess_ctl;
bool flat_struct = result_type.basetype == SPIRType::Struct && ptr_type.storage == StorageClassInput;
bool flat_data_type = flat_matrix || is_array(result_type) || flat_struct;
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
if (!flat_data_type)
return false;
if (has_decoration(ptr, DecorationPatch))
return false;
// Now, we must unflatten a composite type and take care of interleaving array access with gl_in/gl_out.
// Lots of painful code duplication since we *really* should not unroll these kinds of loads in entry point fixup
// unless we're forced to do this when the code is emitting inoptimal OpLoads.
string expr;
uint32_t interface_index = get_extended_decoration(ptr, SPIRVCrossDecorationInterfaceMemberIndex);
auto *var = maybe_get_backing_variable(ptr);
bool ptr_is_io_variable = ir.ids[ptr].get_type() == TypeVariable;
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
auto &expr_type = get_pointee_type(ptr_type.self);
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
const auto &iface_type = expression_type(stage_in_ptr_var_id);
if (result_type.array.size() > 2)
{
SPIRV_CROSS_THROW("Cannot load tessellation IO variables with more than 2 dimensions.");
}
else if (result_type.array.size() == 2)
{
if (!ptr_is_io_variable)
SPIRV_CROSS_THROW("Loading an array-of-array must be loaded directly from an IO variable.");
if (interface_index == uint32_t(-1))
SPIRV_CROSS_THROW("Interface index is unknown. Cannot continue.");
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (result_type.basetype == SPIRType::Struct || flat_matrix)
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
SPIRV_CROSS_THROW("Cannot load array-of-array of composite type in tessellation IO.");
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
expr += type_to_glsl(result_type) + "({ ";
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
uint32_t num_control_points = to_array_size_literal(result_type, 1);
uint32_t base_interface_index = interface_index;
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
auto &sub_type = get<SPIRType>(result_type.parent_type);
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
for (uint32_t i = 0; i < num_control_points; i++)
{
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
expr += type_to_glsl(sub_type) + "({ ";
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
interface_index = base_interface_index;
uint32_t array_size = to_array_size_literal(result_type, 0);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (multi_patch_tess_ctl)
{
for (uint32_t j = 0; j < array_size; j++)
{
const uint32_t indices[3] = { i, interface_index, j };
AccessChainMeta meta;
expr +=
access_chain_internal(stage_in_ptr_var_id, indices, 3,
ACCESS_CHAIN_INDEX_IS_LITERAL_BIT | ACCESS_CHAIN_PTR_CHAIN_BIT, &meta);
// If the expression has more vector components than the result type, insert
// a swizzle. This shouldn't happen normally on valid SPIR-V, but it might
// happen if we replace the type of an input variable.
if (!is_matrix(sub_type) && sub_type.basetype != SPIRType::Struct &&
expr_type.vecsize > sub_type.vecsize)
expr += vector_swizzle(sub_type.vecsize, 0);
if (j + 1 < array_size)
expr += ", ";
}
}
else
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
{
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
for (uint32_t j = 0; j < array_size; j++, interface_index++)
{
const uint32_t indices[2] = { i, interface_index };
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
AccessChainMeta meta;
expr +=
access_chain_internal(stage_in_ptr_var_id, indices, 2,
ACCESS_CHAIN_INDEX_IS_LITERAL_BIT | ACCESS_CHAIN_PTR_CHAIN_BIT, &meta);
if (!is_matrix(sub_type) && sub_type.basetype != SPIRType::Struct &&
expr_type.vecsize > sub_type.vecsize)
expr += vector_swizzle(sub_type.vecsize, 0);
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (j + 1 < array_size)
expr += ", ";
}
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
}
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
expr += " })";
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
if (i + 1 < num_control_points)
expr += ", ";
}
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
expr += " })";
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
}
MSL: Fix handling of matrices and structs in the output control point array. Prior to this point, we were treating them as flattened, as they are in old-style tessellation control shaders, and still are for structs in new-style shaders. This is not true for outputs; output composites are not flattened at all. This semantic mismatch broke a Vulkan CTS test. It should now pass.
2020-08-03 05:53:42 +00:00
else if (flat_struct)
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
{
bool is_array_of_struct = is_array(result_type);
if (is_array_of_struct && !ptr_is_io_variable)
SPIRV_CROSS_THROW("Loading array of struct from IO variable must come directly from IO variable.");
uint32_t num_control_points = 1;
if (is_array_of_struct)
{
num_control_points = to_array_size_literal(result_type, 0);
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
expr += type_to_glsl(result_type) + "({ ";
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
}
auto &struct_type = is_array_of_struct ? get<SPIRType>(result_type.parent_type) : result_type;
assert(struct_type.array.empty());
for (uint32_t i = 0; i < num_control_points; i++)
{
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
expr += type_to_glsl(struct_type) + "{ ";
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
for (uint32_t j = 0; j < uint32_t(struct_type.member_types.size()); j++)
{
// The base interface index is stored per variable for structs.
if (var)
{
Run format_all.sh.
2019-10-28 11:55:14 +00:00
interface_index =
get_extended_member_decoration(var->self, j, SPIRVCrossDecorationInterfaceMemberIndex);
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
}
if (interface_index == uint32_t(-1))
SPIRV_CROSS_THROW("Interface index is unknown. Cannot continue.");
const auto &mbr_type = get<SPIRType>(struct_type.member_types[j]);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
const auto &expr_mbr_type = get<SPIRType>(expr_type.member_types[j]);
MSL: Fix handling of matrices and structs in the output control point array. Prior to this point, we were treating them as flattened, as they are in old-style tessellation control shaders, and still are for structs in new-style shaders. This is not true for outputs; output composites are not flattened at all. This semantic mismatch broke a Vulkan CTS test. It should now pass.
2020-08-03 05:53:42 +00:00
if (is_matrix(mbr_type) && ptr_type.storage == StorageClassInput && !multi_patch_tess_ctl)
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
{
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
expr += type_to_glsl(mbr_type) + "(";
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
for (uint32_t k = 0; k < mbr_type.columns; k++, interface_index++)
{
if (is_array_of_struct)
{
const uint32_t indices[2] = { i, interface_index };
AccessChainMeta meta;
Run format_all.sh.
2019-10-28 11:55:14 +00:00
expr += access_chain_internal(
stage_in_ptr_var_id, indices, 2,
ACCESS_CHAIN_INDEX_IS_LITERAL_BIT | ACCESS_CHAIN_PTR_CHAIN_BIT, &meta);
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
}
else
expr += to_expression(ptr) + "." + to_member_name(iface_type, interface_index);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (expr_mbr_type.vecsize > mbr_type.vecsize)
expr += vector_swizzle(mbr_type.vecsize, 0);
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
if (k + 1 < mbr_type.columns)
expr += ", ";
}
expr += ")";
}
else if (is_array(mbr_type))
{
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
expr += type_to_glsl(mbr_type) + "({ ";
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
uint32_t array_size = to_array_size_literal(mbr_type, 0);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (multi_patch_tess_ctl)
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
{
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
for (uint32_t k = 0; k < array_size; k++)
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
{
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (is_array_of_struct)
{
const uint32_t indices[3] = { i, interface_index, k };
AccessChainMeta meta;
expr += access_chain_internal(
stage_in_ptr_var_id, indices, 3,
ACCESS_CHAIN_INDEX_IS_LITERAL_BIT | ACCESS_CHAIN_PTR_CHAIN_BIT, &meta);
}
else
expr += join(to_expression(ptr), ".", to_member_name(iface_type, interface_index), "[",
k, "]");
if (expr_mbr_type.vecsize > mbr_type.vecsize)
expr += vector_swizzle(mbr_type.vecsize, 0);
if (k + 1 < array_size)
expr += ", ";
}
}
else
{
for (uint32_t k = 0; k < array_size; k++, interface_index++)
{
if (is_array_of_struct)
{
const uint32_t indices[2] = { i, interface_index };
AccessChainMeta meta;
expr += access_chain_internal(
stage_in_ptr_var_id, indices, 2,
ACCESS_CHAIN_INDEX_IS_LITERAL_BIT | ACCESS_CHAIN_PTR_CHAIN_BIT, &meta);
}
else
expr += to_expression(ptr) + "." + to_member_name(iface_type, interface_index);
if (expr_mbr_type.vecsize > mbr_type.vecsize)
expr += vector_swizzle(mbr_type.vecsize, 0);
if (k + 1 < array_size)
expr += ", ";
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
}
}
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
expr += " })";
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
}
else
{
if (is_array_of_struct)
{
const uint32_t indices[2] = { i, interface_index };
AccessChainMeta meta;
expr += access_chain_internal(stage_in_ptr_var_id, indices, 2,
Run format_all.sh.
2019-10-28 11:55:14 +00:00
ACCESS_CHAIN_INDEX_IS_LITERAL_BIT | ACCESS_CHAIN_PTR_CHAIN_BIT,
&meta);
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
}
else
expr += to_expression(ptr) + "." + to_member_name(iface_type, interface_index);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (expr_mbr_type.vecsize > mbr_type.vecsize)
expr += vector_swizzle(mbr_type.vecsize, 0);
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
}
if (j + 1 < struct_type.member_types.size())
expr += ", ";
}
expr += " }";
if (i + 1 < num_control_points)
expr += ", ";
}
if (is_array_of_struct)
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
expr += " })";
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
}
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
else if (flat_matrix)
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
{
bool is_array_of_matrix = is_array(result_type);
if (is_array_of_matrix && !ptr_is_io_variable)
SPIRV_CROSS_THROW("Loading array of matrix from IO variable must come directly from IO variable.");
if (interface_index == uint32_t(-1))
SPIRV_CROSS_THROW("Interface index is unknown. Cannot continue.");
if (is_array_of_matrix)
{
// Loading a matrix from each control point.
uint32_t base_interface_index = interface_index;
uint32_t num_control_points = to_array_size_literal(result_type, 0);
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
expr += type_to_glsl(result_type) + "({ ";
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
auto &matrix_type = get_variable_element_type(get<SPIRVariable>(ptr));
for (uint32_t i = 0; i < num_control_points; i++)
{
interface_index = base_interface_index;
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
expr += type_to_glsl(matrix_type) + "(";
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
for (uint32_t j = 0; j < result_type.columns; j++, interface_index++)
{
const uint32_t indices[2] = { i, interface_index };
AccessChainMeta meta;
Run format_all.sh.
2019-10-28 11:55:14 +00:00
expr +=
access_chain_internal(stage_in_ptr_var_id, indices, 2,
ACCESS_CHAIN_INDEX_IS_LITERAL_BIT | ACCESS_CHAIN_PTR_CHAIN_BIT, &meta);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (expr_type.vecsize > result_type.vecsize)
expr += vector_swizzle(result_type.vecsize, 0);
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
if (j + 1 < result_type.columns)
expr += ", ";
}
expr += ")";
if (i + 1 < num_control_points)
expr += ", ";
}
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
expr += " })";
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
}
else
{
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
expr += type_to_glsl(result_type) + "(";
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
for (uint32_t i = 0; i < result_type.columns; i++, interface_index++)
{
expr += to_expression(ptr) + "." + to_member_name(iface_type, interface_index);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (expr_type.vecsize > result_type.vecsize)
expr += vector_swizzle(result_type.vecsize, 0);
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
if (i + 1 < result_type.columns)
expr += ", ";
}
expr += ")";
}
}
else if (ptr_is_io_variable)
{
assert(is_array(result_type));
assert(result_type.array.size() == 1);
if (interface_index == uint32_t(-1))
SPIRV_CROSS_THROW("Interface index is unknown. Cannot continue.");
// We're loading an array directly from a global variable.
// This means we're loading one member from each control point.
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
expr += type_to_glsl(result_type) + "({ ";
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
uint32_t num_control_points = to_array_size_literal(result_type, 0);
for (uint32_t i = 0; i < num_control_points; i++)
{
const uint32_t indices[2] = { i, interface_index };
AccessChainMeta meta;
expr += access_chain_internal(stage_in_ptr_var_id, indices, 2,
ACCESS_CHAIN_INDEX_IS_LITERAL_BIT | ACCESS_CHAIN_PTR_CHAIN_BIT, &meta);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (expr_type.vecsize > result_type.vecsize)
expr += vector_swizzle(result_type.vecsize, 0);
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
if (i + 1 < num_control_points)
expr += ", ";
}
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
expr += " })";
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
}
else
{
// We're loading an array from a concrete control point.
assert(is_array(result_type));
assert(result_type.array.size() == 1);
if (interface_index == uint32_t(-1))
SPIRV_CROSS_THROW("Interface index is unknown. Cannot continue.");
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
expr += type_to_glsl(result_type) + "({ ";
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
uint32_t array_size = to_array_size_literal(result_type, 0);
for (uint32_t i = 0; i < array_size; i++, interface_index++)
{
expr += to_expression(ptr) + "." + to_member_name(iface_type, interface_index);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (expr_type.vecsize > result_type.vecsize)
expr += vector_swizzle(result_type.vecsize, 0);
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
if (i + 1 < array_size)
expr += ", ";
}
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
expr += " })";
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
}
emit_op(result_type_id, id, expr, false);
register_read(id, ptr, false);
return true;
}
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
bool CompilerMSL::emit_tessellation_access_chain(const uint32_t *ops, uint32_t length)
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
{
// If this is a per-vertex output, remap it to the I/O array buffer.
MSL: Slight cleanup in emit_tessellation_access_chain. Hoist out some conditionals and make it clear that we go into this path if strip_array is used when declaring resources, i.e. there was no explicit unflatten step.
2019-10-25 12:28:33 +00:00
// Any object which did not go through IO flattening shenanigans will go there instead.
// We will unflatten on-demand instead as needed, but not all possible cases can be supported, especially with arrays.
MSL: Deal with chained access chains for tessellation IO variables. Need to specially deal with this since we might have to split up access chain and deal with indexing into IB struct.
2019-10-26 15:09:24 +00:00
auto *var = maybe_get_backing_variable(ops[2]);
MSL: Slight cleanup in emit_tessellation_access_chain. Hoist out some conditionals and make it clear that we go into this path if strip_array is used when declaring resources, i.e. there was no explicit unflatten step.
2019-10-25 12:28:33 +00:00
bool patch = false;
bool flat_data = false;
MSL: Deal with chained access chains for tessellation IO variables. Need to specially deal with this since we might have to split up access chain and deal with indexing into IB struct.
2019-10-26 15:09:24 +00:00
bool ptr_is_chain = false;
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
bool multi_patch = get_execution_model() == ExecutionModelTessellationControl && msl_options.multi_patch_workgroup;
MSL: Deal with chained access chains for tessellation IO variables. Need to specially deal with this since we might have to split up access chain and deal with indexing into IB struct.
2019-10-26 15:09:24 +00:00
MSL: Slight cleanup in emit_tessellation_access_chain. Hoist out some conditionals and make it clear that we go into this path if strip_array is used when declaring resources, i.e. there was no explicit unflatten step.
2019-10-25 12:28:33 +00:00
if (var)
{
Run format_all.sh.
2019-10-28 11:55:14 +00:00
patch = has_decoration(ops[2], DecorationPatch) || is_patch_block(get_variable_data_type(*var));
MSL: Slight cleanup in emit_tessellation_access_chain. Hoist out some conditionals and make it clear that we go into this path if strip_array is used when declaring resources, i.e. there was no explicit unflatten step.
2019-10-25 12:28:33 +00:00
// Should match strip_array in add_interface_block.
Run format_all.sh.
2019-10-28 11:55:14 +00:00
flat_data = var->storage == StorageClassInput ||
(var->storage == StorageClassOutput && get_execution_model() == ExecutionModelTessellationControl);
MSL: Deal with chained access chains for tessellation IO variables. Need to specially deal with this since we might have to split up access chain and deal with indexing into IB struct.
2019-10-26 15:09:24 +00:00
// We might have a chained access chain, where
// we first take the access chain to the control point, and then we chain into a member or something similar.
// In this case, we need to skip gl_in/gl_out remapping.
ptr_is_chain = var->self != ID(ops[2]);
MSL: Slight cleanup in emit_tessellation_access_chain. Hoist out some conditionals and make it clear that we go into this path if strip_array is used when declaring resources, i.e. there was no explicit unflatten step.
2019-10-25 12:28:33 +00:00
}
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
BuiltIn bi_type = BuiltIn(get_decoration(ops[2], DecorationBuiltIn));
MSL: Slight cleanup in emit_tessellation_access_chain. Hoist out some conditionals and make it clear that we go into this path if strip_array is used when declaring resources, i.e. there was no explicit unflatten step.
2019-10-25 12:28:33 +00:00
if (var && flat_data && !patch &&
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
(!is_builtin_variable(*var) || bi_type == BuiltInPosition || bi_type == BuiltInPointSize ||
bi_type == BuiltInClipDistance || bi_type == BuiltInCullDistance ||
get_variable_data_type(*var).basetype == SPIRType::Struct))
{
AccessChainMeta meta;
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
SmallVector<uint32_t> indices;
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint32_t next_id = ir.increase_bound_by(1);
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
indices.reserve(length - 3 + 1);
MSL: Deal with chained access chains for tessellation IO variables. Need to specially deal with this since we might have to split up access chain and deal with indexing into IB struct.
2019-10-26 15:09:24 +00:00
uint32_t first_non_array_index = ptr_is_chain ? 3 : 4;
VariableID stage_var_id = var->storage == StorageClassInput ? stage_in_ptr_var_id : stage_out_ptr_var_id;
VariableID ptr = ptr_is_chain ? VariableID(ops[2]) : stage_var_id;
if (!ptr_is_chain)
{
// Index into gl_in/gl_out with first array index.
indices.push_back(ops[3]);
}
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
auto &result_ptr_type = get<SPIRType>(ops[0]);
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
uint32_t const_mbr_id = next_id++;
MSL: Deal with chained access chains for tessellation IO variables. Need to specially deal with this since we might have to split up access chain and deal with indexing into IB struct.
2019-10-26 15:09:24 +00:00
uint32_t index = get_extended_decoration(var->self, SPIRVCrossDecorationInterfaceMemberIndex);
Run format_all.sh.
2019-02-14 08:28:46 +00:00
if (var->storage == StorageClassInput || has_decoration(get_variable_element_type(*var).self, DecorationBlock))
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
{
MSL: Deal with chained access chains for tessellation IO variables. Need to specially deal with this since we might have to split up access chain and deal with indexing into IB struct.
2019-10-26 15:09:24 +00:00
uint32_t i = first_non_array_index;
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
auto *type = &get_variable_element_type(*var);
MSL: Deal with chained access chains for tessellation IO variables. Need to specially deal with this since we might have to split up access chain and deal with indexing into IB struct.
2019-10-26 15:09:24 +00:00
if (index == uint32_t(-1) && length >= (first_non_array_index + 1))
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
{
// Maybe this is a struct type in the input class, in which case
// we put it as a decoration on the corresponding member.
MSL: Deal with chained access chains for tessellation IO variables. Need to specially deal with this since we might have to split up access chain and deal with indexing into IB struct.
2019-10-26 15:09:24 +00:00
index = get_extended_member_decoration(var->self, get_constant(ops[first_non_array_index]).scalar(),
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
SPIRVCrossDecorationInterfaceMemberIndex);
assert(index != uint32_t(-1));
i++;
MSL: Deal with chained access chains for tessellation IO variables. Need to specially deal with this since we might have to split up access chain and deal with indexing into IB struct.
2019-10-26 15:09:24 +00:00
type = &get<SPIRType>(type->member_types[get_constant(ops[first_non_array_index]).scalar()]);
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
}
MSL: Slight cleanup in emit_tessellation_access_chain. Hoist out some conditionals and make it clear that we go into this path if strip_array is used when declaring resources, i.e. there was no explicit unflatten step.
2019-10-25 12:28:33 +00:00
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
// In this case, we're poking into flattened structures and arrays, so now we have to
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
// combine the following indices. If we encounter a non-constant index,
// we're hosed.
for (; i < length; ++i)
{
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if ((multi_patch || (!is_array(*type) && !is_matrix(*type))) && type->basetype != SPIRType::Struct)
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
break;
MSL: Report tess input array failures more accurately. We cannot dynamically index into an array of inputs at the moment. Do not fail with opaque "bad cast" error.
2019-10-25 08:53:12 +00:00
auto *c = maybe_get<SPIRConstant>(ops[i]);
if (!c || c->specialization)
Run format_all.sh.
2019-10-28 11:55:14 +00:00
SPIRV_CROSS_THROW("Trying to dynamically index into an array interface variable in tessellation. "
"This is currently unsupported.");
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
// We're in flattened space, so just increment the member index into IO block.
// We can only do this once in the current implementation, so either:
// Struct, Matrix or 1-dimensional array for a control point.
MSL: Report tess input array failures more accurately. We cannot dynamically index into an array of inputs at the moment. Do not fail with opaque "bad cast" error.
2019-10-25 08:53:12 +00:00
index += c->scalar();
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
if (type->parent_type)
type = &get<SPIRType>(type->parent_type);
else if (type->basetype == SPIRType::Struct)
MSL: Report tess input array failures more accurately. We cannot dynamically index into an array of inputs at the moment. Do not fail with opaque "bad cast" error.
2019-10-25 08:53:12 +00:00
type = &get<SPIRType>(type->member_types[c->scalar()]);
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
}
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if ((!multi_patch && (is_matrix(result_ptr_type) || is_array(result_ptr_type))) ||
result_ptr_type.basetype == SPIRType::Struct)
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
{
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
// We're not going to emit the actual member name, we let any further OpLoad take care of that.
// Tag the access chain with the member index we're referencing.
set_extended_decoration(ops[1], SPIRVCrossDecorationInterfaceMemberIndex, index);
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
}
else
{
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
// Access the appropriate member of gl_in/gl_out.
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
set<SPIRConstant>(const_mbr_id, get_uint_type_id(), index, false);
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
indices.push_back(const_mbr_id);
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
// Append any straggling access chain indices.
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
if (i < length)
indices.insert(indices.end(), ops + i, ops + length);
}
}
else
{
assert(index != uint32_t(-1));
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
set<SPIRConstant>(const_mbr_id, get_uint_type_id(), index, false);
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
indices.push_back(const_mbr_id);
indices.insert(indices.end(), ops + 4, ops + length);
}
// We use the pointer to the base of the input/output array here,
// so this is always a pointer chain.
MSL: Deal with chained access chains for tessellation IO variables. Need to specially deal with this since we might have to split up access chain and deal with indexing into IB struct.
2019-10-26 15:09:24 +00:00
string e;
if (!ptr_is_chain)
{
// This is the start of an access chain, use ptr_chain to index into control point array.
e = access_chain(ptr, indices.data(), uint32_t(indices.size()), result_ptr_type, &meta, true);
}
else
{
// If we're accessing a struct, we need to use member indices which are based on the IO block,
// not actual struct type, so we have to use a split access chain here where
// first path resolves the control point index, i.e. gl_in[index], and second half deals with
// looking up flattened member name.
// However, it is possible that we partially accessed a struct,
// by taking pointer to member inside the control-point array.
// For this case, we fall back to a natural access chain since we have already dealt with remapping struct members.
// One way to check this here is if we have 2 implied read expressions.
// First one is the gl_in/gl_out struct itself, then an index into that array.
// If we have traversed further, we use a normal access chain formulation.
auto *ptr_expr = maybe_get<SPIRExpression>(ptr);
if (ptr_expr && ptr_expr->implied_read_expressions.size() == 2)
{
e = join(to_expression(ptr),
access_chain_internal(stage_var_id, indices.data(), uint32_t(indices.size()),
ACCESS_CHAIN_CHAIN_ONLY_BIT, &meta));
}
else
{
e = access_chain_internal(ptr, indices.data(), uint32_t(indices.size()), 0, &meta);
}
}
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
// Get the actual type of the object that was accessed. If it's a vector type and we changed it,
// then we'll need to add a swizzle.
// For this, we can't necessarily rely on the type of the base expression, because it might be
// another access chain, and it will therefore already have the "correct" type.
auto *expr_type = &get_variable_data_type(*var);
if (has_extended_decoration(ops[2], SPIRVCrossDecorationTessIOOriginalInputTypeID))
expr_type = &get<SPIRType>(get_extended_decoration(ops[2], SPIRVCrossDecorationTessIOOriginalInputTypeID));
for (uint32_t i = 3; i < length; i++)
{
if (!is_array(*expr_type) && expr_type->basetype == SPIRType::Struct)
expr_type = &get<SPIRType>(expr_type->member_types[get<SPIRConstant>(ops[i]).scalar()]);
else
expr_type = &get<SPIRType>(expr_type->parent_type);
}
if (!is_array(*expr_type) && !is_matrix(*expr_type) && expr_type->basetype != SPIRType::Struct &&
expr_type->vecsize > result_ptr_type.vecsize)
e += vector_swizzle(result_ptr_type.vecsize, 0);
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
auto &expr = set<SPIRExpression>(ops[1], move(e), ops[0], should_forward(ops[2]));
expr.loaded_from = var->self;
expr.need_transpose = meta.need_transpose;
expr.access_chain = true;
// Mark the result as being packed if necessary.
if (meta.storage_is_packed)
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
set_extended_decoration(ops[1], SPIRVCrossDecorationPhysicalTypePacked);
if (meta.storage_physical_type != 0)
set_extended_decoration(ops[1], SPIRVCrossDecorationPhysicalTypeID, meta.storage_physical_type);
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
if (meta.storage_is_invariant)
set_decoration(ops[1], DecorationInvariant);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
// Save the type we found in case the result is used in another access chain.
set_extended_decoration(ops[1], SPIRVCrossDecorationTessIOOriginalInputTypeID, expr_type->self);
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
MSL: Deal with chained access chains for tessellation IO variables. Need to specially deal with this since we might have to split up access chain and deal with indexing into IB struct.
2019-10-26 15:09:24 +00:00
// If we have some expression dependencies in our access chain, this access chain is technically a forwarded
// temporary which could be subject to invalidation.
// Need to assume we're forwarded while calling inherit_expression_depdendencies.
forwarded_temporaries.insert(ops[1]);
// The access chain itself is never forced to a temporary, but its dependencies might.
suppressed_usage_tracking.insert(ops[1]);
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
for (uint32_t i = 2; i < length; i++)
{
inherit_expression_dependencies(ops[1], ops[i]);
add_implied_read_expression(expr, ops[i]);
}
MSL: Deal with chained access chains for tessellation IO variables. Need to specially deal with this since we might have to split up access chain and deal with indexing into IB struct.
2019-10-26 15:09:24 +00:00
// If we have no dependencies after all, i.e., all indices in the access chain are immutable temporaries,
// we're not forwarded after all.
if (expr.expression_dependencies.empty())
forwarded_temporaries.erase(ops[1]);
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
return true;
}
// If this is the inner tessellation level, and we're tessellating triangles,
// drop the last index. It isn't an array in this case, so we can't have an
// array reference here. We need to make this ID a variable instead of an
// expression so we don't try to dereference it as a variable pointer.
MSL: Drop stores to nonexistent tess levels. In SPIR-V, there are always two inner levels and four outer levels, even if the input patch isn't a quad patch. But in MSL, due to requirements imposed by Metal, only one inner level and three outer levels exist when the input patch is a triangle patch. We must explicitly ignore any write to the nonexistent second inner and fourth outer levels in this case.
2019-02-20 06:33:46 +00:00
// Don't do this if the index is a constant 1, though. We need to drop stores
// to that one.
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
auto *m = ir.find_meta(var ? var->self : ID(0));
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
if (get_execution_model() == ExecutionModelTessellationControl && var && m &&
m->decoration.builtin_type == BuiltInTessLevelInner && get_entry_point().flags.get(ExecutionModeTriangles))
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
{
Fix formatting.
2019-02-20 15:19:25 +00:00
auto *c = maybe_get<SPIRConstant>(ops[3]);
Run format_all.sh. Missed some nits in earlier reviews.
2019-02-20 16:27:15 +00:00
if (c && c->scalar() == 1)
return false;
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
auto &dest_var = set<SPIRVariable>(ops[1], *var);
dest_var.basetype = ops[0];
ir.meta[ops[1]] = ir.meta[ops[2]];
inherit_expression_dependencies(ops[1], ops[2]);
return true;
}
return false;
}
Fix formatting.
2019-02-20 15:19:25 +00:00
bool CompilerMSL::is_out_of_bounds_tessellation_level(uint32_t id_lhs)
{
MSL: Drop stores to nonexistent tess levels. In SPIR-V, there are always two inner levels and four outer levels, even if the input patch isn't a quad patch. But in MSL, due to requirements imposed by Metal, only one inner level and three outer levels exist when the input patch is a triangle patch. We must explicitly ignore any write to the nonexistent second inner and fourth outer levels in this case.
2019-02-20 06:33:46 +00:00
if (!get_entry_point().flags.get(ExecutionModeTriangles))
return false;
// In SPIR-V, TessLevelInner always has two elements and TessLevelOuter always has
// four. This is true even if we are tessellating triangles. This allows clients
// to use a single tessellation control shader with multiple tessellation evaluation
// shaders.
// In Metal, however, only the first element of TessLevelInner and the first three
// of TessLevelOuter are accessible. This stems from how in Metal, the tessellation
// levels must be stored to a dedicated buffer in a particular format that depends
// on the patch type. Therefore, in Triangles mode, any access to the second
// inner level or the fourth outer level must be dropped.
const auto *e = maybe_get<SPIRExpression>(id_lhs);
Run format_all.sh. Missed some nits in earlier reviews.
2019-02-20 16:27:15 +00:00
if (!e || !e->access_chain)
return false;
MSL: Drop stores to nonexistent tess levels. In SPIR-V, there are always two inner levels and four outer levels, even if the input patch isn't a quad patch. But in MSL, due to requirements imposed by Metal, only one inner level and three outer levels exist when the input patch is a triangle patch. We must explicitly ignore any write to the nonexistent second inner and fourth outer levels in this case.
2019-02-20 06:33:46 +00:00
BuiltIn builtin = BuiltIn(get_decoration(e->loaded_from, DecorationBuiltIn));
Run format_all.sh. Missed some nits in earlier reviews.
2019-02-20 16:27:15 +00:00
if (builtin != BuiltInTessLevelInner && builtin != BuiltInTessLevelOuter)
return false;
MSL: Drop stores to nonexistent tess levels. In SPIR-V, there are always two inner levels and four outer levels, even if the input patch isn't a quad patch. But in MSL, due to requirements imposed by Metal, only one inner level and three outer levels exist when the input patch is a triangle patch. We must explicitly ignore any write to the nonexistent second inner and fourth outer levels in this case.
2019-02-20 06:33:46 +00:00
auto *c = maybe_get<SPIRConstant>(e->implied_read_expressions[1]);
Run format_all.sh. Missed some nits in earlier reviews.
2019-02-20 16:27:15 +00:00
if (!c)
return false;
return (builtin == BuiltInTessLevelInner && c->scalar() == 1) ||
(builtin == BuiltInTessLevelOuter && c->scalar() == 3);
MSL: Drop stores to nonexistent tess levels. In SPIR-V, there are always two inner levels and four outer levels, even if the input patch isn't a quad patch. But in MSL, due to requirements imposed by Metal, only one inner level and three outer levels exist when the input patch is a triangle patch. We must explicitly ignore any write to the nonexistent second inner and fourth outer levels in this case.
2019-02-20 06:33:46 +00:00
}
MSL: Workaround broken vector -> scalar access chain in MSL. On MSL, the compiler refuses to allow access chains into a normal vector type. What happens in practice instead is a read-modify-write where a vector type is loaded, modified and written back. The workaround is to convert a vector into a pointer-to-scalar before the access chain continues to add the scalar index.
2020-07-01 11:02:11 +00:00
void CompilerMSL::prepare_access_chain_for_scalar_access(std::string &expr, const SPIRType &type,
spv::StorageClass storage, bool &is_packed)
{
// If there is any risk of writes happening with the access chain in question,
// and there is a risk of concurrent write access to other components,
// we must cast the access chain to a plain pointer to ensure we only access the exact scalars we expect.
// The MSL compiler refuses to allow component-level access for any non-packed vector types.
if (!is_packed && (storage == StorageClassStorageBuffer || storage == StorageClassWorkgroup))
{
const char *addr_space = storage == StorageClassWorkgroup ? "threadgroup" : "device";
expr = join("((", addr_space, " ", type_to_glsl(type), "*)&", enclose_expression(expr), ")");
// Further indexing should happen with packed rules (array index, not swizzle).
is_packed = true;
}
}
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
// Override for MSL-specific syntax instructions
void CompilerMSL::emit_instruction(const Instruction &instruction)
{
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
#define MSL_BOP(op) emit_binary_op(ops[0], ops[1], ops[2], ops[3], #op)
#define MSL_BOP_CAST(op, type) \
Run format.sh.
2016-11-12 09:04:50 +00:00
emit_binary_op_cast(ops[0], ops[1], ops[2], ops[3], #op, type, opcode_is_sign_invariant(opcode))
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
#define MSL_UOP(op) emit_unary_op(ops[0], ops[1], ops[2], #op)
#define MSL_QFOP(op) emit_quaternary_func_op(ops[0], ops[1], ops[2], ops[3], ops[4], ops[5], #op)
#define MSL_TFOP(op) emit_trinary_func_op(ops[0], ops[1], ops[2], ops[3], ops[4], #op)
#define MSL_BFOP(op) emit_binary_func_op(ops[0], ops[1], ops[2], ops[3], #op)
#define MSL_BFOP_CAST(op, type) \
Run format.sh.
2016-11-12 09:04:50 +00:00
emit_binary_func_op_cast(ops[0], ops[1], ops[2], ops[3], #op, type, opcode_is_sign_invariant(opcode))
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
#define MSL_UFOP(op) emit_unary_func_op(ops[0], ops[1], ops[2], #op)
MSL: Support unordered relational operators. The SPIR-V spec says that these check if the operands either are unordered or satisfy the given condition. So that's just what we'll do, using Metal's `isunordered()` stdlib function. Apple's optimizers ought to be able to collapse that to a single unordered compare.
2018-08-31 18:46:02 +00:00
#define MSL_UNORD_BOP(op) emit_binary_unord_op(ops[0], ops[1], ops[2], ops[3], #op)
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
auto ops = stream(instruction);
auto opcode = static_cast<Op>(instruction.op);
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
// If we need to do implicit bitcasts, make sure we do it with the correct type.
uint32_t integer_width = get_integer_width_for_instruction(instruction);
auto int_type = to_signed_basetype(integer_width);
auto uint_type = to_unsigned_basetype(integer_width);
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
switch (opcode)
{
Fix conversion of the SampleMask intrinsic from SPIRV, where it is an array to Metal where it isn't.
2019-08-14 14:54:18 +00:00
case OpLoad:
{
uint32_t id = ops[1];
uint32_t ptr = ops[2];
MSL: Rewrite tessellation_access_chain. To support loading array of array properly in tessellation, we need a rewrite of how tessellation access chains are handled. The major change is to remove the implicit unflatten step inside access_chain which does not take into account the case where you load directly from a control point array variable. We defer unflatten step until OpLoad time instead. This fixes cases where we load array of {array,matrix,struct}. Removes the hacky path for MSL access chain index workaround.
2019-10-25 14:41:02 +00:00
if (is_tessellation_shader())
{
if (!emit_tessellation_io_load(ops[0], id, ptr))
CompilerGLSL::emit_instruction(instruction);
}
else
{
// Sample mask input for Metal is not an array
if (BuiltIn(get_decoration(ptr, DecorationBuiltIn)) == BuiltInSampleMask)
set_decoration(id, DecorationBuiltIn, BuiltInSampleMask);
CompilerGLSL::emit_instruction(instruction);
}
Fix conversion of the SampleMask intrinsic from SPIRV, where it is an array to Metal where it isn't.
2019-08-14 14:54:18 +00:00
break;
}
MSL sort interface struct members by offset instead of location. MSL support OpFMod as fmod() function. Remove SPIRType::is_packed member.
2016-12-04 17:32:58 +00:00
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
// Comparisons
case OpIEqual:
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
MSL_BOP_CAST(==, int_type);
break;
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
case OpLogicalEqual:
case OpFOrdEqual:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
MSL_BOP(==);
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
break;
case OpINotEqual:
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
MSL_BOP_CAST(!=, int_type);
break;
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
case OpLogicalNotEqual:
case OpFOrdNotEqual:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
MSL_BOP(!=);
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
break;
case OpUGreaterThan:
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
MSL_BOP_CAST(>, uint_type);
break;
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
case OpSGreaterThan:
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
MSL_BOP_CAST(>, int_type);
break;
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
case OpFOrdGreaterThan:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
MSL_BOP(>);
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
break;
case OpUGreaterThanEqual:
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
MSL_BOP_CAST(>=, uint_type);
break;
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
case OpSGreaterThanEqual:
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
MSL_BOP_CAST(>=, int_type);
break;
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
case OpFOrdGreaterThanEqual:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
MSL_BOP(>=);
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
break;
case OpULessThan:
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
MSL_BOP_CAST(<, uint_type);
break;
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
case OpSLessThan:
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
MSL_BOP_CAST(<, int_type);
break;
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
case OpFOrdLessThan:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
MSL_BOP(<);
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
break;
case OpULessThanEqual:
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
MSL_BOP_CAST(<=, uint_type);
break;
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
case OpSLessThanEqual:
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
MSL_BOP_CAST(<=, int_type);
break;
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
case OpFOrdLessThanEqual:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
MSL_BOP(<=);
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
break;
MSL: Support unordered relational operators. The SPIR-V spec says that these check if the operands either are unordered or satisfy the given condition. So that's just what we'll do, using Metal's `isunordered()` stdlib function. Apple's optimizers ought to be able to collapse that to a single unordered compare.
2018-08-31 18:46:02 +00:00
case OpFUnordEqual:
MSL_UNORD_BOP(==);
break;
case OpFUnordNotEqual:
MSL_UNORD_BOP(!=);
break;
case OpFUnordGreaterThan:
MSL_UNORD_BOP(>);
break;
case OpFUnordGreaterThanEqual:
MSL_UNORD_BOP(>=);
break;
case OpFUnordLessThan:
MSL_UNORD_BOP(<);
break;
case OpFUnordLessThanEqual:
MSL_UNORD_BOP(<=);
break;
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
// Derivatives
case OpDPdx:
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpDPdxFine:
case OpDPdxCoarse:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
MSL_UFOP(dfdx);
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
break;
case OpDPdy:
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpDPdyFine:
case OpDPdyCoarse:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
MSL_UFOP(dfdy);
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
break;
Some compat fixes for MSL and Half.
2018-03-06 16:07:59 +00:00
case OpFwidth:
case OpFwidthCoarse:
case OpFwidthFine:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
MSL_UFOP(fwidth);
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Some compat fixes for MSL and Half.
2018-03-06 16:07:59 +00:00
break;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
// Bitfield
case OpBitFieldInsert:
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
{
Run format_all.sh.
2019-08-28 12:25:26 +00:00
emit_bitfield_insert_op(ops[0], ops[1], ops[2], ops[3], ops[4], ops[5], "insert_bits", SPIRType::UInt);
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
break;
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpBitFieldSExtract:
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
{
Run format_all.sh.
2019-08-28 12:25:26 +00:00
emit_trinary_func_op_bitextract(ops[0], ops[1], ops[2], ops[3], ops[4], "extract_bits", int_type, int_type,
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
SPIRType::UInt, SPIRType::UInt);
break;
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpBitFieldUExtract:
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
{
Run format_all.sh.
2019-08-28 12:25:26 +00:00
emit_trinary_func_op_bitextract(ops[0], ops[1], ops[2], ops[3], ops[4], "extract_bits", uint_type, uint_type,
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
SPIRType::UInt, SPIRType::UInt);
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
break;
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpBitReverse:
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
// BitReverse does not have issues with sign since result type must match input type.
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
MSL_UFOP(reverse_bits);
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
break;
case OpBitCount:
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
{
auto basetype = expression_type(ops[2]).basetype;
emit_unary_func_op_cast(ops[0], ops[1], ops[2], "popcount", basetype, basetype);
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
break;
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
Implement FRem.
2018-02-15 12:31:29 +00:00
case OpFRem:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
MSL_BFOP(fmod);
Implement FRem.
2018-02-15 12:31:29 +00:00
break;
Add an option to SPIRV-Cross to enforce invariant floating point math to prevent different depth calculation between prepass & basepass when running on Metal 2.0 and earlier.
2019-08-14 15:25:18 +00:00
case OpFMul:
if (msl_options.invariant_float_math)
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
MSL_BFOP(spvFMul);
Add an option to SPIRV-Cross to enforce invariant floating point math to prevent different depth calculation between prepass & basepass when running on Metal 2.0 and earlier.
2019-08-14 15:25:18 +00:00
else
MSL_BOP(*);
break;
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Add an option to SPIRV-Cross to enforce invariant floating point math to prevent different depth calculation between prepass & basepass when running on Metal 2.0 and earlier.
2019-08-14 15:25:18 +00:00
case OpFAdd:
if (msl_options.invariant_float_math)
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
MSL_BFOP(spvFAdd);
Add an option to SPIRV-Cross to enforce invariant floating point math to prevent different depth calculation between prepass & basepass when running on Metal 2.0 and earlier.
2019-08-14 15:25:18 +00:00
else
MSL_BOP(+);
break;
Implement FRem.
2018-02-15 12:31:29 +00:00
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
// Atomics
case OpAtomicExchange:
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
uint32_t ptr = ops[2];
uint32_t mem_sem = ops[4];
uint32_t val = ops[5];
emit_atomic_func_op(result_type, id, "atomic_exchange_explicit", mem_sem, mem_sem, false, ptr, val);
break;
}
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpAtomicCompareExchange:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
uint32_t ptr = ops[2];
uint32_t mem_sem_pass = ops[4];
uint32_t mem_sem_fail = ops[5];
uint32_t val = ops[6];
uint32_t comp = ops[7];
emit_atomic_func_op(result_type, id, "atomic_compare_exchange_weak_explicit", mem_sem_pass, mem_sem_fail, true,
MSL: Fix OpAtomicIIncrement and OpAtomicIDecrement. We were passing a constant '1' to `emit_atomic_func_op()`--which caused us to refer to SPIR-V value `%1`, which is almost certainly not what we want! What we really want is to add/subtract the literal constant '1' to/from the memory location.
2018-09-10 19:47:35 +00:00
ptr, comp, true, false, val);
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
break;
}
Fix atomic_compare_exchange_weak_explicit. Need to emit a CAS loop. Fix shared memory declaration. Declare atomic ops with correct memory scope.
2018-05-15 14:03:20 +00:00
case OpAtomicCompareExchangeWeak:
SPIRV_CROSS_THROW("OpAtomicCompareExchangeWeak is only supported in kernel profile.");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpAtomicLoad:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
uint32_t ptr = ops[2];
uint32_t mem_sem = ops[4];
emit_atomic_func_op(result_type, id, "atomic_load_explicit", mem_sem, mem_sem, false, ptr, 0);
break;
}
case OpAtomicStore:
{
uint32_t result_type = expression_type(ops[0]).self;
uint32_t id = ops[0];
uint32_t ptr = ops[0];
uint32_t mem_sem = ops[2];
uint32_t val = ops[3];
emit_atomic_func_op(result_type, id, "atomic_store_explicit", mem_sem, mem_sem, false, ptr, val);
break;
}
MSL: Fix OpAtomicIIncrement and OpAtomicIDecrement. We were passing a constant '1' to `emit_atomic_func_op()`--which caused us to refer to SPIR-V value `%1`, which is almost certainly not what we want! What we really want is to add/subtract the literal constant '1' to/from the memory location.
2018-09-10 19:47:35 +00:00
#define MSL_AFMO_IMPL(op, valsrc, valconst) \
do \
{ \
uint32_t result_type = ops[0]; \
uint32_t id = ops[1]; \
uint32_t ptr = ops[2]; \
uint32_t mem_sem = ops[4]; \
uint32_t val = valsrc; \
emit_atomic_func_op(result_type, id, "atomic_fetch_" #op "_explicit", mem_sem, mem_sem, false, ptr, val, \
false, valconst); \
Edits resulting from review of PR #186.
2017-05-22 17:38:23 +00:00
} while (false)
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
MSL: Fix OpAtomicIIncrement and OpAtomicIDecrement. We were passing a constant '1' to `emit_atomic_func_op()`--which caused us to refer to SPIR-V value `%1`, which is almost certainly not what we want! What we really want is to add/subtract the literal constant '1' to/from the memory location.
2018-09-10 19:47:35 +00:00
#define MSL_AFMO(op) MSL_AFMO_IMPL(op, ops[5], false)
#define MSL_AFMIO(op) MSL_AFMO_IMPL(op, 1, true)
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpAtomicIIncrement:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
MSL_AFMIO(add);
Edits resulting from review of PR #186.
2017-05-22 17:38:23 +00:00
break;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpAtomicIDecrement:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
MSL_AFMIO(sub);
Edits resulting from review of PR #186.
2017-05-22 17:38:23 +00:00
break;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpAtomicIAdd:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
MSL_AFMO(add);
Edits resulting from review of PR #186.
2017-05-22 17:38:23 +00:00
break;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpAtomicISub:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
MSL_AFMO(sub);
Edits resulting from review of PR #186.
2017-05-22 17:38:23 +00:00
break;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpAtomicSMin:
case OpAtomicUMin:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
MSL_AFMO(min);
Edits resulting from review of PR #186.
2017-05-22 17:38:23 +00:00
break;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpAtomicSMax:
case OpAtomicUMax:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
MSL_AFMO(max);
Edits resulting from review of PR #186.
2017-05-22 17:38:23 +00:00
break;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpAtomicAnd:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
MSL_AFMO(and);
Edits resulting from review of PR #186.
2017-05-22 17:38:23 +00:00
break;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpAtomicOr:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
MSL_AFMO(or);
Edits resulting from review of PR #186.
2017-05-22 17:38:23 +00:00
break;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpAtomicXor:
CompilerMSL vertex entry point return void when rasterization disabled. Add CompilerMSL::Options::disable_rasterization input/output API flag. Disable rasterization via API flag or when writing to textures. Disable rasterization when shader declares no output. Add test shaders for vertex no output and write texture forcing void output.
2018-07-26 04:50:33 +00:00
MSL_AFMO(xor);
Edits resulting from review of PR #186.
2017-05-22 17:38:23 +00:00
break;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
// Images
Fixes from review of PR #190.
2017-06-01 20:29:39 +00:00
// Reads == Fetches in Metal
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpImageRead:
Fixes from review of PR #190.
2017-06-01 20:29:39 +00:00
{
// Mark that this shader reads from this image
uint32_t img_id = ops[2];
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
auto &type = expression_type(img_id);
if (type.image.dim != DimSubpassData)
MSL improvements: - pack/unpack nested constant buffer structs - support for write-only textures (only global ones for now) - better rt index support for msl generator
2017-12-06 17:51:23 +00:00
{
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
auto *p_var = maybe_get_backing_variable(img_id);
if (p_var && has_decoration(p_var->self, DecorationNonReadable))
{
unset_decoration(p_var->self, DecorationNonReadable);
Detect invalid DoWhileLoop early. We had a bug where error conditions in DoWhileLoop emit path would not detect that statements were being emitted due to the masking behavior which happens when force_recompile is true. Fix this. Also, refactor force_recompile into member functions so we can properly break on any situation where this is set, without having to rely on watchpoints in debuggers.
2019-04-05 10:06:10 +00:00
force_recompile();
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
}
MSL improvements: - pack/unpack nested constant buffer structs - support for write-only textures (only global ones for now) - better rt index support for msl generator
2017-12-06 17:51:23 +00:00
}
Fixes from review of PR #190.
2017-06-01 20:29:39 +00:00
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
emit_texture_op(instruction, false);
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
break;
Fixes from review of PR #190.
2017-06-01 20:29:39 +00:00
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Emulate texture2D atomic operations
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
case OpImageTexelPointer:
{
// When using the pointer, we need to know which variable it is actually loaded from.
auto *var = maybe_get_backing_variable(ops[2]);
MSL: Minor cleanups for texture atomic emulation. Storing pointers to internal objects is generally not done, IDs are preferred.
2019-10-24 09:30:20 +00:00
if (var && atomic_image_vars.count(var->self))
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
std::string coord = to_expression(ops[3]);
auto &type = expression_type(ops[2]);
if (type.image.dim == Dim2D)
{
coord = join("spvImage2DAtomicCoord(", coord, ", ", to_expression(ops[2]), ")");
}
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
auto &e = set<SPIRExpression>(id, join(to_expression(ops[2]), "_atomic[", coord, "]"), result_type, true);
Merge branch 'ue4_dev'
2019-09-20 13:28:46 +00:00
e.loaded_from = var ? var->self : ID(0);
MSL: Minor cleanups for texture atomic emulation. Storing pointers to internal objects is generally not done, IDs are preferred.
2019-10-24 09:30:20 +00:00
inherit_expression_dependencies(id, ops[3]);
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
}
else
{
OpImageTexelPointer needs to use an int coordinate type for GLSL, but not for MSL.
2019-08-26 15:28:13 +00:00
uint32_t result_type = ops[0];
uint32_t id = ops[1];
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
auto &e =
set<SPIRExpression>(id, join(to_expression(ops[2]), ", ", to_expression(ops[3])), result_type, true);
OpImageTexelPointer needs to use an int coordinate type for GLSL, but not for MSL.
2019-08-26 15:28:13 +00:00
// When using the pointer, we need to know which variable it is actually loaded from.
Merge branch 'ue4_dev'
2019-09-20 13:28:46 +00:00
e.loaded_from = var ? var->self : ID(0);
MSL: Minor cleanups for texture atomic emulation. Storing pointers to internal objects is generally not done, IDs are preferred.
2019-10-24 09:30:20 +00:00
inherit_expression_dependencies(id, ops[3]);
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
}
break;
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpImageWrite:
{
uint32_t img_id = ops[0];
uint32_t coord_id = ops[1];
uint32_t texel_id = ops[2];
const uint32_t *opt = &ops[3];
MSL: Correct number of words to skip in OpImageWrite. The length field in `Instruction` doesn't include the initial opcode/length word. We only need to skip three words instead of four.
2018-09-04 06:15:17 +00:00
uint32_t length = instruction.length - 3;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
// Bypass pointers because we need the real image struct
auto &type = expression_type(img_id);
auto &img_type = get<SPIRType>(type.self);
// Ensure this image has been marked as being written to and force a
// recommpile so that the image type output will include write access
Support emitting SPIR-V type declarations tuned for specified SPIR-V objects. CompilerGLSL type_to_glsl() and image_type_glsl() functions support optional object ID. Add SPIRType::Image::access member to support SPIR-V OpTypeImage access qualifier. Remove SPIRType::Image::is_read and ::is_written members. Use DecorationNonReadable and DecorationNonWritable to mark read/write access for image variables. CompilerMSL emit access qualifiers per image variable, instead of per image type. CompilerGLSL and CompilerHLSL behaviour is unchanged.
2017-05-30 00:45:05 +00:00
auto *p_var = maybe_get_backing_variable(img_id);
if (p_var && has_decoration(p_var->self, DecorationNonWritable))
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
{
Support emitting SPIR-V type declarations tuned for specified SPIR-V objects. CompilerGLSL type_to_glsl() and image_type_glsl() functions support optional object ID. Add SPIRType::Image::access member to support SPIR-V OpTypeImage access qualifier. Remove SPIRType::Image::is_read and ::is_written members. Use DecorationNonReadable and DecorationNonWritable to mark read/write access for image variables. CompilerMSL emit access qualifiers per image variable, instead of per image type. CompilerGLSL and CompilerHLSL behaviour is unchanged.
2017-05-30 00:45:05 +00:00
unset_decoration(p_var->self, DecorationNonWritable);
Detect invalid DoWhileLoop early. We had a bug where error conditions in DoWhileLoop emit path would not detect that statements were being emitted due to the masking behavior which happens when force_recompile is true. Fix this. Also, refactor force_recompile into member functions so we can properly break on any situation where this is set, without having to rely on watchpoints in debuggers.
2019-04-05 10:06:10 +00:00
force_recompile();
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
}
bool forward = false;
uint32_t bias = 0;
uint32_t lod = 0;
uint32_t flags = 0;
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
if (length)
{
flags = *opt++;
length--;
}
Run format.sh.
2016-11-12 09:04:50 +00:00
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
auto test = [&](uint32_t &v, uint32_t flag) {
if (length && (flags & flag))
{
v = *opt++;
length--;
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
};
test(bias, ImageOperandsBiasMask);
test(lod, ImageOperandsLodMask);
MSL: Fix image load/store for short vectors. Same fixes as for GLSL.
2019-01-17 13:53:42 +00:00
auto &texel_type = expression_type(texel_id);
auto store_type = texel_type;
store_type.vecsize = 4;
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
TextureFunctionArguments args = {};
args.base.img = img_id;
args.base.imgtype = &img_type;
args.base.is_fetch = true;
args.coord = coord_id;
args.lod = lod;
Run format_all.sh.
2019-06-21 14:02:22 +00:00
statement(join(to_expression(img_id), ".write(",
remap_swizzle(store_type, texel_type.vecsize, to_expression(texel_id)), ", ",
Run format_all.sh.
2020-07-01 09:42:58 +00:00
CompilerMSL::to_function_args(args, &forward), ");"));
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
Support emitting SPIR-V type declarations tuned for specified SPIR-V objects. CompilerGLSL type_to_glsl() and image_type_glsl() functions support optional object ID. Add SPIRType::Image::access member to support SPIR-V OpTypeImage access qualifier. Remove SPIRType::Image::is_read and ::is_written members. Use DecorationNonReadable and DecorationNonWritable to mark read/write access for image variables. CompilerMSL emit access qualifiers per image variable, instead of per image type. CompilerGLSL and CompilerHLSL behaviour is unchanged.
2017-05-30 00:45:05 +00:00
if (p_var && variable_storage_is_aliased(*p_var))
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
flush_all_aliased_variables();
break;
}
case OpImageQuerySize:
case OpImageQuerySizeLod:
{
uint32_t rslt_type_id = ops[0];
auto &rslt_type = get<SPIRType>(rslt_type_id);
uint32_t id = ops[1];
uint32_t img_id = ops[2];
string img_exp = to_expression(img_id);
auto &img_type = expression_type(img_id);
Dim img_dim = img_type.image.dim;
Fix some warnings on older GCC.
2017-11-06 08:49:52 +00:00
bool img_is_array = img_type.image.arrayed;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
if (img_type.basetype != SPIRType::Image)
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Invalid type for OpImageQuerySize.");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
string lod;
if (opcode == OpImageQuerySizeLod)
{
// LOD index defaults to zero, so don't bother outputing level zero index
string decl_lod = to_expression(ops[3]);
if (decl_lod != "0")
lod = decl_lod;
}
string expr = type_to_glsl(rslt_type) + "(";
expr += img_exp + ".get_width(" + lod + ")";
if (img_dim == Dim2D || img_dim == DimCube || img_dim == Dim3D)
expr += ", " + img_exp + ".get_height(" + lod + ")";
if (img_dim == Dim3D)
expr += ", " + img_exp + ".get_depth(" + lod + ")";
Fix some warnings on older GCC.
2017-11-06 08:49:52 +00:00
if (img_is_array)
Added a new 'emulate_cube_array' option to SPIRV-Cross to cope with translating TextureCubeArray into texture2d_array for iOS where this type is not available. (Original Author: Mark Satterthwaite)
2019-09-13 21:24:27 +00:00
{
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
expr += ", " + img_exp + ".get_array_size()";
Added a new 'emulate_cube_array' option to SPIRV-Cross to cope with translating TextureCubeArray into texture2d_array for iOS where this type is not available. (Original Author: Mark Satterthwaite)
2019-09-13 21:24:27 +00:00
if (img_dim == DimCube && msl_options.emulate_cube_array)
expr += " / 6";
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
expr += ")";
emit_op(rslt_type_id, id, expr, should_forward(img_id));
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
break;
}
MSL: textureQueryLod() is not supported. Don't bother with hacky workaround unless required.
2018-09-13 11:44:46 +00:00
case OpImageQueryLod:
MSL: Support OpImageQueryLod. Correctness is a bit unclear at the moment. The spec document for 2.2 is not updated for query-lod, but this is the best we can do anyways.
2019-06-12 09:36:52 +00:00
{
if (!msl_options.supports_msl_version(2, 2))
SPIRV_CROSS_THROW("ImageQueryLod is only supported on MSL 2.2 and up.");
uint32_t result_type = ops[0];
uint32_t id = ops[1];
uint32_t image_id = ops[2];
uint32_t coord_id = ops[3];
emit_uninitialized_temporary_expression(result_type, id);
auto sampler_expr = to_sampler_expression(image_id);
auto *combined = maybe_get<SPIRCombinedImageSampler>(image_id);
auto image_expr = combined ? to_expression(combined->image) : to_expression(image_id);
// TODO: It is unclear if calculcate_clamped_lod also conditionally rounds
// the reported LOD based on the sampler. NEAREST miplevel should
// round the LOD, but LINEAR miplevel should not round.
// Let's hope this does not become an issue ...
Run format_all.sh.
2019-06-21 14:02:22 +00:00
statement(to_expression(id), ".x = ", image_expr, ".calculate_clamped_lod(", sampler_expr, ", ",
to_expression(coord_id), ");");
statement(to_expression(id), ".y = ", image_expr, ".calculate_unclamped_lod(", sampler_expr, ", ",
to_expression(coord_id), ");");
MSL: Support OpImageQueryLod. Correctness is a bit unclear at the moment. The spec document for 2.2 is not updated for query-lod, but this is the best we can do anyways.
2019-06-12 09:36:52 +00:00
register_control_dependent_expression(id);
break;
}
MSL: textureQueryLod() is not supported. Don't bother with hacky workaround unless required.
2018-09-13 11:44:46 +00:00
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
#define MSL_ImgQry(qrytype) \
Edits resulting from review of PR #186.
2017-05-22 17:38:23 +00:00
do \
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
{ \
uint32_t rslt_type_id = ops[0]; \
auto &rslt_type = get<SPIRType>(rslt_type_id); \
uint32_t id = ops[1]; \
uint32_t img_id = ops[2]; \
string img_exp = to_expression(img_id); \
string expr = type_to_glsl(rslt_type) + "(" + img_exp + ".get_num_" #qrytype "())"; \
emit_op(rslt_type_id, id, expr, should_forward(img_id)); \
Edits resulting from review of PR #186.
2017-05-22 17:38:23 +00:00
} while (false)
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpImageQueryLevels:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
MSL_ImgQry(mip_levels);
Edits resulting from review of PR #186.
2017-05-22 17:38:23 +00:00
break;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
Edits resulting from review of PR #186.
2017-05-22 17:38:23 +00:00
case OpImageQuerySamples:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
MSL_ImgQry(samples);
Edits resulting from review of PR #186.
2017-05-22 17:38:23 +00:00
break;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
MSL: Handle OpImage on OpSampledImage expressions. I have seen this happen. The included test case is one such case.
2018-09-30 00:07:16 +00:00
case OpImage:
{
Refactor MSL to use SPIRCombinedImageSampler. Avoids special "meta" data to express this type. Makes MSL implementation in line with HLSL.
2018-10-05 07:49:57 +00:00
uint32_t result_type = ops[0];
MSL: Handle OpImage on OpSampledImage expressions. I have seen this happen. The included test case is one such case.
2018-09-30 00:07:16 +00:00
uint32_t id = ops[1];
Refactor MSL to use SPIRCombinedImageSampler. Avoids special "meta" data to express this type. Makes MSL implementation in line with HLSL.
2018-10-05 07:49:57 +00:00
auto *combined = maybe_get<SPIRCombinedImageSampler>(ops[2]);
MSL: Handle OpImage on OpSampledImage expressions. I have seen this happen. The included test case is one such case.
2018-09-30 00:07:16 +00:00
Refactor MSL to use SPIRCombinedImageSampler. Avoids special "meta" data to express this type. Makes MSL implementation in line with HLSL.
2018-10-05 07:49:57 +00:00
if (combined)
{
auto &e = emit_op(result_type, id, to_expression(combined->image), true, true);
auto *var = maybe_get_backing_variable(combined->image);
if (var)
e.loaded_from = var->self;
}
else
MSL: Handle OpImage on OpSampledImage expressions. I have seen this happen. The included test case is one such case.
2018-09-30 00:07:16 +00:00
{
Refactor MSL to use SPIRCombinedImageSampler. Avoids special "meta" data to express this type. Makes MSL implementation in line with HLSL.
2018-10-05 07:49:57 +00:00
auto *var = maybe_get_backing_variable(ops[2]);
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
SPIRExpression *e;
if (var && has_extended_decoration(var->self, SPIRVCrossDecorationDynamicImageSampler))
e = &emit_op(result_type, id, join(to_expression(ops[2]), ".plane0"), true, true);
else
e = &emit_op(result_type, id, to_expression(ops[2]), true, true);
Refactor MSL to use SPIRCombinedImageSampler. Avoids special "meta" data to express this type. Makes MSL implementation in line with HLSL.
2018-10-05 07:49:57 +00:00
if (var)
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
e->loaded_from = var->self;
MSL: Handle OpImage on OpSampledImage expressions. I have seen this happen. The included test case is one such case.
2018-09-30 00:07:16 +00:00
}
break;
}
Edits resulting from review of PR #186.
2017-05-22 17:38:23 +00:00
// Casting
case OpQuantizeToF16:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
uint32_t arg = ops[2];
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
Edits resulting from review of PR #186.
2017-05-22 17:38:23 +00:00
string exp;
auto &type = get<SPIRType>(result_type);
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
Edits resulting from review of PR #186.
2017-05-22 17:38:23 +00:00
switch (type.vecsize)
{
case 1:
exp = join("float(half(", to_expression(arg), "))");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
break;
Edits resulting from review of PR #186.
2017-05-22 17:38:23 +00:00
case 2:
exp = join("float2(half2(", to_expression(arg), "))");
break;
case 3:
exp = join("float3(half3(", to_expression(arg), "))");
break;
case 4:
exp = join("float4(half4(", to_expression(arg), "))");
break;
default:
SPIRV_CROSS_THROW("Illegal argument to OpQuantizeToF16.");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
}
Edits resulting from review of PR #186.
2017-05-22 17:38:23 +00:00
emit_op(result_type, id, exp, should_forward(arg));
break;
}
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
case OpInBoundsAccessChain:
case OpAccessChain:
case OpPtrAccessChain:
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
if (is_tessellation_shader())
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
{
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
if (!emit_tessellation_access_chain(ops, instruction.length))
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
CompilerGLSL::emit_instruction(instruction);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
}
MSL: Hoist out complicated tesc workaround code.
2019-02-14 08:28:17 +00:00
else
CompilerGLSL::emit_instruction(instruction);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
break;
Fix issue #245: assignment of flattened input struct. Emit input struct assignment by assigning member by member from stage_in struct. Map qualified member name from pointer type, not base type. Add Comiler::expression_type_id() function, similar to expression_type().
2017-08-12 04:21:13 +00:00
case OpStore:
MSL: Drop stores to nonexistent tess levels. In SPIR-V, there are always two inner levels and four outer levels, even if the input patch isn't a quad patch. But in MSL, due to requirements imposed by Metal, only one inner level and three outer levels exist when the input patch is a triangle patch. We must explicitly ignore any write to the nonexistent second inner and fourth outer levels in this case.
2019-02-20 06:33:46 +00:00
if (is_out_of_bounds_tessellation_level(ops[0]))
break;
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
if (maybe_emit_array_assignment(ops[0], ops[1]))
break;
Fix issue #245: assignment of flattened input struct. Emit input struct assignment by assigning member by member from stage_in struct. Map qualified member name from pointer type, not base type. Add Comiler::expression_type_id() function, similar to expression_type().
2017-08-12 04:21:13 +00:00
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
CompilerGLSL::emit_instruction(instruction);
break;
// Compute barriers
case OpMemoryBarrier:
emit_barrier(0, ops[0], ops[1]);
break;
case OpControlBarrier:
// In GLSL a memory barrier is often followed by a control barrier.
// But in MSL, memory barriers are also control barriers, so don't
// emit a simple control barrier if a memory barrier has just been emitted.
if (previous_instruction_opcode != OpMemoryBarrier)
emit_barrier(ops[0], ops[1], ops[2]);
Fix issue #245: assignment of flattened input struct. Emit input struct assignment by assigning member by member from stage_in struct. Map qualified member name from pointer type, not base type. Add Comiler::expression_type_id() function, similar to expression_type().
2017-08-12 04:21:13 +00:00
break;
MSL/HLSL: Support OpOuterProduct.
2019-07-01 08:57:27 +00:00
case OpOuterProduct:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
uint32_t a = ops[2];
uint32_t b = ops[3];
auto &type = get<SPIRType>(result_type);
string expr = type_to_glsl_constructor(type);
expr += "(";
for (uint32_t col = 0; col < type.columns; col++)
{
expr += to_enclosed_expression(a);
expr += " * ";
expr += to_extract_component_expression(b, col);
if (col + 1 < type.columns)
expr += ", ";
}
expr += ")";
emit_op(result_type, id, expr, should_forward(a) && should_forward(b));
inherit_expression_dependencies(id, a);
inherit_expression_dependencies(id, b);
break;
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
Further adjustments to make Metal backend work again in UE4 on Mac.
2019-09-17 15:40:01 +00:00
case OpVectorTimesMatrix:
case OpMatrixTimesVector:
MSL: Support extended arithmetic opcodes.
2018-11-13 20:11:50 +00:00
{
MSL: Fall back to GLSL path for non-invariant FP implementation.
2019-10-24 09:34:52 +00:00
if (!msl_options.invariant_float_math)
{
CompilerGLSL::emit_instruction(instruction);
break;
}
Further adjustments to make Metal backend work again in UE4 on Mac.
2019-09-17 15:40:01 +00:00
// If the matrix needs transpose, just flip the multiply order.
auto *e = maybe_get<SPIRExpression>(ops[opcode == OpMatrixTimesVector ? 2 : 3]);
if (e && e->need_transpose)
MSL: Support extended arithmetic opcodes.
2018-11-13 20:11:50 +00:00
{
Further adjustments to make Metal backend work again in UE4 on Mac.
2019-09-17 15:40:01 +00:00
e->need_transpose = false;
string expr;
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Further adjustments to make Metal backend work again in UE4 on Mac.
2019-09-17 15:40:01 +00:00
if (opcode == OpMatrixTimesVector)
{
MSL: Fall back to GLSL path for non-invariant FP implementation.
2019-10-24 09:34:52 +00:00
expr = join("spvFMulVectorMatrix(", to_enclosed_unpacked_expression(ops[3]), ", ",
to_unpacked_row_major_matrix_expression(ops[2]), ")");
Further adjustments to make Metal backend work again in UE4 on Mac.
2019-09-17 15:40:01 +00:00
}
else
{
MSL: Fall back to GLSL path for non-invariant FP implementation.
2019-10-24 09:34:52 +00:00
expr = join("spvFMulMatrixVector(", to_unpacked_row_major_matrix_expression(ops[3]), ", ",
to_enclosed_unpacked_expression(ops[2]), ")");
Further adjustments to make Metal backend work again in UE4 on Mac.
2019-09-17 15:40:01 +00:00
}
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Further adjustments to make Metal backend work again in UE4 on Mac.
2019-09-17 15:40:01 +00:00
bool forward = should_forward(ops[2]) && should_forward(ops[3]);
emit_op(ops[0], ops[1], expr, forward);
e->need_transpose = true;
inherit_expression_dependencies(ops[1], ops[2]);
inherit_expression_dependencies(ops[1], ops[3]);
}
MSL: Fall back to GLSL path for non-invariant FP implementation.
2019-10-24 09:34:52 +00:00
else
Added '--msl-invariant-float-math' option and new test case for it.
2019-10-09 15:22:25 +00:00
{
if (opcode == OpMatrixTimesVector)
MSL_BFOP(spvFMulMatrixVector);
else
MSL_BFOP(spvFMulVectorMatrix);
}
Further adjustments to make Metal backend work again in UE4 on Mac.
2019-09-17 15:40:01 +00:00
break;
}
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Further adjustments to make Metal backend work again in UE4 on Mac.
2019-09-17 15:40:01 +00:00
case OpMatrixTimesMatrix:
{
MSL: Fall back to GLSL path for non-invariant matrix multiply as well.
2019-10-24 09:37:22 +00:00
if (!msl_options.invariant_float_math)
{
CompilerGLSL::emit_instruction(instruction);
break;
}
Further adjustments to make Metal backend work again in UE4 on Mac.
2019-09-17 15:40:01 +00:00
auto *a = maybe_get<SPIRExpression>(ops[2]);
auto *b = maybe_get<SPIRExpression>(ops[3]);
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Further adjustments to make Metal backend work again in UE4 on Mac.
2019-09-17 15:40:01 +00:00
// If both matrices need transpose, we can multiply in flipped order and tag the expression as transposed.
// a^T * b^T = (b * a)^T.
if (a && b && a->need_transpose && b->need_transpose)
{
a->need_transpose = false;
b->need_transpose = false;
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Run format_all.sh.
2019-10-28 11:55:14 +00:00
auto expr =
join("spvFMulMatrixMatrix(", enclose_expression(to_unpacked_row_major_matrix_expression(ops[3])), ", ",
enclose_expression(to_unpacked_row_major_matrix_expression(ops[2])), ")");
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Further adjustments to make Metal backend work again in UE4 on Mac.
2019-09-17 15:40:01 +00:00
bool forward = should_forward(ops[2]) && should_forward(ops[3]);
auto &e = emit_op(ops[0], ops[1], expr, forward);
e.need_transpose = true;
a->need_transpose = true;
b->need_transpose = true;
inherit_expression_dependencies(ops[1], ops[2]);
inherit_expression_dependencies(ops[1], ops[3]);
}
else
MSL: Fall back to GLSL path for non-invariant matrix multiply as well.
2019-10-24 09:37:22 +00:00
MSL_BFOP(spvFMulMatrixMatrix);
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Further adjustments to make Metal backend work again in UE4 on Mac.
2019-09-17 15:40:01 +00:00
break;
}
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
MSL: Support extended arithmetic opcodes.
2018-11-13 20:11:50 +00:00
case OpIAddCarry:
case OpISubBorrow:
{
uint32_t result_type = ops[0];
uint32_t result_id = ops[1];
uint32_t op0 = ops[2];
uint32_t op1 = ops[3];
auto &type = get<SPIRType>(result_type);
MSL: Cleanup temporary use with emit_uninitialized_temporary.
2019-07-26 09:16:43 +00:00
emit_uninitialized_temporary_expression(result_type, result_id);
MSL: Support extended arithmetic opcodes.
2018-11-13 20:11:50 +00:00
auto &res_type = get<SPIRType>(type.member_types[1]);
if (opcode == OpIAddCarry)
{
statement(to_expression(result_id), ".", to_member_name(type, 0), " = ", to_enclosed_expression(op0), " + ",
to_enclosed_expression(op1), ";");
statement(to_expression(result_id), ".", to_member_name(type, 1), " = select(", type_to_glsl(res_type),
Correct carry/borrow bit checks. Don't use `addsat()`/`subsat()`; that'll erroneously flag cases where the sum is exactly the maximum integer value, or the difference is exactly 0. Also, correct the condition for the `select()` function; it's basically `mix()` with a boolean factor. (What was I *thinking*?)
2018-11-14 16:13:56 +00:00
"(1), ", type_to_glsl(res_type), "(0), ", to_expression(result_id), ".", to_member_name(type, 0),
" >= max(", to_expression(op0), ", ", to_expression(op1), "));");
MSL: Support extended arithmetic opcodes.
2018-11-13 20:11:50 +00:00
}
else
{
statement(to_expression(result_id), ".", to_member_name(type, 0), " = ", to_enclosed_expression(op0), " - ",
to_enclosed_expression(op1), ";");
statement(to_expression(result_id), ".", to_member_name(type, 1), " = select(", type_to_glsl(res_type),
Correct carry/borrow bit checks. Don't use `addsat()`/`subsat()`; that'll erroneously flag cases where the sum is exactly the maximum integer value, or the difference is exactly 0. Also, correct the condition for the `select()` function; it's basically `mix()` with a boolean factor. (What was I *thinking*?)
2018-11-14 16:13:56 +00:00
"(1), ", type_to_glsl(res_type), "(0), ", to_enclosed_expression(op0),
" >= ", to_enclosed_expression(op1), ");");
MSL: Support extended arithmetic opcodes.
2018-11-13 20:11:50 +00:00
}
break;
}
case OpUMulExtended:
case OpSMulExtended:
{
uint32_t result_type = ops[0];
uint32_t result_id = ops[1];
uint32_t op0 = ops[2];
uint32_t op1 = ops[3];
auto &type = get<SPIRType>(result_type);
MSL: Cleanup temporary use with emit_uninitialized_temporary.
2019-07-26 09:16:43 +00:00
emit_uninitialized_temporary_expression(result_type, result_id);
MSL: Support extended arithmetic opcodes.
2018-11-13 20:11:50 +00:00
statement(to_expression(result_id), ".", to_member_name(type, 0), " = ", to_enclosed_expression(op0), " * ",
to_enclosed_expression(op1), ";");
statement(to_expression(result_id), ".", to_member_name(type, 1), " = mulhi(", to_expression(op0), ", ",
to_expression(op1), ");");
break;
}
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
case OpArrayLength:
{
auto &type = expression_type(ops[2]);
uint32_t offset = type_struct_member_offset(type, ops[3]);
uint32_t stride = type_struct_member_array_stride(type, ops[3]);
auto expr = join("(", to_buffer_size_expression(ops[2]), " - ", offset, ") / ", stride);
emit_op(ops[0], ops[1], expr, true);
break;
}
MSL: Support the SPV_INTEL_shader_integer_functions2 extension. This provides a few functions normally available in OpenCL to the SPIR-V shader environment. These functions happen to be available in Metal as well. No GLSL, unfortunately. Intel has yet to publish a `GL_INTEL_shader_integer_functions2` spec.
2019-07-11 23:20:19 +00:00
// SPV_INTEL_shader_integer_functions2
case OpUCountLeadingZerosINTEL:
MSL_UFOP(clz);
break;
case OpUCountTrailingZerosINTEL:
MSL_UFOP(ctz);
break;
case OpAbsISubINTEL:
case OpAbsUSubINTEL:
MSL_BFOP(absdiff);
break;
case OpIAddSatINTEL:
case OpUAddSatINTEL:
MSL_BFOP(addsat);
break;
case OpIAverageINTEL:
case OpUAverageINTEL:
MSL_BFOP(hadd);
break;
case OpIAverageRoundedINTEL:
case OpUAverageRoundedINTEL:
MSL_BFOP(rhadd);
break;
case OpISubSatINTEL:
case OpUSubSatINTEL:
MSL_BFOP(subsat);
break;
case OpIMul32x16INTEL:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
uint32_t a = ops[2], b = ops[3];
bool forward = should_forward(a) && should_forward(b);
emit_op(result_type, id, join("int(short(", to_expression(a), ")) * int(short(", to_expression(b), "))"),
forward);
inherit_expression_dependencies(id, a);
inherit_expression_dependencies(id, b);
break;
}
case OpUMul32x16INTEL:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
uint32_t a = ops[2], b = ops[3];
bool forward = should_forward(a) && should_forward(b);
emit_op(result_type, id, join("uint(ushort(", to_expression(a), ")) * uint(ushort(", to_expression(b), "))"),
forward);
inherit_expression_dependencies(id, a);
inherit_expression_dependencies(id, b);
break;
}
MSL: Support SPV_EXT_demote_to_helper_invocation for MSL 2.3. MSL 2.3 has everything needed to support this extension on all platforms. The existing `discard_fragment()` function was given demote semantics, similar to Direct3D, and the `simd_is_helper_thread()` function was finally added to iOS. I've left the old test alone. Should I remove it in favor of these?
2020-09-29 04:07:55 +00:00
// SPV_EXT_demote_to_helper_invocation
case OpDemoteToHelperInvocationEXT:
if (!msl_options.supports_msl_version(2, 3))
SPIRV_CROSS_THROW("discard_fragment() does not formally have demote semantics until MSL 2.3.");
CompilerGLSL::emit_instruction(instruction);
break;
Support the SPV_EXT_demote_to_helper_invocation extension. This extension provides a new operation which causes a fragment to be discarded without terminating the fragment shader invocation. The invocation for the discarded fragment becomes a helper invocation, so that derivatives will remain defined. The old `HelperInvocation` builtin becomes undefined when this occurs, so a second new instruction queries the current helper invocation status. This is only fully supported for GLSL. HLSL doesn't support the `IsHelperInvocation` operation and MSL doesn't support the `DemoteToHelperInvocation` op. Fixes #1052.
2019-07-13 20:57:33 +00:00
case OpIsHelperInvocationEXT:
MSL: Support SPV_EXT_demote_to_helper_invocation for MSL 2.3. MSL 2.3 has everything needed to support this extension on all platforms. The existing `discard_fragment()` function was given demote semantics, similar to Direct3D, and the `simd_is_helper_thread()` function was finally added to iOS. I've left the old test alone. Should I remove it in favor of these?
2020-09-29 04:07:55 +00:00
if (msl_options.is_ios() && !msl_options.supports_msl_version(2, 3))
SPIRV_CROSS_THROW("simd_is_helper_thread() requires MSL 2.3 on iOS.");
Support the SPV_EXT_demote_to_helper_invocation extension. This extension provides a new operation which causes a fragment to be discarded without terminating the fragment shader invocation. The invocation for the discarded fragment becomes a helper invocation, so that derivatives will remain defined. The old `HelperInvocation` builtin becomes undefined when this occurs, so a second new instruction queries the current helper invocation status. This is only fully supported for GLSL. HLSL doesn't support the `IsHelperInvocation` operation and MSL doesn't support the `DemoteToHelperInvocation` op. Fixes #1052.
2019-07-13 20:57:33 +00:00
else if (msl_options.is_macos() && !msl_options.supports_msl_version(2, 1))
MSL: Support SPV_EXT_demote_to_helper_invocation for MSL 2.3. MSL 2.3 has everything needed to support this extension on all platforms. The existing `discard_fragment()` function was given demote semantics, similar to Direct3D, and the `simd_is_helper_thread()` function was finally added to iOS. I've left the old test alone. Should I remove it in favor of these?
2020-09-29 04:07:55 +00:00
SPIRV_CROSS_THROW("simd_is_helper_thread() requires MSL 2.1 on macOS.");
Don't forward uses of an OpIsHelperInvocationEXT op. If this is computed *before* a `demote`, but used *after*, forwarding it will produce the wrong value. This does make for uglier shaders, but it's necessary right now to ensure correctness. I needed to use an assembly shader to produce the test for this. `spirv-opt` is not smart enough (or too smart?) to eliminate the variable that would be used in GLSL to express this.
2019-07-18 22:32:35 +00:00
emit_op(ops[0], ops[1], "simd_is_helper_thread()", false);
Support the SPV_EXT_demote_to_helper_invocation extension. This extension provides a new operation which causes a fragment to be discarded without terminating the fragment shader invocation. The invocation for the discarded fragment becomes a helper invocation, so that derivatives will remain defined. The old `HelperInvocation` builtin becomes undefined when this occurs, so a second new instruction queries the current helper invocation status. This is only fully supported for GLSL. HLSL doesn't support the `IsHelperInvocation` operation and MSL doesn't support the `DemoteToHelperInvocation` op. Fixes #1052.
2019-07-13 20:57:33 +00:00
break;
Support the SPV_EXT_fragment_shader_interlock extension. This was straightforward to implement in GLSL. The `ShadingRateInterlockOrderedEXT` and `ShadingRateInterlockUnorderedEXT` modes aren't implemented yet, because we don't support `SPV_NV_shading_rate` or `SPV_EXT_fragment_invocation_density` yet. HLSL and MSL were more interesting. They don't support this directly, but they do support marking resources as "rasterizer ordered," which does roughly the same thing. So this implementation scans all accesses inside the critical section and marks all storage resources found therein as rasterizer ordered. They also don't support the fine-grained controls on pixel- vs. sample-level interlock and disabling ordering guarantees that GLSL and SPIR-V do, but that's OK. "Unordered" here merely means the order is undefined; that it just so happens to be the same as rasterizer order is immaterial. As for pixel- vs. sample-level interlock, Vulkan explicitly states: > With sample shading enabled, [the `PixelInterlockOrderedEXT` and > `PixelInterlockUnorderedEXT`] execution modes are treated like > `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT` > respectively. and: > If [the `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT`] > execution modes are used in single-sample mode they are treated like > `PixelInterlockOrderedEXT` or `PixelInterlockUnorderedEXT` > respectively. So this will DTRT for MoltenVK and gfx-rs, at least. MSL additionally supports multiple raster order groups; resources that are not accessed together can be placed in different ROGs to allow them to be synchronized separately. A more sophisticated analysis might be able to place resources optimally, but that's outside the scope of this change. For now, we assign all resources to group 0, which should do for our purposes. `glslang` doesn't support the `RasterizerOrdered` UAVs this implementation produces for HLSL, so the test case needs `fxc.exe`. It also insists on GLSL 4.50 for `GL_ARB_fragment_shader_interlock`, even though the spec says it needs either 4.20 or `GL_ARB_shader_image_load_store`; and it doesn't support the `GL_NV_fragment_shader_interlock` extension at all. So I haven't been able to test those code paths. Fixes #1002.
2019-08-04 05:07:20 +00:00
case OpBeginInvocationInterlockEXT:
case OpEndInvocationInterlockEXT:
if (!msl_options.supports_msl_version(2, 0))
SPIRV_CROSS_THROW("Raster order groups require MSL 2.0.");
break; // Nothing to do in the body
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
default:
CompilerGLSL::emit_instruction(instruction);
break;
}
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
previous_instruction_opcode = opcode;
}
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
void CompilerMSL::emit_texture_op(const Instruction &i, bool sparse)
SPIRV doesn't distinguish depth textures from regular textures, but Metal does, so if we've ever seen a depth comparison operation we must ensure that the texture is specified as a depth-texture.
2019-08-14 14:46:23 +00:00
{
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
if (sparse)
SPIRV_CROSS_THROW("Sparse feedback not yet supported in MSL.");
Further updates for pull request #1162; also added two test cases for spvCubemapTo2DArrayFace function and added '--msl-framebuffer-fetch'/ '--msl-emulate-cube-array' compiler options.
2019-09-27 19:49:54 +00:00
if (msl_options.is_ios() && msl_options.ios_use_framebuffer_fetch_subpasses)
{
auto *ops = stream(i);
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Further updates for pull request #1162; also added two test cases for spvCubemapTo2DArrayFace function and added '--msl-framebuffer-fetch'/ '--msl-emulate-cube-array' compiler options.
2019-09-27 19:49:54 +00:00
uint32_t result_type_id = ops[0];
uint32_t id = ops[1];
uint32_t img = ops[2];
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Further updates for pull request #1162; also added two test cases for spvCubemapTo2DArrayFace function and added '--msl-framebuffer-fetch'/ '--msl-emulate-cube-array' compiler options.
2019-09-27 19:49:54 +00:00
auto &type = expression_type(img);
auto &imgtype = get<SPIRType>(type.self);
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Further updates for pull request #1162; also added two test cases for spvCubemapTo2DArrayFace function and added '--msl-framebuffer-fetch'/ '--msl-emulate-cube-array' compiler options.
2019-09-27 19:49:54 +00:00
// Use Metal's native frame-buffer fetch API for subpass inputs.
if (imgtype.image.dim == DimSubpassData)
{
MSL: Simplify framebuffer fetch implementation.
2019-10-24 09:48:29 +00:00
// Subpass inputs cannot be invalidated,
// so just forward the expression directly.
Further updates for pull request #1162; also added two test cases for spvCubemapTo2DArrayFace function and added '--msl-framebuffer-fetch'/ '--msl-emulate-cube-array' compiler options.
2019-09-27 19:49:54 +00:00
string expr = to_expression(img);
MSL: Simplify framebuffer fetch implementation.
2019-10-24 09:48:29 +00:00
emit_op(result_type_id, id, expr, true);
Further updates for pull request #1162; also added two test cases for spvCubemapTo2DArrayFace function and added '--msl-framebuffer-fetch'/ '--msl-emulate-cube-array' compiler options.
2019-09-27 19:49:54 +00:00
return;
}
On iOS sub-passes can be implemented using the frame-buffer fetch API which is much more efficient than binding the textures. Change was made in three parts. 1. Use Metal's native frame-buffer fetch API for subpass inputs. 2. Make sure that frame-buffer-fetch is only available on iOS. 3. Default to using Metal's native frame-buffer fetch for subpass inputs on iOS.
2019-08-14 14:48:47 +00:00
}
Further updates for pull request #1162; also added two test cases for spvCubemapTo2DArrayFace function and added '--msl-framebuffer-fetch'/ '--msl-emulate-cube-array' compiler options.
2019-09-27 19:49:54 +00:00
// Fallback to default implementation
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
CompilerGLSL::emit_texture_op(i, sparse);
SPIRV doesn't distinguish depth textures from regular textures, but Metal does, so if we've ever seen a depth comparison operation we must ensure that the texture is specified as a depth-texture.
2019-08-14 14:46:23 +00:00
}
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
void CompilerMSL::emit_barrier(uint32_t id_exe_scope, uint32_t id_mem_scope, uint32_t id_mem_sem)
{
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
if (get_execution_model() != ExecutionModelGLCompute && get_execution_model() != ExecutionModelTessellationControl)
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
return;
Implement a simple evaluator of specialization constants. In some cases, we need to get a literal value from a spec constant op. Mostly relevant when emitting buffers, so implement a 32-bit integer scalar subset of the evaluator. Can be extended as needed to support evaluating any specialization constant operation.
2020-09-14 08:42:31 +00:00
uint32_t exe_scope = id_exe_scope ? evaluate_constant_u32(id_exe_scope) : uint32_t(ScopeInvocation);
uint32_t mem_scope = id_mem_scope ? evaluate_constant_u32(id_mem_scope) : uint32_t(ScopeInvocation);
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
// Use the wider of the two scopes (smaller value)
exe_scope = min(exe_scope, mem_scope);
string bar_stmt;
if ((msl_options.is_ios() && msl_options.supports_msl_version(1, 2)) || msl_options.supports_msl_version(2))
bar_stmt = exe_scope < ScopeSubgroup ? "threadgroup_barrier" : "simdgroup_barrier";
else
bar_stmt = "threadgroup_barrier";
bar_stmt += "(";
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
Implement a simple evaluator of specialization constants. In some cases, we need to get a literal value from a spec constant op. Mostly relevant when emitting buffers, so implement a 32-bit integer scalar subset of the evaluator. Can be extended as needed to support evaluating any specialization constant operation.
2020-09-14 08:42:31 +00:00
uint32_t mem_sem = id_mem_sem ? evaluate_constant_u32(id_mem_sem) : uint32_t(MemorySemanticsMaskNone);
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
// Use the | operator to combine flags if we can.
if (msl_options.supports_msl_version(1, 2))
{
string mem_flags = "";
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
// For tesc shaders, this also affects objects in the Output storage class.
// Since in Metal, these are placed in a device buffer, we have to sync device memory here.
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
if (get_execution_model() == ExecutionModelTessellationControl ||
(mem_sem & (MemorySemanticsUniformMemoryMask | MemorySemanticsCrossWorkgroupMemoryMask)))
mem_flags += "mem_flags::mem_device";
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Fix tessellation patch function processing
Fixes to the generation of Metal tessellation shaders from SPIRV so that it works correctly in more complicated cases. First, when generating from HLSL before invoking the code that comes from the HLSL patch-function a control-flow and full memory-barrier are required to ensure that all the temporary values in thread-local storage for the patch are available. Second, the inputs to control and evaluation shaders must be properly forwarded from the global variables in SPIRV to the member variables in the relevant input structure. Finally when arrays of interpolators are used for input or output we need to add an extra level of array indirection because Metal works at a different granularity than SPIRV. Five parts. 1. Fix tessellation patch function processing. 2. Fix loads from tessellation control inputs not being forwarded to the gl_in structure array. 3. Fix loads from tessellation evaluation inputs not being forwarded to the stage_in structure array. 4. Workaround SPIRV losing an array indirection in tessellation shaders - not the best solution but enough to keep things progressing. 5. Apparently gl_TessLevelInner/Outer is special and needs to not be placed into the input array.
2019-08-14 14:51:48 +00:00
if (get_execution_model() == ExecutionModelTessellationControl ||
Remove obsolete use of AtomicCounterMemoryMask.
2019-12-04 14:30:07 +00:00
(mem_sem & (MemorySemanticsSubgroupMemoryMask | MemorySemanticsWorkgroupMemoryMask)))
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
{
if (!mem_flags.empty())
mem_flags += " | ";
mem_flags += "mem_flags::mem_threadgroup";
}
if (mem_sem & MemorySemanticsImageMemoryMask)
{
if (!mem_flags.empty())
mem_flags += " | ";
mem_flags += "mem_flags::mem_texture";
}
if (mem_flags.empty())
mem_flags = "mem_flags::mem_none";
bar_stmt += mem_flags;
}
CompilerMSL support platform semantics. Support customizing MSL based on iOS or macOS platform. Support SPIV-V containing multiple memory semantics.
2017-12-26 18:39:07 +00:00
else
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
{
if ((mem_sem & (MemorySemanticsUniformMemoryMask | MemorySemanticsCrossWorkgroupMemoryMask)) &&
Remove obsolete use of AtomicCounterMemoryMask.
2019-12-04 14:30:07 +00:00
(mem_sem & (MemorySemanticsSubgroupMemoryMask | MemorySemanticsWorkgroupMemoryMask)))
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
bar_stmt += "mem_flags::mem_device_and_threadgroup";
else if (mem_sem & (MemorySemanticsUniformMemoryMask | MemorySemanticsCrossWorkgroupMemoryMask))
bar_stmt += "mem_flags::mem_device";
Remove obsolete use of AtomicCounterMemoryMask.
2019-12-04 14:30:07 +00:00
else if (mem_sem & (MemorySemanticsSubgroupMemoryMask | MemorySemanticsWorkgroupMemoryMask))
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
bar_stmt += "mem_flags::mem_threadgroup";
else if (mem_sem & MemorySemanticsImageMemoryMask)
bar_stmt += "mem_flags::mem_texture";
else
bar_stmt += "mem_flags::mem_none";
}
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
bar_stmt += ");";
statement(bar_stmt);
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
assert(current_emitting_block);
flush_control_dependent_expressions(current_emitting_block->self);
flush_all_active_variables();
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
}
Run format_all.sh.
2019-08-28 12:25:26 +00:00
void CompilerMSL::emit_array_copy(const string &lhs, uint32_t rhs_id, StorageClass lhs_storage,
StorageClass rhs_storage)
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
{
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Allow Metal to use the array<T> template to make arrays a value type.
// This, however, cannot be used for threadgroup address specifiers, so consider the custom array copy as fallback.
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
bool lhs_thread = (lhs_storage == StorageClassOutput || lhs_storage == StorageClassFunction ||
lhs_storage == StorageClassGeneric || lhs_storage == StorageClassPrivate);
bool rhs_thread = (rhs_storage == StorageClassInput || rhs_storage == StorageClassFunction ||
rhs_storage == StorageClassGeneric || rhs_storage == StorageClassPrivate);
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
// If threadgroup storage qualifiers are *not* used:
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
// Avoid spvCopy* wrapper functions; Otherwise, spvUnsafeArray<> template cannot be used with that storage qualifier.
MSL: Add a workaround path to force native arrays for everything.
2020-02-24 11:47:14 +00:00
if (lhs_thread && rhs_thread && !using_builtin_array())
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
{
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
statement(lhs, " = ", to_expression(rhs_id), ";");
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
}
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
else
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
{
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
// Assignment from an array initializer is fine.
auto &type = expression_type(rhs_id);
auto *var = maybe_get_backing_variable(rhs_id);
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
// Unfortunately, we cannot template on address space in MSL,
// so explicit address space redirection it is ...
bool is_constant = false;
if (ir.ids[rhs_id].get_type() == TypeConstant)
{
is_constant = true;
}
else if (var && var->remapped_variable && var->statically_assigned &&
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
ir.ids[var->static_expression].get_type() == TypeConstant)
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
{
is_constant = true;
}
MSL: Improve handling of array types in buffer objects. When loading and storing array types which belong to buffer objects, we need to treat these values as not being value types. Also, need to handle array load/store from/to more address space combinations.
2020-06-18 09:37:24 +00:00
else if (rhs_storage == StorageClassUniform)
{
is_constant = true;
}
MSL: Deal with array copies from and to threadgroup.
2019-08-27 11:16:16 +00:00
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
// For the case where we have OpLoad triggering an array copy,
// we cannot easily detect this case ahead of time since it's
// context dependent. We might have to force a recompile here
// if this is the only use of array copies in our shader.
if (type.array.size() > 1)
{
Fix -Wduplicate-enum and -Wrange-for-analysis.
2020-09-04 08:04:25 +00:00
if (type.array.size() > kArrayCopyMultidimMax)
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
SPIRV_CROSS_THROW("Cannot support this many dimensions for arrays of arrays.");
auto func = static_cast<SPVFuncImpl>(SPVFuncImplArrayCopyMultidimBase + type.array.size());
add_spv_func_and_recompile(func);
}
else
add_spv_func_and_recompile(SPVFuncImplArrayCopy);
const char *tag = nullptr;
if (lhs_thread && is_constant)
tag = "FromConstantToStack";
else if (lhs_storage == StorageClassWorkgroup && is_constant)
tag = "FromConstantToThreadGroup";
else if (lhs_thread && rhs_thread)
tag = "FromStackToStack";
else if (lhs_storage == StorageClassWorkgroup && rhs_thread)
tag = "FromStackToThreadGroup";
else if (lhs_thread && rhs_storage == StorageClassWorkgroup)
tag = "FromThreadGroupToStack";
else if (lhs_storage == StorageClassWorkgroup && rhs_storage == StorageClassWorkgroup)
tag = "FromThreadGroupToThreadGroup";
MSL: Improve handling of array types in buffer objects. When loading and storing array types which belong to buffer objects, we need to treat these values as not being value types. Also, need to handle array load/store from/to more address space combinations.
2020-06-18 09:37:24 +00:00
else if (lhs_storage == StorageClassStorageBuffer && rhs_storage == StorageClassStorageBuffer)
tag = "FromDeviceToDevice";
else if (lhs_storage == StorageClassStorageBuffer && is_constant)
tag = "FromConstantToDevice";
else if (lhs_storage == StorageClassStorageBuffer && rhs_storage == StorageClassWorkgroup)
tag = "FromThreadGroupToDevice";
else if (lhs_storage == StorageClassStorageBuffer && rhs_thread)
tag = "FromStackToDevice";
else if (lhs_storage == StorageClassWorkgroup && rhs_storage == StorageClassStorageBuffer)
tag = "FromDeviceToThreadGroup";
else if (lhs_thread && rhs_storage == StorageClassStorageBuffer)
tag = "FromDeviceToStack";
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
else
SPIRV_CROSS_THROW("Unknown storage class used for copying arrays.");
MSL: Deal with array copies from and to threadgroup.
2019-08-27 11:16:16 +00:00
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
// Pass internal array of spvUnsafeArray<> into wrapper functions
MSL: Reinstate workaround for returning arrays.
2020-02-24 12:04:10 +00:00
if (lhs_thread && !msl_options.force_native_arrays)
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
statement("spvArrayCopy", tag, type.array.size(), "(", lhs, ".elements, ", to_expression(rhs_id), ");");
MSL: Reinstate workaround for returning arrays.
2020-02-24 12:04:10 +00:00
else if (rhs_thread && !msl_options.force_native_arrays)
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
statement("spvArrayCopy", tag, type.array.size(), "(", lhs, ", ", to_expression(rhs_id), ".elements);");
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
else
statement("spvArrayCopy", tag, type.array.size(), "(", lhs, ", ", to_expression(rhs_id), ");");
}
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
}
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
// Since MSL does not allow arrays to be copied via simple variable assignment,
// if the LHS and RHS represent an assignment of an entire array, it must be
// implemented by calling an array copy function.
// Returns whether the struct assignment was emitted.
bool CompilerMSL::maybe_emit_array_assignment(uint32_t id_lhs, uint32_t id_rhs)
{
// We only care about assignments of an entire array
auto &type = expression_type(id_rhs);
if (type.array.size() == 0)
return false;
MSL cannot declare inline arrays except in certain cases.
2018-02-08 12:06:29 +00:00
auto *var = maybe_get<SPIRVariable>(id_lhs);
Deduce constant LUTs from read-write variables.
2018-07-05 11:25:57 +00:00
// Is this a remapped, static constant? Don't do anything.
MSL: Fix segfault when trying to store to an array inside struct.
2018-08-08 14:48:22 +00:00
if (var && var->remapped_variable && var->statically_assigned)
Deduce constant LUTs from read-write variables.
2018-07-05 11:25:57 +00:00
return true;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
if (ir.ids[id_rhs].get_type() == TypeConstant && var && var->deferred_declaration)
MSL cannot declare inline arrays except in certain cases.
2018-02-08 12:06:29 +00:00
{
// Special case, if we end up declaring a variable when assigning the constant array,
// we can avoid the copy by directly assigning the constant expression.
// This is likely necessary to be able to use a variable as a true look-up table, as it is unlikely
// the compiler will be able to optimize the spvArrayCopy() into a constant LUT.
// After a variable has been declared, we can no longer assign constant arrays in MSL unfortunately.
statement(to_expression(id_lhs), " = ", constant_expression(get<SPIRConstant>(id_rhs)), ";");
return true;
}
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
// Ensure the LHS variable has been declared
auto *p_v_lhs = maybe_get_backing_variable(id_lhs);
if (p_v_lhs)
flush_variable_declaration(p_v_lhs->self);
MSL: Deal with loading non-value-type arrays.
2020-06-18 10:46:39 +00:00
emit_array_copy(to_expression(id_lhs), id_rhs, get_expression_effective_storage_class(id_lhs),
get_expression_effective_storage_class(id_rhs));
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
register_write(id_lhs);
return true;
Fix issue #245: assignment of flattened input struct. Emit input struct assignment by assigning member by member from stage_in struct. Map qualified member name from pointer type, not base type. Add Comiler::expression_type_id() function, similar to expression_type().
2017-08-12 04:21:13 +00:00
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
// Emits one of the atomic functions. In MSL, the atomic functions operate on pointers
void CompilerMSL::emit_atomic_func_op(uint32_t result_type, uint32_t result_id, const char *op, uint32_t mem_order_1,
uint32_t mem_order_2, bool has_mem_order_2, uint32_t obj, uint32_t op1,
Clarify name of this parameter.
2018-09-13 13:56:23 +00:00
bool op1_is_pointer, bool op1_is_literal, uint32_t op2)
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
{
string exp = string(op) + "(";
Rename get_non_pointer_type() methods. This better reflects their purpose now.
2019-01-08 18:54:40 +00:00
auto &type = get_pointee_type(expression_type(obj));
MSL: Handle coherent, volatile, and restrict. This maps them to their MSL equivalents. I've mapped `Coherent` to `volatile` since MSL doesn't have anything weaker than `volatile` but stronger than nothing. As part of this, I had to remove the implicit `volatile` added for atomic operation casts. If the buffer is already `coherent` or `volatile`, then we would add a second `volatile`, which would be redundant. I think this is OK even when the buffer *doesn't* have `coherent`: `T *` is implicitly convertible to `volatile T *`, but not vice-versa. It seems to compile OK at any rate. (Note that the non-`volatile` overloads of the atomic functions documented in the spec aren't present in the MSL 2.2 stdlib headers.) `restrict` is tricky, because in MSL, as in C++, it needs to go *after* the asterisk or ampersand for the pointer type it's modifying. Another issue is that, in the `Simple`, `GLSL450`, and `Vulkan` memory models, `Restrict` is the default (i.e. does not need to be specified); but MSL likely follows the `OpenCL` model where `Aliased` is the default. We probably need to implicitly set either `Restrict` or `Aliased` depending on the module's declared memory model.
2019-07-10 16:17:40 +00:00
exp += "(";
Fix atomic_compare_exchange_weak_explicit. Need to emit a CAS loop. Fix shared memory declaration. Declare atomic ops with correct memory scope.
2018-05-15 14:03:20 +00:00
auto *var = maybe_get_backing_variable(obj);
if (!var)
SPIRV_CROSS_THROW("No backing variable for atomic operation.");
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Emulate texture2D atomic operations
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
const auto &res_type = get<SPIRType>(var->basetype);
if (res_type.storage == StorageClassUniformConstant && res_type.basetype == SPIRType::Image)
{
exp += "device";
}
else
{
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
exp += get_argument_address_space(*var);
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
}
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
exp += " atomic_";
exp += type_to_glsl(type);
exp += "*)";
Fix atomic_compare_exchange_weak_explicit. Need to emit a CAS loop. Fix shared memory declaration. Declare atomic ops with correct memory scope.
2018-05-15 14:03:20 +00:00
exp += "&";
exp += to_enclosed_expression(obj);
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
Fix atomic_compare_exchange_weak_explicit. Need to emit a CAS loop. Fix shared memory declaration. Declare atomic ops with correct memory scope.
2018-05-15 14:03:20 +00:00
bool is_atomic_compare_exchange_strong = op1_is_pointer && op1;
if (is_atomic_compare_exchange_strong)
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
{
Fix atomic_compare_exchange_weak_explicit. Need to emit a CAS loop. Fix shared memory declaration. Declare atomic ops with correct memory scope.
2018-05-15 14:03:20 +00:00
assert(strcmp(op, "atomic_compare_exchange_weak_explicit") == 0);
assert(op2);
assert(has_mem_order_2);
exp += ", &";
exp += to_name(result_id);
exp += ", ";
exp += to_expression(op2);
exp += ", ";
exp += get_memory_order(mem_order_1);
exp += ", ";
exp += get_memory_order(mem_order_2);
exp += ")";
MSL: Fix infinite CAS loop on atomic_compare_exchange_weak_explicit().
2019-04-06 01:28:57 +00:00
// MSL only supports the weak atomic compare exchange, so emit a CAS loop here.
// The MSL function returns false if the atomic write fails OR the comparison test fails,
// so we must validate that it wasn't the comparison test that failed before continuing
// the CAS loop, otherwise it will loop infinitely, with the comparison test always failing.
// The function updates the comparitor value from the memory value, so the additional
// comparison test evaluates the memory value against the expected value.
MSL: Cleanup temporary use with emit_uninitialized_temporary.
2019-07-26 09:16:43 +00:00
emit_uninitialized_temporary_expression(result_type, result_id);
Fix atomic_compare_exchange_weak_explicit. Need to emit a CAS loop. Fix shared memory declaration. Declare atomic ops with correct memory scope.
2018-05-15 14:03:20 +00:00
statement("do");
begin_scope();
statement(to_name(result_id), " = ", to_expression(op1), ";");
MSL: Fix infinite CAS loop on atomic_compare_exchange_weak_explicit().
2019-04-06 01:28:57 +00:00
end_scope_decl(join("while (!", exp, " && ", to_name(result_id), " == ", to_enclosed_expression(op1), ")"));
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
}
Fix atomic_compare_exchange_weak_explicit. Need to emit a CAS loop. Fix shared memory declaration. Declare atomic ops with correct memory scope.
2018-05-15 14:03:20 +00:00
else
{
assert(strcmp(op, "atomic_compare_exchange_weak_explicit") != 0);
if (op1)
MSL: Fix OpAtomicIIncrement and OpAtomicIDecrement. We were passing a constant '1' to `emit_atomic_func_op()`--which caused us to refer to SPIR-V value `%1`, which is almost certainly not what we want! What we really want is to add/subtract the literal constant '1' to/from the memory location.
2018-09-10 19:47:35 +00:00
{
Clarify name of this parameter.
2018-09-13 13:56:23 +00:00
if (op1_is_literal)
MSL: Fix OpAtomicIIncrement and OpAtomicIDecrement. We were passing a constant '1' to `emit_atomic_func_op()`--which caused us to refer to SPIR-V value `%1`, which is almost certainly not what we want! What we really want is to add/subtract the literal constant '1' to/from the memory location.
2018-09-10 19:47:35 +00:00
exp += join(", ", op1);
else
exp += ", " + to_expression(op1);
}
Fix atomic_compare_exchange_weak_explicit. Need to emit a CAS loop. Fix shared memory declaration. Declare atomic ops with correct memory scope.
2018-05-15 14:03:20 +00:00
if (op2)
exp += ", " + to_expression(op2);
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
Fix atomic_compare_exchange_weak_explicit. Need to emit a CAS loop. Fix shared memory declaration. Declare atomic ops with correct memory scope.
2018-05-15 14:03:20 +00:00
exp += string(", ") + get_memory_order(mem_order_1);
if (has_mem_order_2)
exp += string(", ") + get_memory_order(mem_order_2);
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
Fix atomic_compare_exchange_weak_explicit. Need to emit a CAS loop. Fix shared memory declaration. Declare atomic ops with correct memory scope.
2018-05-15 14:03:20 +00:00
exp += ")";
Implement OpAtomicLoad/OpAtomicStore. Need some emulation on GLSL/HLSL, fix bug with atomic store on MSL.
2020-04-27 10:09:59 +00:00
if (strcmp(op, "atomic_store_explicit") != 0)
emit_op(result_type, result_id, exp, false);
else
statement(exp, ";");
Fix atomic_compare_exchange_weak_explicit. Need to emit a CAS loop. Fix shared memory declaration. Declare atomic ops with correct memory scope.
2018-05-15 14:03:20 +00:00
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
flush_all_atomic_capable_variables();
}
// Metal only supports relaxed memory order for now
const char *CompilerMSL::get_memory_order(uint32_t)
{
return "memory_order_relaxed";
}
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
// Override for MSL-specific extension syntax instructions
void CompilerMSL::emit_glsl_op(uint32_t result_type, uint32_t id, uint32_t eop, const uint32_t *args, uint32_t count)
{
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
auto op = static_cast<GLSLstd450>(eop);
// If we need to do implicit bitcasts, make sure we do it with the correct type.
uint32_t integer_width = get_integer_width_for_glsl_instruction(op, args, count);
auto int_type = to_signed_basetype(integer_width);
auto uint_type = to_unsigned_basetype(integer_width);
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
switch (op)
{
case GLSLstd450Atan2:
emit_binary_func_op(result_type, id, args[0], args[1], "atan2");
break;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case GLSLstd450InverseSqrt:
emit_unary_func_op(result_type, id, args[0], "rsqrt");
break;
case GLSLstd450RoundEven:
emit_unary_func_op(result_type, id, args[0], "rint");
break;
Deal correctly with return sign of bitscan operations.
2019-07-12 08:57:56 +00:00
case GLSLstd450FindILsb:
{
// In this template version of findLSB, we return T.
auto basetype = expression_type(args[0]).basetype;
emit_unary_func_op_cast(result_type, id, args[0], "spvFindLSB", basetype, basetype);
break;
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case GLSLstd450FindSMsb:
Deal correctly with return sign of bitscan operations.
2019-07-12 08:57:56 +00:00
emit_unary_func_op_cast(result_type, id, args[0], "spvFindSMSB", int_type, int_type);
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
break;
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case GLSLstd450FindUMsb:
Deal correctly with return sign of bitscan operations.
2019-07-12 08:57:56 +00:00
emit_unary_func_op_cast(result_type, id, args[0], "spvFindUMSB", uint_type, uint_type);
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
break;
case GLSLstd450PackSnorm4x8:
emit_unary_func_op(result_type, id, args[0], "pack_float_to_snorm4x8");
break;
case GLSLstd450PackUnorm4x8:
emit_unary_func_op(result_type, id, args[0], "pack_float_to_unorm4x8");
break;
case GLSLstd450PackSnorm2x16:
emit_unary_func_op(result_type, id, args[0], "pack_float_to_snorm2x16");
break;
case GLSLstd450PackUnorm2x16:
emit_unary_func_op(result_type, id, args[0], "pack_float_to_unorm2x16");
break;
Implement packHalf2x16/unpackHalf2x16 on MSL.
2018-03-12 16:51:14 +00:00
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case GLSLstd450PackHalf2x16:
Implement packHalf2x16/unpackHalf2x16 on MSL.
2018-03-12 16:51:14 +00:00
{
auto expr = join("as_type<uint>(half2(", to_expression(args[0]), "))");
emit_op(result_type, id, expr, should_forward(args[0]));
inherit_expression_dependencies(id, args[0]);
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
break;
Implement packHalf2x16/unpackHalf2x16 on MSL.
2018-03-12 16:51:14 +00:00
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case GLSLstd450UnpackSnorm4x8:
emit_unary_func_op(result_type, id, args[0], "unpack_snorm4x8_to_float");
break;
case GLSLstd450UnpackUnorm4x8:
emit_unary_func_op(result_type, id, args[0], "unpack_unorm4x8_to_float");
break;
case GLSLstd450UnpackSnorm2x16:
emit_unary_func_op(result_type, id, args[0], "unpack_snorm2x16_to_float");
break;
case GLSLstd450UnpackUnorm2x16:
emit_unary_func_op(result_type, id, args[0], "unpack_unorm2x16_to_float");
break;
Implement packHalf2x16/unpackHalf2x16 on MSL.
2018-03-12 16:51:14 +00:00
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case GLSLstd450UnpackHalf2x16:
Implement packHalf2x16/unpackHalf2x16 on MSL.
2018-03-12 16:51:14 +00:00
{
auto expr = join("float2(as_type<half2>(", to_expression(args[0]), "))");
emit_op(result_type, id, expr, should_forward(args[0]));
inherit_expression_dependencies(id, args[0]);
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
break;
Implement packHalf2x16/unpackHalf2x16 on MSL.
2018-03-12 16:51:14 +00:00
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case GLSLstd450PackDouble2x32:
emit_unary_func_op(result_type, id, args[0], "unsupported_GLSLstd450PackDouble2x32"); // Currently unsupported
break;
case GLSLstd450UnpackDouble2x32:
emit_unary_func_op(result_type, id, args[0], "unsupported_GLSLstd450UnpackDouble2x32"); // Currently unsupported
break;
case GLSLstd450MatrixInverse:
{
auto &mat_type = get<SPIRType>(result_type);
switch (mat_type.columns)
{
case 2:
emit_unary_func_op(result_type, id, args[0], "spvInverse2x2");
break;
case 3:
emit_unary_func_op(result_type, id, args[0], "spvInverse3x3");
break;
case 4:
emit_unary_func_op(result_type, id, args[0], "spvInverse4x4");
break;
default:
break;
}
break;
}
MSL: Emit F{Min,Max,Clamp} as fast:: and N{Min,Max,Clamp} as precise::. This roughly matches their semantics in SPIR-V and MSL. For `FMin`, `FMax`, and `FClamp`, and the Metal functions `fast::min()`, `fast::max()`, and `fast::clamp()`, the result is undefined if any operand is NaN. For the 'N' operations and their corresponding MSL `precise::` functions, the result is consistent with IEEE 754 (first non-NaN wins; result is NaN if all operands are NaN). We can only do this with 32-bit floats, though, because Metal only provides these variants for `float`. `half` only has one variant of these functions that is presumably consistent with IEEE 754. I guess that's OK; the SPIR-V spec only says that `F{Min,Max,Clamp}` are undefined for NaNs. Performance might suffer, though.
2018-08-31 23:15:07 +00:00
case GLSLstd450FMin:
// If the result type isn't float, don't bother calling the specific
// precise::/fast:: version. Metal doesn't have those for half and
// double types.
if (get<SPIRType>(result_type).basetype != SPIRType::Float)
emit_binary_func_op(result_type, id, args[0], args[1], "min");
else
emit_binary_func_op(result_type, id, args[0], args[1], "fast::min");
break;
case GLSLstd450FMax:
if (get<SPIRType>(result_type).basetype != SPIRType::Float)
emit_binary_func_op(result_type, id, args[0], args[1], "max");
else
emit_binary_func_op(result_type, id, args[0], args[1], "fast::max");
break;
case GLSLstd450FClamp:
// TODO: If args[1] is 0 and args[2] is 1, emit a saturate() call.
if (get<SPIRType>(result_type).basetype != SPIRType::Float)
emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "clamp");
else
emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "fast::clamp");
break;
case GLSLstd450NMin:
if (get<SPIRType>(result_type).basetype != SPIRType::Float)
emit_binary_func_op(result_type, id, args[0], args[1], "min");
else
emit_binary_func_op(result_type, id, args[0], args[1], "precise::min");
break;
case GLSLstd450NMax:
if (get<SPIRType>(result_type).basetype != SPIRType::Float)
emit_binary_func_op(result_type, id, args[0], args[1], "max");
else
emit_binary_func_op(result_type, id, args[0], args[1], "precise::max");
break;
case GLSLstd450NClamp:
// TODO: If args[1] is 0 and args[2] is 1, emit a saturate() call.
if (get<SPIRType>(result_type).basetype != SPIRType::Float)
emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "clamp");
else
emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "precise::clamp");
break;
Fixups for PR #353.
2017-12-05 08:58:12 +00:00
// TODO:
// GLSLstd450InterpolateAtCentroid (centroid_no_perspective qualifier)
// GLSLstd450InterpolateAtSample (sample_no_perspective qualifier)
// GLSLstd450InterpolateAtOffset
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
Deal with scalar input values for distance/length/normalize. HLSL and MSL don't support it, so fall back to simpler intrinsics.
2019-06-28 09:19:19 +00:00
case GLSLstd450Distance:
// MSL does not support scalar versions here.
if (expression_type(args[0]).vecsize == 1)
{
// Equivalent to length(a - b) -> abs(a - b).
emit_op(result_type, id,
Fix #1445: MSL: Enclose args when convert distance(a,b) to abs(a-b)
2020-08-13 08:57:13 +00:00
join("abs(", to_enclosed_unpacked_expression(args[0]), " - ",
to_enclosed_unpacked_expression(args[1]), ")"),
Deal with scalar input values for distance/length/normalize. HLSL and MSL don't support it, so fall back to simpler intrinsics.
2019-06-28 09:19:19 +00:00
should_forward(args[0]) && should_forward(args[1]));
inherit_expression_dependencies(id, args[0]);
inherit_expression_dependencies(id, args[1]);
}
else
CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count);
break;
case GLSLstd450Length:
// MSL does not support scalar versions here.
if (expression_type(args[0]).vecsize == 1)
{
// Equivalent to abs().
emit_unary_func_op(result_type, id, args[0], "abs");
}
else
CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count);
break;
case GLSLstd450Normalize:
// MSL does not support scalar versions here.
if (expression_type(args[0]).vecsize == 1)
{
// Returns -1 or 1 for valid input, sign() does the job.
emit_unary_func_op(result_type, id, args[0], "sign");
}
else
CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count);
break;
MSL/HLSL: Support scalar reflect and refract.
2019-07-03 10:24:58 +00:00
case GLSLstd450Reflect:
if (get<SPIRType>(result_type).vecsize == 1)
emit_binary_func_op(result_type, id, args[0], args[1], "spvReflect");
else
CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count);
break;
case GLSLstd450Refract:
if (get<SPIRType>(result_type).vecsize == 1)
emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "spvRefract");
else
CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count);
break;
Test glsl.std450 more exhaustively. Make sure to test everything with scalar as well to catch any weird edge cases. Not all opcodes are covered here, just the arithmetic ones. FP64 packing is also ignored.
2019-07-17 09:24:31 +00:00
case GLSLstd450FaceForward:
if (get<SPIRType>(result_type).vecsize == 1)
emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "spvFaceForward");
else
CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count);
break;
MSL: Deal with Modf/Frexp where output is access chain to scalar. This is not allowed as we cannot take mutable reference to a vec.{x,y,z,w}. We only care about scalar since entire vectors are fine.
2019-07-26 09:02:38 +00:00
case GLSLstd450Modf:
case GLSLstd450Frexp:
{
// Special case. If the variable is a scalar access chain, we cannot use it directly. We have to emit a temporary.
auto *ptr = maybe_get<SPIRExpression>(args[1]);
if (ptr && ptr->access_chain && is_scalar(expression_type(args[1])))
{
register_call_out_argument(args[1]);
forced_temporaries.insert(id);
// Need to create temporaries and copy over to access chain after.
// We cannot directly take the reference of a vector swizzle in MSL, even if it's scalar ...
uint32_t &tmp_id = extra_sub_expressions[id];
if (!tmp_id)
tmp_id = ir.increase_bound_by(1);
uint32_t tmp_type_id = get_pointee_type_id(ptr->expression_type);
emit_uninitialized_temporary_expression(tmp_type_id, tmp_id);
emit_binary_func_op(result_type, id, args[0], tmp_id, eop == GLSLstd450Modf ? "modf" : "frexp");
statement(to_expression(args[1]), " = ", to_expression(tmp_id), ";");
}
else
CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count);
break;
}
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
default:
CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count);
break;
}
}
MSL: Support the SPV_AMD_shader_trinary_minmax extension. This requires MSL 2.1.
2019-07-11 16:49:34 +00:00
void CompilerMSL::emit_spv_amd_shader_trinary_minmax_op(uint32_t result_type, uint32_t id, uint32_t eop,
const uint32_t *args, uint32_t count)
{
enum AMDShaderTrinaryMinMax
{
FMin3AMD = 1,
UMin3AMD = 2,
SMin3AMD = 3,
FMax3AMD = 4,
UMax3AMD = 5,
SMax3AMD = 6,
FMid3AMD = 7,
UMid3AMD = 8,
SMid3AMD = 9
};
if (!msl_options.supports_msl_version(2, 1))
SPIRV_CROSS_THROW("Trinary min/max functions require MSL 2.1.");
auto op = static_cast<AMDShaderTrinaryMinMax>(eop);
switch (op)
{
case FMid3AMD:
case UMid3AMD:
case SMid3AMD:
emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "median3");
break;
default:
CompilerGLSL::emit_spv_amd_shader_trinary_minmax_op(result_type, id, eop, args, count);
break;
}
}
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
// Emit a structure declaration for the specified interface variable.
void CompilerMSL::emit_interface_block(uint32_t ib_var_id)
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (ib_var_id)
{
auto &ib_var = get<SPIRVariable>(ib_var_id);
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
auto &ib_type = get_variable_data_type(ib_var);
MSL: Support global I/O block and struct Input/Output usage. Implement this by flattening outputs and unflattening inputs explicitly. This allows us to pass down a single struct instead of dealing with the insanity that would be passing down each flattened member separately. Remove stage_uniforms_var_id. Seems to be dead code. Naked uniforms do not exist in SPIR-V for Vulkan, which this seems to have been intended for. It was also unused elsewhere.
2018-09-13 12:42:05 +00:00
assert(ib_type.basetype == SPIRType::Struct && !ib_type.member_types.empty());
emit_struct(ib_type);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
// Emits the declaration signature of the specified function.
// If this is the entry point function, Metal-specific return value and function arguments are added.
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
void CompilerMSL::emit_function_prototype(SPIRFunction &func, const Bitset &)
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
{
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
if (func.self != ir.default_entry_point)
Handle overloaded functions which share the same OpName. Awkward, but legal SPIR-V.
2018-02-23 13:13:46 +00:00
add_function_overload(func);
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
local_variable_names = resource_names;
In order to use Metal shader libraries properly you have to ensure that you have no duplicated global symbol names for different entities, otherwise 'metallib' won't be able to combine multiple shaders into a single library. This is broken into two parts. 1. Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries. 2. Metal helper functions must be static force-inline otherwise they will cause problems when linked together in a single Metallib.
2019-08-13 22:20:02 +00:00
string decl;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
processing_entry_point = func.self == ir.default_entry_point;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Metal helper functions must be static force-inline otherwise they will cause problems when linked together in a single Metallib.
In order to use Metal shader libraries properly you have to ensure that you have no duplicated global symbol names for different entities, otherwise 'metallib' won't be able to combine multiple shaders into a single library. This is broken into two parts. 1. Constant arrays of non-primitive types (i.e. matrices) won't link properly into Metal libraries. 2. Metal helper functions must be static force-inline otherwise they will cause problems when linked together in a single Metallib.
2019-08-13 22:20:02 +00:00
if (!processing_entry_point)
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
statement(force_inline);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto &type = get<SPIRType>(func.return_type);
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
MSL: Reinstate workaround for returning arrays.
2020-02-24 12:04:10 +00:00
if (!type.array.empty() && msl_options.force_native_arrays)
{
// We cannot return native arrays in MSL, so "return" through an out variable.
decl += "void";
}
else
{
decl += func_type_decl(type);
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
decl += " ";
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
decl += to_name(func.self);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
decl += "(";
MSL: Reinstate workaround for returning arrays.
2020-02-24 12:04:10 +00:00
if (!type.array.empty() && msl_options.force_native_arrays)
{
// Fake arrays returns by writing to an out array instead.
decl += "thread ";
decl += type_to_glsl(type);
decl += " (&SPIRV_Cross_return_value)";
decl += type_to_array_glsl(type);
if (!func.arguments.empty())
decl += ", ";
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (processing_entry_point)
{
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
if (msl_options.argument_buffers)
decl += entry_point_args_argument_buffer(!func.arguments.empty());
else
decl += entry_point_args_classic(!func.arguments.empty());
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
CompilerMSL support matrices & arrays in stage-in & stage-out. Support flattening StorageOutput & StorageInput matrices and arrays. No longer move matrix & array inputs to separate buffer. Add separate SPIRFunction::fixup_statements_in & SPIRFunction::fixup_statements_out instead of just SPIRFunction::fixup_statements. Emit SPIRFunction::fixup_statements at beginning of functions. CompilerMSL track vars_needing_early_declaration. Pass global output variables as variables to functions that access them. Sort input structs by location, same as output structs. Emit struct declarations in order output, input, uniforms. Regenerate reference shaders to new formats defined by above.
2018-06-12 15:41:35 +00:00
// If entry point function has variables that require early declaration,
// ensure they each have an empty initializer, creating one if needed.
// This is done at this late stage because the initialization expression
// is cleared after each compilation pass.
for (auto var_id : vars_needing_early_declaration)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
CompilerMSL support matrices & arrays in stage-in & stage-out. Support flattening StorageOutput & StorageInput matrices and arrays. No longer move matrix & array inputs to separate buffer. Add separate SPIRFunction::fixup_statements_in & SPIRFunction::fixup_statements_out instead of just SPIRFunction::fixup_statements. Emit SPIRFunction::fixup_statements at beginning of functions. CompilerMSL track vars_needing_early_declaration. Pass global output variables as variables to functions that access them. Sort input structs by location, same as output structs. Emit struct declarations in order output, input, uniforms. Regenerate reference shaders to new formats defined by above.
2018-06-12 15:41:35 +00:00
auto &ed_var = get<SPIRVariable>(var_id);
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
ID &initializer = ed_var.initializer;
Support initializers on StorageClassOutput.
2019-01-30 09:29:08 +00:00
if (!initializer)
initializer = ir.increase_bound_by(1);
CompilerMSL support matrices & arrays in stage-in & stage-out. Support flattening StorageOutput & StorageInput matrices and arrays. No longer move matrix & array inputs to separate buffer. Add separate SPIRFunction::fixup_statements_in & SPIRFunction::fixup_statements_out instead of just SPIRFunction::fixup_statements. Emit SPIRFunction::fixup_statements at beginning of functions. CompilerMSL track vars_needing_early_declaration. Pass global output variables as variables to functions that access them. Sort input structs by location, same as output structs. Emit struct declarations in order output, input, uniforms. Regenerate reference shaders to new formats defined by above.
2018-06-12 15:41:35 +00:00
Support initializers on StorageClassOutput.
2019-01-30 09:29:08 +00:00
// Do not override proper initializers.
if (ir.ids[initializer].get_type() == TypeNone || ir.ids[initializer].get_type() == TypeExpression)
set<SPIRExpression>(ed_var.initializer, "{}", ed_var.basetype, true);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
}
for (auto &arg : func.arguments)
{
MSL: Fix naming issue of aliased global variables. When the name of an alias global variable collides with a global declaration, MSL would emit inconsistent names, sometimes with the naming fix, sometimes without, because names were being tracked in two separate meta blocks. Fix this by always redirecting parameter naming to the original base variable as necessary.
2018-08-27 07:59:55 +00:00
uint32_t name_id = arg.id;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto *var = maybe_get<SPIRVariable>(arg.id);
Run clang-format.
2016-10-24 13:24:24 +00:00
if (var)
{
MSL: Fix naming issue of aliased global variables. When the name of an alias global variable collides with a global declaration, MSL would emit inconsistent names, sometimes with the naming fix, sometimes without, because names were being tracked in two separate meta blocks. Fix this by always redirecting parameter naming to the original base variable as necessary.
2018-08-27 07:59:55 +00:00
// If we need to modify the name of the variable, make sure we modify the original variable.
// Our alias is just a shadow variable.
if (arg.alias_global_variable && var->basevariable)
name_id = var->basevariable;
Run clang-format.
2016-10-24 13:24:24 +00:00
var->parameter = &arg; // Hold a pointer to the parameter so we can invalidate the readonly field if needed.
}
For MSL, extract global var refs from within functions and convert them to function args.
2016-07-06 20:55:45 +00:00
MSL: Fix naming issue of aliased global variables. When the name of an alias global variable collides with a global declaration, MSL would emit inconsistent names, sometimes with the naming fix, sometimes without, because names were being tracked in two separate meta blocks. Fix this by always redirecting parameter naming to the original base variable as necessary.
2018-08-27 07:59:55 +00:00
add_local_variable_name(name_id);
Run clang-format.
2016-10-24 13:24:24 +00:00
decl += argument_decl(arg);
MSL support textures and samplers as function args. Add automatic sampler func arg when passing SampledImage type. Pass texture and sampler in thread address space.
2016-07-07 00:30:47 +00:00
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
bool is_dynamic_img_sampler = has_extended_decoration(arg.id, SPIRVCrossDecorationDynamicImageSampler);
Run clang-format.
2016-10-24 13:24:24 +00:00
auto &arg_type = get<SPIRType>(arg.type);
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
if (arg_type.basetype == SPIRType::SampledImage && !is_dynamic_img_sampler)
{
// Manufacture automatic plane args for multiplanar texture
uint32_t planes = 1;
if (auto *constexpr_sampler = find_constexpr_sampler(name_id))
if (constexpr_sampler->ycbcr_conversion_enable)
planes = constexpr_sampler->planes;
for (uint32_t i = 1; i < planes; i++)
decl += join(", ", argument_decl(arg), plane_name_suffix, i);
// Manufacture automatic sampler arg for SampledImage texture
if (arg_type.image.dim != DimBuffer)
decl += join(", thread const ", sampler_type(arg_type), " ", to_sampler_expression(arg.id));
}
MSL support textures and samplers as function args. Add automatic sampler func arg when passing SampledImage type. Pass texture and sampler in thread address space.
2016-07-07 00:30:47 +00:00
MSL: Fix passing a sampled image to a function. In the past, SPIRV-Cross threw an error in this case because it couldn't work out which swizzle from the auxiliary buffer needs to be passed. Now, we pass the swizzle around with the texture object, like a combined image-sampler and its associated sampler.
2019-01-13 23:31:50 +00:00
// Manufacture automatic swizzle arg.
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
if (msl_options.swizzle_texture_samples && has_sampled_images && is_sampled_image_type(arg_type) &&
!is_dynamic_img_sampler)
MSL: Deal with texture swizzle on arrays of images.
2019-05-09 09:25:45 +00:00
{
Fix GCC 4.x warning.
2019-05-09 10:28:34 +00:00
bool arg_is_array = !arg_type.array.empty();
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
decl += join(", constant uint", arg_is_array ? "* " : "& ", to_swizzle_expression(arg.id));
}
if (buffers_requiring_array_length.count(name_id))
{
bool arg_is_array = !arg_type.array.empty();
decl += join(", constant uint", arg_is_array ? "* " : "& ", to_buffer_size_expression(name_id));
MSL: Deal with texture swizzle on arrays of images.
2019-05-09 09:25:45 +00:00
}
MSL: Fix passing a sampled image to a function. In the past, SPIRV-Cross threw an error in this case because it couldn't work out which swizzle from the auxiliary buffer needs to be passed. Now, we pass the swizzle around with the texture object, like a combined image-sampler and its associated sampler.
2019-01-13 23:31:50 +00:00
Run clang-format.
2016-10-24 13:24:24 +00:00
if (&arg != &func.arguments.back())
decl += ", ";
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
decl += ")";
Run style formatter.
2017-01-20 16:33:59 +00:00
statement(decl);
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
static bool needs_chroma_reconstruction(const MSLConstexprSampler *constexpr_sampler)
{
// For now, only multiplanar images need explicit reconstruction. GBGR and BGRG images
// use implicit reconstruction.
return constexpr_sampler && constexpr_sampler->ycbcr_conversion_enable && constexpr_sampler->planes > 1;
}
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
// Returns the texture sampling function string for the specified image and sampling characteristics.
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
string CompilerMSL::to_function_name(const TextureFunctionNameArguments &args)
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
{
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
VariableID img = args.base.img;
auto &imgtype = *args.base.imgtype;
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
const MSLConstexprSampler *constexpr_sampler = nullptr;
bool is_dynamic_img_sampler = false;
if (auto *var = maybe_get_backing_variable(img))
{
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
constexpr_sampler = find_constexpr_sampler(var->basevariable ? var->basevariable : VariableID(var->self));
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
is_dynamic_img_sampler = has_extended_decoration(var->self, SPIRVCrossDecorationDynamicImageSampler);
}
MSL: Add an option to insert texture swizzles into generated shaders. It's intended to be used with MoltenVK to support arbitrary `VkComponentMapping` settings. The idea is that MoltenVK will pass a buffer (which it set to some buffer index that isn't being used) containing packed versions of the `VkComponentMapping` struct, one for each sampled image. Yes, this is horribly ugly. It is unfortunately necessary. Much of the ugliness is to support swizzling gather operations, where we need to alter the component that the gather operates on--something complicated by the `gather()` method requiring the passed-in component to be a constant expression. It doesn't even support swizzling gathers on depth textures, though I could add that if it turns out we need it.
2018-09-20 01:36:33 +00:00
// Special-case gather. We have to alter the component being looked up
// in the swizzle case.
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (msl_options.swizzle_texture_samples && args.base.is_gather && !is_dynamic_img_sampler &&
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
(!constexpr_sampler || !constexpr_sampler->ycbcr_conversion_enable))
MSL: Add an option to insert texture swizzles into generated shaders. It's intended to be used with MoltenVK to support arbitrary `VkComponentMapping` settings. The idea is that MoltenVK will pass a buffer (which it set to some buffer index that isn't being used) containing packed versions of the `VkComponentMapping` struct, one for each sampled image. Yes, this is horribly ugly. It is unfortunately necessary. Much of the ugliness is to support swizzling gather operations, where we need to alter the component that the gather operates on--something complicated by the `gather()` method requiring the passed-in component to be a constant expression. It doesn't even support swizzling gathers on depth textures, though I could add that if it turns out we need it.
2018-09-20 01:36:33 +00:00
{
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
add_spv_func_and_recompile(imgtype.image.depth ? SPVFuncImplGatherCompareSwizzle : SPVFuncImplGatherSwizzle);
return imgtype.image.depth ? "spvGatherCompareSwizzle" : "spvGatherSwizzle";
MSL: Add an option to insert texture swizzles into generated shaders. It's intended to be used with MoltenVK to support arbitrary `VkComponentMapping` settings. The idea is that MoltenVK will pass a buffer (which it set to some buffer index that isn't being used) containing packed versions of the `VkComponentMapping` struct, one for each sampled image. Yes, this is horribly ugly. It is unfortunately necessary. Much of the ugliness is to support swizzling gather operations, where we need to alter the component that the gather operates on--something complicated by the `gather()` method requiring the passed-in component to be a constant expression. It doesn't even support swizzling gathers on depth textures, though I could add that if it turns out we need it.
2018-09-20 01:36:33 +00:00
}
Refactor MSL to use SPIRCombinedImageSampler. Avoids special "meta" data to express this type. Makes MSL implementation in line with HLSL.
2018-10-05 07:49:57 +00:00
auto *combined = maybe_get<SPIRCombinedImageSampler>(img);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Texture reference
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
string fname;
if (needs_chroma_reconstruction(constexpr_sampler) && !is_dynamic_img_sampler)
{
if (constexpr_sampler->planes != 2 && constexpr_sampler->planes != 3)
SPIRV_CROSS_THROW("Unhandled number of color image planes!");
// 444 images aren't downsampled, so we don't need to do linear filtering.
if (constexpr_sampler->resolution == MSL_FORMAT_RESOLUTION_444 ||
constexpr_sampler->chroma_filter == MSL_SAMPLER_FILTER_NEAREST)
{
if (constexpr_sampler->planes == 2)
add_spv_func_and_recompile(SPVFuncImplChromaReconstructNearest2Plane);
else
add_spv_func_and_recompile(SPVFuncImplChromaReconstructNearest3Plane);
fname = "spvChromaReconstructNearest";
}
else // Linear with a downsampled format
{
fname = "spvChromaReconstructLinear";
switch (constexpr_sampler->resolution)
{
case MSL_FORMAT_RESOLUTION_444:
assert(false);
break; // not reached
case MSL_FORMAT_RESOLUTION_422:
switch (constexpr_sampler->x_chroma_offset)
{
case MSL_CHROMA_LOCATION_COSITED_EVEN:
if (constexpr_sampler->planes == 2)
add_spv_func_and_recompile(SPVFuncImplChromaReconstructLinear422CositedEven2Plane);
else
add_spv_func_and_recompile(SPVFuncImplChromaReconstructLinear422CositedEven3Plane);
fname += "422CositedEven";
break;
case MSL_CHROMA_LOCATION_MIDPOINT:
if (constexpr_sampler->planes == 2)
add_spv_func_and_recompile(SPVFuncImplChromaReconstructLinear422Midpoint2Plane);
else
add_spv_func_and_recompile(SPVFuncImplChromaReconstructLinear422Midpoint3Plane);
fname += "422Midpoint";
break;
default:
SPIRV_CROSS_THROW("Invalid chroma location.");
}
break;
case MSL_FORMAT_RESOLUTION_420:
fname += "420";
switch (constexpr_sampler->x_chroma_offset)
{
case MSL_CHROMA_LOCATION_COSITED_EVEN:
switch (constexpr_sampler->y_chroma_offset)
{
case MSL_CHROMA_LOCATION_COSITED_EVEN:
if (constexpr_sampler->planes == 2)
add_spv_func_and_recompile(
SPVFuncImplChromaReconstructLinear420XCositedEvenYCositedEven2Plane);
else
add_spv_func_and_recompile(
SPVFuncImplChromaReconstructLinear420XCositedEvenYCositedEven3Plane);
fname += "XCositedEvenYCositedEven";
break;
case MSL_CHROMA_LOCATION_MIDPOINT:
if (constexpr_sampler->planes == 2)
add_spv_func_and_recompile(
SPVFuncImplChromaReconstructLinear420XCositedEvenYMidpoint2Plane);
else
add_spv_func_and_recompile(
SPVFuncImplChromaReconstructLinear420XCositedEvenYMidpoint3Plane);
fname += "XCositedEvenYMidpoint";
break;
default:
SPIRV_CROSS_THROW("Invalid Y chroma location.");
}
break;
case MSL_CHROMA_LOCATION_MIDPOINT:
switch (constexpr_sampler->y_chroma_offset)
{
case MSL_CHROMA_LOCATION_COSITED_EVEN:
if (constexpr_sampler->planes == 2)
add_spv_func_and_recompile(
SPVFuncImplChromaReconstructLinear420XMidpointYCositedEven2Plane);
else
add_spv_func_and_recompile(
SPVFuncImplChromaReconstructLinear420XMidpointYCositedEven3Plane);
fname += "XMidpointYCositedEven";
break;
case MSL_CHROMA_LOCATION_MIDPOINT:
if (constexpr_sampler->planes == 2)
add_spv_func_and_recompile(SPVFuncImplChromaReconstructLinear420XMidpointYMidpoint2Plane);
else
add_spv_func_and_recompile(SPVFuncImplChromaReconstructLinear420XMidpointYMidpoint3Plane);
fname += "XMidpointYMidpoint";
break;
default:
SPIRV_CROSS_THROW("Invalid Y chroma location.");
}
break;
default:
SPIRV_CROSS_THROW("Invalid X chroma location.");
}
break;
default:
SPIRV_CROSS_THROW("Invalid format resolution.");
}
}
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
{
fname = to_expression(combined ? combined->image : img) + ".";
// Texture function and sampler
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.base.is_fetch)
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
fname += "read";
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
else if (args.base.is_gather)
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
fname += "gather";
else
fname += "sample";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.has_dref)
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
fname += "_compare";
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
return fname;
}
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
string CompilerMSL::convert_to_f32(const string &expr, uint32_t components)
{
SPIRType t;
t.basetype = SPIRType::Float;
t.vecsize = components;
t.columns = 1;
return join(type_to_glsl_constructor(t), "(", expr, ")");
}
static inline bool sampling_type_needs_f32_conversion(const SPIRType &type)
{
// Double is not supported to begin with, but doesn't hurt to check for completion.
return type.basetype == SPIRType::Half || type.basetype == SPIRType::Double;
}
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
// Returns the function args for a texture sampling function for the specified image and sampling characteristics.
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
string CompilerMSL::to_function_args(const TextureFunctionArguments &args, bool *p_forward)
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
{
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
VariableID img = args.base.img;
auto &imgtype = *args.base.imgtype;
uint32_t lod = args.lod;
uint32_t grad_x = args.grad_x;
uint32_t grad_y = args.grad_y;
uint32_t bias = args.bias;
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
const MSLConstexprSampler *constexpr_sampler = nullptr;
bool is_dynamic_img_sampler = false;
if (auto *var = maybe_get_backing_variable(img))
{
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
constexpr_sampler = find_constexpr_sampler(var->basevariable ? var->basevariable : VariableID(var->self));
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
is_dynamic_img_sampler = has_extended_decoration(var->self, SPIRVCrossDecorationDynamicImageSampler);
}
CompilerMSL support OpImageFetch and Metal read() function. Don't emit automatic sampler when using texture read(). Convert tex coords to uintN() when using texture read(). Emit face when read()ing cube textures.
2017-01-20 22:30:36 +00:00
string farg_str;
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
bool forward = true;
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
if (!is_dynamic_img_sampler)
MSL: Add an option to insert texture swizzles into generated shaders. It's intended to be used with MoltenVK to support arbitrary `VkComponentMapping` settings. The idea is that MoltenVK will pass a buffer (which it set to some buffer index that isn't being used) containing packed versions of the `VkComponentMapping` struct, one for each sampled image. Yes, this is horribly ugly. It is unfortunately necessary. Much of the ugliness is to support swizzling gather operations, where we need to alter the component that the gather operates on--something complicated by the `gather()` method requiring the passed-in component to be a constant expression. It doesn't even support swizzling gathers on depth textures, though I could add that if it turns out we need it.
2018-09-20 01:36:33 +00:00
{
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
// Texture reference (for some cases)
if (needs_chroma_reconstruction(constexpr_sampler))
{
// Multiplanar images need two or three textures.
farg_str += to_expression(img);
for (uint32_t i = 1; i < constexpr_sampler->planes; i++)
farg_str += join(", ", to_expression(img), plane_name_suffix, i);
}
else if ((!constexpr_sampler || !constexpr_sampler->ycbcr_conversion_enable) &&
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
msl_options.swizzle_texture_samples && args.base.is_gather)
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
{
auto *combined = maybe_get<SPIRCombinedImageSampler>(img);
farg_str += to_expression(combined ? combined->image : img);
}
// Sampler reference
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (!args.base.is_fetch)
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
{
if (!farg_str.empty())
farg_str += ", ";
farg_str += to_sampler_expression(img);
}
if ((!constexpr_sampler || !constexpr_sampler->ycbcr_conversion_enable) &&
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
msl_options.swizzle_texture_samples && args.base.is_gather)
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
{
// Add the swizzle constant from the swizzle buffer.
farg_str += ", " + to_swizzle_expression(img);
used_swizzle_buffer = true;
}
Refactor MSL to use SPIRCombinedImageSampler. Avoids special "meta" data to express this type. Makes MSL implementation in line with HLSL.
2018-10-05 07:49:57 +00:00
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
// Swizzled gather puts the component before the other args, to allow template
// deduction to work.
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.component && msl_options.swizzle_texture_samples)
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
{
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
forward = should_forward(args.component);
farg_str += ", " + to_component_argument(args.component);
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
}
MSL: Add an option to insert texture swizzles into generated shaders. It's intended to be used with MoltenVK to support arbitrary `VkComponentMapping` settings. The idea is that MoltenVK will pass a buffer (which it set to some buffer index that isn't being used) containing packed versions of the `VkComponentMapping` struct, one for each sampled image. Yes, this is horribly ugly. It is unfortunately necessary. Much of the ugliness is to support swizzling gather operations, where we need to alter the component that the gather operates on--something complicated by the `gather()` method requiring the passed-in component to be a constant expression. It doesn't even support swizzling gathers on depth textures, though I could add that if it turns out we need it.
2018-09-20 01:36:33 +00:00
}
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
// Texture coordinates
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
forward = forward && should_forward(args.coord);
auto coord_expr = to_enclosed_expression(args.coord);
auto &coord_type = expression_type(args.coord);
Some compat fixes for MSL and Half.
2018-03-06 16:07:59 +00:00
bool coord_is_fp = type_is_floating_point(coord_type);
CompilerMSL round floating point tex coords for read() and tex array index.
2017-04-25 20:32:16 +00:00
bool is_cube_fetch = false;
CompilerMSL add support for texel buffers. Compiler MSL support DimBuffer as image dimension. CompilerMSL check texture coordinate result type dimension before adding swizzles. Update MSL reference shaders affected by this update.
2017-02-09 17:14:30 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
string tex_coords = coord_expr;
HLSL/MSL: Fix texture projection with Dref. We need to divide the Dref by q.
2019-01-28 08:39:45 +00:00
uint32_t alt_coord_component = 0;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
switch (imgtype.image.dim)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
CompilerMSL add support for texel buffers. Compiler MSL support DimBuffer as image dimension. CompilerMSL check texture coordinate result type dimension before adding swizzles. Update MSL reference shaders affected by this update.
2017-02-09 17:14:30 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case Dim1D:
CompilerMSL add support for texel buffers. Compiler MSL support DimBuffer as image dimension. CompilerMSL check texture coordinate result type dimension before adding swizzles. Update MSL reference shaders affected by this update.
2017-02-09 17:14:30 +00:00
if (coord_type.vecsize > 1)
HLSL/MSL: Fix texture projection with Dref. We need to divide the Dref by q.
2019-01-28 08:39:45 +00:00
tex_coords = enclose_expression(tex_coords) + ".x";
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.base.is_fetch)
CompilerMSL round floating point tex coords for read() and tex array index.
2017-04-25 20:32:16 +00:00
tex_coords = "uint(" + round_fp_tex_coords(tex_coords, coord_is_fp) + ")";
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
else if (sampling_type_needs_f32_conversion(coord_type))
tex_coords = convert_to_f32(tex_coords, 1);
CompilerMSL round floating point tex coords for read() and tex array index.
2017-04-25 20:32:16 +00:00
MSL: Support option for treating 1D textures as 2D textures of height 1. Add CompilerMSL::Options::texture_1D_as_2D. Metal imposes significant restrictions on 1D textures, including not being renderable, clearable, or permitting mipmaps. This option allows SPIR-V 1D textures to be treated as 2D textures to permit this additional behaviour. App must of course supply the textures to Metal as 2D textures.
2019-10-24 16:31:20 +00:00
if (msl_options.texture_1D_as_2D)
{
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.base.is_fetch)
MSL: Support option for treating 1D textures as 2D textures of height 1. Fixes from feedback. Change vertical sampling of 1D texture from 0.0 to 0.5 to avoid edge conditions.
2019-10-24 18:48:21 +00:00
tex_coords = "uint2(" + tex_coords + ", 0)";
else
tex_coords = "float2(" + tex_coords + ", 0.5)";
MSL: Support option for treating 1D textures as 2D textures of height 1. Add CompilerMSL::Options::texture_1D_as_2D. Metal imposes significant restrictions on 1D textures, including not being renderable, clearable, or permitting mipmaps. This option allows SPIR-V 1D textures to be treated as 2D textures to permit this additional behaviour. App must of course supply the textures to Metal as 2D textures.
2019-10-24 16:31:20 +00:00
}
HLSL/MSL: Fix texture projection with Dref. We need to divide the Dref by q.
2019-01-28 08:39:45 +00:00
alt_coord_component = 1;
CompilerMSL add support for texel buffers. Compiler MSL support DimBuffer as image dimension. CompilerMSL check texture coordinate result type dimension before adding swizzles. Update MSL reference shaders affected by this update.
2017-02-09 17:14:30 +00:00
break;
case DimBuffer:
if (coord_type.vecsize > 1)
HLSL/MSL: Fix texture projection with Dref. We need to divide the Dref by q.
2019-01-28 08:39:45 +00:00
tex_coords = enclose_expression(tex_coords) + ".x";
CompilerMSL add support for texel buffers. Compiler MSL support DimBuffer as image dimension. CompilerMSL check texture coordinate result type dimension before adding swizzles. Update MSL reference shaders affected by this update.
2017-02-09 17:14:30 +00:00
MSL: Support native texture_buffer type, throw error on atomics. Atomics are not supported on images or texture_buffers in MSL. Properly throw an error if OpImageTexelPointer is used (since it can only be used for atomic operations anyways).
2019-04-23 10:17:21 +00:00
if (msl_options.texture_buffer_native)
{
MSL: Cast texture_buffer index to uint.
2019-04-23 10:46:48 +00:00
tex_coords = "uint(" + round_fp_tex_coords(tex_coords, coord_is_fp) + ")";
MSL: Support native texture_buffer type, throw error on atomics. Atomics are not supported on images or texture_buffers in MSL. Properly throw an error if OpImageTexelPointer is used (since it can only be used for atomic operations anyways).
2019-04-23 10:17:21 +00:00
}
else
{
// Metal texel buffer textures are 2D, so convert 1D coord to 2D.
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Support for Metal 2.1's new texture_buffer type.
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.base.is_fetch)
Support Metal 2.1's texture_buffer type which is the equivalent to HLSL's Buffer/RWBuffer, so doesn't require modifying buffer sizes to match alignments.
2019-08-14 14:43:04 +00:00
{
if (msl_options.texel_buffer_texture_width > 0)
{
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
tex_coords = "spvTexelBufferCoord(" + round_fp_tex_coords(tex_coords, coord_is_fp) + ")";
}
Support Metal 2.1's texture_buffer type which is the equivalent to HLSL's Buffer/RWBuffer, so doesn't require modifying buffer sizes to match alignments.
2019-08-14 14:43:04 +00:00
else
{
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
tex_coords = "spvTexelBufferCoord(" + round_fp_tex_coords(tex_coords, coord_is_fp) + ", " +
to_expression(img) + ")";
Support Metal 2.1's texture_buffer type which is the equivalent to HLSL's Buffer/RWBuffer, so doesn't require modifying buffer sizes to match alignments.
2019-08-14 14:43:04 +00:00
}
}
MSL: Support native texture_buffer type, throw error on atomics. Atomics are not supported on images or texture_buffers in MSL. Properly throw an error if OpImageTexelPointer is used (since it can only be used for atomic operations anyways).
2019-04-23 10:17:21 +00:00
}
CompilerMSL round floating point tex coords for read() and tex array index.
2017-04-25 20:32:16 +00:00
HLSL/MSL: Fix texture projection with Dref. We need to divide the Dref by q.
2019-01-28 08:39:45 +00:00
alt_coord_component = 1;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
case DimSubpassData:
MSL: Simplify framebuffer fetch implementation.
2019-10-24 09:48:29 +00:00
// If we're using Metal's native frame-buffer fetch API for subpass inputs,
// this path will not be hit.
MSL: Support layered input attachments. These need to use arrayed texture types, or Metal will complain when binding the resource. The target layer is addressed relative to the Layer output by the vertex pipeline, or to the ViewIndex if in a multiview pipeline. Unlike with the s/t coordinates, Vulkan does not forbid non-zero layer coordinates here, though this cannot be expressed in Vulkan GLSL. Supporting 3D textures will require additional work. Part of the problem is that Metal does not allow texture views to subset a 3D texture, so we need some way to pass the base depth to the shader.
2020-08-28 00:24:20 +00:00
tex_coords = "uint2(gl_FragCoord.xy)";
alt_coord_component = 2;
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case Dim2D:
CompilerMSL remove option to flip fragment coordinates.
2017-04-25 15:25:50 +00:00
if (coord_type.vecsize > 2)
HLSL/MSL: Fix texture projection with Dref. We need to divide the Dref by q.
2019-01-28 08:39:45 +00:00
tex_coords = enclose_expression(tex_coords) + ".xy";
CompilerMSL support OpImageFetch and Metal read() function. Don't emit automatic sampler when using texture read(). Convert tex coords to uintN() when using texture read(). Emit face when read()ing cube textures.
2017-01-20 22:30:36 +00:00
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.base.is_fetch)
CompilerMSL round floating point tex coords for read() and tex array index.
2017-04-25 20:32:16 +00:00
tex_coords = "uint2(" + round_fp_tex_coords(tex_coords, coord_is_fp) + ")";
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
else if (sampling_type_needs_f32_conversion(coord_type))
tex_coords = convert_to_f32(tex_coords, 2);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
HLSL/MSL: Fix texture projection with Dref. We need to divide the Dref by q.
2019-01-28 08:39:45 +00:00
alt_coord_component = 2;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case Dim3D:
CompilerMSL remove option to flip fragment coordinates.
2017-04-25 15:25:50 +00:00
if (coord_type.vecsize > 3)
HLSL/MSL: Fix texture projection with Dref. We need to divide the Dref by q.
2019-01-28 08:39:45 +00:00
tex_coords = enclose_expression(tex_coords) + ".xyz";
CompilerMSL support OpImageFetch and Metal read() function. Don't emit automatic sampler when using texture read(). Convert tex coords to uintN() when using texture read(). Emit face when read()ing cube textures.
2017-01-20 22:30:36 +00:00
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.base.is_fetch)
CompilerMSL round floating point tex coords for read() and tex array index.
2017-04-25 20:32:16 +00:00
tex_coords = "uint3(" + round_fp_tex_coords(tex_coords, coord_is_fp) + ")";
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
else if (sampling_type_needs_f32_conversion(coord_type))
tex_coords = convert_to_f32(tex_coords, 3);
CompilerMSL support OpImageFetch and Metal read() function. Don't emit automatic sampler when using texture read(). Convert tex coords to uintN() when using texture read(). Emit face when read()ing cube textures.
2017-01-20 22:30:36 +00:00
HLSL/MSL: Fix texture projection with Dref. We need to divide the Dref by q.
2019-01-28 08:39:45 +00:00
alt_coord_component = 3;
CompilerMSL support OpImageFetch and Metal read() function. Don't emit automatic sampler when using texture read(). Convert tex coords to uintN() when using texture read(). Emit face when read()ing cube textures.
2017-01-20 22:30:36 +00:00
break;
case DimCube:
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.base.is_fetch)
CompilerMSL support OpImageFetch and Metal read() function. Don't emit automatic sampler when using texture read(). Convert tex coords to uintN() when using texture read(). Emit face when read()ing cube textures.
2017-01-20 22:30:36 +00:00
{
CompilerMSL round floating point tex coords for read() and tex array index.
2017-04-25 20:32:16 +00:00
is_cube_fetch = true;
tex_coords += ".xy";
tex_coords = "uint2(" + round_fp_tex_coords(tex_coords, coord_is_fp) + ")";
CompilerMSL support OpImageFetch and Metal read() function. Don't emit automatic sampler when using texture read(). Convert tex coords to uintN() when using texture read(). Emit face when read()ing cube textures.
2017-01-20 22:30:36 +00:00
}
else
{
CompilerMSL remove option to flip fragment coordinates.
2017-04-25 15:25:50 +00:00
if (coord_type.vecsize > 3)
HLSL/MSL: Fix texture projection with Dref. We need to divide the Dref by q.
2019-01-28 08:39:45 +00:00
tex_coords = enclose_expression(tex_coords) + ".xyz";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
if (sampling_type_needs_f32_conversion(coord_type))
tex_coords = convert_to_f32(tex_coords, 3);
HLSL/MSL: Fix texture projection with Dref. We need to divide the Dref by q.
2019-01-28 08:39:45 +00:00
alt_coord_component = 3;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
default:
break;
}
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.base.is_fetch && args.offset)
MSL: Fix support for texelFetchOffset. Just apply the offset directly, MSL has no immediate offset parameter.
2018-08-07 13:28:04 +00:00
{
// Fetch offsets must be applied directly to the coordinate.
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
forward = forward && should_forward(args.offset);
auto &type = expression_type(args.offset);
Need to make sure the fetch expression is uint.
2018-08-07 14:02:17 +00:00
if (type.basetype != SPIRType::UInt)
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
tex_coords += " + " + bitcast_expression(SPIRType::UInt, args.offset);
Need to make sure the fetch expression is uint.
2018-08-07 14:02:17 +00:00
else
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
tex_coords += " + " + to_enclosed_expression(args.offset);
MSL: Fix support for texelFetchOffset. Just apply the offset directly, MSL has no immediate offset parameter.
2018-08-07 13:28:04 +00:00
}
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
else if (args.base.is_fetch && args.coffset)
MSL: Fix support for texelFetchOffset. Just apply the offset directly, MSL has no immediate offset parameter.
2018-08-07 13:28:04 +00:00
{
// Fetch offsets must be applied directly to the coordinate.
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
forward = forward && should_forward(args.coffset);
auto &type = expression_type(args.coffset);
Need to make sure the fetch expression is uint.
2018-08-07 14:02:17 +00:00
if (type.basetype != SPIRType::UInt)
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
tex_coords += " + " + bitcast_expression(SPIRType::UInt, args.coffset);
Need to make sure the fetch expression is uint.
2018-08-07 14:02:17 +00:00
else
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
tex_coords += " + " + to_enclosed_expression(args.coffset);
MSL: Fix support for texelFetchOffset. Just apply the offset directly, MSL has no immediate offset parameter.
2018-08-07 13:28:04 +00:00
}
CompilerMSL support OpImageFetch and Metal read() function. Don't emit automatic sampler when using texture read(). Convert tex coords to uintN() when using texture read(). Emit face when read()ing cube textures.
2017-01-20 22:30:36 +00:00
// If projection, use alt coord as divisor
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.base.is_proj)
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
{
if (sampling_type_needs_f32_conversion(coord_type))
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
tex_coords += " / " + convert_to_f32(to_extract_component_expression(args.coord, alt_coord_component), 1);
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
else
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
tex_coords += " / " + to_extract_component_expression(args.coord, alt_coord_component);
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
}
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
CompilerMSL support OpImageFetch and Metal read() function. Don't emit automatic sampler when using texture read(). Convert tex coords to uintN() when using texture read(). Emit face when read()ing cube textures.
2017-01-20 22:30:36 +00:00
if (!farg_str.empty())
farg_str += ", ";
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
Further updates for pull request #1162; also added two test cases for spvCubemapTo2DArrayFace function and added '--msl-framebuffer-fetch'/ '--msl-emulate-cube-array' compiler options.
2019-09-27 19:49:54 +00:00
if (imgtype.image.dim == DimCube && imgtype.image.arrayed && msl_options.emulate_cube_array)
Fix image load/store on cube arrays in MSL.
2018-05-25 10:43:25 +00:00
{
Added a new 'emulate_cube_array' option to SPIRV-Cross to cope with translating TextureCubeArray into texture2d_array for iOS where this type is not available. (Original Author: Mark Satterthwaite)
2019-09-13 21:24:27 +00:00
farg_str += "spvCubemapTo2DArrayFace(" + tex_coords + ").xy";
CompilerMSL support OpImageFetch and Metal read() function. Don't emit automatic sampler when using texture read(). Convert tex coords to uintN() when using texture read(). Emit face when read()ing cube textures.
2017-01-20 22:30:36 +00:00
Added a new 'emulate_cube_array' option to SPIRV-Cross to cope with translating TextureCubeArray into texture2d_array for iOS where this type is not available. (Original Author: Mark Satterthwaite)
2019-09-13 21:24:27 +00:00
if (is_cube_fetch)
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
farg_str += ", uint(" + to_extract_component_expression(args.coord, 2) + ")";
Fix image load/store on cube arrays in MSL.
2018-05-25 10:43:25 +00:00
else
Run format_all.sh.
2020-07-01 09:42:58 +00:00
farg_str +=
", uint(spvCubemapTo2DArrayFace(" + tex_coords + ").z) + (uint(" +
round_fp_tex_coords(to_extract_component_expression(args.coord, alt_coord_component), coord_is_fp) +
") * 6u)";
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
add_spv_func_and_recompile(SPVFuncImplCubemapTo2DArrayFace);
Fix image load/store on cube arrays in MSL.
2018-05-25 10:43:25 +00:00
}
Added a new 'emulate_cube_array' option to SPIRV-Cross to cope with translating TextureCubeArray into texture2d_array for iOS where this type is not available. (Original Author: Mark Satterthwaite)
2019-09-13 21:24:27 +00:00
else
Fix image load/store on cube arrays in MSL.
2018-05-25 10:43:25 +00:00
{
Added a new 'emulate_cube_array' option to SPIRV-Cross to cope with translating TextureCubeArray into texture2d_array for iOS where this type is not available. (Original Author: Mark Satterthwaite)
2019-09-13 21:24:27 +00:00
farg_str += tex_coords;
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Added a new 'emulate_cube_array' option to SPIRV-Cross to cope with translating TextureCubeArray into texture2d_array for iOS where this type is not available. (Original Author: Mark Satterthwaite)
2019-09-13 21:24:27 +00:00
// If fetch from cube, add face explicitly
if (is_cube_fetch)
{
// Special case for cube arrays, face and layer are packed in one dimension.
if (imgtype.image.arrayed)
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
farg_str += ", uint(" + to_extract_component_expression(args.coord, 2) + ") % 6u";
Added a new 'emulate_cube_array' option to SPIRV-Cross to cope with translating TextureCubeArray into texture2d_array for iOS where this type is not available. (Original Author: Mark Satterthwaite)
2019-09-13 21:24:27 +00:00
else
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
farg_str +=
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
", uint(" + round_fp_tex_coords(to_extract_component_expression(args.coord, 2), coord_is_fp) + ")";
Added a new 'emulate_cube_array' option to SPIRV-Cross to cope with translating TextureCubeArray into texture2d_array for iOS where this type is not available. (Original Author: Mark Satterthwaite)
2019-09-13 21:24:27 +00:00
}
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Added a new 'emulate_cube_array' option to SPIRV-Cross to cope with translating TextureCubeArray into texture2d_array for iOS where this type is not available. (Original Author: Mark Satterthwaite)
2019-09-13 21:24:27 +00:00
// If array, use alt coord
if (imgtype.image.arrayed)
{
// Special case for cube arrays, face and layer are packed in one dimension.
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (imgtype.image.dim == DimCube && args.base.is_fetch)
MSL: Support layered input attachments. These need to use arrayed texture types, or Metal will complain when binding the resource. The target layer is addressed relative to the Layer output by the vertex pipeline, or to the ViewIndex if in a multiview pipeline. Unlike with the s/t coordinates, Vulkan does not forbid non-zero layer coordinates here, though this cannot be expressed in Vulkan GLSL. Supporting 3D textures will require additional work. Part of the problem is that Metal does not allow texture views to subset a 3D texture, so we need some way to pass the base depth to the shader.
2020-08-28 00:24:20 +00:00
{
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
farg_str += ", uint(" + to_extract_component_expression(args.coord, 2) + ") / 6u";
MSL: Support layered input attachments. These need to use arrayed texture types, or Metal will complain when binding the resource. The target layer is addressed relative to the Layer output by the vertex pipeline, or to the ViewIndex if in a multiview pipeline. Unlike with the s/t coordinates, Vulkan does not forbid non-zero layer coordinates here, though this cannot be expressed in Vulkan GLSL. Supporting 3D textures will require additional work. Part of the problem is that Metal does not allow texture views to subset a 3D texture, so we need some way to pass the base depth to the shader.
2020-08-28 00:24:20 +00:00
}
Added a new 'emulate_cube_array' option to SPIRV-Cross to cope with translating TextureCubeArray into texture2d_array for iOS where this type is not available. (Original Author: Mark Satterthwaite)
2019-09-13 21:24:27 +00:00
else
MSL: Support layered input attachments. These need to use arrayed texture types, or Metal will complain when binding the resource. The target layer is addressed relative to the Layer output by the vertex pipeline, or to the ViewIndex if in a multiview pipeline. Unlike with the s/t coordinates, Vulkan does not forbid non-zero layer coordinates here, though this cannot be expressed in Vulkan GLSL. Supporting 3D textures will require additional work. Part of the problem is that Metal does not allow texture views to subset a 3D texture, so we need some way to pass the base depth to the shader.
2020-08-28 00:24:20 +00:00
{
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
farg_str +=
", uint(" +
Run format_all.sh.
2020-07-01 09:42:58 +00:00
round_fp_tex_coords(to_extract_component_expression(args.coord, alt_coord_component), coord_is_fp) +
")";
MSL: Support layered input attachments. These need to use arrayed texture types, or Metal will complain when binding the resource. The target layer is addressed relative to the Layer output by the vertex pipeline, or to the ViewIndex if in a multiview pipeline. Unlike with the s/t coordinates, Vulkan does not forbid non-zero layer coordinates here, though this cannot be expressed in Vulkan GLSL. Supporting 3D textures will require additional work. Part of the problem is that Metal does not allow texture views to subset a 3D texture, so we need some way to pass the base depth to the shader.
2020-08-28 00:24:20 +00:00
if (imgtype.image.dim == DimSubpassData)
{
if (msl_options.multiview)
farg_str += " + gl_ViewIndex";
else if (msl_options.arrayed_subpass_input)
farg_str += " + gl_Layer";
}
}
}
else if (imgtype.image.dim == DimSubpassData)
{
if (msl_options.multiview)
farg_str += ", gl_ViewIndex";
else if (msl_options.arrayed_subpass_input)
farg_str += ", gl_Layer";
Added a new 'emulate_cube_array' option to SPIRV-Cross to cope with translating TextureCubeArray into texture2d_array for iOS where this type is not available. (Original Author: Mark Satterthwaite)
2019-09-13 21:24:27 +00:00
}
Fix image load/store on cube arrays in MSL.
2018-05-25 10:43:25 +00:00
}
CompilerMSL support OpImageFetch and Metal read() function. Don't emit automatic sampler when using texture read(). Convert tex coords to uintN() when using texture read(). Emit face when read()ing cube textures.
2017-01-20 22:30:36 +00:00
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
// Depth compare reference value
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.dref)
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
{
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
forward = forward && should_forward(args.dref);
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
farg_str += ", ";
HLSL/MSL: Fix texture projection with Dref. We need to divide the Dref by q.
2019-01-28 08:39:45 +00:00
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
auto &dref_type = expression_type(args.dref);
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
string dref_expr;
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.base.is_proj)
Run format_all.sh.
2020-07-01 09:42:58 +00:00
dref_expr = join(to_enclosed_expression(args.dref), " / ",
to_extract_component_expression(args.coord, alt_coord_component));
HLSL/MSL: Fix texture projection with Dref. We need to divide the Dref by q.
2019-01-28 08:39:45 +00:00
else
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
dref_expr = to_expression(args.dref);
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
if (sampling_type_needs_f32_conversion(dref_type))
dref_expr = convert_to_f32(dref_expr, 1);
farg_str += dref_expr;
MSL: Workaround missing gradient2d() for sampler_compare.
2019-01-07 09:01:00 +00:00
if (msl_options.is_macos() && (grad_x || grad_y))
{
// For sample compare, MSL does not support gradient2d for all targets (only iOS apparently according to docs).
// However, the most common case here is to have a constant gradient of 0, as that is the only way to express
// LOD == 0 in GLSL with sampler2DArrayShadow (cascaded shadow mapping).
// We will detect a compile-time constant 0 value for gradient and promote that to level(0) on MSL.
bool constant_zero_x = !grad_x || expression_is_constant_null(grad_x);
bool constant_zero_y = !grad_y || expression_is_constant_null(grad_y);
if (constant_zero_x && constant_zero_y)
{
lod = 0;
grad_x = 0;
grad_y = 0;
farg_str += ", level(0)";
}
else
{
Run format_all.sh.
2019-01-07 09:01:28 +00:00
SPIRV_CROSS_THROW("Using non-constant 0.0 gradient() qualifier for sample_compare. This is not "
"supported in MSL macOS.");
MSL: Workaround missing gradient2d() for sampler_compare.
2019-01-07 09:01:00 +00:00
}
}
if (msl_options.is_macos() && bias)
{
// Bias is not supported either on macOS with sample_compare.
// Verify it is compile-time zero, and drop the argument.
if (expression_is_constant_null(bias))
{
bias = 0;
}
else
{
SPIRV_CROSS_THROW(
Run format_all.sh.
2019-01-07 09:01:28 +00:00
"Using non-constant 0.0 bias() qualifier for sample_compare. This is not supported in MSL macOS.");
MSL: Workaround missing gradient2d() for sampler_compare.
2019-01-07 09:01:00 +00:00
}
}
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// LOD Options
Ignore LOD when sampling 1D textures in MSL. Not supported.
2018-04-03 11:01:52 +00:00
// Metal does not support LOD for 1D textures.
MSL: Support option for treating 1D textures as 2D textures of height 1. Add CompilerMSL::Options::texture_1D_as_2D. Metal imposes significant restrictions on 1D textures, including not being renderable, clearable, or permitting mipmaps. This option allows SPIR-V 1D textures to be treated as 2D textures to permit this additional behaviour. App must of course supply the textures to Metal as 2D textures.
2019-10-24 16:31:20 +00:00
if (bias && (imgtype.image.dim != Dim1D || msl_options.texture_1D_as_2D))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
forward = forward && should_forward(bias);
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
farg_str += ", bias(" + to_expression(bias) + ")";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Ignore LOD when sampling 1D textures in MSL. Not supported.
2018-04-03 11:01:52 +00:00
// Metal does not support LOD for 1D textures.
MSL: Support option for treating 1D textures as 2D textures of height 1. Add CompilerMSL::Options::texture_1D_as_2D. Metal imposes significant restrictions on 1D textures, including not being renderable, clearable, or permitting mipmaps. This option allows SPIR-V 1D textures to be treated as 2D textures to permit this additional behaviour. App must of course supply the textures to Metal as 2D textures.
2019-10-24 16:31:20 +00:00
if (lod && (imgtype.image.dim != Dim1D || msl_options.texture_1D_as_2D))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
forward = forward && should_forward(lod);
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.base.is_fetch)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
farg_str += ", " + to_expression(lod);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
else
{
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
farg_str += ", level(" + to_expression(lod) + ")";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
}
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
else if (args.base.is_fetch && !lod && (imgtype.image.dim != Dim1D || msl_options.texture_1D_as_2D) &&
MSL: Support option for treating 1D textures as 2D textures of height 1. Add CompilerMSL::Options::texture_1D_as_2D. Metal imposes significant restrictions on 1D textures, including not being renderable, clearable, or permitting mipmaps. This option allows SPIR-V 1D textures to be treated as 2D textures to permit this additional behaviour. App must of course supply the textures to Metal as 2D textures.
2019-10-24 16:31:20 +00:00
imgtype.image.dim != DimBuffer && !imgtype.image.ms && imgtype.image.sampled != 2)
Deal with OpImageFetch without explicit LOD.
2018-04-30 08:53:21 +00:00
{
// Lod argument is optional in OpImageFetch, but we require a LOD value, pick 0 as the default.
// Check for sampled type as well, because is_fetch is also used for OpImageRead in MSL.
farg_str += ", 0";
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Ignore LOD when sampling 1D textures in MSL. Not supported.
2018-04-03 11:01:52 +00:00
// Metal does not support LOD for 1D textures.
MSL: Support option for treating 1D textures as 2D textures of height 1. Add CompilerMSL::Options::texture_1D_as_2D. Metal imposes significant restrictions on 1D textures, including not being renderable, clearable, or permitting mipmaps. This option allows SPIR-V 1D textures to be treated as 2D textures to permit this additional behaviour. App must of course supply the textures to Metal as 2D textures.
2019-10-24 16:31:20 +00:00
if ((grad_x || grad_y) && (imgtype.image.dim != Dim1D || msl_options.texture_1D_as_2D))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
forward = forward && should_forward(grad_x);
forward = forward && should_forward(grad_y);
string grad_opt;
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
switch (imgtype.image.dim)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
case Dim2D:
grad_opt = "2d";
break;
case Dim3D:
grad_opt = "3d";
break;
case DimCube:
Added a new 'emulate_cube_array' option to SPIRV-Cross to cope with translating TextureCubeArray into texture2d_array for iOS where this type is not available. (Original Author: Mark Satterthwaite)
2019-09-13 21:24:27 +00:00
if (imgtype.image.arrayed && msl_options.emulate_cube_array)
grad_opt = "2d";
else
grad_opt = "cube";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
default:
grad_opt = "unsupported_gradient_dimension";
break;
}
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
farg_str += ", gradient" + grad_opt + "(" + to_expression(grad_x) + ", " + to_expression(grad_y) + ")";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.min_lod)
MSL: Support MinLod operand.
2019-06-11 09:10:16 +00:00
{
if (msl_options.is_macos())
{
if (!msl_options.supports_msl_version(2, 2))
SPIRV_CROSS_THROW("min_lod_clamp() is only supported in MSL 2.2+ and up on macOS.");
}
else if (msl_options.is_ios())
SPIRV_CROSS_THROW("min_lod_clamp() is not supported on iOS.");
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
forward = forward && should_forward(args.min_lod);
farg_str += ", min_lod_clamp(" + to_expression(args.min_lod) + ")";
MSL: Support MinLod operand.
2019-06-11 09:10:16 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Add offsets
string offset_expr;
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.coffset && !args.base.is_fetch)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
forward = forward && should_forward(args.coffset);
offset_expr = to_expression(args.coffset);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
else if (args.offset && !args.base.is_fetch)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
forward = forward && should_forward(args.offset);
offset_expr = to_expression(args.offset);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
if (!offset_expr.empty())
{
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
switch (imgtype.image.dim)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
case Dim2D:
CompilerMSL remove option to flip fragment coordinates.
2017-04-25 15:25:50 +00:00
if (coord_type.vecsize > 2)
Ignore LOD when sampling 1D textures in MSL. Not supported.
2018-04-03 11:01:52 +00:00
offset_expr = enclose_expression(offset_expr) + ".xy";
Compiler MSL default gather offset when component specified.
2018-04-30 20:30:29 +00:00
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
farg_str += ", " + offset_expr;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case Dim3D:
CompilerMSL remove option to flip fragment coordinates.
2017-04-25 15:25:50 +00:00
if (coord_type.vecsize > 3)
Ignore LOD when sampling 1D textures in MSL. Not supported.
2018-04-03 11:01:52 +00:00
offset_expr = enclose_expression(offset_expr) + ".xyz";
Compiler MSL default gather offset when component specified.
2018-04-30 20:30:29 +00:00
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
farg_str += ", " + offset_expr;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
default:
break;
}
}
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.component)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Compiler MSL default gather offset when component specified.
2018-04-30 20:30:29 +00:00
// If 2D has gather component, ensure it also has an offset arg
if (imgtype.image.dim == Dim2D && offset_expr.empty())
farg_str += ", int2(0)";
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
if (!msl_options.swizzle_texture_samples || is_dynamic_img_sampler)
{
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
forward = forward && should_forward(args.component);
farg_str += ", " + to_component_argument(args.component);
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.sample)
CompilerMSL support OpImageFetch and Metal read() function. Don't emit automatic sampler when using texture read(). Convert tex coords to uintN() when using texture read(). Emit face when read()ing cube textures.
2017-01-20 22:30:36 +00:00
{
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
forward = forward && should_forward(args.sample);
CompilerMSL support OpImageFetch and Metal read() function. Don't emit automatic sampler when using texture read(). Convert tex coords to uintN() when using texture read(). Emit face when read()ing cube textures.
2017-01-20 22:30:36 +00:00
farg_str += ", ";
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
farg_str += to_expression(args.sample);
CompilerMSL support OpImageFetch and Metal read() function. Don't emit automatic sampler when using texture read(). Convert tex coords to uintN() when using texture read(). Emit face when read()ing cube textures.
2017-01-20 22:30:36 +00:00
}
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
*p_forward = forward;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
return farg_str;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
CompilerMSL round floating point tex coords for read() and tex array index.
2017-04-25 20:32:16 +00:00
// If the texture coordinates are floating point, invokes MSL round() function to round them.
string CompilerMSL::round_fp_tex_coords(string tex_coords, bool coord_is_fp)
{
return coord_is_fp ? ("round(" + tex_coords + ")") : tex_coords;
}
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
// Returns a string to use in an image sampling function argument.
// The ID must be a scalar constant.
string CompilerMSL::to_component_argument(uint32_t id)
{
Implement a simple evaluator of specialization constants. In some cases, we need to get a literal value from a spec constant op. Mostly relevant when emitting buffers, so implement a 32-bit integer scalar subset of the evaluator. Can be extended as needed to support evaluating any specialization constant operation.
2020-09-14 08:42:31 +00:00
uint32_t component_index = evaluate_constant_u32(id);
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
switch (component_index)
{
case 0:
return "component::x";
case 1:
return "component::y";
case 2:
return "component::z";
case 3:
return "component::w";
default:
SPIRV_CROSS_THROW("The value (" + to_string(component_index) + ") of OpConstant ID " + to_string(id) +
" is not a valid Component index, which must be one of 0, 1, 2, or 3.");
return "component::x";
}
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
Track sampler ID in Meta for OpSampledImage objects. Add virtual CompilerGLSL emit_sampled_image_op function for OpSampledImage. Under MSL, set sampler ID for local OpSampledImage objects and extract it when emitting sampler.
2016-04-24 01:47:41 +00:00
// Establish sampled image as expression object and assign the sampler to it.
void CompilerMSL::emit_sampled_image_op(uint32_t result_type, uint32_t result_id, uint32_t image_id, uint32_t samp_id)
{
Refactor MSL to use SPIRCombinedImageSampler. Avoids special "meta" data to express this type. Makes MSL implementation in line with HLSL.
2018-10-05 07:49:57 +00:00
set<SPIRCombinedImageSampler>(result_id, result_type, image_id, samp_id);
Track sampler ID in Meta for OpSampledImage objects. Add virtual CompilerGLSL emit_sampled_image_op function for OpSampledImage. Under MSL, set sampler ID for local OpSampledImage objects and extract it when emitting sampler.
2016-04-24 01:47:41 +00:00
}
Run format_all.sh.
2020-07-01 09:42:58 +00:00
string CompilerMSL::to_texture_op(const Instruction &i, bool sparse, bool *forward,
SmallVector<uint32_t> &inherited_expressions)
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
{
auto *ops = stream(i);
uint32_t result_type_id = ops[0];
uint32_t img = ops[2];
auto &result_type = get<SPIRType>(result_type_id);
auto op = static_cast<Op>(i.op);
bool is_gather = (op == OpImageGather || op == OpImageDrefGather);
// Bypass pointers because we need the real image struct
auto &type = expression_type(img);
auto &imgtype = get<SPIRType>(type.self);
const MSLConstexprSampler *constexpr_sampler = nullptr;
bool is_dynamic_img_sampler = false;
if (auto *var = maybe_get_backing_variable(img))
{
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
constexpr_sampler = find_constexpr_sampler(var->basevariable ? var->basevariable : VariableID(var->self));
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
is_dynamic_img_sampler = has_extended_decoration(var->self, SPIRVCrossDecorationDynamicImageSampler);
}
string expr;
if (constexpr_sampler && constexpr_sampler->ycbcr_conversion_enable && !is_dynamic_img_sampler)
{
// If this needs sampler Y'CbCr conversion, we need to do some additional
// processing.
switch (constexpr_sampler->ycbcr_model)
{
Fix missing switch cases in Y'CbCr conversion Otherwise the following lines will never be reached for the other two valid ycbcr_models (RGB_IDENTITY and YCBCR_IDENTITY) as they would cause a SPIRV_CROSS_THROW.
2020-06-06 20:01:05 +00:00
case MSL_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY:
case MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY:
// Default
break;
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
case MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_709:
add_spv_func_and_recompile(SPVFuncImplConvertYCbCrBT709);
expr += "spvConvertYCbCrBT709(";
break;
case MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_601:
add_spv_func_and_recompile(SPVFuncImplConvertYCbCrBT601);
expr += "spvConvertYCbCrBT601(";
break;
case MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_2020:
add_spv_func_and_recompile(SPVFuncImplConvertYCbCrBT2020);
expr += "spvConvertYCbCrBT2020(";
break;
default:
SPIRV_CROSS_THROW("Invalid Y'CbCr model conversion.");
}
if (constexpr_sampler->ycbcr_model != MSL_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY)
{
switch (constexpr_sampler->ycbcr_range)
{
case MSL_SAMPLER_YCBCR_RANGE_ITU_FULL:
add_spv_func_and_recompile(SPVFuncImplExpandITUFullRange);
expr += "spvExpandITUFullRange(";
break;
case MSL_SAMPLER_YCBCR_RANGE_ITU_NARROW:
add_spv_func_and_recompile(SPVFuncImplExpandITUNarrowRange);
expr += "spvExpandITUNarrowRange(";
break;
default:
SPIRV_CROSS_THROW("Invalid Y'CbCr range.");
}
}
}
else if (msl_options.swizzle_texture_samples && !is_gather && is_sampled_image_type(imgtype) &&
!is_dynamic_img_sampler)
{
add_spv_func_and_recompile(SPVFuncImplTextureSwizzle);
expr += "spvTextureSwizzle(";
}
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
string inner_expr = CompilerGLSL::to_texture_op(i, sparse, forward, inherited_expressions);
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
if (constexpr_sampler && constexpr_sampler->ycbcr_conversion_enable && !is_dynamic_img_sampler)
{
if (!constexpr_sampler->swizzle_is_identity())
{
static const char swizzle_names[] = "rgba";
if (!constexpr_sampler->swizzle_has_one_or_zero())
{
// If we can, do it inline.
expr += inner_expr + ".";
for (uint32_t c = 0; c < 4; c++)
{
switch (constexpr_sampler->swizzle[c])
{
case MSL_COMPONENT_SWIZZLE_IDENTITY:
expr += swizzle_names[c];
break;
case MSL_COMPONENT_SWIZZLE_R:
case MSL_COMPONENT_SWIZZLE_G:
case MSL_COMPONENT_SWIZZLE_B:
case MSL_COMPONENT_SWIZZLE_A:
expr += swizzle_names[constexpr_sampler->swizzle[c] - MSL_COMPONENT_SWIZZLE_R];
break;
default:
SPIRV_CROSS_THROW("Invalid component swizzle.");
}
}
}
else
{
// Otherwise, we need to emit a temporary and swizzle that.
uint32_t temp_id = ir.increase_bound_by(1);
emit_op(result_type_id, temp_id, inner_expr, false);
for (auto &inherit : inherited_expressions)
inherit_expression_dependencies(temp_id, inherit);
inherited_expressions.clear();
inherited_expressions.push_back(temp_id);
switch (op)
{
case OpImageSampleDrefImplicitLod:
case OpImageSampleImplicitLod:
case OpImageSampleProjImplicitLod:
case OpImageSampleProjDrefImplicitLod:
register_control_dependent_expression(temp_id);
break;
default:
break;
}
expr += type_to_glsl(result_type) + "(";
for (uint32_t c = 0; c < 4; c++)
{
switch (constexpr_sampler->swizzle[c])
{
case MSL_COMPONENT_SWIZZLE_IDENTITY:
expr += to_expression(temp_id) + "." + swizzle_names[c];
break;
case MSL_COMPONENT_SWIZZLE_ZERO:
expr += "0";
break;
case MSL_COMPONENT_SWIZZLE_ONE:
expr += "1";
break;
case MSL_COMPONENT_SWIZZLE_R:
case MSL_COMPONENT_SWIZZLE_G:
case MSL_COMPONENT_SWIZZLE_B:
case MSL_COMPONENT_SWIZZLE_A:
expr += to_expression(temp_id) + "." +
swizzle_names[constexpr_sampler->swizzle[c] - MSL_COMPONENT_SWIZZLE_R];
break;
default:
SPIRV_CROSS_THROW("Invalid component swizzle.");
}
if (c < 3)
expr += ", ";
}
expr += ")";
}
}
else
expr += inner_expr;
if (constexpr_sampler->ycbcr_model != MSL_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY)
{
expr += join(", ", constexpr_sampler->bpc, ")");
if (constexpr_sampler->ycbcr_model != MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY)
expr += ")";
}
}
else
{
expr += inner_expr;
if (msl_options.swizzle_texture_samples && !is_gather && is_sampled_image_type(imgtype) &&
!is_dynamic_img_sampler)
{
// Add the swizzle constant from the swizzle buffer.
expr += ", " + to_swizzle_expression(img) + ")";
used_swizzle_buffer = true;
}
}
return expr;
}
static string create_swizzle(MSLComponentSwizzle swizzle)
{
switch (swizzle)
{
case MSL_COMPONENT_SWIZZLE_IDENTITY:
return "spvSwizzle::none";
case MSL_COMPONENT_SWIZZLE_ZERO:
return "spvSwizzle::zero";
case MSL_COMPONENT_SWIZZLE_ONE:
return "spvSwizzle::one";
case MSL_COMPONENT_SWIZZLE_R:
return "spvSwizzle::red";
case MSL_COMPONENT_SWIZZLE_G:
return "spvSwizzle::green";
case MSL_COMPONENT_SWIZZLE_B:
return "spvSwizzle::blue";
case MSL_COMPONENT_SWIZZLE_A:
return "spvSwizzle::alpha";
default:
SPIRV_CROSS_THROW("Invalid component swizzle.");
return "";
}
}
MSL support textures and samplers as function args. Add automatic sampler func arg when passing SampledImage type. Pass texture and sampler in thread address space.
2016-07-07 00:30:47 +00:00
// Returns a string representation of the ID, usable as a function arg.
// Manufacture automatic sampler arg for SampledImage texture.
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
string CompilerMSL::to_func_call_arg(const SPIRFunction::Parameter &arg, uint32_t id)
MSL support textures and samplers as function args. Add automatic sampler func arg when passing SampledImage type. Pass texture and sampler in thread address space.
2016-07-07 00:30:47 +00:00
{
MSL: Fix case where we pass arrays to functions by value. MSL does not support value semantics for arrays (sigh), so we need to force constant references and deal with copies if we have a different address space than what we end up guessing.
2019-01-14 09:08:35 +00:00
string arg_str;
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
auto &type = expression_type(id);
bool is_dynamic_img_sampler = has_extended_decoration(arg.id, SPIRVCrossDecorationDynamicImageSampler);
// If the argument *itself* is a "dynamic" combined-image sampler, then we can just pass that around.
bool arg_is_dynamic_img_sampler = has_extended_decoration(id, SPIRVCrossDecorationDynamicImageSampler);
if (is_dynamic_img_sampler && !arg_is_dynamic_img_sampler)
arg_str = join("spvDynamicImageSampler<", type_to_glsl(get<SPIRType>(type.image.type)), ">(");
MSL: Reintroduce workaround for constant arrays being passed by value.
2020-02-24 12:22:52 +00:00
auto *c = maybe_get<SPIRConstant>(id);
if (msl_options.force_native_arrays && c && !get<SPIRType>(c->constant_type).array.empty())
{
// If we are passing a constant array directly to a function for some reason,
// the callee will expect an argument in thread const address space
// (since we can only bind to arrays with references in MSL).
// To resolve this, we must emit a copy in this address space.
// This kind of code gen should be rare enough that performance is not a real concern.
// Inline the SPIR-V to avoid this kind of suboptimal codegen.
//
// We risk calling this inside a continue block (invalid code),
// so just create a thread local copy in the current function.
arg_str = join("_", id, "_array_copy");
auto &constants = current_function->constant_arrays_needed_on_stack;
auto itr = find(begin(constants), end(constants), ID(id));
if (itr == end(constants))
{
force_recompile();
constants.push_back(id);
}
}
else
arg_str += CompilerGLSL::to_func_call_arg(arg, id);
MSL support textures and samplers as function args. Add automatic sampler func arg when passing SampledImage type. Pass texture and sampler in thread address space.
2016-07-07 00:30:47 +00:00
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
// Need to check the base variable in case we need to apply a qualified alias.
uint32_t var_id = 0;
auto *var = maybe_get<SPIRVariable>(id);
if (var)
var_id = var->basevariable;
MSL support textures and samplers as function args. Add automatic sampler func arg when passing SampledImage type. Pass texture and sampler in thread address space.
2016-07-07 00:30:47 +00:00
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
if (!arg_is_dynamic_img_sampler)
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
{
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
auto *constexpr_sampler = find_constexpr_sampler(var_id ? var_id : id);
if (type.basetype == SPIRType::SampledImage)
{
// Manufacture automatic plane args for multiplanar texture
uint32_t planes = 1;
if (constexpr_sampler && constexpr_sampler->ycbcr_conversion_enable)
{
planes = constexpr_sampler->planes;
// If this parameter isn't aliasing a global, then we need to use
// the special "dynamic image-sampler" class to pass it--and we need
// to use it for *every* non-alias parameter, in case a combined
// image-sampler with a Y'CbCr conversion is passed. Hopefully, this
// pathological case is so rare that it should never be hit in practice.
if (!arg.alias_global_variable)
add_spv_func_and_recompile(SPVFuncImplDynamicImageSampler);
}
for (uint32_t i = 1; i < planes; i++)
arg_str += join(", ", CompilerGLSL::to_func_call_arg(arg, id), plane_name_suffix, i);
// Manufacture automatic sampler arg if the arg is a SampledImage texture.
if (type.image.dim != DimBuffer)
arg_str += ", " + to_sampler_expression(var_id ? var_id : id);
// Add sampler Y'CbCr conversion info if we have it
if (is_dynamic_img_sampler && constexpr_sampler && constexpr_sampler->ycbcr_conversion_enable)
{
SmallVector<string> samp_args;
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
switch (constexpr_sampler->resolution)
{
case MSL_FORMAT_RESOLUTION_444:
// Default
break;
case MSL_FORMAT_RESOLUTION_422:
samp_args.push_back("spvFormatResolution::_422");
break;
case MSL_FORMAT_RESOLUTION_420:
samp_args.push_back("spvFormatResolution::_420");
break;
default:
SPIRV_CROSS_THROW("Invalid format resolution.");
}
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
if (constexpr_sampler->chroma_filter != MSL_SAMPLER_FILTER_NEAREST)
samp_args.push_back("spvChromaFilter::linear");
if (constexpr_sampler->x_chroma_offset != MSL_CHROMA_LOCATION_COSITED_EVEN)
samp_args.push_back("spvXChromaLocation::midpoint");
if (constexpr_sampler->y_chroma_offset != MSL_CHROMA_LOCATION_COSITED_EVEN)
samp_args.push_back("spvYChromaLocation::midpoint");
switch (constexpr_sampler->ycbcr_model)
{
case MSL_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY:
// Default
break;
case MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY:
samp_args.push_back("spvYCbCrModelConversion::ycbcr_identity");
break;
case MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_709:
samp_args.push_back("spvYCbCrModelConversion::ycbcr_bt_709");
break;
case MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_601:
samp_args.push_back("spvYCbCrModelConversion::ycbcr_bt_601");
break;
case MSL_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_BT_2020:
samp_args.push_back("spvYCbCrModelConversion::ycbcr_bt_2020");
break;
default:
SPIRV_CROSS_THROW("Invalid Y'CbCr model conversion.");
}
if (constexpr_sampler->ycbcr_range != MSL_SAMPLER_YCBCR_RANGE_ITU_FULL)
samp_args.push_back("spvYCbCrRange::itu_narrow");
samp_args.push_back(join("spvComponentBits(", constexpr_sampler->bpc, ")"));
arg_str += join(", spvYCbCrSampler(", merge(samp_args), ")");
}
}
if (is_dynamic_img_sampler && constexpr_sampler && constexpr_sampler->ycbcr_conversion_enable)
arg_str += join(", (uint(", create_swizzle(constexpr_sampler->swizzle[3]), ") << 24) | (uint(",
create_swizzle(constexpr_sampler->swizzle[2]), ") << 16) | (uint(",
create_swizzle(constexpr_sampler->swizzle[1]), ") << 8) | uint(",
create_swizzle(constexpr_sampler->swizzle[0]), ")");
else if (msl_options.swizzle_texture_samples && has_sampled_images && is_sampled_image_type(type))
arg_str += ", " + to_swizzle_expression(var_id ? var_id : id);
MSL support textures and samplers as function args. Add automatic sampler func arg when passing SampledImage type. Pass texture and sampler in thread address space.
2016-07-07 00:30:47 +00:00
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
if (buffers_requiring_array_length.count(var_id))
arg_str += ", " + to_buffer_size_expression(var_id ? var_id : id);
if (is_dynamic_img_sampler)
arg_str += ")";
}
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Emulate texture2D atomic operations
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
auto *backing_var = maybe_get_backing_variable(var_id);
MSL: Minor cleanups for texture atomic emulation. Storing pointers to internal objects is generally not done, IDs are preferred.
2019-10-24 09:30:20 +00:00
if (backing_var && atomic_image_vars.count(backing_var->self))
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
{
arg_str += ", " + to_expression(var_id) + "_atomic";
}
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Run clang-format.
2016-10-24 13:24:24 +00:00
return arg_str;
MSL support textures and samplers as function args. Add automatic sampler func arg when passing SampledImage type. Pass texture and sampler in thread address space.
2016-07-07 00:30:47 +00:00
}
Track sampler ID in Meta for OpSampledImage objects. Add virtual CompilerGLSL emit_sampled_image_op function for OpSampledImage. Under MSL, set sampler ID for local OpSampledImage objects and extract it when emitting sampler.
2016-04-24 01:47:41 +00:00
// If the ID represents a sampled image that has been assigned a sampler already,
// generate an expression for the sampler, otherwise generate a fake sampler name
// by appending a suffix to the expression constructed from the ID.
string CompilerMSL::to_sampler_expression(uint32_t id)
{
Refactor MSL to use SPIRCombinedImageSampler. Avoids special "meta" data to express this type. Makes MSL implementation in line with HLSL.
2018-10-05 07:49:57 +00:00
auto *combined = maybe_get<SPIRCombinedImageSampler>(id);
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
auto expr = to_expression(combined ? combined->image : VariableID(id));
Support array of images and samplers in MSL.
2018-04-03 12:00:34 +00:00
auto index = expr.find_first_of('[');
Refactor MSL to use SPIRCombinedImageSampler. Avoids special "meta" data to express this type. Makes MSL implementation in line with HLSL.
2018-10-05 07:49:57 +00:00
uint32_t samp_id = 0;
if (combined)
samp_id = combined->sampler;
Support array of images and samplers in MSL.
2018-04-03 12:00:34 +00:00
if (index == string::npos)
return samp_id ? to_expression(samp_id) : expr + sampler_name_suffix;
else
{
auto image_expr = expr.substr(0, index);
auto array_expr = expr.substr(index);
return samp_id ? to_expression(samp_id) : (image_expr + sampler_name_suffix + array_expr);
}
Track sampler ID in Meta for OpSampledImage objects. Add virtual CompilerGLSL emit_sampled_image_op function for OpSampledImage. Under MSL, set sampler ID for local OpSampledImage objects and extract it when emitting sampler.
2016-04-24 01:47:41 +00:00
}
MSL: Fix passing a sampled image to a function. In the past, SPIRV-Cross threw an error in this case because it couldn't work out which swizzle from the auxiliary buffer needs to be passed. Now, we pass the swizzle around with the texture object, like a combined image-sampler and its associated sampler.
2019-01-13 23:31:50 +00:00
string CompilerMSL::to_swizzle_expression(uint32_t id)
{
auto *combined = maybe_get<SPIRCombinedImageSampler>(id);
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
auto expr = to_expression(combined ? combined->image : VariableID(id));
MSL: Fix passing a sampled image to a function. In the past, SPIRV-Cross threw an error in this case because it couldn't work out which swizzle from the auxiliary buffer needs to be passed. Now, we pass the swizzle around with the texture object, like a combined image-sampler and its associated sampler.
2019-01-13 23:31:50 +00:00
auto index = expr.find_first_of('[');
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
// If an image is part of an argument buffer translate this to a legal identifier.
for (auto &c : expr)
if (c == '.')
c = '_';
MSL: Fix passing a sampled image to a function. In the past, SPIRV-Cross threw an error in this case because it couldn't work out which swizzle from the auxiliary buffer needs to be passed. Now, we pass the swizzle around with the texture object, like a combined image-sampler and its associated sampler.
2019-01-13 23:31:50 +00:00
if (index == string::npos)
return expr + swizzle_name_suffix;
else
{
auto image_expr = expr.substr(0, index);
auto array_expr = expr.substr(index);
return image_expr + swizzle_name_suffix + array_expr;
}
}
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
string CompilerMSL::to_buffer_size_expression(uint32_t id)
{
auto expr = to_expression(id);
auto index = expr.find_first_of('[');
// This is quite crude, but we need to translate the reference name (*spvDescriptorSetN.name) to
// the pointer expression spvDescriptorSetN.name to make a reasonable expression here.
// This only happens if we have argument buffers and we are using OpArrayLength on a lone SSBO in that set.
if (expr.size() >= 3 && expr[0] == '(' && expr[1] == '*')
expr = address_of_expression(expr);
// If a buffer is part of an argument buffer translate this to a legal identifier.
for (auto &c : expr)
if (c == '.')
c = '_';
if (index == string::npos)
return expr + buffer_size_name_suffix;
else
{
auto buffer_expr = expr.substr(0, index);
auto array_expr = expr.substr(index);
return buffer_expr + buffer_size_name_suffix + array_expr;
}
}
Handle blocks of patch I/O. In this case, each member of the block will be decorated with `DecorationPatch`, rather than the block variable having the decoration.
2019-02-15 23:21:38 +00:00
// Checks whether the type is a Block all of whose members have DecorationPatch.
bool CompilerMSL::is_patch_block(const SPIRType &type)
{
if (!has_decoration(type.self, DecorationBlock))
return false;
for (uint32_t i = 0; i < type.member_types.size(); i++)
{
if (!has_member_decoration(type.self, i, DecorationPatch))
return false;
}
return true;
}
CompilerMSL support conversion of non-square row-major matrices.
2018-01-04 21:33:45 +00:00
// Checks whether the ID is a row_major matrix that requires conversion before use
bool CompilerMSL::is_non_native_row_major_matrix(uint32_t id)
{
Remove obsolete matrix workaround code.
2019-07-22 14:27:47 +00:00
auto *e = maybe_get<SPIRExpression>(id);
if (e)
return e->need_transpose;
else
return has_decoration(id, DecorationRowMajor);
CompilerMSL support conversion of non-square row-major matrices.
2018-01-04 21:33:45 +00:00
}
// Checks whether the member is a row_major matrix that requires conversion before use
bool CompilerMSL::member_is_non_native_row_major_matrix(const SPIRType &type, uint32_t index)
{
MSL: Support storing to row-major column. Defer transposes to actual Load or Store.
2019-07-22 09:13:44 +00:00
return has_member_decoration(type.self, index, DecorationRowMajor);
CompilerMSL support conversion of non-square row-major matrices.
2018-01-04 21:33:45 +00:00
}
Run format_all.sh.
2019-07-23 10:23:41 +00:00
string CompilerMSL::convert_row_major_matrix(string exp_str, const SPIRType &exp_type, uint32_t physical_type_id,
bool is_packed)
CompilerMSL support conversion of non-square row-major matrices.
2018-01-04 21:33:45 +00:00
{
MSL: Support storing to row-major column. Defer transposes to actual Load or Store.
2019-07-22 09:13:44 +00:00
if (!is_matrix(exp_type))
{
return CompilerGLSL::convert_row_major_matrix(move(exp_str), exp_type, physical_type_id, is_packed);
}
else
{
strip_enclosed_expression(exp_str);
if (physical_type_id != 0 || is_packed)
exp_str = unpack_expression_type(exp_str, exp_type, physical_type_id, is_packed, true);
return join("transpose(", exp_str, ")");
}
CompilerMSL support conversion of non-square row-major matrices.
2018-01-04 21:33:45 +00:00
}
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
// Called automatically at the end of the entry point function
void CompilerMSL::emit_fixup()
{
Allow flip_vert_y in all relevant stages.
2020-09-28 12:09:39 +00:00
if (is_vertex_like_shader() && stage_out_var_id && !qual_pos_var_name.empty() && !capture_output_to_buffer)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Deprecate set_options()/get_options() interface, replace it. Replace with common/hlsl/msl instead. The old interface had some bad interaction with overloading which meant you had to up-cast to base class to be able to use set_options, which was awkward.
2018-03-09 14:25:25 +00:00
if (options.vertex.fixup_clipspace)
Format code
2017-01-15 15:39:03 +00:00
statement(qual_pos_var_name, ".z = (", qual_pos_var_name, ".z + ", qual_pos_var_name,
".w) * 0.5; // Adjust clip-space for Metal");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Deprecate set_options()/get_options() interface, replace it. Replace with common/hlsl/msl instead. The old interface had some bad interaction with overloading which meant you had to up-cast to base class to be able to use set_options, which was awkward.
2018-03-09 14:25:25 +00:00
if (options.vertex.flip_vert_y)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
statement(qual_pos_var_name, ".y = -(", qual_pos_var_name, ".y);", " // Invert Y-axis for Metal");
}
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
// Return a string defining a structure member, with padding and packing.
string CompilerMSL::to_struct_member(const SPIRType &type, uint32_t member_type_id, uint32_t index,
const string &qualifier)
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
{
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
if (member_is_remapped_physical_type(type, index))
member_type_id = get_extended_member_decoration(type.self, index, SPIRVCrossDecorationPhysicalTypeID);
auto &physical_type = get<SPIRType>(member_type_id);
spirv_msl auto-alignment of members of MSL uniform structs. spirv_msl optionally add padding and packing to allow MSL struct members to align with SPIR-V struct alignments. spirv_cross add convenience methods for testing Decorations. spirv_glsl replace member_decl() function with new emit_stuct_member(). Allow struct member types to be marked as packed via DecorationCPacked decoration.
2017-03-01 02:44:36 +00:00
// If this member is packed, mark it as so.
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
string pack_pfx;
MSL: Start considering float[] and float2[] in std140 layout.
2019-01-16 15:16:39 +00:00
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Allow Metal to use the array<T> template to make arrays a value type
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
uint32_t orig_id = 0;
if (has_extended_member_decoration(type.self, index, SPIRVCrossDecorationInterfaceOrigID))
orig_id = get_extended_member_decoration(type.self, index, SPIRVCrossDecorationInterfaceOrigID);
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
bool row_major = false;
if (is_matrix(physical_type))
row_major = has_member_decoration(type.self, index, DecorationRowMajor);
SPIRType row_major_physical_type;
const SPIRType *declared_type = &physical_type;
MSL: Do not generate UnsafeArray<> for any array inside buffer objects. This avoids a lot of huge code changes. Arrays generally cannot be copied in and out of buffers, at least no compiler frontend seems to do it. Also avoids a lot of issues surrounding packed vectors and matrices.
2019-10-24 10:22:30 +00:00
// If a struct is being declared with physical layout,
// do not use array<T> wrappers.
// This avoids a lot of complicated cases with packed vectors and matrices,
// and generally we cannot copy full arrays in and out of buffers into Function
// address space.
MSL: Do not declare array of UBO/SSBO as spvUnsafeArray<T>. There is no need for these to be copied, and cuts down on template stamping bloat.
2019-10-24 11:57:05 +00:00
// Array of resources should also be declared as builtin arrays.
MSL: Do not generate UnsafeArray<> for any array inside buffer objects. This avoids a lot of huge code changes. Arrays generally cannot be copied in and out of buffers, at least no compiler frontend seems to do it. Also avoids a lot of issues surrounding packed vectors and matrices.
2019-10-24 10:22:30 +00:00
if (has_member_decoration(type.self, index, DecorationOffset))
MSL: Add a workaround path to force native arrays for everything.
2020-02-24 11:47:14 +00:00
is_using_builtin_array = true;
MSL: Do not declare array of UBO/SSBO as spvUnsafeArray<T>. There is no need for these to be copied, and cuts down on template stamping bloat.
2019-10-24 11:57:05 +00:00
else if (has_extended_member_decoration(type.self, index, SPIRVCrossDecorationResourceIndexPrimary))
MSL: Add a workaround path to force native arrays for everything.
2020-02-24 11:47:14 +00:00
is_using_builtin_array = true;
MSL: Do not generate UnsafeArray<> for any array inside buffer objects. This avoids a lot of huge code changes. Arrays generally cannot be copied in and out of buffers, at least no compiler frontend seems to do it. Also avoids a lot of issues surrounding packed vectors and matrices.
2019-10-24 10:22:30 +00:00
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
if (member_is_packed_physical_type(type, index))
CompilerMSL support smaller offsets for 3-row row-major matrices. Support MSL typedefs to declare 3-row row-major matrices as 3-column matrices. Allow those matrices to be decorated as packed. Support transposing those matrices when used. Modify how member alignments are calculated.
2018-02-11 21:52:57 +00:00
{
// If we're packing a matrix, output an appropriate typedef
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
if (physical_type.basetype == SPIRType::Struct)
MSL: Add a preliminary check for bad arrays of structs. ArrayStride can be larger than the declared struct size. We have no obvious solution for now, but warn about it in the MSL output for the time being.
2019-01-28 10:32:06 +00:00
{
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
SPIRV_CROSS_THROW("Cannot emit a packed struct currently.");
MSL: Add a preliminary check for bad arrays of structs. ArrayStride can be larger than the declared struct size. We have no obvious solution for now, but warn about it in the MSL output for the time being.
2019-01-28 10:32:06 +00:00
}
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
else if (is_matrix(physical_type))
CompilerMSL support smaller offsets for 3-row row-major matrices. Support MSL typedefs to declare 3-row row-major matrices as 3-column matrices. Allow those matrices to be decorated as packed. Support transposing those matrices when used. Modify how member alignments are calculated.
2018-02-11 21:52:57 +00:00
{
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
uint32_t rows = physical_type.vecsize;
uint32_t cols = physical_type.columns;
MSL: Start considering float[] and float2[] in std140 layout.
2019-01-16 15:16:39 +00:00
pack_pfx = "packed_";
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
if (row_major)
MSL: Handle packed matrices. The old method of using a different unpacked matrix type doesn't work for scalar alignment. It certainly wouldn't have any effect for a square matrix, since the number of columns and rows are the same. So now we'll store them as arrays of packed vectors.
2019-07-10 23:37:31 +00:00
{
// These are stored transposed.
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
rows = physical_type.columns;
cols = physical_type.vecsize;
MSL: Handle packed matrices. The old method of using a different unpacked matrix type doesn't work for scalar alignment. It certainly wouldn't have any effect for a square matrix, since the number of columns and rows are the same. So now we'll store them as arrays of packed vectors.
2019-07-10 23:37:31 +00:00
pack_pfx = "packed_rm_";
}
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
string base_type = physical_type.width == 16 ? "half" : "float";
CompilerMSL support smaller offsets for 3-row row-major matrices. Support MSL typedefs to declare 3-row row-major matrices as 3-column matrices. Allow those matrices to be decorated as packed. Support transposing those matrices when used. Modify how member alignments are calculated.
2018-02-11 21:52:57 +00:00
string td_line = "typedef ";
MSL: Handle packed matrices. The old method of using a different unpacked matrix type doesn't work for scalar alignment. It certainly wouldn't have any effect for a square matrix, since the number of columns and rows are the same. So now we'll store them as arrays of packed vectors.
2019-07-10 23:37:31 +00:00
td_line += "packed_" + base_type + to_string(rows);
CompilerMSL support smaller offsets for 3-row row-major matrices. Support MSL typedefs to declare 3-row row-major matrices as 3-column matrices. Allow those matrices to be decorated as packed. Support transposing those matrices when used. Modify how member alignments are calculated.
2018-02-11 21:52:57 +00:00
td_line += " " + pack_pfx;
MSL: Handle packed matrices. The old method of using a different unpacked matrix type doesn't work for scalar alignment. It certainly wouldn't have any effect for a square matrix, since the number of columns and rows are the same. So now we'll store them as arrays of packed vectors.
2019-07-10 23:37:31 +00:00
// Use the actual matrix size here.
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
td_line += base_type + to_string(physical_type.columns) + "x" + to_string(physical_type.vecsize);
MSL: Handle packed matrices. The old method of using a different unpacked matrix type doesn't work for scalar alignment. It certainly wouldn't have any effect for a square matrix, since the number of columns and rows are the same. So now we'll store them as arrays of packed vectors.
2019-07-10 23:37:31 +00:00
td_line += "[" + to_string(cols) + "]";
CompilerMSL support smaller offsets for 3-row row-major matrices. Support MSL typedefs to declare 3-row row-major matrices as 3-column matrices. Allow those matrices to be decorated as packed. Support transposing those matrices when used. Modify how member alignments are calculated.
2018-02-11 21:52:57 +00:00
td_line += ";";
add_typedef_line(td_line);
}
Fix #1359: MSL: If the packed type is scalar, don't emit "pack_" prefix. Scalar type is already packed in metal.
2020-05-05 16:39:56 +00:00
else if (!is_scalar(physical_type)) // scalar type is already packed.
MSL: Start considering float[] and float2[] in std140 layout.
2019-01-16 15:16:39 +00:00
pack_pfx = "packed_";
CompilerMSL support smaller offsets for 3-row row-major matrices. Support MSL typedefs to declare 3-row row-major matrices as 3-column matrices. Allow those matrices to be decorated as packed. Support transposing those matrices when used. Modify how member alignments are calculated.
2018-02-11 21:52:57 +00:00
}
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
else if (row_major)
{
// Need to declare type with flipped vecsize/columns.
row_major_physical_type = physical_type;
swap(row_major_physical_type.vecsize, row_major_physical_type.columns);
declared_type = &row_major_physical_type;
}
spirv_msl auto-alignment of members of MSL uniform structs. spirv_msl optionally add padding and packing to allow MSL struct members to align with SPIR-V struct alignments. spirv_cross add convenience methods for testing Decorations. spirv_glsl replace member_decl() function with new emit_stuct_member(). Allow struct member types to be marked as packed via DecorationCPacked decoration.
2017-03-01 02:44:36 +00:00
Rename "push descriptor set" to "discrete descriptor set". Check for case where iOS doesn't support writable argument buffer textures.
2019-03-15 20:53:21 +00:00
// Very specifically, image load-store in argument buffers are disallowed on MSL on iOS.
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
if (msl_options.is_ios() && physical_type.basetype == SPIRType::Image && physical_type.image.sampled == 2)
Rename "push descriptor set" to "discrete descriptor set". Check for case where iOS doesn't support writable argument buffer textures.
2019-03-15 20:53:21 +00:00
{
if (!has_decoration(orig_id, DecorationNonWritable))
SPIRV_CROSS_THROW("Writable images are not allowed in argument buffers on iOS.");
}
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
// Array information is baked into these types.
string array_type;
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
if (physical_type.basetype != SPIRType::Image && physical_type.basetype != SPIRType::Sampler &&
physical_type.basetype != SPIRType::SampledImage)
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
{
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
BuiltIn builtin = BuiltInMax;
Disabled spvUnsafeArray<> type for packed vectors and added test cases for those arrays.
2019-10-09 21:59:47 +00:00
if (is_member_builtin(type, index, &builtin))
MSL: Add a workaround path to force native arrays for everything.
2020-02-24 11:47:14 +00:00
is_using_builtin_array = true;
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
array_type = type_to_array_glsl(physical_type);
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
}
MSL: Do not generate UnsafeArray<> for any array inside buffer objects. This avoids a lot of huge code changes. Arrays generally cannot be copied in and out of buffers, at least no compiler frontend seems to do it. Also avoids a lot of issues surrounding packed vectors and matrices.
2019-10-24 10:22:30 +00:00
auto result = join(pack_pfx, type_to_glsl(*declared_type, orig_id), " ", qualifier, to_member_name(type, index),
member_attribute_qualifier(type, index), array_type, ";");
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
MSL: Add a workaround path to force native arrays for everything.
2020-02-24 11:47:14 +00:00
is_using_builtin_array = false;
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
return result;
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
}
// Emit a structure member, padding and packing to maintain the correct memeber alignments.
void CompilerMSL::emit_struct_member(const SPIRType &type, uint32_t member_type_id, uint32_t index,
const string &qualifier, uint32_t)
{
Start considering how to emit physical type ID.
2019-07-18 15:05:28 +00:00
// If this member requires padding to maintain its declared offset, emit a dummy padding member before it.
Tests run clean.
2019-07-22 08:23:39 +00:00
if (has_extended_member_decoration(type.self, index, SPIRVCrossDecorationPaddingTarget))
Start considering how to emit physical type ID.
2019-07-18 15:05:28 +00:00
{
Tests run clean.
2019-07-22 08:23:39 +00:00
uint32_t pad_len = get_extended_member_decoration(type.self, index, SPIRVCrossDecorationPaddingTarget);
statement("char _m", index, "_pad", "[", pad_len, "];");
Start considering how to emit physical type ID.
2019-07-18 15:05:28 +00:00
}
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
// Handle HLSL-style 0-based vertex/instance index.
builtin_declaration = true;
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
statement(to_struct_member(type, member_type_id, index, qualifier));
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
builtin_declaration = false;
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
Tests run clean.
2019-07-22 08:23:39 +00:00
void CompilerMSL::emit_struct_padding_target(const SPIRType &type)
{
uint32_t struct_size = get_declared_struct_size_msl(type, true, true);
uint32_t target_size = get_extended_decoration(type.self, SPIRVCrossDecorationPaddingTarget);
if (target_size < struct_size)
SPIRV_CROSS_THROW("Cannot pad with negative bytes.");
else if (target_size > struct_size)
statement("char _m0_final_padding[", target_size - struct_size, "];");
}
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
// Return a MSL qualifier for the specified function attribute member
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
string CompilerMSL::member_attribute_qualifier(const SPIRType &type, uint32_t index)
{
Add support for multiple entry points. - Only consider I/O variables if part of OpEntryPoint. - Keep a safe fallback if #entry-points is 1 to avoid potentially breaking previously working shaders.
2016-07-28 09:16:02 +00:00
auto &execution = get_entry_point();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
CompilerMSL add support for MSL qualifiers on gl_ClipDistance and other array-based builtins.
2017-05-23 17:24:41 +00:00
uint32_t mbr_type_id = type.member_types[index];
auto &mbr_type = get<SPIRType>(mbr_type_id);
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
BuiltIn builtin = BuiltInMax;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
bool is_builtin = is_member_builtin(type, index, &builtin);
MSL: Rewrite how resource indices are fallback-assigned. We used to use the Binding decoration for this, but this method is hopelessly broken. If no explicit MSL resource remapping exists, we remap automatically in a manner which should always "just work".
2019-06-21 10:44:33 +00:00
if (has_extended_member_decoration(type.self, index, SPIRVCrossDecorationResourceIndexPrimary))
Support the SPV_EXT_fragment_shader_interlock extension. This was straightforward to implement in GLSL. The `ShadingRateInterlockOrderedEXT` and `ShadingRateInterlockUnorderedEXT` modes aren't implemented yet, because we don't support `SPV_NV_shading_rate` or `SPV_EXT_fragment_invocation_density` yet. HLSL and MSL were more interesting. They don't support this directly, but they do support marking resources as "rasterizer ordered," which does roughly the same thing. So this implementation scans all accesses inside the critical section and marks all storage resources found therein as rasterizer ordered. They also don't support the fine-grained controls on pixel- vs. sample-level interlock and disabling ordering guarantees that GLSL and SPIR-V do, but that's OK. "Unordered" here merely means the order is undefined; that it just so happens to be the same as rasterizer order is immaterial. As for pixel- vs. sample-level interlock, Vulkan explicitly states: > With sample shading enabled, [the `PixelInterlockOrderedEXT` and > `PixelInterlockUnorderedEXT`] execution modes are treated like > `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT` > respectively. and: > If [the `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT`] > execution modes are used in single-sample mode they are treated like > `PixelInterlockOrderedEXT` or `PixelInterlockUnorderedEXT` > respectively. So this will DTRT for MoltenVK and gfx-rs, at least. MSL additionally supports multiple raster order groups; resources that are not accessed together can be placed in different ROGs to allow them to be synchronized separately. A more sophisticated analysis might be able to place resources optimally, but that's outside the scope of this change. For now, we assign all resources to group 0, which should do for our purposes. `glslang` doesn't support the `RasterizerOrdered` UAVs this implementation produces for HLSL, so the test case needs `fxc.exe`. It also insists on GLSL 4.50 for `GL_ARB_fragment_shader_interlock`, even though the spec says it needs either 4.20 or `GL_ARB_shader_image_load_store`; and it doesn't support the `GL_NV_fragment_shader_interlock` extension at all. So I haven't been able to test those code paths. Fixes #1002.
2019-08-04 05:07:20 +00:00
{
string quals = join(
" [[id(", get_extended_member_decoration(type.self, index, SPIRVCrossDecorationResourceIndexPrimary), ")");
if (interlocked_resources.count(
get_extended_member_decoration(type.self, index, SPIRVCrossDecorationInterfaceOrigID)))
quals += ", raster_order_group(0)";
quals += "]]";
return quals;
}
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Vertex function inputs
if (execution.model == ExecutionModelVertex && type.storage == StorageClassInput)
{
if (is_builtin)
{
switch (builtin)
{
case BuiltInVertexId:
case BuiltInVertexIndex:
Support the shader_draw_parameters extension.
2018-08-28 18:47:29 +00:00
case BuiltInBaseVertex:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case BuiltInInstanceId:
case BuiltInInstanceIndex:
Support the shader_draw_parameters extension.
2018-08-28 18:47:29 +00:00
case BuiltInBaseInstance:
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (msl_options.vertex_for_tessellation)
return "";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return string(" [[") + builtin_qualifier(builtin) + "]]";
Throw an exception anytime we try to compile DrawIndex to MSL.
2018-08-29 17:05:33 +00:00
case BuiltInDrawIndex:
SPIRV_CROSS_THROW("DrawIndex is not supported in MSL.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
default:
return "";
}
}
uint32_t locn = get_ordered_member_location(type.self, index);
CompilerMSL support separate indexed MTLBuffers for stage_in containing matrices. Add DecorationBinding to Compiler::get_member_decoration()/set_member_decoration().
2017-01-29 18:28:20 +00:00
if (locn != k_unknown_location)
return string(" [[attribute(") + convert_to_string(locn) + ")]]";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
// Vertex and tessellation evaluation function outputs
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (((execution.model == ExecutionModelVertex && !msl_options.vertex_for_tessellation) ||
execution.model == ExecutionModelTessellationEvaluation) &&
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
type.storage == StorageClassOutput)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
if (is_builtin)
{
switch (builtin)
{
CompilerMSL elide unused builtins from entry function input and output structs. Add Compiler::has_active_builtin() function. Update test reference shaders that included unused builtins.
2017-05-24 13:31:38 +00:00
case BuiltInPointSize:
// Only mark the PointSize builtin if really rendering points.
// Some shaders may include a PointSize builtin even when used to render
// non-point topologies, and Metal will reject this builtin when compiling
// the shader into a render pipeline that uses a non-point topology.
Deprecate set_options()/get_options() interface, replace it. Replace with common/hlsl/msl instead. The old interface had some bad interaction with overloading which meant you had to up-cast to base class to be able to use set_options, which was awkward.
2018-03-09 14:25:25 +00:00
return msl_options.enable_point_size_builtin ? (string(" [[") + builtin_qualifier(builtin) + "]]") : "";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
MSL: Handle the ViewportIndex builtin. This requires MSL 2.0+. Also, force `ViewportIndex` and `Layer` to be defined as the correct type, which is always `uint` in MSL. Since Metal doesn't yet have geometry shaders, the vertex shader (or tessellation evaluation shader == "post-tessellation vertex shader" in Metal jargon) is the only kind of shader that can set this output. This currently requires an extension to Vulkan, which causes validation of the SPIR-V binaries for the test cases to fail. Therefore, the test cases are marked "invalid", even though they're actually perfectly valid SPIR-V--they just won't work without the `SPV_EXT_shader_viewport_index_layer` extension.
2018-09-12 23:00:17 +00:00
case BuiltInViewportIndex:
if (!msl_options.supports_msl_version(2, 0))
SPIRV_CROSS_THROW("ViewportIndex requires Metal 2.0.");
/* fallthrough */
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case BuiltInPosition:
case BuiltInLayer:
CompilerMSL add support for MSL qualifiers on gl_ClipDistance and other array-based builtins.
2017-05-23 17:24:41 +00:00
return string(" [[") + builtin_qualifier(builtin) + "]]" + (mbr_type.array.empty() ? "" : " ");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
case BuiltInClipDistance:
if (has_member_decoration(type.self, index, DecorationLocation))
return join(" [[user(clip", get_member_decoration(type.self, index, DecorationLocation), ")]]");
else
return string(" [[") + builtin_qualifier(builtin) + "]]" + (mbr_type.array.empty() ? "" : " ");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
default:
return "";
}
}
MSL: Account for components when assigning locations to varyings. Two varyings (vertex outputs/fragment inputs) might have the same location but be in different components--e.g. the compiler may have packed what were two different varyings into a single varying vector. Giving both varyings the same `[[user]]` attribute won't work--it may yield unexpected results, or flat out fail to link. We could eventually pack such varyings into a single vector, but that would require us to handle the case where the varyings are different types--e.g. a `float` and a `uint` packed into the same vector. For now, it seems most prudent to give them unique `[[user]]` locations and let Apple's compiler work out the best way to pack them.
2018-09-05 22:31:10 +00:00
uint32_t comp;
uint32_t locn = get_ordered_member_location(type.self, index, &comp);
CompilerMSL support separate indexed MTLBuffers for stage_in containing matrices. Add DecorationBinding to Compiler::get_member_decoration()/set_member_decoration().
2017-01-29 18:28:20 +00:00
if (locn != k_unknown_location)
MSL: Account for components when assigning locations to varyings. Two varyings (vertex outputs/fragment inputs) might have the same location but be in different components--e.g. the compiler may have packed what were two different varyings into a single varying vector. Giving both varyings the same `[[user]]` attribute won't work--it may yield unexpected results, or flat out fail to link. We could eventually pack such varyings into a single vector, but that would require us to handle the case where the varyings are different types--e.g. a `float` and a `uint` packed into the same vector. For now, it seems most prudent to give them unique `[[user]]` locations and let Apple's compiler work out the best way to pack them.
2018-09-05 22:31:10 +00:00
{
if (comp != k_unknown_component)
return string(" [[user(locn") + convert_to_string(locn) + "_" + convert_to_string(comp) + ")]]";
else
return string(" [[user(locn") + convert_to_string(locn) + ")]]";
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
// Tessellation control function inputs
if (execution.model == ExecutionModelTessellationControl && type.storage == StorageClassInput)
{
if (is_builtin)
{
switch (builtin)
{
case BuiltInInvocationId:
case BuiltInPrimitiveId:
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (msl_options.multi_patch_workgroup)
return "";
/* fallthrough */
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
case BuiltInSubgroupLocalInvocationId: // FIXME: Should work in any stage
case BuiltInSubgroupSize: // FIXME: Should work in any stage
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
return string(" [[") + builtin_qualifier(builtin) + "]]" + (mbr_type.array.empty() ? "" : " ");
case BuiltInPatchVertices:
return "";
// Others come from stage input.
default:
break;
}
}
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (msl_options.multi_patch_workgroup)
return "";
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
uint32_t locn = get_ordered_member_location(type.self, index);
if (locn != k_unknown_location)
return string(" [[attribute(") + convert_to_string(locn) + ")]]";
}
// Tessellation control function outputs
if (execution.model == ExecutionModelTessellationControl && type.storage == StorageClassOutput)
{
// For this type of shader, we always arrange for it to capture its
// output to a buffer. For this reason, qualifiers are irrelevant here.
return "";
}
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
// Tessellation evaluation function inputs
if (execution.model == ExecutionModelTessellationEvaluation && type.storage == StorageClassInput)
{
if (is_builtin)
{
switch (builtin)
{
case BuiltInPrimitiveId:
case BuiltInTessCoord:
return string(" [[") + builtin_qualifier(builtin) + "]]";
case BuiltInPatchVertices:
return "";
// Others come from stage input.
default:
break;
}
}
// The special control point array must not be marked with an attribute.
if (get_type(type.member_types[index]).basetype == SPIRType::ControlPointArray)
return "";
uint32_t locn = get_ordered_member_location(type.self, index);
if (locn != k_unknown_location)
return string(" [[attribute(") + convert_to_string(locn) + ")]]";
}
// Tessellation evaluation function outputs were handled above.
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Fragment function inputs
if (execution.model == ExecutionModelFragment && type.storage == StorageClassInput)
{
MSL: Support PrimitiveID in fragment and barycentrics.
2019-06-13 09:33:40 +00:00
string quals;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (is_builtin)
{
switch (builtin)
{
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
case BuiltInViewIndex:
MSL: Don't set the layer for multiview if the device doesn't support it. Some older iOS devices don't support layered rendering. In that case, don't set `[[render_target_array_index]]`, because the compiler will reject the shader in that case. The client will then have to unroll the render pass manually.
2020-08-23 21:44:41 +00:00
if (!msl_options.multiview || !msl_options.multiview_layered_rendering)
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
break;
/* fallthrough */
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case BuiltInFrontFacing:
case BuiltInPointCoord:
Add support for BuiltInFragCoord (changed from BuiltInSamplePosition).
2016-07-04 15:49:46 +00:00
case BuiltInFragCoord:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case BuiltInSampleId:
case BuiltInSampleMask:
case BuiltInLayer:
MSL: Support PrimitiveID in fragment and barycentrics.
2019-06-13 09:33:40 +00:00
case BuiltInBaryCoordNV:
case BuiltInBaryCoordNoPerspNV:
MSL: Handle interpolation qualifiers.
2018-09-04 21:08:22 +00:00
quals = builtin_qualifier(builtin);
MSL: Support PrimitiveID in fragment and barycentrics.
2019-06-13 09:33:40 +00:00
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
case BuiltInClipDistance:
return join(" [[user(clip", get_member_decoration(type.self, index, DecorationLocation), ")]]");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
default:
MSL: Handle interpolation qualifiers.
2018-09-04 21:08:22 +00:00
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
}
MSL: Handle interpolation qualifiers.
2018-09-04 21:08:22 +00:00
else
{
MSL: Account for components when assigning locations to varyings. Two varyings (vertex outputs/fragment inputs) might have the same location but be in different components--e.g. the compiler may have packed what were two different varyings into a single varying vector. Giving both varyings the same `[[user]]` attribute won't work--it may yield unexpected results, or flat out fail to link. We could eventually pack such varyings into a single vector, but that would require us to handle the case where the varyings are different types--e.g. a `float` and a `uint` packed into the same vector. For now, it seems most prudent to give them unique `[[user]]` locations and let Apple's compiler work out the best way to pack them.
2018-09-05 22:31:10 +00:00
uint32_t comp;
uint32_t locn = get_ordered_member_location(type.self, index, &comp);
MSL: Handle interpolation qualifiers.
2018-09-04 21:08:22 +00:00
if (locn != k_unknown_location)
MSL: Account for components when assigning locations to varyings. Two varyings (vertex outputs/fragment inputs) might have the same location but be in different components--e.g. the compiler may have packed what were two different varyings into a single varying vector. Giving both varyings the same `[[user]]` attribute won't work--it may yield unexpected results, or flat out fail to link. We could eventually pack such varyings into a single vector, but that would require us to handle the case where the varyings are different types--e.g. a `float` and a `uint` packed into the same vector. For now, it seems most prudent to give them unique `[[user]]` locations and let Apple's compiler work out the best way to pack them.
2018-09-05 22:31:10 +00:00
{
MSL: Add trivial tests for Component decoration. Verifies that Component decoration is honored for vertex outputs and fragment inputs.
2020-01-07 10:36:51 +00:00
// For user-defined attributes, this is fine. From Vulkan spec:
// A user-defined output variable is considered to match an input variable in the subsequent stage if
// the two variables are declared with the same Location and Component decoration and match in type
// and decoration, except that interpolation decorations are not required to match. For the purposes
// of interface matching, variables declared without a Component decoration are considered to have a
// Component decoration of zero.
if (comp != k_unknown_component && comp != 0)
MSL: Account for components when assigning locations to varyings. Two varyings (vertex outputs/fragment inputs) might have the same location but be in different components--e.g. the compiler may have packed what were two different varyings into a single varying vector. Giving both varyings the same `[[user]]` attribute won't work--it may yield unexpected results, or flat out fail to link. We could eventually pack such varyings into a single vector, but that would require us to handle the case where the varyings are different types--e.g. a `float` and a `uint` packed into the same vector. For now, it seems most prudent to give them unique `[[user]]` locations and let Apple's compiler work out the best way to pack them.
2018-09-05 22:31:10 +00:00
quals = string("user(locn") + convert_to_string(locn) + "_" + convert_to_string(comp) + ")";
else
quals = string("user(locn") + convert_to_string(locn) + ")";
}
MSL: Handle interpolation qualifiers.
2018-09-04 21:08:22 +00:00
}
MSL: Support PrimitiveID in fragment and barycentrics.
2019-06-13 09:33:40 +00:00
if (builtin == BuiltInBaryCoordNV || builtin == BuiltInBaryCoordNoPerspNV)
{
if (has_member_decoration(type.self, index, DecorationFlat) ||
has_member_decoration(type.self, index, DecorationCentroid) ||
has_member_decoration(type.self, index, DecorationSample) ||
has_member_decoration(type.self, index, DecorationNoPerspective))
{
// NoPerspective is baked into the builtin type.
Run format_all.sh.
2019-06-21 14:02:22 +00:00
SPIRV_CROSS_THROW(
"Flat, Centroid, Sample, NoPerspective decorations are not supported for BaryCoord inputs.");
MSL: Support PrimitiveID in fragment and barycentrics.
2019-06-13 09:33:40 +00:00
}
}
MSL: Handle interpolation qualifiers.
2018-09-04 21:08:22 +00:00
// Don't bother decorating integers with the 'flat' attribute; it's
// the default (in fact, the only option). Also don't bother with the
// FragCoord builtin; it's always noperspective on Metal.
if (!type_is_integral(mbr_type) && (!is_builtin || builtin != BuiltInFragCoord))
{
if (has_member_decoration(type.self, index, DecorationFlat))
{
if (!quals.empty())
quals += ", ";
quals += "flat";
}
else if (has_member_decoration(type.self, index, DecorationCentroid))
{
if (!quals.empty())
quals += ", ";
if (has_member_decoration(type.self, index, DecorationNoPerspective))
quals += "centroid_no_perspective";
else
quals += "centroid_perspective";
}
else if (has_member_decoration(type.self, index, DecorationSample))
{
if (!quals.empty())
quals += ", ";
if (has_member_decoration(type.self, index, DecorationNoPerspective))
quals += "sample_no_perspective";
else
quals += "sample_perspective";
}
else if (has_member_decoration(type.self, index, DecorationNoPerspective))
{
if (!quals.empty())
quals += ", ";
quals += "center_no_perspective";
}
}
MSL: Support PrimitiveID in fragment and barycentrics.
2019-06-13 09:33:40 +00:00
MSL: Handle interpolation qualifiers.
2018-09-04 21:08:22 +00:00
if (!quals.empty())
return " [[" + quals + "]]";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
// Fragment function outputs
if (execution.model == ExecutionModelFragment && type.storage == StorageClassOutput)
{
if (is_builtin)
{
switch (builtin)
{
MSL: Support stencil export.
2019-06-12 08:06:59 +00:00
case BuiltInFragStencilRefEXT:
MSL: Add options to control emission of fragment outputs. Like with `point_size` when not rendering points, Metal complains when writing to a variable using the `[[depth]]` qualifier when no depth buffer be attached. In that case, we must avoid emitting `FragDepth`, just like with `PointSize`. I assume it will also complain if there be no stencil attachment and the shader write to `[[stencil]]`, or it write to `[[color(n)]]` but there be no color attachment at n.
2020-04-10 06:13:33 +00:00
// Similar to PointSize, only mark FragStencilRef if there's a stencil buffer.
// Some shaders may include a FragStencilRef builtin even when used to render
// without a stencil attachment, and Metal will reject this builtin
// when compiling the shader into a render pipeline that does not set
// stencilAttachmentPixelFormat.
if (!msl_options.enable_frag_stencil_ref_builtin)
return "";
MSL: Support stencil export.
2019-06-12 08:06:59 +00:00
if (!msl_options.supports_msl_version(2, 1))
SPIRV_CROSS_THROW("Stencil export only supported in MSL 2.1 and up.");
return string(" [[") + builtin_qualifier(builtin) + "]]";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case BuiltInFragDepth:
MSL: Add options to control emission of fragment outputs. Like with `point_size` when not rendering points, Metal complains when writing to a variable using the `[[depth]]` qualifier when no depth buffer be attached. In that case, we must avoid emitting `FragDepth`, just like with `PointSize`. I assume it will also complain if there be no stencil attachment and the shader write to `[[stencil]]`, or it write to `[[color(n)]]` but there be no color attachment at n.
2020-04-10 06:13:33 +00:00
// Ditto FragDepth.
if (!msl_options.enable_frag_depth_builtin)
return "";
/* fallthrough */
case BuiltInSampleMask:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return string(" [[") + builtin_qualifier(builtin) + "]]";
default:
return "";
}
}
MSL: Add color attribute qualifiers to fragment function outputs
2016-10-01 06:46:43 +00:00
uint32_t locn = get_ordered_member_location(type.self, index);
MSL: Add options to control emission of fragment outputs. Like with `point_size` when not rendering points, Metal complains when writing to a variable using the `[[depth]]` qualifier when no depth buffer be attached. In that case, we must avoid emitting `FragDepth`, just like with `PointSize`. I assume it will also complain if there be no stencil attachment and the shader write to `[[stencil]]`, or it write to `[[color(n)]]` but there be no color attachment at n.
2020-04-10 06:13:33 +00:00
// Metal will likely complain about missing color attachments, too.
if (locn != k_unknown_location && !(msl_options.enable_frag_output_mask & (1 << locn)))
return "";
Support dual-source blending on GLSL and MSL.
2018-04-03 13:56:22 +00:00
if (locn != k_unknown_location && has_member_decoration(type.self, index, DecorationIndex))
Run format_all.sh.
2018-04-10 10:32:14 +00:00
return join(" [[color(", locn, "), index(", get_member_decoration(type.self, index, DecorationIndex),
")]]");
Support dual-source blending on GLSL and MSL.
2018-04-03 13:56:22 +00:00
else if (locn != k_unknown_location)
return join(" [[color(", locn, ")]]");
else if (has_member_decoration(type.self, index, DecorationIndex))
return join(" [[index(", get_member_decoration(type.self, index, DecorationIndex), ")]]");
else
return "";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
spirv_msl: Add support for gl_GlobalInvocationId
2017-01-22 18:09:04 +00:00
// Compute function inputs
if (execution.model == ExecutionModelGLCompute && type.storage == StorageClassInput)
{
if (is_builtin)
{
switch (builtin)
{
case BuiltInGlobalInvocationId:
Add WorkGroupID/NumWorkGroups to MSL. Fix block name alias.
2017-09-29 10:16:53 +00:00
case BuiltInWorkgroupId:
case BuiltInNumWorkgroups:
msl: Add support for gl_LocalInvocationID and gl_LocalInvocationIndex
2017-01-27 01:22:31 +00:00
case BuiltInLocalInvocationId:
case BuiltInLocalInvocationIndex:
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
case BuiltInNumSubgroups:
case BuiltInSubgroupId:
case BuiltInSubgroupLocalInvocationId: // FIXME: Should work in any stage
case BuiltInSubgroupSize: // FIXME: Should work in any stage
spirv_msl: Add support for gl_GlobalInvocationId
2017-01-22 18:09:04 +00:00
return string(" [[") + builtin_qualifier(builtin) + "]]";
default:
return "";
}
}
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return "";
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
MSL sort interface struct members by offset instead of location. MSL support OpFMod as fmod() function. Remove SPIRType::is_packed member.
2016-12-04 17:32:58 +00:00
// Returns the location decoration of the member with the specified index in the specified type.
// If the location of the member has been explicitly set, that location is used. If not, this
// function assumes the members are ordered in their location order, and simply returns the
// index as the location.
MSL: Account for components when assigning locations to varyings. Two varyings (vertex outputs/fragment inputs) might have the same location but be in different components--e.g. the compiler may have packed what were two different varyings into a single varying vector. Giving both varyings the same `[[user]]` attribute won't work--it may yield unexpected results, or flat out fail to link. We could eventually pack such varyings into a single vector, but that would require us to handle the case where the varyings are different types--e.g. a `float` and a `uint` packed into the same vector. For now, it seems most prudent to give them unique `[[user]]` locations and let Apple's compiler work out the best way to pack them.
2018-09-05 22:31:10 +00:00
uint32_t CompilerMSL::get_ordered_member_location(uint32_t type_id, uint32_t index, uint32_t *comp)
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
{
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
auto &m = ir.meta[type_id];
MSL sort interface struct members by offset instead of location. MSL support OpFMod as fmod() function. Remove SPIRType::is_packed member.
2016-12-04 17:32:58 +00:00
if (index < m.members.size())
{
auto &dec = m.members[index];
MSL: Account for components when assigning locations to varyings. Two varyings (vertex outputs/fragment inputs) might have the same location but be in different components--e.g. the compiler may have packed what were two different varyings into a single varying vector. Giving both varyings the same `[[user]]` attribute won't work--it may yield unexpected results, or flat out fail to link. We could eventually pack such varyings into a single vector, but that would require us to handle the case where the varyings are different types--e.g. a `float` and a `uint` packed into the same vector. For now, it seems most prudent to give them unique `[[user]]` locations and let Apple's compiler work out the best way to pack them.
2018-09-05 22:31:10 +00:00
if (comp)
{
if (dec.decoration_flags.get(DecorationComponent))
*comp = dec.component;
else
*comp = k_unknown_component;
}
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (dec.decoration_flags.get(DecorationLocation))
MSL sort interface struct members by offset instead of location. MSL support OpFMod as fmod() function. Remove SPIRType::is_packed member.
2016-12-04 17:32:58 +00:00
return dec.location;
}
return index;
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
// Returns the type declaration for a function, including the
// entry type if the current function is the entry point function
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
string CompilerMSL::func_type_decl(SPIRType &type)
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// The regular function return type. If not processing the entry point function, that's all we need
Support returning arrays from functions in GLSL/MSL. Not possible in HLSL apparently, need workaround ...
2018-02-05 08:34:54 +00:00
string return_type = type_to_glsl(type) + type_to_array_glsl(type);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (!processing_entry_point)
return return_type;
CompilerMSL vertex entry point return void when rasterization disabled. Add CompilerMSL::Options::disable_rasterization input/output API flag. Disable rasterization via API flag or when writing to textures. Disable rasterization when shader declares no output. Add test shaders for vertex no output and write texture forcing void output.
2018-07-26 04:50:33 +00:00
// If an outgoing interface block has been defined, and it should be returned, override the entry point return type
Add CompilerMSL::get_is_rasterization_disabled() to manage rasterization status.
2018-07-26 20:40:32 +00:00
bool ep_should_return_output = !get_is_rasterization_disabled();
CompilerMSL vertex entry point return void when rasterization disabled. Add CompilerMSL::Options::disable_rasterization input/output API flag. Disable rasterization via API flag or when writing to textures. Disable rasterization when shader declares no output. Add test shaders for vertex no output and write texture forcing void output.
2018-07-26 04:50:33 +00:00
if (stage_out_var_id && ep_should_return_output)
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
return_type = type_to_glsl(get_stage_out_struct_type()) + type_to_array_glsl(type);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Prepend a entry type, based on the execution model
string entry_type;
CompilerMSL vertex entry point return void when rasterization disabled. Add CompilerMSL::Options::disable_rasterization input/output API flag. Disable rasterization via API flag or when writing to textures. Disable rasterization when shader declares no output. Add test shaders for vertex no output and write texture forcing void output.
2018-07-26 04:50:33 +00:00
auto &execution = get_entry_point();
Run clang-format.
2016-10-24 13:24:24 +00:00
switch (execution.model)
{
case ExecutionModelVertex:
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (msl_options.vertex_for_tessellation && !msl_options.supports_msl_version(1, 2))
SPIRV_CROSS_THROW("Tessellation requires Metal 1.2.");
entry_type = msl_options.vertex_for_tessellation ? "kernel" : "vertex";
Run clang-format.
2016-10-24 13:24:24 +00:00
break;
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
case ExecutionModelTessellationEvaluation:
if (!msl_options.supports_msl_version(1, 2))
SPIRV_CROSS_THROW("Tessellation requires Metal 1.2.");
if (execution.flags.get(ExecutionModeIsolines))
SPIRV_CROSS_THROW("Metal does not support isoline tessellation.");
if (msl_options.is_ios())
entry_type =
join("[[ patch(", execution.flags.get(ExecutionModeTriangles) ? "triangle" : "quad", ") ]] vertex");
else
entry_type = join("[[ patch(", execution.flags.get(ExecutionModeTriangles) ? "triangle" : "quad", ", ",
execution.output_vertices, ") ]] vertex");
break;
Run clang-format.
2016-10-24 13:24:24 +00:00
case ExecutionModelFragment:
Support the SPV_KHR_post_depth_coverage extension. Using the `PostDepthCoverage` mode specifies that the `gl_SampleMaskIn` variable is to contain the computed coverage mask following the early fragment tests, which this mode requires and implicitly enables. Note that unlike Vulkan and OpenGL, Metal places this on the sample mask input itself, and furthermore does *not* implicitly enable early fragment testing. If it isn't enabled explicitly with an `[[early_fragment_tests]]` attribute, the compiler will error out. So we have to enable that mode explicitly if `PostDepthCoverage` is enabled but `EarlyFragmentTests` isn't. For Metal, only iOS supports this; for some reason, Apple has yet to implement it on macOS, even though many desktop cards support it.
2019-07-11 03:42:39 +00:00
entry_type = execution.flags.get(ExecutionModeEarlyFragmentTests) ||
execution.flags.get(ExecutionModePostDepthCoverage) ?
"[[ early_fragment_tests ]] fragment" :
"fragment";
Run clang-format.
2016-10-24 13:24:24 +00:00
break;
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
case ExecutionModelTessellationControl:
if (!msl_options.supports_msl_version(1, 2))
SPIRV_CROSS_THROW("Tessellation requires Metal 1.2.");
Throw an error if the shader specifies isoline tessellation.
2019-02-11 23:21:36 +00:00
if (execution.flags.get(ExecutionModeIsolines))
SPIRV_CROSS_THROW("Metal does not support isoline tessellation.");
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
/* fallthrough */
Run clang-format.
2016-10-24 13:24:24 +00:00
case ExecutionModelGLCompute:
case ExecutionModelKernel:
entry_type = "kernel";
break;
default:
entry_type = "unknown";
break;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return entry_type + " " + return_type;
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
// In MSL, address space qualifiers are required for all pointer or reference variables
msl: Handle writable SSBO in function arguments
2017-01-27 00:40:56 +00:00
string CompilerMSL::get_argument_address_space(const SPIRVariable &argument)
{
const auto &type = get<SPIRType>(argument.basetype);
MSL: Unify the get_*_address_space() methods. These methods have largely the same logic, with minor differences. That I felt compelled to duplicate the logic into another method was one of the things that bothered me about the variable pointers change. This cleans that part of the code up; now we don't have two places to change.
2019-07-26 06:06:35 +00:00
return get_type_address_space(type, argument.self, true);
}
string CompilerMSL::get_type_address_space(const SPIRType &type, uint32_t id, bool argument)
{
// This can be called for variable pointer contexts as well, so be very careful about which method we choose.
MSL: Handle coherent, volatile, and restrict. This maps them to their MSL equivalents. I've mapped `Coherent` to `volatile` since MSL doesn't have anything weaker than `volatile` but stronger than nothing. As part of this, I had to remove the implicit `volatile` added for atomic operation casts. If the buffer is already `coherent` or `volatile`, then we would add a second `volatile`, which would be redundant. I think this is OK even when the buffer *doesn't* have `coherent`: `T *` is implicitly convertible to `volatile T *`, but not vice-versa. It seems to compile OK at any rate. (Note that the non-`volatile` overloads of the atomic functions documented in the spec aren't present in the MSL 2.2 stdlib headers.) `restrict` is tricky, because in MSL, as in C++, it needs to go *after* the asterisk or ampersand for the pointer type it's modifying. Another issue is that, in the `Simple`, `GLSL450`, and `Vulkan` memory models, `Restrict` is the default (i.e. does not need to be specified); but MSL likely follows the `OpenCL` model where `Aliased` is the default. We probably need to implicitly set either `Restrict` or `Aliased` depending on the module's declared memory model.
2019-07-10 16:17:40 +00:00
Bitset flags;
MSL: Unify the get_*_address_space() methods. These methods have largely the same logic, with minor differences. That I felt compelled to duplicate the logic into another method was one of the things that bothered me about the variable pointers change. This cleans that part of the code up; now we don't have two places to change.
2019-07-26 06:06:35 +00:00
auto *var = maybe_get<SPIRVariable>(id);
if (var && type.basetype == SPIRType::Struct &&
MSL: Handle coherent, volatile, and restrict. This maps them to their MSL equivalents. I've mapped `Coherent` to `volatile` since MSL doesn't have anything weaker than `volatile` but stronger than nothing. As part of this, I had to remove the implicit `volatile` added for atomic operation casts. If the buffer is already `coherent` or `volatile`, then we would add a second `volatile`, which would be redundant. I think this is OK even when the buffer *doesn't* have `coherent`: `T *` is implicitly convertible to `volatile T *`, but not vice-versa. It seems to compile OK at any rate. (Note that the non-`volatile` overloads of the atomic functions documented in the spec aren't present in the MSL 2.2 stdlib headers.) `restrict` is tricky, because in MSL, as in C++, it needs to go *after* the asterisk or ampersand for the pointer type it's modifying. Another issue is that, in the `Simple`, `GLSL450`, and `Vulkan` memory models, `Restrict` is the default (i.e. does not need to be specified); but MSL likely follows the `OpenCL` model where `Aliased` is the default. We probably need to implicitly set either `Restrict` or `Aliased` depending on the module's declared memory model.
2019-07-10 16:17:40 +00:00
(has_decoration(type.self, DecorationBlock) || has_decoration(type.self, DecorationBufferBlock)))
MSL: Unify the get_*_address_space() methods. These methods have largely the same logic, with minor differences. That I felt compelled to duplicate the logic into another method was one of the things that bothered me about the variable pointers change. This cleans that part of the code up; now we don't have two places to change.
2019-07-26 06:06:35 +00:00
flags = get_buffer_block_flags(id);
MSL: Handle coherent, volatile, and restrict. This maps them to their MSL equivalents. I've mapped `Coherent` to `volatile` since MSL doesn't have anything weaker than `volatile` but stronger than nothing. As part of this, I had to remove the implicit `volatile` added for atomic operation casts. If the buffer is already `coherent` or `volatile`, then we would add a second `volatile`, which would be redundant. I think this is OK even when the buffer *doesn't* have `coherent`: `T *` is implicitly convertible to `volatile T *`, but not vice-versa. It seems to compile OK at any rate. (Note that the non-`volatile` overloads of the atomic functions documented in the spec aren't present in the MSL 2.2 stdlib headers.) `restrict` is tricky, because in MSL, as in C++, it needs to go *after* the asterisk or ampersand for the pointer type it's modifying. Another issue is that, in the `Simple`, `GLSL450`, and `Vulkan` memory models, `Restrict` is the default (i.e. does not need to be specified); but MSL likely follows the `OpenCL` model where `Aliased` is the default. We probably need to implicitly set either `Restrict` or `Aliased` depending on the module's declared memory model.
2019-07-10 16:17:40 +00:00
else
MSL: Unify the get_*_address_space() methods. These methods have largely the same logic, with minor differences. That I felt compelled to duplicate the logic into another method was one of the things that bothered me about the variable pointers change. This cleans that part of the code up; now we don't have two places to change.
2019-07-26 06:06:35 +00:00
flags = get_decoration_bitset(id);
msl: Handle writable SSBO in function arguments
2017-01-27 00:40:56 +00:00
MSL: Unify the get_*_address_space() methods. These methods have largely the same logic, with minor differences. That I felt compelled to duplicate the logic into another method was one of the things that bothered me about the variable pointers change. This cleans that part of the code up; now we don't have two places to change.
2019-07-26 06:06:35 +00:00
const char *addr_space = nullptr;
CompilerMSL declare threadgroup variables accessed in called functions.
2018-01-24 20:38:17 +00:00
switch (type.storage)
msl: Handle writable SSBO in function arguments
2017-01-27 00:40:56 +00:00
{
CompilerMSL declare threadgroup variables accessed in called functions.
2018-01-24 20:38:17 +00:00
case StorageClassWorkgroup:
MSL: Handle coherent, volatile, and restrict. This maps them to their MSL equivalents. I've mapped `Coherent` to `volatile` since MSL doesn't have anything weaker than `volatile` but stronger than nothing. As part of this, I had to remove the implicit `volatile` added for atomic operation casts. If the buffer is already `coherent` or `volatile`, then we would add a second `volatile`, which would be redundant. I think this is OK even when the buffer *doesn't* have `coherent`: `T *` is implicitly convertible to `volatile T *`, but not vice-versa. It seems to compile OK at any rate. (Note that the non-`volatile` overloads of the atomic functions documented in the spec aren't present in the MSL 2.2 stdlib headers.) `restrict` is tricky, because in MSL, as in C++, it needs to go *after* the asterisk or ampersand for the pointer type it's modifying. Another issue is that, in the `Simple`, `GLSL450`, and `Vulkan` memory models, `Restrict` is the default (i.e. does not need to be specified); but MSL likely follows the `OpenCL` model where `Aliased` is the default. We probably need to implicitly set either `Restrict` or `Aliased` depending on the module's declared memory model.
2019-07-10 16:17:40 +00:00
addr_space = "threadgroup";
break;
CompilerMSL declare threadgroup variables accessed in called functions.
2018-01-24 20:38:17 +00:00
case StorageClassStorageBuffer:
Declare read-only SSBOs as const device in MSL.
2018-05-25 08:03:46 +00:00
{
MSL: Fix crash where variable storage buffer pointers are passed down. Only deal with readonly decoration for actual block types.
2019-03-28 09:16:46 +00:00
// For arguments from variable pointers, we use the write count deduction, so
// we should not assume any constness here. Only for global SSBOs.
bool readonly = false;
MSL: Unify the get_*_address_space() methods. These methods have largely the same logic, with minor differences. That I felt compelled to duplicate the logic into another method was one of the things that bothered me about the variable pointers change. This cleans that part of the code up; now we don't have two places to change.
2019-07-26 06:06:35 +00:00
if (!var || has_decoration(type.self, DecorationBlock))
MSL: Handle coherent, volatile, and restrict. This maps them to their MSL equivalents. I've mapped `Coherent` to `volatile` since MSL doesn't have anything weaker than `volatile` but stronger than nothing. As part of this, I had to remove the implicit `volatile` added for atomic operation casts. If the buffer is already `coherent` or `volatile`, then we would add a second `volatile`, which would be redundant. I think this is OK even when the buffer *doesn't* have `coherent`: `T *` is implicitly convertible to `volatile T *`, but not vice-versa. It seems to compile OK at any rate. (Note that the non-`volatile` overloads of the atomic functions documented in the spec aren't present in the MSL 2.2 stdlib headers.) `restrict` is tricky, because in MSL, as in C++, it needs to go *after* the asterisk or ampersand for the pointer type it's modifying. Another issue is that, in the `Simple`, `GLSL450`, and `Vulkan` memory models, `Restrict` is the default (i.e. does not need to be specified); but MSL likely follows the `OpenCL` model where `Aliased` is the default. We probably need to implicitly set either `Restrict` or `Aliased` depending on the module's declared memory model.
2019-07-10 16:17:40 +00:00
readonly = flags.get(DecorationNonWritable);
MSL: Fix crash where variable storage buffer pointers are passed down. Only deal with readonly decoration for actual block types.
2019-03-28 09:16:46 +00:00
MSL: Handle coherent, volatile, and restrict. This maps them to their MSL equivalents. I've mapped `Coherent` to `volatile` since MSL doesn't have anything weaker than `volatile` but stronger than nothing. As part of this, I had to remove the implicit `volatile` added for atomic operation casts. If the buffer is already `coherent` or `volatile`, then we would add a second `volatile`, which would be redundant. I think this is OK even when the buffer *doesn't* have `coherent`: `T *` is implicitly convertible to `volatile T *`, but not vice-versa. It seems to compile OK at any rate. (Note that the non-`volatile` overloads of the atomic functions documented in the spec aren't present in the MSL 2.2 stdlib headers.) `restrict` is tricky, because in MSL, as in C++, it needs to go *after* the asterisk or ampersand for the pointer type it's modifying. Another issue is that, in the `Simple`, `GLSL450`, and `Vulkan` memory models, `Restrict` is the default (i.e. does not need to be specified); but MSL likely follows the `OpenCL` model where `Aliased` is the default. We probably need to implicitly set either `Restrict` or `Aliased` depending on the module's declared memory model.
2019-07-10 16:17:40 +00:00
addr_space = readonly ? "const device" : "device";
break;
Declare read-only SSBOs as const device in MSL.
2018-05-25 08:03:46 +00:00
}
CompilerMSL declare threadgroup variables accessed in called functions.
2018-01-24 20:38:17 +00:00
case StorageClassUniform:
case StorageClassUniformConstant:
case StorageClassPushConstant:
if (type.basetype == SPIRType::Struct)
Declare read-only SSBOs as const device in MSL.
2018-05-25 08:03:46 +00:00
{
bool ssbo = has_decoration(type.self, DecorationBufferBlock);
CompilerMSL disable rasterization on buffer writes in vertex shader.
2018-07-27 20:53:36 +00:00
if (ssbo)
MSL: Unify the get_*_address_space() methods. These methods have largely the same logic, with minor differences. That I felt compelled to duplicate the logic into another method was one of the things that bothered me about the variable pointers change. This cleans that part of the code up; now we don't have two places to change.
2019-07-26 06:06:35 +00:00
addr_space = flags.get(DecorationNonWritable) ? "const device" : "device";
CompilerMSL disable rasterization on buffer writes in vertex shader.
2018-07-27 20:53:36 +00:00
else
MSL: Handle coherent, volatile, and restrict. This maps them to their MSL equivalents. I've mapped `Coherent` to `volatile` since MSL doesn't have anything weaker than `volatile` but stronger than nothing. As part of this, I had to remove the implicit `volatile` added for atomic operation casts. If the buffer is already `coherent` or `volatile`, then we would add a second `volatile`, which would be redundant. I think this is OK even when the buffer *doesn't* have `coherent`: `T *` is implicitly convertible to `volatile T *`, but not vice-versa. It seems to compile OK at any rate. (Note that the non-`volatile` overloads of the atomic functions documented in the spec aren't present in the MSL 2.2 stdlib headers.) `restrict` is tricky, because in MSL, as in C++, it needs to go *after* the asterisk or ampersand for the pointer type it's modifying. Another issue is that, in the `Simple`, `GLSL450`, and `Vulkan` memory models, `Restrict` is the default (i.e. does not need to be specified); but MSL likely follows the `OpenCL` model where `Aliased` is the default. We probably need to implicitly set either `Restrict` or `Aliased` depending on the module's declared memory model.
2019-07-10 16:17:40 +00:00
addr_space = "constant";
Declare read-only SSBOs as const device in MSL.
2018-05-25 08:03:46 +00:00
}
MSL: Unify the get_*_address_space() methods. These methods have largely the same logic, with minor differences. That I felt compelled to duplicate the logic into another method was one of the things that bothered me about the variable pointers change. This cleans that part of the code up; now we don't have two places to change.
2019-07-26 06:06:35 +00:00
else if (!argument)
MSL: Fix case where subpassInput is passed to leaf functions.
2020-04-27 09:23:24 +00:00
{
MSL: Unify the get_*_address_space() methods. These methods have largely the same logic, with minor differences. That I felt compelled to duplicate the logic into another method was one of the things that bothered me about the variable pointers change. This cleans that part of the code up; now we don't have two places to change.
2019-07-26 06:06:35 +00:00
addr_space = "constant";
MSL: Fix case where subpassInput is passed to leaf functions.
2020-04-27 09:23:24 +00:00
}
else if (type_is_msl_framebuffer_fetch(type))
{
// Subpass inputs are passed around by value.
addr_space = "";
}
CompilerMSL declare threadgroup variables accessed in called functions.
2018-01-24 20:38:17 +00:00
break;
MSL: Properly support passing parameters by value. MSL would force thread const& which would not work if the input argument came from a different storage class. Emit proper non-reference arguments for such values.
2018-08-06 13:41:10 +00:00
case StorageClassFunction:
case StorageClassGeneric:
MSL: Handle coherent, volatile, and restrict. This maps them to their MSL equivalents. I've mapped `Coherent` to `volatile` since MSL doesn't have anything weaker than `volatile` but stronger than nothing. As part of this, I had to remove the implicit `volatile` added for atomic operation casts. If the buffer is already `coherent` or `volatile`, then we would add a second `volatile`, which would be redundant. I think this is OK even when the buffer *doesn't* have `coherent`: `T *` is implicitly convertible to `volatile T *`, but not vice-versa. It seems to compile OK at any rate. (Note that the non-`volatile` overloads of the atomic functions documented in the spec aren't present in the MSL 2.2 stdlib headers.) `restrict` is tricky, because in MSL, as in C++, it needs to go *after* the asterisk or ampersand for the pointer type it's modifying. Another issue is that, in the `Simple`, `GLSL450`, and `Vulkan` memory models, `Restrict` is the default (i.e. does not need to be specified); but MSL likely follows the `OpenCL` model where `Aliased` is the default. We probably need to implicitly set either `Restrict` or `Aliased` depending on the module's declared memory model.
2019-07-10 16:17:40 +00:00
break;
MSL: Properly support passing parameters by value. MSL would force thread const& which would not work if the input argument came from a different storage class. Emit proper non-reference arguments for such values.
2018-08-06 13:41:10 +00:00
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
case StorageClassInput:
MSL: Unify the get_*_address_space() methods. These methods have largely the same logic, with minor differences. That I felt compelled to duplicate the logic into another method was one of the things that bothered me about the variable pointers change. This cleans that part of the code up; now we don't have two places to change.
2019-07-26 06:06:35 +00:00
if (get_execution_model() == ExecutionModelTessellationControl && var &&
var->basevariable == stage_in_ptr_var_id)
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
addr_space = msl_options.multi_patch_workgroup ? "constant" : "threadgroup";
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
break;
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
case StorageClassOutput:
if (capture_output_to_buffer)
MSL: Handle coherent, volatile, and restrict. This maps them to their MSL equivalents. I've mapped `Coherent` to `volatile` since MSL doesn't have anything weaker than `volatile` but stronger than nothing. As part of this, I had to remove the implicit `volatile` added for atomic operation casts. If the buffer is already `coherent` or `volatile`, then we would add a second `volatile`, which would be redundant. I think this is OK even when the buffer *doesn't* have `coherent`: `T *` is implicitly convertible to `volatile T *`, but not vice-versa. It seems to compile OK at any rate. (Note that the non-`volatile` overloads of the atomic functions documented in the spec aren't present in the MSL 2.2 stdlib headers.) `restrict` is tricky, because in MSL, as in C++, it needs to go *after* the asterisk or ampersand for the pointer type it's modifying. Another issue is that, in the `Simple`, `GLSL450`, and `Vulkan` memory models, `Restrict` is the default (i.e. does not need to be specified); but MSL likely follows the `OpenCL` model where `Aliased` is the default. We probably need to implicitly set either `Restrict` or `Aliased` depending on the module's declared memory model.
2019-07-10 16:17:40 +00:00
addr_space = "device";
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
break;
CompilerMSL declare threadgroup variables accessed in called functions.
2018-01-24 20:38:17 +00:00
default:
break;
msl: Handle writable SSBO in function arguments
2017-01-27 00:40:56 +00:00
}
MSL: Handle coherent, volatile, and restrict. This maps them to their MSL equivalents. I've mapped `Coherent` to `volatile` since MSL doesn't have anything weaker than `volatile` but stronger than nothing. As part of this, I had to remove the implicit `volatile` added for atomic operation casts. If the buffer is already `coherent` or `volatile`, then we would add a second `volatile`, which would be redundant. I think this is OK even when the buffer *doesn't* have `coherent`: `T *` is implicitly convertible to `volatile T *`, but not vice-versa. It seems to compile OK at any rate. (Note that the non-`volatile` overloads of the atomic functions documented in the spec aren't present in the MSL 2.2 stdlib headers.) `restrict` is tricky, because in MSL, as in C++, it needs to go *after* the asterisk or ampersand for the pointer type it's modifying. Another issue is that, in the `Simple`, `GLSL450`, and `Vulkan` memory models, `Restrict` is the default (i.e. does not need to be specified); but MSL likely follows the `OpenCL` model where `Aliased` is the default. We probably need to implicitly set either `Restrict` or `Aliased` depending on the module's declared memory model.
2019-07-10 16:17:40 +00:00
if (!addr_space)
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
// No address space for plain values.
MSL: Unify the get_*_address_space() methods. These methods have largely the same logic, with minor differences. That I felt compelled to duplicate the logic into another method was one of the things that bothered me about the variable pointers change. This cleans that part of the code up; now we don't have two places to change.
2019-07-26 06:06:35 +00:00
addr_space = type.pointer || (argument && type.basetype == SPIRType::ControlPointArray) ? "thread" : "";
MSL: Handle coherent, volatile, and restrict. This maps them to their MSL equivalents. I've mapped `Coherent` to `volatile` since MSL doesn't have anything weaker than `volatile` but stronger than nothing. As part of this, I had to remove the implicit `volatile` added for atomic operation casts. If the buffer is already `coherent` or `volatile`, then we would add a second `volatile`, which would be redundant. I think this is OK even when the buffer *doesn't* have `coherent`: `T *` is implicitly convertible to `volatile T *`, but not vice-versa. It seems to compile OK at any rate. (Note that the non-`volatile` overloads of the atomic functions documented in the spec aren't present in the MSL 2.2 stdlib headers.) `restrict` is tricky, because in MSL, as in C++, it needs to go *after* the asterisk or ampersand for the pointer type it's modifying. Another issue is that, in the `Simple`, `GLSL450`, and `Vulkan` memory models, `Restrict` is the default (i.e. does not need to be specified); but MSL likely follows the `OpenCL` model where `Aliased` is the default. We probably need to implicitly set either `Restrict` or `Aliased` depending on the module's declared memory model.
2019-07-10 16:17:40 +00:00
return join(flags.get(DecorationVolatile) || flags.get(DecorationCoherent) ? "volatile " : "", addr_space);
}
const char *CompilerMSL::to_restrict(uint32_t id, bool space)
{
// This can be called for variable pointer contexts as well, so be very careful about which method we choose.
Bitset flags;
if (ir.ids[id].get_type() == TypeVariable)
{
uint32_t type_id = expression_type_id(id);
auto &type = expression_type(id);
if (type.basetype == SPIRType::Struct &&
(has_decoration(type_id, DecorationBlock) || has_decoration(type_id, DecorationBufferBlock)))
flags = get_buffer_block_flags(id);
else
flags = get_decoration_bitset(id);
}
else
flags = get_decoration_bitset(id);
return flags.get(DecorationRestrict) ? (space ? "restrict " : "restrict") : "";
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
}
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
string CompilerMSL::entry_point_arg_stage_in()
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
{
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
string decl;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (get_execution_model() == ExecutionModelTessellationControl && msl_options.multi_patch_workgroup)
return decl;
CompilerMSL refactored to simplify handling of vertex attributes. Combine all vertex attributes into a single stage_in structure. Remove unneeded structure members from MSLConfiguration, MSLVertexAttr and Meta::Decoration. Remove unneeded CompilerMSL functions that supported struct offsets and padding.
2017-01-01 19:43:20 +00:00
// Stage-in structure
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
uint32_t stage_in_id;
if (get_execution_model() == ExecutionModelTessellationEvaluation)
stage_in_id = patch_stage_in_var_id;
else
stage_in_id = stage_in_var_id;
if (stage_in_id)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
auto &var = get<SPIRVariable>(stage_in_id);
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
auto &type = get_variable_data_type(var);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
add_resource_name(var.self);
decl = join(type_to_glsl(type), " ", to_name(var.self), " [[stage_in]]");
}
return decl;
}
MSL: Factor a really gnarly condition into its own method. That branch has become nigh unreadable. This new method should make it readable again.
2020-07-22 21:25:10 +00:00
// Returns true if this input builtin should be a direct parameter on a shader function parameter list,
// and false for builtins that should be passed or calculated some other way.
bool CompilerMSL::is_direct_input_builtin(BuiltIn bi_type)
{
switch (bi_type)
{
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
// Vertex function in
case BuiltInVertexId:
case BuiltInVertexIndex:
case BuiltInBaseVertex:
case BuiltInInstanceId:
case BuiltInInstanceIndex:
case BuiltInBaseInstance:
return get_execution_model() != ExecutionModelVertex || !msl_options.vertex_for_tessellation;
MSL: Factor a really gnarly condition into its own method. That branch has become nigh unreadable. This new method should make it readable again.
2020-07-22 21:25:10 +00:00
// Tess. control function in
case BuiltInPosition:
case BuiltInPointSize:
case BuiltInClipDistance:
case BuiltInCullDistance:
case BuiltInPatchVertices:
return false;
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
case BuiltInInvocationId:
case BuiltInPrimitiveId:
return get_execution_model() != ExecutionModelTessellationControl || !msl_options.multi_patch_workgroup;
MSL: Factor a really gnarly condition into its own method. That branch has become nigh unreadable. This new method should make it readable again.
2020-07-22 21:25:10 +00:00
// Tess. evaluation function in
case BuiltInTessLevelInner:
case BuiltInTessLevelOuter:
return false;
// Fragment function in
case BuiltInSamplePosition:
case BuiltInHelperInvocation:
case BuiltInBaryCoordNV:
case BuiltInBaryCoordNoPerspNV:
return false;
case BuiltInViewIndex:
MSL: Don't set the layer for multiview if the device doesn't support it. Some older iOS devices don't support layered rendering. In that case, don't set `[[render_target_array_index]]`, because the compiler will reject the shader in that case. The client will then have to unroll the render pass manually.
2020-08-23 21:44:41 +00:00
return get_execution_model() == ExecutionModelFragment && msl_options.multiview &&
msl_options.multiview_layered_rendering;
MSL: Factor a really gnarly condition into its own method. That branch has become nigh unreadable. This new method should make it readable again.
2020-07-22 21:25:10 +00:00
// Any stage function in
case BuiltInDeviceIndex:
case BuiltInSubgroupEqMask:
case BuiltInSubgroupGeMask:
case BuiltInSubgroupGtMask:
case BuiltInSubgroupLeMask:
case BuiltInSubgroupLtMask:
return false;
case BuiltInSubgroupLocalInvocationId:
case BuiltInSubgroupSize:
return get_execution_model() == ExecutionModelGLCompute ||
(get_execution_model() == ExecutionModelFragment && msl_options.supports_msl_version(2, 2));
default:
return true;
}
}
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
void CompilerMSL::entry_point_args_builtin(string &ep_args)
{
// Builtin variables
Support the SPV_KHR_post_depth_coverage extension. Using the `PostDepthCoverage` mode specifies that the `gl_SampleMaskIn` variable is to contain the computed coverage mask following the early fragment tests, which this mode requires and implicitly enables. Note that unlike Vulkan and OpenGL, Metal places this on the sample mask input itself, and furthermore does *not* implicitly enable early fragment testing. If it isn't enabled explicitly with an `[[early_fragment_tests]]` attribute, the compiler will error out. So we have to enable that mode explicitly if `PostDepthCoverage` is enabled but `EarlyFragmentTests` isn't. For Metal, only iOS supports this; for some reason, Apple has yet to implement it on macOS, even though many desktop cards support it.
2019-07-11 03:42:39 +00:00
SmallVector<pair<SPIRVariable *, BuiltIn>, 8> active_builtins;
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
ir.for_each_typed_id<SPIRVariable>([&](uint32_t var_id, SPIRVariable &var) {
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
auto bi_type = BuiltIn(get_decoration(var_id, DecorationBuiltIn));
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
// Don't emit SamplePosition as a separate parameter. In the entry
// point, we get that by calling get_sample_position() on the sample ID.
if (var.storage == StorageClassInput && is_builtin_variable(var) &&
get_variable_data_type(var).basetype != SPIRType::Struct &&
get_variable_data_type(var).basetype != SPIRType::ControlPointArray)
{
MSL: Fix declaration of unused input variables. In multiple-entry-point modules, we declared builtin inputs which were not supposed to be used for that entry point. Fix this, by being more strict when checking which builtins to emit.
2019-05-31 11:19:33 +00:00
// If the builtin is not part of the active input builtin set, don't emit it.
// Relevant for multiple entry-point modules which might declare unused builtins.
if (!active_input_builtins.get(bi_type) || !interface_variable_exists_in_entry_point(var_id))
return;
Support the SPV_KHR_post_depth_coverage extension. Using the `PostDepthCoverage` mode specifies that the `gl_SampleMaskIn` variable is to contain the computed coverage mask following the early fragment tests, which this mode requires and implicitly enables. Note that unlike Vulkan and OpenGL, Metal places this on the sample mask input itself, and furthermore does *not* implicitly enable early fragment testing. If it isn't enabled explicitly with an `[[early_fragment_tests]]` attribute, the compiler will error out. So we have to enable that mode explicitly if `PostDepthCoverage` is enabled but `EarlyFragmentTests` isn't. For Metal, only iOS supports this; for some reason, Apple has yet to implement it on macOS, even though many desktop cards support it.
2019-07-11 03:42:39 +00:00
// Remember this variable. We may need to correct its type.
active_builtins.push_back(make_pair(&var, bi_type));
MSL: Factor a really gnarly condition into its own method. That branch has become nigh unreadable. This new method should make it readable again.
2020-07-22 21:25:10 +00:00
if (is_direct_input_builtin(bi_type))
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
{
if (!ep_args.empty())
ep_args += ", ";
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Handle HLSL-style 0-based vertex/instance index.
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
builtin_declaration = true;
MSL: Support PrimitiveID in fragment and barycentrics.
2019-06-13 09:33:40 +00:00
ep_args += builtin_type_decl(bi_type, var_id) + " " + to_expression(var_id);
Support the SPV_KHR_post_depth_coverage extension. Using the `PostDepthCoverage` mode specifies that the `gl_SampleMaskIn` variable is to contain the computed coverage mask following the early fragment tests, which this mode requires and implicitly enables. Note that unlike Vulkan and OpenGL, Metal places this on the sample mask input itself, and furthermore does *not* implicitly enable early fragment testing. If it isn't enabled explicitly with an `[[early_fragment_tests]]` attribute, the compiler will error out. So we have to enable that mode explicitly if `PostDepthCoverage` is enabled but `EarlyFragmentTests` isn't. For Metal, only iOS supports this; for some reason, Apple has yet to implement it on macOS, even though many desktop cards support it.
2019-07-11 03:42:39 +00:00
ep_args += " [[" + builtin_qualifier(bi_type);
if (bi_type == BuiltInSampleMask && get_entry_point().flags.get(ExecutionModePostDepthCoverage))
{
if (!msl_options.supports_msl_version(2))
SPIRV_CROSS_THROW("Post-depth coverage requires Metal 2.0.");
if (!msl_options.is_ios())
SPIRV_CROSS_THROW("Post-depth coverage is only supported on iOS.");
ep_args += ", post_depth_coverage";
}
ep_args += "]]";
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
builtin_declaration = false;
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
}
}
MSL: Adjust BuiltInWorkgroupId for vkCmdDispatchBase(). This command allows the caller to set the base value of `BuiltInWorkgroupId`, and thus of `BuiltInGlobalInvocationId`. Metal provides no direct support for this... but it does provide a builtin, `[[grid_origin]]`, normally used to pass the base values for the stage input region, which we will now abuse to pass the dispatch base and avoid burning a buffer binding. `[[grid_origin]]`, as part of Metal's support for compute stage input, requires MSL 1.2. For 1.0 and 1.1, we're forced to provide a buffer. (Curiously, this builtin was undocumented until the MSL 2.2 release. Go figure.)
2019-07-22 18:08:04 +00:00
if (var.storage == StorageClassInput &&
has_extended_decoration(var_id, SPIRVCrossDecorationBuiltInDispatchBase))
{
// This is a special implicit builtin, not corresponding to any SPIR-V builtin,
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
// which holds the base that was passed to vkCmdDispatchBase() or vkCmdDrawIndexed(). If it's present,
MSL: Adjust BuiltInWorkgroupId for vkCmdDispatchBase(). This command allows the caller to set the base value of `BuiltInWorkgroupId`, and thus of `BuiltInGlobalInvocationId`. Metal provides no direct support for this... but it does provide a builtin, `[[grid_origin]]`, normally used to pass the base values for the stage input region, which we will now abuse to pass the dispatch base and avoid burning a buffer binding. `[[grid_origin]]`, as part of Metal's support for compute stage input, requires MSL 1.2. For 1.0 and 1.1, we're forced to provide a buffer. (Curiously, this builtin was undocumented until the MSL 2.2 release. Go figure.)
2019-07-22 18:08:04 +00:00
// assume we emitted it for a good reason.
assert(msl_options.supports_msl_version(1, 2));
if (!ep_args.empty())
ep_args += ", ";
ep_args += type_to_glsl(get_variable_data_type(var)) + " " + to_expression(var_id) + " [[grid_origin]]";
}
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (var.storage == StorageClassInput &&
has_extended_decoration(var_id, SPIRVCrossDecorationBuiltInStageInputSize))
{
// This is another special implicit builtin, not corresponding to any SPIR-V builtin,
// which holds the number of vertices and instances to draw. If it's present,
// assume we emitted it for a good reason.
assert(msl_options.supports_msl_version(1, 2));
if (!ep_args.empty())
ep_args += ", ";
ep_args += type_to_glsl(get_variable_data_type(var)) + " " + to_expression(var_id) + " [[grid_size]]";
}
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
});
Support the SPV_KHR_post_depth_coverage extension. Using the `PostDepthCoverage` mode specifies that the `gl_SampleMaskIn` variable is to contain the computed coverage mask following the early fragment tests, which this mode requires and implicitly enables. Note that unlike Vulkan and OpenGL, Metal places this on the sample mask input itself, and furthermore does *not* implicitly enable early fragment testing. If it isn't enabled explicitly with an `[[early_fragment_tests]]` attribute, the compiler will error out. So we have to enable that mode explicitly if `PostDepthCoverage` is enabled but `EarlyFragmentTests` isn't. For Metal, only iOS supports this; for some reason, Apple has yet to implement it on macOS, even though many desktop cards support it.
2019-07-11 03:42:39 +00:00
// Correct the types of all encountered active builtins. We couldn't do this before
// because ensure_correct_builtin_type() may increase the bound, which isn't allowed
// while iterating over IDs.
for (auto &var : active_builtins)
var.first->basetype = ensure_correct_builtin_type(var.first->basetype, var.second);
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Handle HLSL-style 0-based vertex/instance index.
MSL: Be a little clearer how needs_base_vertex_idx is implemented. There is an implicit tristate with {-1, 0, +1} values, but it was not obvious how this was supposed to work before studying the implementation, so refactor into a tristate enum class.
2019-10-24 10:41:37 +00:00
if (needs_base_vertex_arg == TriState::Yes)
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
ep_args += built_in_func_arg(BuiltInBaseVertex, !ep_args.empty());
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
MSL: Be a little clearer how needs_base_vertex_idx is implemented. There is an implicit tristate with {-1, 0, +1} values, but it was not obvious how this was supposed to work before studying the implementation, so refactor into a tristate enum class.
2019-10-24 10:41:37 +00:00
if (needs_base_instance_arg == TriState::Yes)
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
ep_args += built_in_func_arg(BuiltInBaseInstance, !ep_args.empty());
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
if (capture_output_to_buffer)
{
// Add parameters to hold the indirect draw parameters and the shader output. This has to be handled
// specially because it needs to be a pointer, not a reference.
if (stage_out_var_id)
{
if (!ep_args.empty())
ep_args += ", ";
ep_args += join("device ", type_to_glsl(get_stage_out_struct_type()), "* ", output_buffer_var_name,
" [[buffer(", msl_options.shader_output_buffer_index, ")]]");
}
Only use MSL constant address space for tessellation control shader.
2019-04-16 16:56:02 +00:00
if (get_execution_model() == ExecutionModelTessellationControl)
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
{
if (!ep_args.empty())
ep_args += ", ";
ep_args +=
Run format_all.sh.
2019-04-23 10:21:53 +00:00
join("constant uint* spvIndirectParams [[buffer(", msl_options.indirect_params_buffer_index, ")]]");
Correct formatting.
2019-04-16 18:13:57 +00:00
}
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
else if (stage_out_var_id &&
!(get_execution_model() == ExecutionModelVertex && msl_options.vertex_for_tessellation))
Correct formatting.
2019-04-16 18:13:57 +00:00
{
if (!ep_args.empty())
ep_args += ", ";
ep_args +=
Run format_all.sh.
2019-04-23 10:21:53 +00:00
join("device uint* spvIndirectParams [[buffer(", msl_options.indirect_params_buffer_index, ")]]");
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
}
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (get_execution_model() == ExecutionModelVertex && msl_options.vertex_for_tessellation &&
(active_input_builtins.get(BuiltInVertexIndex) || active_input_builtins.get(BuiltInVertexId)) &&
msl_options.vertex_index_type != Options::IndexType::None)
{
// Add the index buffer so we can set gl_VertexIndex correctly.
if (!ep_args.empty())
ep_args += ", ";
switch (msl_options.vertex_index_type)
{
case Options::IndexType::None:
break;
case Options::IndexType::UInt16:
ep_args += join("const device ushort* ", index_buffer_var_name, " [[buffer(",
msl_options.shader_index_buffer_index, ")]]");
break;
case Options::IndexType::UInt32:
ep_args += join("const device uint* ", index_buffer_var_name, " [[buffer(",
msl_options.shader_index_buffer_index, ")]]");
break;
}
}
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
// Tessellation control shaders get three additional parameters:
// a buffer to hold the per-patch data, a buffer to hold the per-patch
// tessellation levels, and a block of workgroup memory to hold the
// input control point data.
if (get_execution_model() == ExecutionModelTessellationControl)
{
if (patch_stage_out_var_id)
{
if (!ep_args.empty())
ep_args += ", ";
ep_args +=
join("device ", type_to_glsl(get_patch_stage_out_struct_type()), "* ", patch_output_buffer_var_name,
" [[buffer(", convert_to_string(msl_options.shader_patch_output_buffer_index), ")]]");
}
if (!ep_args.empty())
ep_args += ", ";
ep_args += join("device ", get_tess_factor_struct_name(), "* ", tess_factor_buffer_var_name, " [[buffer(",
convert_to_string(msl_options.shader_tess_factor_buffer_index), ")]]");
if (stage_in_var_id)
{
if (!ep_args.empty())
ep_args += ", ";
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (msl_options.multi_patch_workgroup)
{
ep_args += join("device ", type_to_glsl(get_stage_in_struct_type()), "* ", input_buffer_var_name,
" [[buffer(", convert_to_string(msl_options.shader_input_buffer_index), ")]]");
}
else
{
ep_args += join("threadgroup ", type_to_glsl(get_stage_in_struct_type()), "* ", input_wg_var_name,
" [[threadgroup(", convert_to_string(msl_options.shader_input_wg_index), ")]]");
}
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
}
}
}
}
string CompilerMSL::entry_point_args_argument_buffer(bool append_comma)
{
string ep_args = entry_point_arg_stage_in();
MSL: Support custom bindings for argument buffer itself.
2019-06-24 08:45:13 +00:00
Bitset claimed_bindings;
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
for (uint32_t i = 0; i < kMaxArgumentBuffers; i++)
{
uint32_t id = argument_buffer_ids[i];
if (id == 0)
continue;
add_resource_name(id);
auto &var = get<SPIRVariable>(id);
auto &type = get_variable_data_type(var);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (!ep_args.empty())
ep_args += ", ";
CompilerMSL refactored to simplify handling of vertex attributes. Combine all vertex attributes into a single stage_in structure. Remove unneeded structure members from MSLConfiguration, MSLVertexAttr and Meta::Decoration. Remove unneeded CompilerMSL functions that supported struct offsets and padding.
2017-01-01 19:43:20 +00:00
MSL: Support custom bindings for argument buffer itself.
2019-06-24 08:45:13 +00:00
// Check if the argument buffer binding itself has been remapped.
uint32_t buffer_binding;
auto itr = resource_bindings.find({ get_entry_point().model, i, kArgumentBufferBinding });
if (itr != end(resource_bindings))
{
buffer_binding = itr->second.first.msl_buffer;
itr->second.second = true;
}
else
{
// As a fallback, directly map desc set <-> binding.
// If that was taken, take the next buffer binding.
if (claimed_bindings.get(i))
buffer_binding = next_metal_resource_index_buffer;
else
buffer_binding = i;
}
claimed_bindings.set(buffer_binding);
MSL: Handle coherent, volatile, and restrict. This maps them to their MSL equivalents. I've mapped `Coherent` to `volatile` since MSL doesn't have anything weaker than `volatile` but stronger than nothing. As part of this, I had to remove the implicit `volatile` added for atomic operation casts. If the buffer is already `coherent` or `volatile`, then we would add a second `volatile`, which would be redundant. I think this is OK even when the buffer *doesn't* have `coherent`: `T *` is implicitly convertible to `volatile T *`, but not vice-versa. It seems to compile OK at any rate. (Note that the non-`volatile` overloads of the atomic functions documented in the spec aren't present in the MSL 2.2 stdlib headers.) `restrict` is tricky, because in MSL, as in C++, it needs to go *after* the asterisk or ampersand for the pointer type it's modifying. Another issue is that, in the `Simple`, `GLSL450`, and `Vulkan` memory models, `Restrict` is the default (i.e. does not need to be specified); but MSL likely follows the `OpenCL` model where `Aliased` is the default. We probably need to implicitly set either `Restrict` or `Aliased` depending on the module's declared memory model.
2019-07-10 16:17:40 +00:00
ep_args += get_argument_address_space(var) + " " + type_to_glsl(type) + "& " + to_restrict(id) + to_name(id);
MSL: Support custom bindings for argument buffer itself.
2019-06-24 08:45:13 +00:00
ep_args += " [[buffer(" + convert_to_string(buffer_binding) + ")]]";
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
MSL: Support custom bindings for argument buffer itself.
2019-06-24 08:45:13 +00:00
next_metal_resource_index_buffer = max(next_metal_resource_index_buffer, buffer_binding + 1);
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
}
Rename "push descriptor set" to "discrete descriptor set". Check for case where iOS doesn't support writable argument buffer textures.
2019-03-15 20:53:21 +00:00
entry_point_args_discrete_descriptors(ep_args);
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
entry_point_args_builtin(ep_args);
if (!ep_args.empty() && append_comma)
ep_args += ", ";
return ep_args;
}
MSL: Support remapping constexpr samplers by set/binding. Older API was oriented around IDs which are not available unless you're doing full reflection, which is awkward for certain use cases which know their set/bindings up front. Optimize resource bindings to be hashmap rather than doing linear seeks all the time.
2019-06-10 13:41:36 +00:00
const MSLConstexprSampler *CompilerMSL::find_constexpr_sampler(uint32_t id) const
{
// Try by ID.
{
auto itr = constexpr_samplers_by_id.find(id);
if (itr != end(constexpr_samplers_by_id))
return &itr->second;
}
// Try by binding.
{
uint32_t desc_set = get_decoration(id, DecorationDescriptorSet);
uint32_t binding = get_decoration(id, DecorationBinding);
auto itr = constexpr_samplers_by_binding.find({ desc_set, binding });
if (itr != end(constexpr_samplers_by_binding))
return &itr->second;
}
return nullptr;
}
Rename "push descriptor set" to "discrete descriptor set". Check for case where iOS doesn't support writable argument buffer textures.
2019-03-15 20:53:21 +00:00
void CompilerMSL::entry_point_args_discrete_descriptors(string &ep_args)
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
{
MSL: Order resources by type and binding index in the output We've hit a bizarre bug on NVidia / macOS 10.13 where if two subsequent draw calls use two different shaders that both have VS use buffers 0 & 1, but one declares them in the increasing binding order and another one declares them in the decreasing binding order, then the second draw call (with the decreasing order) doesn't get correct data in some cases. This has been reported to Apple and they will probably fix it at some point; to work around that it's sufficient to sort resources by their binding index. For consistency we also sort by type to get a stable order, and output builtins after that to prevent random bugs like this from happening.
2018-01-26 02:19:38 +00:00
// Output resources, sorted by resource index & type
// We need to sort to work around a bug on macOS 10.13 with NVidia drivers where switching between shaders
// with different order of buffers can result in issues with buffer assignments inside the driver.
struct Resource
{
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
SPIRVariable *var;
MSL: Order resources by type and binding index in the output We've hit a bizarre bug on NVidia / macOS 10.13 where if two subsequent draw calls use two different shaders that both have VS use buffers 0 & 1, but one declares them in the increasing binding order and another one declares them in the decreasing binding order, then the second draw call (with the decreasing order) doesn't get correct data in some cases. This has been reported to Apple and they will probably fix it at some point; to work around that it's sufficient to sort resources by their binding index. For consistency we also sort by type to get a stable order, and output builtins after that to prevent random bugs like this from happening.
2018-01-26 02:19:38 +00:00
string name;
SPIRType::BaseType basetype;
uint32_t index;
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
uint32_t plane;
Adjustments after rebase of ue4_dev branch.
2019-09-13 18:03:02 +00:00
uint32_t secondary_index;
MSL: Order resources by type and binding index in the output We've hit a bizarre bug on NVidia / macOS 10.13 where if two subsequent draw calls use two different shaders that both have VS use buffers 0 & 1, but one declares them in the increasing binding order and another one declares them in the decreasing binding order, then the second draw call (with the decreasing order) doesn't get correct data in some cases. This has been reported to Apple and they will probably fix it at some point; to work around that it's sufficient to sort resources by their binding index. For consistency we also sort by type to get a stable order, and output builtins after that to prevent random bugs like this from happening.
2018-01-26 02:19:38 +00:00
};
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
SmallVector<Resource> resources;
MSL: Order resources by type and binding index in the output We've hit a bizarre bug on NVidia / macOS 10.13 where if two subsequent draw calls use two different shaders that both have VS use buffers 0 & 1, but one declares them in the increasing binding order and another one declares them in the decreasing binding order, then the second draw call (with the decreasing order) doesn't get correct data in some cases. This has been reported to Apple and they will probably fix it at some point; to work around that it's sufficient to sort resources by their binding index. For consistency we also sort by type to get a stable order, and output builtins after that to prevent random bugs like this from happening.
2018-01-26 02:19:38 +00:00
MSL: Force storage images on iOS to use discrete descriptors. Writable textures cannot use argument buffers on iOS. They must be passed as arguments directly to the shader function. Since we won't know if a given storage image will have the `NonWritable` decoration at the time we encode the argument buffer, we must therefore pass all storage images as discrete arguments. Previously, we were throwing an error if we encountered an argument buffer with a writable texture in it on iOS.
2019-09-04 18:57:17 +00:00
ir.for_each_typed_id<SPIRVariable>([&](uint32_t var_id, SPIRVariable &var) {
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
if ((var.storage == StorageClassUniform || var.storage == StorageClassUniformConstant ||
var.storage == StorageClassPushConstant || var.storage == StorageClassStorageBuffer) &&
!is_hidden_variable(var))
{
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
auto &type = get_variable_data_type(var);
MSL: Force storage images on iOS to use discrete descriptors. Writable textures cannot use argument buffers on iOS. They must be passed as arguments directly to the shader function. Since we won't know if a given storage image will have the `NonWritable` decoration at the time we encode the argument buffer, we must therefore pass all storage images as discrete arguments. Previously, we were throwing an error if we encountered an argument buffer with a writable texture in it on iOS.
2019-09-04 18:57:17 +00:00
// Very specifically, image load-store in argument buffers are disallowed on MSL on iOS.
// But we won't know when the argument buffer is encoded whether this image will have
// a NonWritable decoration. So just use discrete arguments for all storage images
// on iOS.
if (!(msl_options.is_ios() && type.basetype == SPIRType::Image && type.image.sampled == 2) &&
MSL: Support dynamic offsets for buffers in argument buffers. Vulkan has two types of buffer descriptors, `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` and `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC`, which allow the client to offset the buffers by an amount given when the descriptor set is bound to a pipeline. Metal provides no direct support for this when the buffer in question is in an argument buffer, so once again we're on our own. These offsets cannot be stored or associated in any way with the argument buffer itself, because they are set at bind time. Different pipelines may have different offsets set. Therefore, we must use a separate buffer, not in any argument buffer, to hold these offsets. Then the shader must manually offset the buffer pointer. This change fully supports arrays, including arrays of arrays, even though Vulkan forbids them. It does not, however, support runtime arrays. Perhaps later.
2019-09-06 04:14:12 +00:00
var.storage != StorageClassPushConstant)
MSL: Support VK_KHR_push_descriptor. If we have argument buffers, we also need to support using plain descriptor sets for certain cases where API wants it.
2019-03-15 13:07:03 +00:00
{
uint32_t desc_set = get_decoration(var_id, DecorationDescriptorSet);
if (descriptor_set_is_argument_buffer(desc_set))
return;
}
MSL: Support remapping constexpr samplers by set/binding. Older API was oriented around IDs which are not available unless you're doing full reflection, which is awkward for certain use cases which know their set/bindings up front. Optimize resource bindings to be hashmap rather than doing linear seeks all the time.
2019-06-10 13:41:36 +00:00
const MSLConstexprSampler *constexpr_sampler = nullptr;
if (type.basetype == SPIRType::SampledImage || type.basetype == SPIRType::Sampler)
{
constexpr_sampler = find_constexpr_sampler(var_id);
if (constexpr_sampler)
{
// Mark this ID as a constexpr sampler for later in case it came from set/bindings.
constexpr_samplers_by_id[var_id] = *constexpr_sampler;
}
}
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Emulate texture2D atomic operations
Adjustments after rebase of ue4_dev branch.
2019-09-13 18:03:02 +00:00
uint32_t secondary_index = 0;
MSL: Minor cleanups for texture atomic emulation. Storing pointers to internal objects is generally not done, IDs are preferred.
2019-10-24 09:30:20 +00:00
if (atomic_image_vars.count(var.self))
Adjustments after rebase of ue4_dev branch.
2019-09-13 18:03:02 +00:00
{
secondary_index = get_metal_resource_index(var, SPIRType::AtomicCounter, 0);
}
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
if (type.basetype == SPIRType::SampledImage)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
MSL: Deal with resource name aliasing. Apparently we didn't use those yet. MSL seems to be able to alias struct types and variable types to a degree, so that's why it has escaped testing until now.
2019-01-18 15:27:57 +00:00
add_resource_name(var_id);
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
uint32_t plane_count = 1;
if (constexpr_sampler && constexpr_sampler->ycbcr_conversion_enable)
plane_count = constexpr_sampler->planes;
for (uint32_t i = 0; i < plane_count; i++)
resources.push_back({ &var, to_name(var_id), SPIRType::Image,
Adjustments after rebase of ue4_dev branch.
2019-09-13 18:03:02 +00:00
get_metal_resource_index(var, SPIRType::Image, i), i, secondary_index });
MSL: Order resources by type and binding index in the output We've hit a bizarre bug on NVidia / macOS 10.13 where if two subsequent draw calls use two different shaders that both have VS use buffers 0 & 1, but one declares them in the increasing binding order and another one declares them in the decreasing binding order, then the second draw call (with the decreasing order) doesn't get correct data in some cases. This has been reported to Apple and they will probably fix it at some point; to work around that it's sufficient to sort resources by their binding index. For consistency we also sort by type to get a stable order, and output builtins after that to prevent random bugs like this from happening.
2018-01-26 02:19:38 +00:00
MSL: Support remapping constexpr samplers by set/binding. Older API was oriented around IDs which are not available unless you're doing full reflection, which is awkward for certain use cases which know their set/bindings up front. Optimize resource bindings to be hashmap rather than doing linear seeks all the time.
2019-06-10 13:41:36 +00:00
if (type.image.dim != DimBuffer && !constexpr_sampler)
MSL: Order resources by type and binding index in the output We've hit a bizarre bug on NVidia / macOS 10.13 where if two subsequent draw calls use two different shaders that both have VS use buffers 0 & 1, but one declares them in the increasing binding order and another one declares them in the decreasing binding order, then the second draw call (with the decreasing order) doesn't get correct data in some cases. This has been reported to Apple and they will probably fix it at some point; to work around that it's sufficient to sort resources by their binding index. For consistency we also sort by type to get a stable order, and output builtins after that to prevent random bugs like this from happening.
2018-01-26 02:19:38 +00:00
{
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
resources.push_back({ &var, to_sampler_expression(var_id), SPIRType::Sampler,
Adjustments after rebase of ue4_dev branch.
2019-09-13 18:03:02 +00:00
get_metal_resource_index(var, SPIRType::Sampler), 0, 0 });
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
}
MSL: Support remapping constexpr samplers by set/binding. Older API was oriented around IDs which are not available unless you're doing full reflection, which is awkward for certain use cases which know their set/bindings up front. Optimize resource bindings to be hashmap rather than doing linear seeks all the time.
2019-06-10 13:41:36 +00:00
else if (!constexpr_sampler)
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
{
// constexpr samplers are not declared as resources.
MSL: Deal with resource name aliasing. Apparently we didn't use those yet. MSL seems to be able to alias struct types and variable types to a degree, so that's why it has escaped testing until now.
2019-01-18 15:27:57 +00:00
add_resource_name(var_id);
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
resources.push_back({ &var, to_name(var_id), type.basetype,
get_metal_resource_index(var, type.basetype), 0, secondary_index });
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
}
MSL: Order resources by type and binding index in the output We've hit a bizarre bug on NVidia / macOS 10.13 where if two subsequent draw calls use two different shaders that both have VS use buffers 0 & 1, but one declares them in the increasing binding order and another one declares them in the decreasing binding order, then the second draw call (with the decreasing order) doesn't get correct data in some cases. This has been reported to Apple and they will probably fix it at some point; to work around that it's sufficient to sort resources by their binding index. For consistency we also sort by type to get a stable order, and output builtins after that to prevent random bugs like this from happening.
2018-01-26 02:19:38 +00:00
}
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
});
MSL: Order resources by type and binding index in the output We've hit a bizarre bug on NVidia / macOS 10.13 where if two subsequent draw calls use two different shaders that both have VS use buffers 0 & 1, but one declares them in the increasing binding order and another one declares them in the decreasing binding order, then the second draw call (with the decreasing order) doesn't get correct data in some cases. This has been reported to Apple and they will probably fix it at some point; to work around that it's sufficient to sort resources by their binding index. For consistency we also sort by type to get a stable order, and output builtins after that to prevent random bugs like this from happening.
2018-01-26 02:19:38 +00:00
MSL: Support VK_KHR_push_descriptor. If we have argument buffers, we also need to support using plain descriptor sets for certain cases where API wants it.
2019-03-15 13:07:03 +00:00
sort(resources.begin(), resources.end(), [](const Resource &lhs, const Resource &rhs) {
Format spirv_msl.cpp
2018-01-29 14:42:34 +00:00
return tie(lhs.basetype, lhs.index) < tie(rhs.basetype, rhs.index);
});
MSL: Order resources by type and binding index in the output We've hit a bizarre bug on NVidia / macOS 10.13 where if two subsequent draw calls use two different shaders that both have VS use buffers 0 & 1, but one declares them in the increasing binding order and another one declares them in the decreasing binding order, then the second draw call (with the decreasing order) doesn't get correct data in some cases. This has been reported to Apple and they will probably fix it at some point; to work around that it's sufficient to sort resources by their binding index. For consistency we also sort by type to get a stable order, and output builtins after that to prevent random bugs like this from happening.
2018-01-26 02:19:38 +00:00
for (auto &r : resources)
{
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
auto &var = *r.var;
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
auto &type = get_variable_data_type(var);
MSL: Order resources by type and binding index in the output We've hit a bizarre bug on NVidia / macOS 10.13 where if two subsequent draw calls use two different shaders that both have VS use buffers 0 & 1, but one declares them in the increasing binding order and another one declares them in the decreasing binding order, then the second draw call (with the decreasing order) doesn't get correct data in some cases. This has been reported to Apple and they will probably fix it at some point; to work around that it's sufficient to sort resources by their binding index. For consistency we also sort by type to get a stable order, and output builtins after that to prevent random bugs like this from happening.
2018-01-26 02:19:38 +00:00
uint32_t var_id = var.self;
switch (r.basetype)
{
case SPIRType::Struct:
{
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
auto &m = ir.meta[type.self];
MSL: Order resources by type and binding index in the output We've hit a bizarre bug on NVidia / macOS 10.13 where if two subsequent draw calls use two different shaders that both have VS use buffers 0 & 1, but one declares them in the increasing binding order and another one declares them in the decreasing binding order, then the second draw call (with the decreasing order) doesn't get correct data in some cases. This has been reported to Apple and they will probably fix it at some point; to work around that it's sufficient to sort resources by their binding index. For consistency we also sort by type to get a stable order, and output builtins after that to prevent random bugs like this from happening.
2018-01-26 02:19:38 +00:00
if (m.members.size() == 0)
break;
MSL: Expand arrays of buffers passed as input. Even as of Metal 2.1, MSL still doesn't support arrays of buffers directly. Therefore, we must manually expand them. In the prologue, we define arrays holding the argument pointers; these arrays are what the transpiled code ends up referencing. We might be able to do similar things for textures and samplers prior to MSL 2.0. Speaking of which, also enable texture arrays on iOS MSL 1.2.
2018-09-27 01:06:05 +00:00
if (!type.array.empty())
{
Minor cleanups. Throw an error for cases we don't support. Add a blank line after each local array declaration.
2018-09-27 16:01:46 +00:00
if (type.array.size() > 1)
SPIRV_CROSS_THROW("Arrays of arrays of buffers are not supported.");
MSL: Expand arrays of buffers passed as input. Even as of Metal 2.1, MSL still doesn't support arrays of buffers directly. Therefore, we must manually expand them. In the prologue, we define arrays holding the argument pointers; these arrays are what the transpiled code ends up referencing. We might be able to do similar things for textures and samplers prior to MSL 2.0. Speaking of which, also enable texture arrays on iOS MSL 1.2.
2018-09-27 01:06:05 +00:00
// Metal doesn't directly support this, so we must expand the
// array. We'll declare a local array to hold these elements
// later.
Deal with OpSpecConstantOp used as array size. When trying to validate buffer sizes, we usually need to bail out when using SpecConstantOps, but for some very specific cases where we allow unsized arrays currently, we can safely allow "unknown" sized arrays as well. This is probably the best we can do, when we have even more difficult cases than this, we throw a more sensible error message.
2018-11-01 13:56:25 +00:00
uint32_t array_size = to_array_size_literal(type);
Minor cleanups. Throw an error for cases we don't support. Add a blank line after each local array declaration.
2018-09-27 16:01:46 +00:00
if (array_size == 0)
SPIRV_CROSS_THROW("Unsized arrays of buffers are not supported in MSL.");
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Allow Metal to use the array<T> template to make arrays a value type
MSL: Add a workaround path to force native arrays for everything.
2020-02-24 11:47:14 +00:00
is_using_builtin_array = true;
MSL: Expand arrays of buffers passed as input. Even as of Metal 2.1, MSL still doesn't support arrays of buffers directly. Therefore, we must manually expand them. In the prologue, we define arrays holding the argument pointers; these arrays are what the transpiled code ends up referencing. We might be able to do similar things for textures and samplers prior to MSL 2.0. Speaking of which, also enable texture arrays on iOS MSL 1.2.
2018-09-27 01:06:05 +00:00
buffer_arrays.push_back(var_id);
for (uint32_t i = 0; i < array_size; ++i)
{
if (!ep_args.empty())
ep_args += ", ";
MSL: Handle coherent, volatile, and restrict. This maps them to their MSL equivalents. I've mapped `Coherent` to `volatile` since MSL doesn't have anything weaker than `volatile` but stronger than nothing. As part of this, I had to remove the implicit `volatile` added for atomic operation casts. If the buffer is already `coherent` or `volatile`, then we would add a second `volatile`, which would be redundant. I think this is OK even when the buffer *doesn't* have `coherent`: `T *` is implicitly convertible to `volatile T *`, but not vice-versa. It seems to compile OK at any rate. (Note that the non-`volatile` overloads of the atomic functions documented in the spec aren't present in the MSL 2.2 stdlib headers.) `restrict` is tricky, because in MSL, as in C++, it needs to go *after* the asterisk or ampersand for the pointer type it's modifying. Another issue is that, in the `Simple`, `GLSL450`, and `Vulkan` memory models, `Restrict` is the default (i.e. does not need to be specified); but MSL likely follows the `OpenCL` model where `Aliased` is the default. We probably need to implicitly set either `Restrict` or `Aliased` depending on the module's declared memory model.
2019-07-10 16:17:40 +00:00
ep_args += get_argument_address_space(var) + " " + type_to_glsl(type) + "* " + to_restrict(var_id) +
r.name + "_" + convert_to_string(i);
Support the SPV_EXT_fragment_shader_interlock extension. This was straightforward to implement in GLSL. The `ShadingRateInterlockOrderedEXT` and `ShadingRateInterlockUnorderedEXT` modes aren't implemented yet, because we don't support `SPV_NV_shading_rate` or `SPV_EXT_fragment_invocation_density` yet. HLSL and MSL were more interesting. They don't support this directly, but they do support marking resources as "rasterizer ordered," which does roughly the same thing. So this implementation scans all accesses inside the critical section and marks all storage resources found therein as rasterizer ordered. They also don't support the fine-grained controls on pixel- vs. sample-level interlock and disabling ordering guarantees that GLSL and SPIR-V do, but that's OK. "Unordered" here merely means the order is undefined; that it just so happens to be the same as rasterizer order is immaterial. As for pixel- vs. sample-level interlock, Vulkan explicitly states: > With sample shading enabled, [the `PixelInterlockOrderedEXT` and > `PixelInterlockUnorderedEXT`] execution modes are treated like > `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT` > respectively. and: > If [the `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT`] > execution modes are used in single-sample mode they are treated like > `PixelInterlockOrderedEXT` or `PixelInterlockUnorderedEXT` > respectively. So this will DTRT for MoltenVK and gfx-rs, at least. MSL additionally supports multiple raster order groups; resources that are not accessed together can be placed in different ROGs to allow them to be synchronized separately. A more sophisticated analysis might be able to place resources optimally, but that's outside the scope of this change. For now, we assign all resources to group 0, which should do for our purposes. `glslang` doesn't support the `RasterizerOrdered` UAVs this implementation produces for HLSL, so the test case needs `fxc.exe`. It also insists on GLSL 4.50 for `GL_ARB_fragment_shader_interlock`, even though the spec says it needs either 4.20 or `GL_ARB_shader_image_load_store`; and it doesn't support the `GL_NV_fragment_shader_interlock` extension at all. So I haven't been able to test those code paths. Fixes #1002.
2019-08-04 05:07:20 +00:00
ep_args += " [[buffer(" + convert_to_string(r.index + i) + ")";
if (interlocked_resources.count(var_id))
ep_args += ", raster_order_group(0)";
ep_args += "]]";
MSL: Expand arrays of buffers passed as input. Even as of Metal 2.1, MSL still doesn't support arrays of buffers directly. Therefore, we must manually expand them. In the prologue, we define arrays holding the argument pointers; these arrays are what the transpiled code ends up referencing. We might be able to do similar things for textures and samplers prior to MSL 2.0. Speaking of which, also enable texture arrays on iOS MSL 1.2.
2018-09-27 01:06:05 +00:00
}
MSL: Add a workaround path to force native arrays for everything.
2020-02-24 11:47:14 +00:00
is_using_builtin_array = false;
MSL: Expand arrays of buffers passed as input. Even as of Metal 2.1, MSL still doesn't support arrays of buffers directly. Therefore, we must manually expand them. In the prologue, we define arrays holding the argument pointers; these arrays are what the transpiled code ends up referencing. We might be able to do similar things for textures and samplers prior to MSL 2.0. Speaking of which, also enable texture arrays on iOS MSL 1.2.
2018-09-27 01:06:05 +00:00
}
else
{
if (!ep_args.empty())
ep_args += ", ";
MSL: Handle coherent, volatile, and restrict. This maps them to their MSL equivalents. I've mapped `Coherent` to `volatile` since MSL doesn't have anything weaker than `volatile` but stronger than nothing. As part of this, I had to remove the implicit `volatile` added for atomic operation casts. If the buffer is already `coherent` or `volatile`, then we would add a second `volatile`, which would be redundant. I think this is OK even when the buffer *doesn't* have `coherent`: `T *` is implicitly convertible to `volatile T *`, but not vice-versa. It seems to compile OK at any rate. (Note that the non-`volatile` overloads of the atomic functions documented in the spec aren't present in the MSL 2.2 stdlib headers.) `restrict` is tricky, because in MSL, as in C++, it needs to go *after* the asterisk or ampersand for the pointer type it's modifying. Another issue is that, in the `Simple`, `GLSL450`, and `Vulkan` memory models, `Restrict` is the default (i.e. does not need to be specified); but MSL likely follows the `OpenCL` model where `Aliased` is the default. We probably need to implicitly set either `Restrict` or `Aliased` depending on the module's declared memory model.
2019-07-10 16:17:40 +00:00
ep_args +=
get_argument_address_space(var) + " " + type_to_glsl(type) + "& " + to_restrict(var_id) + r.name;
Support the SPV_EXT_fragment_shader_interlock extension. This was straightforward to implement in GLSL. The `ShadingRateInterlockOrderedEXT` and `ShadingRateInterlockUnorderedEXT` modes aren't implemented yet, because we don't support `SPV_NV_shading_rate` or `SPV_EXT_fragment_invocation_density` yet. HLSL and MSL were more interesting. They don't support this directly, but they do support marking resources as "rasterizer ordered," which does roughly the same thing. So this implementation scans all accesses inside the critical section and marks all storage resources found therein as rasterizer ordered. They also don't support the fine-grained controls on pixel- vs. sample-level interlock and disabling ordering guarantees that GLSL and SPIR-V do, but that's OK. "Unordered" here merely means the order is undefined; that it just so happens to be the same as rasterizer order is immaterial. As for pixel- vs. sample-level interlock, Vulkan explicitly states: > With sample shading enabled, [the `PixelInterlockOrderedEXT` and > `PixelInterlockUnorderedEXT`] execution modes are treated like > `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT` > respectively. and: > If [the `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT`] > execution modes are used in single-sample mode they are treated like > `PixelInterlockOrderedEXT` or `PixelInterlockUnorderedEXT` > respectively. So this will DTRT for MoltenVK and gfx-rs, at least. MSL additionally supports multiple raster order groups; resources that are not accessed together can be placed in different ROGs to allow them to be synchronized separately. A more sophisticated analysis might be able to place resources optimally, but that's outside the scope of this change. For now, we assign all resources to group 0, which should do for our purposes. `glslang` doesn't support the `RasterizerOrdered` UAVs this implementation produces for HLSL, so the test case needs `fxc.exe`. It also insists on GLSL 4.50 for `GL_ARB_fragment_shader_interlock`, even though the spec says it needs either 4.20 or `GL_ARB_shader_image_load_store`; and it doesn't support the `GL_NV_fragment_shader_interlock` extension at all. So I haven't been able to test those code paths. Fixes #1002.
2019-08-04 05:07:20 +00:00
ep_args += " [[buffer(" + convert_to_string(r.index) + ")";
if (interlocked_resources.count(var_id))
ep_args += ", raster_order_group(0)";
ep_args += "]]";
MSL: Expand arrays of buffers passed as input. Even as of Metal 2.1, MSL still doesn't support arrays of buffers directly. Therefore, we must manually expand them. In the prologue, we define arrays holding the argument pointers; these arrays are what the transpiled code ends up referencing. We might be able to do similar things for textures and samplers prior to MSL 2.0. Speaking of which, also enable texture arrays on iOS MSL 1.2.
2018-09-27 01:06:05 +00:00
}
MSL: Order resources by type and binding index in the output We've hit a bizarre bug on NVidia / macOS 10.13 where if two subsequent draw calls use two different shaders that both have VS use buffers 0 & 1, but one declares them in the increasing binding order and another one declares them in the decreasing binding order, then the second draw call (with the decreasing order) doesn't get correct data in some cases. This has been reported to Apple and they will probably fix it at some point; to work around that it's sufficient to sort resources by their binding index. For consistency we also sort by type to get a stable order, and output builtins after that to prevent random bugs like this from happening.
2018-01-26 02:19:38 +00:00
break;
}
case SPIRType::Sampler:
if (!ep_args.empty())
ep_args += ", ";
Add test for sampler image arrays.
2018-04-03 12:26:24 +00:00
ep_args += sampler_type(type) + " " + r.name;
MSL: Order resources by type and binding index in the output We've hit a bizarre bug on NVidia / macOS 10.13 where if two subsequent draw calls use two different shaders that both have VS use buffers 0 & 1, but one declares them in the increasing binding order and another one declares them in the decreasing binding order, then the second draw call (with the decreasing order) doesn't get correct data in some cases. This has been reported to Apple and they will probably fix it at some point; to work around that it's sufficient to sort resources by their binding index. For consistency we also sort by type to get a stable order, and output builtins after that to prevent random bugs like this from happening.
2018-01-26 02:19:38 +00:00
ep_args += " [[sampler(" + convert_to_string(r.index) + ")]]";
break;
case SPIRType::Image:
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
{
MSL: Order resources by type and binding index in the output We've hit a bizarre bug on NVidia / macOS 10.13 where if two subsequent draw calls use two different shaders that both have VS use buffers 0 & 1, but one declares them in the increasing binding order and another one declares them in the decreasing binding order, then the second draw call (with the decreasing order) doesn't get correct data in some cases. This has been reported to Apple and they will probably fix it at some point; to work around that it's sufficient to sort resources by their binding index. For consistency we also sort by type to get a stable order, and output builtins after that to prevent random bugs like this from happening.
2018-01-26 02:19:38 +00:00
if (!ep_args.empty())
ep_args += ", ";
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
// Use Metal's native frame-buffer fetch API for subpass inputs.
const auto &basetype = get<SPIRType>(var.basetype);
MSL: Fix case where subpassInput is passed to leaf functions.
2020-04-27 09:23:24 +00:00
if (!type_is_msl_framebuffer_fetch(basetype))
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
{
On iOS sub-passes can be implemented using the frame-buffer fetch API which is much more efficient than binding the textures. Change was made in three parts. 1. Use Metal's native frame-buffer fetch API for subpass inputs. 2. Make sure that frame-buffer-fetch is only available on iOS. 3. Default to using Metal's native frame-buffer fetch for subpass inputs on iOS.
2019-08-14 14:48:47 +00:00
ep_args += image_type_glsl(type, var_id) + " " + r.name;
Merge branch 'ue4_dev'
2019-09-20 13:28:46 +00:00
if (r.plane > 0)
ep_args += join(plane_name_suffix, r.plane);
ep_args += " [[texture(" + convert_to_string(r.index) + ")";
if (interlocked_resources.count(var_id))
ep_args += ", raster_order_group(0)";
ep_args += "]]";
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
}
else
{
MSL: Fix case where subpassInput is passed to leaf functions.
2020-04-27 09:23:24 +00:00
ep_args += image_type_glsl(type, var_id) + " " + r.name;
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
ep_args += " [[color(" + convert_to_string(r.index) + ")]]";
}
// Emulate texture2D atomic operations
MSL: Minor cleanups for texture atomic emulation. Storing pointers to internal objects is generally not done, IDs are preferred.
2019-10-24 09:30:20 +00:00
if (atomic_image_vars.count(var.self))
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
{
ep_args += ", device atomic_" + type_to_glsl(get<SPIRType>(basetype.image.type), 0);
ep_args += "* " + r.name + "_atomic";
MSL: Add missing interlock handling to atomic image buffers.
2020-10-13 16:41:29 +00:00
ep_args += " [[buffer(" + convert_to_string(r.secondary_index) + ")";
if (interlocked_resources.count(var_id))
ep_args += ", raster_order_group(0)";
ep_args += "]]";
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
}
MSL: Order resources by type and binding index in the output We've hit a bizarre bug on NVidia / macOS 10.13 where if two subsequent draw calls use two different shaders that both have VS use buffers 0 & 1, but one declares them in the increasing binding order and another one declares them in the decreasing binding order, then the second draw call (with the decreasing order) doesn't get correct data in some cases. This has been reported to Apple and they will probably fix it at some point; to work around that it's sufficient to sort resources by their binding index. For consistency we also sort by type to get a stable order, and output builtins after that to prevent random bugs like this from happening.
2018-01-26 02:19:38 +00:00
break;
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
}
MSL: Order resources by type and binding index in the output We've hit a bizarre bug on NVidia / macOS 10.13 where if two subsequent draw calls use two different shaders that both have VS use buffers 0 & 1, but one declares them in the increasing binding order and another one declares them in the decreasing binding order, then the second draw call (with the decreasing order) doesn't get correct data in some cases. This has been reported to Apple and they will probably fix it at some point; to work around that it's sufficient to sort resources by their binding index. For consistency we also sort by type to get a stable order, and output builtins after that to prevent random bugs like this from happening.
2018-01-26 02:19:38 +00:00
default:
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
if (!ep_args.empty())
ep_args += ", ";
MSL: Adjust BuiltInWorkgroupId for vkCmdDispatchBase(). This command allows the caller to set the base value of `BuiltInWorkgroupId`, and thus of `BuiltInGlobalInvocationId`. Metal provides no direct support for this... but it does provide a builtin, `[[grid_origin]]`, normally used to pass the base values for the stage input region, which we will now abuse to pass the dispatch base and avoid burning a buffer binding. `[[grid_origin]]`, as part of Metal's support for compute stage input, requires MSL 1.2. For 1.0 and 1.1, we're forced to provide a buffer. (Curiously, this builtin was undocumented until the MSL 2.2 release. Go figure.)
2019-07-22 18:08:04 +00:00
if (!type.pointer)
ep_args += get_type_address_space(get<SPIRType>(var.basetype), var_id) + " " +
type_to_glsl(type, var_id) + "& " + r.name;
else
ep_args += type_to_glsl(type, var_id) + " " + r.name;
Support the SPV_EXT_fragment_shader_interlock extension. This was straightforward to implement in GLSL. The `ShadingRateInterlockOrderedEXT` and `ShadingRateInterlockUnorderedEXT` modes aren't implemented yet, because we don't support `SPV_NV_shading_rate` or `SPV_EXT_fragment_invocation_density` yet. HLSL and MSL were more interesting. They don't support this directly, but they do support marking resources as "rasterizer ordered," which does roughly the same thing. So this implementation scans all accesses inside the critical section and marks all storage resources found therein as rasterizer ordered. They also don't support the fine-grained controls on pixel- vs. sample-level interlock and disabling ordering guarantees that GLSL and SPIR-V do, but that's OK. "Unordered" here merely means the order is undefined; that it just so happens to be the same as rasterizer order is immaterial. As for pixel- vs. sample-level interlock, Vulkan explicitly states: > With sample shading enabled, [the `PixelInterlockOrderedEXT` and > `PixelInterlockUnorderedEXT`] execution modes are treated like > `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT` > respectively. and: > If [the `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT`] > execution modes are used in single-sample mode they are treated like > `PixelInterlockOrderedEXT` or `PixelInterlockUnorderedEXT` > respectively. So this will DTRT for MoltenVK and gfx-rs, at least. MSL additionally supports multiple raster order groups; resources that are not accessed together can be placed in different ROGs to allow them to be synchronized separately. A more sophisticated analysis might be able to place resources optimally, but that's outside the scope of this change. For now, we assign all resources to group 0, which should do for our purposes. `glslang` doesn't support the `RasterizerOrdered` UAVs this implementation produces for HLSL, so the test case needs `fxc.exe`. It also insists on GLSL 4.50 for `GL_ARB_fragment_shader_interlock`, even though the spec says it needs either 4.20 or `GL_ARB_shader_image_load_store`; and it doesn't support the `GL_NV_fragment_shader_interlock` extension at all. So I haven't been able to test those code paths. Fixes #1002.
2019-08-04 05:07:20 +00:00
ep_args += " [[buffer(" + convert_to_string(r.index) + ")";
if (interlocked_resources.count(var_id))
ep_args += ", raster_order_group(0)";
ep_args += "]]";
MSL: Order resources by type and binding index in the output We've hit a bizarre bug on NVidia / macOS 10.13 where if two subsequent draw calls use two different shaders that both have VS use buffers 0 & 1, but one declares them in the increasing binding order and another one declares them in the decreasing binding order, then the second draw call (with the decreasing order) doesn't get correct data in some cases. This has been reported to Apple and they will probably fix it at some point; to work around that it's sufficient to sort resources by their binding index. For consistency we also sort by type to get a stable order, and output builtins after that to prevent random bugs like this from happening.
2018-01-26 02:19:38 +00:00
break;
}
}
MSL: Support VK_KHR_push_descriptor. If we have argument buffers, we also need to support using plain descriptor sets for certain cases where API wants it.
2019-03-15 13:07:03 +00:00
}
MSL: Order resources by type and binding index in the output We've hit a bizarre bug on NVidia / macOS 10.13 where if two subsequent draw calls use two different shaders that both have VS use buffers 0 & 1, but one declares them in the increasing binding order and another one declares them in the decreasing binding order, then the second draw call (with the decreasing order) doesn't get correct data in some cases. This has been reported to Apple and they will probably fix it at some point; to work around that it's sufficient to sort resources by their binding index. For consistency we also sort by type to get a stable order, and output builtins after that to prevent random bugs like this from happening.
2018-01-26 02:19:38 +00:00
MSL: Support VK_KHR_push_descriptor. If we have argument buffers, we also need to support using plain descriptor sets for certain cases where API wants it.
2019-03-15 13:07:03 +00:00
// Returns a string containing a comma-delimited list of args for the entry point function
// This is the "classic" method of MSL 1 when we don't have argument buffer support.
string CompilerMSL::entry_point_args_classic(bool append_comma)
{
string ep_args = entry_point_arg_stage_in();
Rename "push descriptor set" to "discrete descriptor set". Check for case where iOS doesn't support writable argument buffer textures.
2019-03-15 20:53:21 +00:00
entry_point_args_discrete_descriptors(ep_args);
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
entry_point_args_builtin(ep_args);
MSL: Add a setting to capture vertex shader output to a buffer. This will be necessary to support transform feedback, as well as tessellation shaders.
2019-01-08 22:33:32 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (!ep_args.empty() && append_comma)
ep_args += ", ";
return ep_args;
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
MSL: Hoist fixup hooks in entry_point_args() out of the compile loop. Otherwise, in the event of a forced recompile, we could end up adding them twice.
2019-01-16 23:52:53 +00:00
void CompilerMSL::fix_up_shader_inputs_outputs()
{
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
auto &entry_func = this->get<SPIRFunction>(ir.default_entry_point);
// Emit a guard to ensure we don't execute beyond the last vertex.
// Vertex shaders shouldn't have the problems with barriers in non-uniform control flow that
// tessellation control shaders do, so early returns should be OK. We may need to revisit this
// if it ever becomes possible to use barriers from a vertex shader.
if (get_execution_model() == ExecutionModelVertex && msl_options.vertex_for_tessellation)
{
entry_func.fixup_hooks_in.push_back([this]() {
statement("if (any(", to_expression(builtin_invocation_id_id),
" >= ", to_expression(builtin_stage_input_size_id), "))");
statement(" return;");
});
}
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
// Look for sampled images and buffer. Add hooks to set up the swizzle constants or array lengths.
MSL: Hoist fixup hooks in entry_point_args() out of the compile loop. Otherwise, in the event of a forced recompile, we could end up adding them twice.
2019-01-16 23:52:53 +00:00
ir.for_each_typed_id<SPIRVariable>([&](uint32_t, SPIRVariable &var) {
auto &type = get_variable_data_type(var);
uint32_t var_id = var.self;
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
bool ssbo = has_decoration(type.self, DecorationBufferBlock);
MSL: Hoist fixup hooks in entry_point_args() out of the compile loop. Otherwise, in the event of a forced recompile, we could end up adding them twice.
2019-01-16 23:52:53 +00:00
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
if (var.storage == StorageClassUniformConstant && !is_hidden_variable(var))
MSL: Hoist fixup hooks in entry_point_args() out of the compile loop. Otherwise, in the event of a forced recompile, we could end up adding them twice.
2019-01-16 23:52:53 +00:00
{
if (msl_options.swizzle_texture_samples && has_sampled_images && is_sampled_image_type(type))
{
MSL: Deal with texture swizzle on arrays of images.
2019-05-09 09:25:45 +00:00
entry_func.fixup_hooks_in.push_back([this, &type, &var, var_id]() {
bool is_array_type = !type.array.empty();
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
uint32_t desc_set = get_decoration(var_id, DecorationDescriptorSet);
if (descriptor_set_is_argument_buffer(desc_set))
{
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
statement("constant uint", is_array_type ? "* " : "& ", to_swizzle_expression(var_id),
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
is_array_type ? " = &" : " = ", to_name(argument_buffer_ids[desc_set]),
".spvSwizzleConstants", "[",
convert_to_string(get_metal_resource_index(var, SPIRType::Image)), "];");
}
else
{
// If we have an array of images, we need to be able to index into it, so take a pointer instead.
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
statement("constant uint", is_array_type ? "* " : "& ", to_swizzle_expression(var_id),
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
is_array_type ? " = &" : " = ", to_name(swizzle_buffer_id), "[",
convert_to_string(get_metal_resource_index(var, SPIRType::Image)), "];");
}
MSL: Hoist fixup hooks in entry_point_args() out of the compile loop. Otherwise, in the event of a forced recompile, we could end up adding them twice.
2019-01-16 23:52:53 +00:00
});
}
}
Run format_all.sh.
2019-05-27 14:54:13 +00:00
else if ((var.storage == StorageClassStorageBuffer || (var.storage == StorageClassUniform && ssbo)) &&
!is_hidden_variable(var))
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
{
if (buffers_requiring_array_length.count(var.self))
{
entry_func.fixup_hooks_in.push_back([this, &type, &var, var_id]() {
bool is_array_type = !type.array.empty();
uint32_t desc_set = get_decoration(var_id, DecorationDescriptorSet);
if (descriptor_set_is_argument_buffer(desc_set))
{
statement("constant uint", is_array_type ? "* " : "& ", to_buffer_size_expression(var_id),
is_array_type ? " = &" : " = ", to_name(argument_buffer_ids[desc_set]),
".spvBufferSizeConstants", "[",
convert_to_string(get_metal_resource_index(var, SPIRType::Image)), "];");
}
else
{
// If we have an array of images, we need to be able to index into it, so take a pointer instead.
statement("constant uint", is_array_type ? "* " : "& ", to_buffer_size_expression(var_id),
is_array_type ? " = &" : " = ", to_name(buffer_size_buffer_id), "[",
convert_to_string(get_metal_resource_index(var, type.basetype)), "];");
}
});
}
}
MSL: Hoist fixup hooks in entry_point_args() out of the compile loop. Otherwise, in the event of a forced recompile, we could end up adding them twice.
2019-01-16 23:52:53 +00:00
});
// Builtin variables
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
ir.for_each_typed_id<SPIRVariable>([this, &entry_func](uint32_t, SPIRVariable &var) {
MSL: Hoist fixup hooks in entry_point_args() out of the compile loop. Otherwise, in the event of a forced recompile, we could end up adding them twice.
2019-01-16 23:52:53 +00:00
uint32_t var_id = var.self;
BuiltIn bi_type = ir.meta[var_id].decoration.builtin_type;
if (var.storage == StorageClassInput && is_builtin_variable(var))
{
switch (bi_type)
{
case BuiltInSamplePosition:
entry_func.fixup_hooks_in.push_back([=]() {
statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = get_sample_position(",
to_expression(builtin_sample_id_id), ");");
});
break;
case BuiltInHelperInvocation:
if (msl_options.is_ios())
SPIRV_CROSS_THROW("simd_is_helper_thread() is only supported on macOS.");
else if (msl_options.is_macos() && !msl_options.supports_msl_version(2, 1))
SPIRV_CROSS_THROW("simd_is_helper_thread() requires version 2.1 on macOS.");
entry_func.fixup_hooks_in.push_back([=]() {
statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = simd_is_helper_thread();");
});
break;
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
case BuiltInInvocationId:
// This is direct-mapped without multi-patch workgroups.
if (get_execution_model() != ExecutionModelTessellationControl || !msl_options.multi_patch_workgroup)
break;
entry_func.fixup_hooks_in.push_back([=]() {
statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ",
to_expression(builtin_invocation_id_id), ".x % ", this->get_entry_point().output_vertices,
";");
});
break;
case BuiltInPrimitiveId:
// This is natively supported by fragment and tessellation evaluation shaders.
// In tessellation control shaders, this is direct-mapped without multi-patch workgroups.
if (get_execution_model() != ExecutionModelTessellationControl || !msl_options.multi_patch_workgroup)
break;
entry_func.fixup_hooks_in.push_back([=]() {
statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = min(",
to_expression(builtin_invocation_id_id), ".x / ", this->get_entry_point().output_vertices,
", spvIndirectParams[1]);");
});
break;
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
case BuiltInPatchVertices:
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
if (get_execution_model() == ExecutionModelTessellationEvaluation)
entry_func.fixup_hooks_in.push_back([=]() {
statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ",
to_expression(patch_stage_in_var_id), ".gl_in.size();");
});
else
entry_func.fixup_hooks_in.push_back([=]() {
statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = spvIndirectParams[0];");
});
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
break;
MSL: Add an option to set the tessellation domain origin. This is intended to be used to support `VK_KHR_maintenance2`'s tessellation domain origin feature. If `tess_domain_origin_lower_left` is `true`, the `v` coordinate will be inverted with respect to the domain. Additionally, in `Triangles` mode, the `v` and `w` coordinates will be swapped. This is because the winding order is interpreted differently in lower-left mode.
2019-02-06 05:47:50 +00:00
case BuiltInTessCoord:
MSL: Don't bother fixing up triangle tess coords. Instead, I'm going to have MoltenVK reverse the winding order in the lower-left case. This seems to be what the test suite expects to happen anyhow.
2019-02-20 20:07:18 +00:00
// Emit a fixup to account for the shifted domain. Don't do this for triangles;
// MoltenVK will just reverse the winding order instead.
if (msl_options.tess_domain_origin_lower_left && !get_entry_point().flags.get(ExecutionModeTriangles))
MSL: Add an option to set the tessellation domain origin. This is intended to be used to support `VK_KHR_maintenance2`'s tessellation domain origin feature. If `tess_domain_origin_lower_left` is `true`, the `v` coordinate will be inverted with respect to the domain. Additionally, in `Triangles` mode, the `v` and `w` coordinates will be swapped. This is because the winding order is interpreted differently in lower-left mode.
2019-02-06 05:47:50 +00:00
{
string tc = to_expression(var_id);
MSL: Don't bother fixing up triangle tess coords. Instead, I'm going to have MoltenVK reverse the winding order in the lower-left case. This seems to be what the test suite expects to happen anyhow.
2019-02-20 20:07:18 +00:00
entry_func.fixup_hooks_in.push_back([=]() { statement(tc, ".y = 1.0 - ", tc, ".y;"); });
MSL: Add an option to set the tessellation domain origin. This is intended to be used to support `VK_KHR_maintenance2`'s tessellation domain origin feature. If `tess_domain_origin_lower_left` is `true`, the `v` coordinate will be inverted with respect to the domain. Additionally, in `Triangles` mode, the `v` and `w` coordinates will be swapped. This is because the winding order is interpreted differently in lower-left mode.
2019-02-06 05:47:50 +00:00
}
break;
MSL: Support SubgroupLocalInvocationId and SubgroupSize in all stages. MSL prior to 2.2 doesn't support these natively in any stage but compute. But, we can (assuming no threads were terminated prematurely) get their values with some creative uses of the `simd_prefix_exclusive_sum()` and `simd_sum()` functions. Also, fix a missing `to_expression()` with `BuiltInSubgroupEqMask`. For KhronosGroup/MoltenVK#629.
2019-05-31 18:42:36 +00:00
case BuiltInSubgroupLocalInvocationId:
// This is natively supported in compute shaders.
if (get_execution_model() == ExecutionModelGLCompute)
break;
// This is natively supported in fragment shaders in MSL 2.2.
if (get_execution_model() == ExecutionModelFragment && msl_options.supports_msl_version(2, 2))
break;
if (msl_options.is_ios())
SPIRV_CROSS_THROW(
"SubgroupLocalInvocationId cannot be used outside of compute shaders before MSL 2.2 on iOS.");
if (!msl_options.supports_msl_version(2, 1))
SPIRV_CROSS_THROW(
"SubgroupLocalInvocationId cannot be used outside of compute shaders before MSL 2.1.");
// Shaders other than compute shaders don't support the SIMD-group
// builtins directly, but we can emulate them using the SIMD-group
// functions. This might break if some of the subgroup terminated
// before reaching the entry point.
entry_func.fixup_hooks_in.push_back([=]() {
statement(builtin_type_decl(bi_type), " ", to_expression(var_id),
" = simd_prefix_exclusive_sum(1);");
});
break;
case BuiltInSubgroupSize:
// This is natively supported in compute shaders.
if (get_execution_model() == ExecutionModelGLCompute)
break;
// This is natively supported in fragment shaders in MSL 2.2.
if (get_execution_model() == ExecutionModelFragment && msl_options.supports_msl_version(2, 2))
break;
if (msl_options.is_ios())
SPIRV_CROSS_THROW("SubgroupSize cannot be used outside of compute shaders on iOS.");
if (!msl_options.supports_msl_version(2, 1))
SPIRV_CROSS_THROW("SubgroupSize cannot be used outside of compute shaders before Metal 2.1.");
entry_func.fixup_hooks_in.push_back(
[=]() { statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = simd_sum(1);"); });
break;
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
case BuiltInSubgroupEqMask:
if (msl_options.is_ios())
SPIRV_CROSS_THROW("Subgroup ballot functionality is unavailable on iOS.");
if (!msl_options.supports_msl_version(2, 1))
SPIRV_CROSS_THROW("Subgroup ballot functionality requires Metal 2.1.");
entry_func.fixup_hooks_in.push_back([=]() {
statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ",
MSL: Support SubgroupLocalInvocationId and SubgroupSize in all stages. MSL prior to 2.2 doesn't support these natively in any stage but compute. But, we can (assuming no threads were terminated prematurely) get their values with some creative uses of the `simd_prefix_exclusive_sum()` and `simd_sum()` functions. Also, fix a missing `to_expression()` with `BuiltInSubgroupEqMask`. For KhronosGroup/MoltenVK#629.
2019-05-31 18:42:36 +00:00
to_expression(builtin_subgroup_invocation_id_id), " > 32 ? uint4(0, (1 << (",
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
to_expression(builtin_subgroup_invocation_id_id), " - 32)), uint2(0)) : uint4(1 << ",
to_expression(builtin_subgroup_invocation_id_id), ", uint3(0));");
});
break;
case BuiltInSubgroupGeMask:
if (msl_options.is_ios())
SPIRV_CROSS_THROW("Subgroup ballot functionality is unavailable on iOS.");
if (!msl_options.supports_msl_version(2, 1))
SPIRV_CROSS_THROW("Subgroup ballot functionality requires Metal 2.1.");
entry_func.fixup_hooks_in.push_back([=]() {
// Case where index < 32, size < 32:
// mask0 = bfe(0xFFFFFFFF, index, size - index);
// mask1 = bfe(0xFFFFFFFF, 0, 0); // Gives 0
// Case where index < 32 but size >= 32:
// mask0 = bfe(0xFFFFFFFF, index, 32 - index);
// mask1 = bfe(0xFFFFFFFF, 0, size - 32);
// Case where index >= 32:
// mask0 = bfe(0xFFFFFFFF, 32, 0); // Gives 0
// mask1 = bfe(0xFFFFFFFF, index - 32, size - index);
// This is expressed without branches to avoid divergent
// control flow--hence the complicated min/max expressions.
// This is further complicated by the fact that if you attempt
// to bfe out-of-bounds on Metal, undefined behavior is the
// result.
statement(builtin_type_decl(bi_type), " ", to_expression(var_id),
" = uint4(extract_bits(0xFFFFFFFF, min(",
to_expression(builtin_subgroup_invocation_id_id), ", 32u), (uint)max(min((int)",
to_expression(builtin_subgroup_size_id), ", 32) - (int)",
to_expression(builtin_subgroup_invocation_id_id),
", 0)), extract_bits(0xFFFFFFFF, (uint)max((int)",
to_expression(builtin_subgroup_invocation_id_id), " - 32, 0), (uint)max((int)",
to_expression(builtin_subgroup_size_id), " - (int)max(",
to_expression(builtin_subgroup_invocation_id_id), ", 32u), 0)), uint2(0));");
});
break;
case BuiltInSubgroupGtMask:
if (msl_options.is_ios())
SPIRV_CROSS_THROW("Subgroup ballot functionality is unavailable on iOS.");
if (!msl_options.supports_msl_version(2, 1))
SPIRV_CROSS_THROW("Subgroup ballot functionality requires Metal 2.1.");
entry_func.fixup_hooks_in.push_back([=]() {
// The same logic applies here, except now the index is one
// more than the subgroup invocation ID.
statement(builtin_type_decl(bi_type), " ", to_expression(var_id),
" = uint4(extract_bits(0xFFFFFFFF, min(",
to_expression(builtin_subgroup_invocation_id_id), " + 1, 32u), (uint)max(min((int)",
to_expression(builtin_subgroup_size_id), ", 32) - (int)",
to_expression(builtin_subgroup_invocation_id_id),
" - 1, 0)), extract_bits(0xFFFFFFFF, (uint)max((int)",
to_expression(builtin_subgroup_invocation_id_id), " + 1 - 32, 0), (uint)max((int)",
to_expression(builtin_subgroup_size_id), " - (int)max(",
to_expression(builtin_subgroup_invocation_id_id), " + 1, 32u), 0)), uint2(0));");
});
break;
case BuiltInSubgroupLeMask:
if (msl_options.is_ios())
SPIRV_CROSS_THROW("Subgroup ballot functionality is unavailable on iOS.");
if (!msl_options.supports_msl_version(2, 1))
SPIRV_CROSS_THROW("Subgroup ballot functionality requires Metal 2.1.");
entry_func.fixup_hooks_in.push_back([=]() {
statement(builtin_type_decl(bi_type), " ", to_expression(var_id),
" = uint4(extract_bits(0xFFFFFFFF, 0, min(",
to_expression(builtin_subgroup_invocation_id_id),
" + 1, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)",
to_expression(builtin_subgroup_invocation_id_id), " + 1 - 32, 0)), uint2(0));");
});
break;
case BuiltInSubgroupLtMask:
if (msl_options.is_ios())
SPIRV_CROSS_THROW("Subgroup ballot functionality is unavailable on iOS.");
if (!msl_options.supports_msl_version(2, 1))
SPIRV_CROSS_THROW("Subgroup ballot functionality requires Metal 2.1.");
entry_func.fixup_hooks_in.push_back([=]() {
statement(builtin_type_decl(bi_type), " ", to_expression(var_id),
" = uint4(extract_bits(0xFFFFFFFF, 0, min(",
to_expression(builtin_subgroup_invocation_id_id),
", 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)",
to_expression(builtin_subgroup_invocation_id_id), " - 32, 0)), uint2(0));");
});
break;
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
case BuiltInViewIndex:
if (!msl_options.multiview)
{
// According to the Vulkan spec, when not running under a multiview
// render pass, ViewIndex is 0.
entry_func.fixup_hooks_in.push_back([=]() {
statement("const ", builtin_type_decl(bi_type), " ", to_expression(var_id), " = 0;");
});
}
Support the SPV_KHR_device_group extension. The only piece added by this extension is the `DeviceIndex` builtin, which tells the shader which device in a grouped logical device it is running on. Metal's pipeline state objects are owned by the `MTLDevice` that created them. Since Metal doesn't support logical grouping of devices the way Vulkan does, we'll thus have to create a pipeline state for each device in a grouped logical device. The upcoming peer group support in Metal 3 will not change this. For this reason, for Metal, the device index is supplied as a constant at pipeline compile time. There's an interaction between `VK_KHR_device_group` and `VK_KHR_multiview` in the `VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT`, which defines the view index to be the same as the device index. The new `view_index_from_device_index` MSL option supports this functionality.
2019-07-13 02:50:50 +00:00
else if (msl_options.view_index_from_device_index)
{
// In this case, we take the view index from that of the device we're running on.
entry_func.fixup_hooks_in.push_back([=]() {
statement("const ", builtin_type_decl(bi_type), " ", to_expression(var_id), " = ",
msl_options.device_index, ";");
});
// We actually don't want to set the render_target_array_index here.
// Since every physical device is rendering a different view,
// there's no need for layered rendering here.
}
MSL: Don't set the layer for multiview if the device doesn't support it. Some older iOS devices don't support layered rendering. In that case, don't set `[[render_target_array_index]]`, because the compiler will reject the shader in that case. The client will then have to unroll the render pass manually.
2020-08-23 21:44:41 +00:00
else if (!msl_options.multiview_layered_rendering)
{
// In this case, the views are rendered one at a time. The view index, then,
// is just the first part of the "view mask".
entry_func.fixup_hooks_in.push_back([=]() {
statement("const ", builtin_type_decl(bi_type), " ", to_expression(var_id), " = ",
to_expression(view_mask_buffer_id), "[0];");
});
}
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
else if (get_execution_model() == ExecutionModelFragment)
{
// Because we adjusted the view index in the vertex shader, we have to
// adjust it back here.
entry_func.fixup_hooks_in.push_back([=]() {
statement(to_expression(var_id), " += ", to_expression(view_mask_buffer_id), "[0];");
});
}
else if (get_execution_model() == ExecutionModelVertex)
{
// Metal provides no special support for multiview, so we smuggle
// the view index in the instance index.
entry_func.fixup_hooks_in.push_back([=]() {
statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ",
MSL: Fix multiview view index calculation with a non-zero base instance. Account for a non-zero base instance when calculating the view index and the "real" instance index. Before, it was likely broken with a non-zero base instance, since the calculated instance index could be less than the base instance.
2020-08-07 22:46:28 +00:00
to_expression(view_mask_buffer_id), "[0] + (", to_expression(builtin_instance_idx_id),
" - ", to_expression(builtin_base_instance_id), ") % ",
to_expression(view_mask_buffer_id), "[1];");
statement(to_expression(builtin_instance_idx_id), " = (",
to_expression(builtin_instance_idx_id), " - ",
to_expression(builtin_base_instance_id), ") / ", to_expression(view_mask_buffer_id),
"[1] + ", to_expression(builtin_base_instance_id), ";");
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
});
// In addition to setting the variable itself, we also need to
// set the render_target_array_index with it on output. We have to
// offset this by the base view index, because Metal isn't in on
// our little game here.
entry_func.fixup_hooks_out.push_back([=]() {
statement(to_expression(builtin_layer_id), " = ", to_expression(var_id), " - ",
to_expression(view_mask_buffer_id), "[0];");
});
}
break;
Support the SPV_KHR_device_group extension. The only piece added by this extension is the `DeviceIndex` builtin, which tells the shader which device in a grouped logical device it is running on. Metal's pipeline state objects are owned by the `MTLDevice` that created them. Since Metal doesn't support logical grouping of devices the way Vulkan does, we'll thus have to create a pipeline state for each device in a grouped logical device. The upcoming peer group support in Metal 3 will not change this. For this reason, for Metal, the device index is supplied as a constant at pipeline compile time. There's an interaction between `VK_KHR_device_group` and `VK_KHR_multiview` in the `VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT`, which defines the view index to be the same as the device index. The new `view_index_from_device_index` MSL option supports this functionality.
2019-07-13 02:50:50 +00:00
case BuiltInDeviceIndex:
// Metal pipelines belong to the devices which create them, so we'll
// need to create a MTLPipelineState for every MTLDevice in a grouped
// VkDevice. We can assume, then, that the device index is constant.
entry_func.fixup_hooks_in.push_back([=]() {
statement("const ", builtin_type_decl(bi_type), " ", to_expression(var_id), " = ",
msl_options.device_index, ";");
});
break;
MSL: Adjust BuiltInWorkgroupId for vkCmdDispatchBase(). This command allows the caller to set the base value of `BuiltInWorkgroupId`, and thus of `BuiltInGlobalInvocationId`. Metal provides no direct support for this... but it does provide a builtin, `[[grid_origin]]`, normally used to pass the base values for the stage input region, which we will now abuse to pass the dispatch base and avoid burning a buffer binding. `[[grid_origin]]`, as part of Metal's support for compute stage input, requires MSL 1.2. For 1.0 and 1.1, we're forced to provide a buffer. (Curiously, this builtin was undocumented until the MSL 2.2 release. Go figure.)
2019-07-22 18:08:04 +00:00
case BuiltInWorkgroupId:
if (!msl_options.dispatch_base || !active_input_builtins.get(BuiltInWorkgroupId))
break;
// The vkCmdDispatchBase() command lets the client set the base value
// of WorkgroupId. Metal has no direct equivalent; we must make this
// adjustment ourselves.
entry_func.fixup_hooks_in.push_back([=]() {
statement(to_expression(var_id), " += ", to_dereferenced_expression(builtin_dispatch_base_id), ";");
});
break;
case BuiltInGlobalInvocationId:
if (!msl_options.dispatch_base || !active_input_builtins.get(BuiltInGlobalInvocationId))
break;
// GlobalInvocationId is defined as LocalInvocationId + WorkgroupId * WorkgroupSize.
// This needs to be adjusted too.
entry_func.fixup_hooks_in.push_back([=]() {
Workaround MSVC 2013 compiler issues.
2019-07-25 08:28:11 +00:00
auto &execution = this->get_entry_point();
MSL: Adjust BuiltInWorkgroupId for vkCmdDispatchBase(). This command allows the caller to set the base value of `BuiltInWorkgroupId`, and thus of `BuiltInGlobalInvocationId`. Metal provides no direct support for this... but it does provide a builtin, `[[grid_origin]]`, normally used to pass the base values for the stage input region, which we will now abuse to pass the dispatch base and avoid burning a buffer binding. `[[grid_origin]]`, as part of Metal's support for compute stage input, requires MSL 1.2. For 1.0 and 1.1, we're forced to provide a buffer. (Curiously, this builtin was undocumented until the MSL 2.2 release. Go figure.)
2019-07-22 18:08:04 +00:00
uint32_t workgroup_size_id = execution.workgroup_size.constant;
if (workgroup_size_id)
statement(to_expression(var_id), " += ", to_dereferenced_expression(builtin_dispatch_base_id),
" * ", to_expression(workgroup_size_id), ";");
else
statement(to_expression(var_id), " += ", to_dereferenced_expression(builtin_dispatch_base_id),
" * uint3(", execution.workgroup_size.x, ", ", execution.workgroup_size.y, ", ",
execution.workgroup_size.z, ");");
});
break;
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
case BuiltInVertexId:
case BuiltInVertexIndex:
// This is direct-mapped normally.
if (!msl_options.vertex_for_tessellation)
break;
entry_func.fixup_hooks_in.push_back([=]() {
builtin_declaration = true;
switch (msl_options.vertex_index_type)
{
case Options::IndexType::None:
statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ",
to_expression(builtin_invocation_id_id), ".x + ",
to_expression(builtin_dispatch_base_id), ".x;");
break;
case Options::IndexType::UInt16:
case Options::IndexType::UInt32:
statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ", index_buffer_var_name,
"[", to_expression(builtin_invocation_id_id), ".x] + ",
to_expression(builtin_dispatch_base_id), ".x;");
break;
}
builtin_declaration = false;
});
break;
case BuiltInBaseVertex:
// This is direct-mapped normally.
if (!msl_options.vertex_for_tessellation)
break;
entry_func.fixup_hooks_in.push_back([=]() {
statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ",
to_expression(builtin_dispatch_base_id), ".x;");
});
break;
case BuiltInInstanceId:
case BuiltInInstanceIndex:
// This is direct-mapped normally.
if (!msl_options.vertex_for_tessellation)
break;
entry_func.fixup_hooks_in.push_back([=]() {
builtin_declaration = true;
statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ",
to_expression(builtin_invocation_id_id), ".y + ", to_expression(builtin_dispatch_base_id),
".y;");
builtin_declaration = false;
});
break;
case BuiltInBaseInstance:
// This is direct-mapped normally.
if (!msl_options.vertex_for_tessellation)
break;
entry_func.fixup_hooks_in.push_back([=]() {
statement(builtin_type_decl(bi_type), " ", to_expression(var_id), " = ",
to_expression(builtin_dispatch_base_id), ".y;");
});
break;
MSL: Hoist fixup hooks in entry_point_args() out of the compile loop. Otherwise, in the event of a forced recompile, we could end up adding them twice.
2019-01-16 23:52:53 +00:00
default:
break;
}
}
Enabling setting a fixed sampleMask in Metal fragment shaders. In Metal render pipelines don't have an option to set a sampleMask parameter, the only way to get that functionality is to set the sample_mask output of the fragment shader to this value directly. We also need to take care to combine the fixed sample mask with the one that the shader might possibly output.
2020-07-22 16:37:17 +00:00
else if (var.storage == StorageClassOutput && is_builtin_variable(var))
{
if (bi_type == BuiltInSampleMask && get_execution_model() == ExecutionModelFragment &&
Run format_all.sh.
2020-08-24 09:02:49 +00:00
msl_options.additional_fixed_sample_mask != 0xffffffff)
Enabling setting a fixed sampleMask in Metal fragment shaders. In Metal render pipelines don't have an option to set a sampleMask parameter, the only way to get that functionality is to set the sample_mask output of the fragment shader to this value directly. We also need to take care to combine the fixed sample mask with the one that the shader might possibly output.
2020-07-22 16:37:17 +00:00
{
// If the additional fixed sample mask was set, we need to adjust the sample_mask
// output to reflect that. If the shader outputs the sample_mask itself too, we need
// to AND the two masks to get the final one.
if (does_shader_write_sample_mask)
{
entry_func.fixup_hooks_out.push_back([=]() {
Run format_all.sh.
2020-08-24 09:02:49 +00:00
statement(to_expression(builtin_sample_mask_id),
" &= ", msl_options.additional_fixed_sample_mask, ";");
Enabling setting a fixed sampleMask in Metal fragment shaders. In Metal render pipelines don't have an option to set a sampleMask parameter, the only way to get that functionality is to set the sample_mask output of the fragment shader to this value directly. We also need to take care to combine the fixed sample mask with the one that the shader might possibly output.
2020-07-22 16:37:17 +00:00
});
}
else
{
entry_func.fixup_hooks_out.push_back([=]() {
statement(to_expression(builtin_sample_mask_id), " = ",
Run format_all.sh.
2020-08-24 09:02:49 +00:00
msl_options.additional_fixed_sample_mask, ";");
Enabling setting a fixed sampleMask in Metal fragment shaders. In Metal render pipelines don't have an option to set a sampleMask parameter, the only way to get that functionality is to set the sample_mask output of the fragment shader to this value directly. We also need to take care to combine the fixed sample mask with the one that the shader might possibly output.
2020-07-22 16:37:17 +00:00
});
}
}
}
MSL: Hoist fixup hooks in entry_point_args() out of the compile loop. Otherwise, in the event of a forced recompile, we could end up adding them twice.
2019-01-16 23:52:53 +00:00
});
}
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
// Returns the Metal index of the resource of the specified type as used by the specified variable.
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
uint32_t CompilerMSL::get_metal_resource_index(SPIRVariable &var, SPIRType::BaseType basetype, uint32_t plane)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Add support for multiple entry points. - Only consider I/O variables if part of OpEntryPoint. - Keep a safe fallback if #entry-points is 1 to avoid potentially breaking previously working shaders.
2016-07-28 09:16:02 +00:00
auto &execution = get_entry_point();
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
auto &var_dec = ir.meta[var.self].decoration;
MSL: Rewrite how resource indices are fallback-assigned. We used to use the Binding decoration for this, but this method is hopelessly broken. If no explicit MSL resource remapping exists, we remap automatically in a manner which should always "just work".
2019-06-21 10:44:33 +00:00
auto &var_type = get<SPIRType>(var.basetype);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
uint32_t var_desc_set = (var.storage == StorageClassPushConstant) ? kPushConstDescSet : var_dec.set;
uint32_t var_binding = (var.storage == StorageClassPushConstant) ? kPushConstBinding : var_dec.binding;
MSL: Support remapping constexpr samplers by set/binding. Older API was oriented around IDs which are not available unless you're doing full reflection, which is awkward for certain use cases which know their set/bindings up front. Optimize resource bindings to be hashmap rather than doing linear seeks all the time.
2019-06-10 13:41:36 +00:00
// If a matching binding has been specified, find and use it.
auto itr = resource_bindings.find({ execution.model, var_desc_set, var_binding });
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
MSL: Fix automatic binding allocation for image atomic buffers. The Primary decoration was used by the atomic buffer, causing the texture binding to be potentially overlapping with other resources.
2019-11-28 10:07:44 +00:00
// Atomic helper buffers for image atomics need to use secondary bindings as well.
bool use_secondary_binding = (var_type.basetype == SPIRType::SampledImage && basetype == SPIRType::Sampler) ||
basetype == SPIRType::AtomicCounter;
Run format_all.sh.
2020-01-08 09:48:30 +00:00
auto resource_decoration =
use_secondary_binding ? SPIRVCrossDecorationResourceIndexSecondary : SPIRVCrossDecorationResourceIndexPrimary;
MSL: Fix automatic binding allocation for image atomic buffers. The Primary decoration was used by the atomic buffer, causing the texture binding to be potentially overlapping with other resources.
2019-11-28 10:07:44 +00:00
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
if (plane == 1)
resource_decoration = SPIRVCrossDecorationResourceIndexTertiary;
if (plane == 2)
resource_decoration = SPIRVCrossDecorationResourceIndexQuaternary;
MSL: Rewrite how resource indices are fallback-assigned. We used to use the Binding decoration for this, but this method is hopelessly broken. If no explicit MSL resource remapping exists, we remap automatically in a manner which should always "just work".
2019-06-21 10:44:33 +00:00
Add a stable C API for SPIRV-Cross. This adds a new C API for SPIRV-Cross which is intended to be stable, both API and ABI wise. The C++ API has been refactored a bit to make the C wrapper easier and cleaner to write. Especially the vertex attribute / resource interfaces for MSL has been rewritten to avoid taking mutable pointers into the interface. This would be very annoying to wrap and it didn't fit well with the rest of the C++ API to begin with. While doing this, I went ahead and removed all the old deprecated interfaces. The CMake build system has also seen an overhaul. It is now possible to build static/shared/CLI separately with -D options. The shared library only exposes the C API, as it is the only ABI-stable API. pkg-configs as well as CMake modules are exported and installed for the shared library configuration.
2019-02-12 10:11:29 +00:00
if (itr != end(resource_bindings))
{
MSL: Support remapping constexpr samplers by set/binding. Older API was oriented around IDs which are not available unless you're doing full reflection, which is awkward for certain use cases which know their set/bindings up front. Optimize resource bindings to be hashmap rather than doing linear seeks all the time.
2019-06-10 13:41:36 +00:00
auto &remap = itr->second;
remap.second = true;
Review fixups.
2019-03-04 09:08:31 +00:00
switch (basetype)
{
case SPIRType::Image:
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
set_extended_decoration(var.self, resource_decoration, remap.first.msl_texture + plane);
return remap.first.msl_texture + plane;
Review fixups.
2019-03-04 09:08:31 +00:00
case SPIRType::Sampler:
MSL: Rewrite how resource indices are fallback-assigned. We used to use the Binding decoration for this, but this method is hopelessly broken. If no explicit MSL resource remapping exists, we remap automatically in a manner which should always "just work".
2019-06-21 10:44:33 +00:00
set_extended_decoration(var.self, resource_decoration, remap.first.msl_sampler);
MSL: Support remapping constexpr samplers by set/binding. Older API was oriented around IDs which are not available unless you're doing full reflection, which is awkward for certain use cases which know their set/bindings up front. Optimize resource bindings to be hashmap rather than doing linear seeks all the time.
2019-06-10 13:41:36 +00:00
return remap.first.msl_sampler;
Review fixups.
2019-03-04 09:08:31 +00:00
default:
MSL: Rewrite how resource indices are fallback-assigned. We used to use the Binding decoration for this, but this method is hopelessly broken. If no explicit MSL resource remapping exists, we remap automatically in a manner which should always "just work".
2019-06-21 10:44:33 +00:00
set_extended_decoration(var.self, resource_decoration, remap.first.msl_buffer);
MSL: Support remapping constexpr samplers by set/binding. Older API was oriented around IDs which are not available unless you're doing full reflection, which is awkward for certain use cases which know their set/bindings up front. Optimize resource bindings to be hashmap rather than doing linear seeks all the time.
2019-06-10 13:41:36 +00:00
return remap.first.msl_buffer;
Review fixups.
2019-03-04 09:08:31 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
MSL: Rewrite how resource indices are fallback-assigned. We used to use the Binding decoration for this, but this method is hopelessly broken. If no explicit MSL resource remapping exists, we remap automatically in a manner which should always "just work".
2019-06-21 10:44:33 +00:00
// If we have already allocated an index, keep using it.
if (has_extended_decoration(var.self, resource_decoration))
return get_extended_decoration(var.self, resource_decoration);
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Allow user to enable decoration binding
Further adjustments to make Metal backend work again in UE4 on Mac.
2019-09-17 15:40:01 +00:00
if (msl_options.enable_decoration_binding)
{
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// If there is no explicit mapping of bindings to MSL, use the declared binding.
Further adjustments to make Metal backend work again in UE4 on Mac.
2019-09-17 15:40:01 +00:00
if (has_decoration(var.self, DecorationBinding))
{
var_binding = get_decoration(var.self, DecorationBinding);
// Avoid emitting sentinel bindings.
if (var_binding < 0x80000000u)
return var_binding;
}
}
MSL: Rewrite how resource indices are fallback-assigned. We used to use the Binding decoration for this, but this method is hopelessly broken. If no explicit MSL resource remapping exists, we remap automatically in a manner which should always "just work".
2019-06-21 10:44:33 +00:00
// If we did not explicitly remap, allocate bindings on demand.
// We cannot reliably use Binding decorations since SPIR-V and MSL's binding models are very different.
Use declared binding in SPIR-V as a fallback for explicit MSL binds.
2018-04-04 08:00:37 +00:00
MSL: Support inline uniform blocks in argument buffers. Here, the inline uniform block is explicit: we instantiate the buffer block itself in the argument buffer, instead of a pointer to the buffer. I just hope this will work with the `MTLArgumentDescriptor` API... Note that Metal recursively assigns individual members of embedded structs IDs. This means for automatic assignment that we have to calculate the binding stride for a given buffer block. For MoltenVK, we'll simply increment the ID by the size of the inline uniform block. Then the later IDs will never conflict with the inline uniform block. We can get away with this because Metal doesn't require that IDs be contiguous, only monotonically increasing.
2019-12-17 04:58:16 +00:00
bool allocate_argument_buffer_ids = false;
if (var.storage != StorageClassPushConstant)
allocate_argument_buffer_ids = descriptor_set_is_argument_buffer(var_desc_set);
Use declared binding in SPIR-V as a fallback for explicit MSL binds.
2018-04-04 08:00:37 +00:00
uint32_t binding_stride = 1;
auto &type = get<SPIRType>(var.basetype);
for (uint32_t i = 0; i < uint32_t(type.array.size()); i++)
MSL: Support dynamic offsets for buffers in argument buffers. Vulkan has two types of buffer descriptors, `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` and `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC`, which allow the client to offset the buffers by an amount given when the descriptor set is bound to a pipeline. Metal provides no direct support for this when the buffer in question is in an argument buffer, so once again we're on our own. These offsets cannot be stored or associated in any way with the argument buffer itself, because they are set at bind time. Different pipelines may have different offsets set. Therefore, we must use a separate buffer, not in any argument buffer, to hold these offsets. Then the shader must manually offset the buffer pointer. This change fully supports arrays, including arrays of arrays, even though Vulkan forbids them. It does not, however, support runtime arrays. Perhaps later.
2019-09-06 04:14:12 +00:00
binding_stride *= to_array_size_literal(type, i);
Use declared binding in SPIR-V as a fallback for explicit MSL binds.
2018-04-04 08:00:37 +00:00
MSL: Rewrite how resource indices are fallback-assigned. We used to use the Binding decoration for this, but this method is hopelessly broken. If no explicit MSL resource remapping exists, we remap automatically in a manner which should always "just work".
2019-06-21 10:44:33 +00:00
assert(binding_stride != 0);
// If a binding has not been specified, revert to incrementing resource indices.
Use declared binding in SPIR-V as a fallback for explicit MSL binds.
2018-04-04 08:00:37 +00:00
uint32_t resource_index;
MSL: Rewrite how resource indices are fallback-assigned. We used to use the Binding decoration for this, but this method is hopelessly broken. If no explicit MSL resource remapping exists, we remap automatically in a manner which should always "just work".
2019-06-21 10:44:33 +00:00
MSL: Use input attachment index directly for resource index fallback.
2020-07-06 07:42:19 +00:00
if (type_is_msl_framebuffer_fetch(type))
{
// Frame-buffer fetch gets its fallback resource index from the input attachment index,
// which is then treated as color index.
resource_index = get_decoration(var.self, DecorationInputAttachmentIndex);
}
else if (allocate_argument_buffer_ids)
MSL: Rewrite how resource indices are fallback-assigned. We used to use the Binding decoration for this, but this method is hopelessly broken. If no explicit MSL resource remapping exists, we remap automatically in a manner which should always "just work".
2019-06-21 10:44:33 +00:00
{
// Allocate from a flat ID binding space.
MSL: Support inline uniform blocks in argument buffers. Here, the inline uniform block is explicit: we instantiate the buffer block itself in the argument buffer, instead of a pointer to the buffer. I just hope this will work with the `MTLArgumentDescriptor` API... Note that Metal recursively assigns individual members of embedded structs IDs. This means for automatic assignment that we have to calculate the binding stride for a given buffer block. For MoltenVK, we'll simply increment the ID by the size of the inline uniform block. Then the later IDs will never conflict with the inline uniform block. We can get away with this because Metal doesn't require that IDs be contiguous, only monotonically increasing.
2019-12-17 04:58:16 +00:00
resource_index = next_metal_resource_ids[var_desc_set];
next_metal_resource_ids[var_desc_set] += binding_stride;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
MSL: Rewrite how resource indices are fallback-assigned. We used to use the Binding decoration for this, but this method is hopelessly broken. If no explicit MSL resource remapping exists, we remap automatically in a manner which should always "just work".
2019-06-21 10:44:33 +00:00
else
{
// Allocate from plain bindings which are allocated per resource type.
switch (basetype)
{
case SPIRType::Image:
resource_index = next_metal_resource_index_texture;
next_metal_resource_index_texture += binding_stride;
break;
case SPIRType::Sampler:
resource_index = next_metal_resource_index_sampler;
next_metal_resource_index_sampler += binding_stride;
break;
default:
resource_index = next_metal_resource_index_buffer;
next_metal_resource_index_buffer += binding_stride;
break;
}
}
set_extended_decoration(var.self, resource_decoration, resource_index);
Use declared binding in SPIR-V as a fallback for explicit MSL binds.
2018-04-04 08:00:37 +00:00
return resource_index;
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
MSL: Fix case where subpassInput is passed to leaf functions.
2020-04-27 09:23:24 +00:00
bool CompilerMSL::type_is_msl_framebuffer_fetch(const SPIRType &type) const
{
Run format_all.sh.
2020-07-01 09:42:58 +00:00
return type.basetype == SPIRType::Image && type.image.dim == DimSubpassData && msl_options.is_ios() &&
msl_options.ios_use_framebuffer_fetch_subpasses;
MSL: Fix case where subpassInput is passed to leaf functions.
2020-04-27 09:23:24 +00:00
}
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
string CompilerMSL::argument_decl(const SPIRFunction::Parameter &arg)
{
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
auto &var = get<SPIRVariable>(arg.id);
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
auto &type = get_variable_data_type(var);
auto &var_type = get<SPIRType>(arg.type);
StorageClass storage = var_type.storage;
bool is_pointer = var_type.pointer;
MSL: Properly support passing parameters by value. MSL would force thread const& which would not work if the input argument came from a different storage class. Emit proper non-reference arguments for such values.
2018-08-06 13:41:10 +00:00
MSL: Fix naming issue of aliased global variables. When the name of an alias global variable collides with a global declaration, MSL would emit inconsistent names, sometimes with the naming fix, sometimes without, because names were being tracked in two separate meta blocks. Fix this by always redirecting parameter naming to the original base variable as necessary.
2018-08-27 07:59:55 +00:00
// If we need to modify the name of the variable, make sure we use the original variable.
// Our alias is just a shadow variable.
uint32_t name_id = var.self;
if (arg.alias_global_variable && var.basevariable)
name_id = var.basevariable;
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
bool constref = !arg.alias_global_variable && is_pointer && arg.write_count == 0;
MSL: Fix case where subpassInput is passed to leaf functions.
2020-04-27 09:23:24 +00:00
// Framebuffer fetch is plain value, const looks out of place, but it is not wrong.
if (type_is_msl_framebuffer_fetch(type))
constref = false;
Format code
2017-01-15 15:39:03 +00:00
Run format_all.sh.
2018-04-03 12:08:15 +00:00
bool type_is_image = type.basetype == SPIRType::Image || type.basetype == SPIRType::SampledImage ||
type.basetype == SPIRType::Sampler;
Support array of images and samplers in MSL.
2018-04-03 12:00:34 +00:00
// Arrays of images/samplers in MSL are always const.
if (!type.array.empty() && type_is_image)
constref = true;
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
string decl;
if (constref)
decl += "const ";
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
// If this is a combined image-sampler for a 2D image with floating-point type,
// we emitted the 'spvDynamicImageSampler' type, and this is *not* an alias parameter
// for a global, then we need to emit a "dynamic" combined image-sampler.
// Unfortunately, this is necessary to properly support passing around
// combined image-samplers with Y'CbCr conversions on them.
bool is_dynamic_img_sampler = !arg.alias_global_variable && type.basetype == SPIRType::SampledImage &&
type.image.dim == Dim2D && type_is_floating_point(get<SPIRType>(type.image.type)) &&
spv_function_implementations.count(SPVFuncImplDynamicImageSampler);
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Allow Metal to use the array<T> template to make arrays a value type
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
string address_space = get_argument_address_space(var);
Use a hook to emit a local for the sample position. That way, we don't have to handle it specially when constructing a call.
2018-09-17 16:51:09 +00:00
bool builtin = is_builtin_variable(var);
MSL: Add a workaround path to force native arrays for everything.
2020-02-24 11:47:14 +00:00
is_using_builtin_array = builtin;
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
if (address_space == "threadgroup")
MSL: Add a workaround path to force native arrays for everything.
2020-02-24 11:47:14 +00:00
is_using_builtin_array = true;
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
if (var.basevariable && (var.basevariable == stage_in_ptr_var_id || var.basevariable == stage_out_ptr_var_id))
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
decl += type_to_glsl(type, arg.id);
else if (builtin)
MSL: Support PrimitiveID in fragment and barycentrics.
2019-06-13 09:33:40 +00:00
decl += builtin_type_decl(static_cast<BuiltIn>(get_decoration(arg.id, DecorationBuiltIn)), arg.id);
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
else if ((storage == StorageClassUniform || storage == StorageClassStorageBuffer) && is_array(type))
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
{
MSL: Add a workaround path to force native arrays for everything.
2020-02-24 11:47:14 +00:00
is_using_builtin_array = true;
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
decl += join(type_to_glsl(type, arg.id), "*");
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
}
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
else if (is_dynamic_img_sampler)
{
decl += join("spvDynamicImageSampler<", type_to_glsl(get<SPIRType>(type.image.type)), ">");
// Mark the variable so that we can handle passing it to another function.
set_extended_decoration(arg.id, SPIRVCrossDecorationDynamicImageSampler);
}
CompilerMSL enhancements to nested function use of globals. Allow function calls to include globals as arguments. Allow function calls to include built-ins as arguments. Include all meta info when creating function args from globals. Do not manufacture a sampler for Buffer-type sampled images. Add code option to test_shaders.py to preserve SPIR-V code for interactive debugging.
2017-12-26 21:32:45 +00:00
else
decl += type_to_glsl(type, arg.id);
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
bool opaque_handle = storage == StorageClassUniformConstant;
MSL: Properly support passing parameters by value. MSL would force thread const& which would not work if the input argument came from a different storage class. Emit proper non-reference arguments for such values.
2018-08-06 13:41:10 +00:00
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
if (!builtin && !opaque_handle && !is_pointer &&
(storage == StorageClassFunction || storage == StorageClassGeneric))
MSL: Properly support passing parameters by value. MSL would force thread const& which would not work if the input argument came from a different storage class. Emit proper non-reference arguments for such values.
2018-08-06 13:41:10 +00:00
{
// If the argument is a pure value and not an opaque type, we will pass by value.
MSL: Reintroduce workaround for constant arrays being passed by value.
2020-02-24 12:22:52 +00:00
if (msl_options.force_native_arrays && is_array(type))
{
// We are receiving an array by value. This is problematic.
// We cannot be sure of the target address space since we are supposed to receive a copy,
// but this is not possible with MSL without some extra work.
// We will have to assume we're getting a reference in thread address space.
// If we happen to get a reference in constant address space, the caller must emit a copy and pass that.
// Thread const therefore becomes the only logical choice, since we cannot "create" a constant array from
// non-constant arrays, but we can create thread const from constant.
decl = string("thread const ") + decl;
decl += " (&";
const char *restrict_kw = to_restrict(name_id);
if (*restrict_kw)
{
decl += " ";
decl += restrict_kw;
}
decl += to_expression(name_id);
decl += ")";
decl += type_to_array_glsl(type);
}
else
{
if (!address_space.empty())
decl = join(address_space, " ", decl);
decl += " ";
decl += to_expression(name_id);
}
MSL: Properly support passing parameters by value. MSL would force thread const& which would not work if the input argument came from a different storage class. Emit proper non-reference arguments for such values.
2018-08-06 13:41:10 +00:00
}
else if (is_array(type) && !type_is_image)
Fix passing arrays of arrays to functions in MSL.
2018-01-29 09:57:52 +00:00
{
MSL: Properly support passing parameters by value. MSL would force thread const& which would not work if the input argument came from a different storage class. Emit proper non-reference arguments for such values.
2018-08-06 13:41:10 +00:00
// Arrays of images and samplers are special cased.
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
if (!address_space.empty())
decl = join(address_space, " ", decl);
MSL: Need to emit two layers of address space. When passing down arrays of buffer pointers, the array itself needs an address space.
2019-03-15 10:29:17 +00:00
MSL: Fixup buffer array case issue on MSL 1.0.
2019-03-15 10:37:34 +00:00
if (msl_options.argument_buffers)
{
MSL: Use correct address space when passing array-of-buffers. Need to check if the descriptor set is actually an argument buffer.
2019-05-27 14:53:30 +00:00
uint32_t desc_set = get_decoration(name_id, DecorationDescriptorSet);
if ((storage == StorageClassUniform || storage == StorageClassStorageBuffer) &&
descriptor_set_is_argument_buffer(desc_set))
{
// An awkward case where we need to emit *more* address space declarations (yay!).
// An example is where we pass down an array of buffer pointers to leaf functions.
// It's a constant array containing pointers to constants.
// The pointer array is always constant however. E.g.
// device SSBO * constant (&array)[N].
// const device SSBO * constant (&array)[N].
// constant SSBO * constant (&array)[N].
// However, this only matters for argument buffers, since for MSL 1.0 style codegen,
// we emit the buffer array on stack instead, and that seems to work just fine apparently.
MSL: Add opt-in support for huge IABs. If there are enough members in an IAB, we cannot use the constant address space as MSL compiler complains about there being too many members. Support emitting the device address space instead.
2019-10-14 10:51:48 +00:00
// If the argument was marked as being in device address space, any pointer to member would
// be const device, not constant.
if (argument_buffer_device_storage_mask & (1u << desc_set))
decl += " const device";
else
decl += " constant";
MSL: Use correct address space when passing array-of-buffers. Need to check if the descriptor set is actually an argument buffer.
2019-05-27 14:53:30 +00:00
}
MSL: Fixup buffer array case issue on MSL 1.0.
2019-03-15 10:37:34 +00:00
}
MSL: Need to emit two layers of address space. When passing down arrays of buffer pointers, the array itself needs an address space.
2019-03-15 10:29:17 +00:00
Fix passing arrays of arrays to functions in MSL.
2018-01-29 09:57:52 +00:00
decl += " (&";
MSL: Handle coherent, volatile, and restrict. This maps them to their MSL equivalents. I've mapped `Coherent` to `volatile` since MSL doesn't have anything weaker than `volatile` but stronger than nothing. As part of this, I had to remove the implicit `volatile` added for atomic operation casts. If the buffer is already `coherent` or `volatile`, then we would add a second `volatile`, which would be redundant. I think this is OK even when the buffer *doesn't* have `coherent`: `T *` is implicitly convertible to `volatile T *`, but not vice-versa. It seems to compile OK at any rate. (Note that the non-`volatile` overloads of the atomic functions documented in the spec aren't present in the MSL 2.2 stdlib headers.) `restrict` is tricky, because in MSL, as in C++, it needs to go *after* the asterisk or ampersand for the pointer type it's modifying. Another issue is that, in the `Simple`, `GLSL450`, and `Vulkan` memory models, `Restrict` is the default (i.e. does not need to be specified); but MSL likely follows the `OpenCL` model where `Aliased` is the default. We probably need to implicitly set either `Restrict` or `Aliased` depending on the module's declared memory model.
2019-07-10 16:17:40 +00:00
const char *restrict_kw = to_restrict(name_id);
if (*restrict_kw)
{
decl += " ";
decl += restrict_kw;
}
MSL: Fix naming issue of aliased global variables. When the name of an alias global variable collides with a global declaration, MSL would emit inconsistent names, sometimes with the naming fix, sometimes without, because names were being tracked in two separate meta blocks. Fix this by always redirecting parameter naming to the original base variable as necessary.
2018-08-27 07:59:55 +00:00
decl += to_expression(name_id);
Fix passing arrays of arrays to functions in MSL.
2018-01-29 09:57:52 +00:00
decl += ")";
decl += type_to_array_glsl(type);
}
Use a hook to emit a local for the sample position. That way, we don't have to handle it specially when constructing a call.
2018-09-17 16:51:09 +00:00
else if (!opaque_handle)
Fix passing arrays of arrays to functions in MSL.
2018-01-29 09:57:52 +00:00
{
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
// If this is going to be a reference to a variable pointer, the address space
// for the reference has to go before the '&', but after the '*'.
if (!address_space.empty())
{
if (decl.back() == '*')
decl += join(" ", address_space, " ");
else
decl = join(address_space, " ", decl);
}
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
decl += "&";
Fix passing arrays of arrays to functions in MSL.
2018-01-29 09:57:52 +00:00
decl += " ";
MSL: Handle coherent, volatile, and restrict. This maps them to their MSL equivalents. I've mapped `Coherent` to `volatile` since MSL doesn't have anything weaker than `volatile` but stronger than nothing. As part of this, I had to remove the implicit `volatile` added for atomic operation casts. If the buffer is already `coherent` or `volatile`, then we would add a second `volatile`, which would be redundant. I think this is OK even when the buffer *doesn't* have `coherent`: `T *` is implicitly convertible to `volatile T *`, but not vice-versa. It seems to compile OK at any rate. (Note that the non-`volatile` overloads of the atomic functions documented in the spec aren't present in the MSL 2.2 stdlib headers.) `restrict` is tricky, because in MSL, as in C++, it needs to go *after* the asterisk or ampersand for the pointer type it's modifying. Another issue is that, in the `Simple`, `GLSL450`, and `Vulkan` memory models, `Restrict` is the default (i.e. does not need to be specified); but MSL likely follows the `OpenCL` model where `Aliased` is the default. We probably need to implicitly set either `Restrict` or `Aliased` depending on the module's declared memory model.
2019-07-10 16:17:40 +00:00
decl += to_restrict(name_id);
MSL: Fix naming issue of aliased global variables. When the name of an alias global variable collides with a global declaration, MSL would emit inconsistent names, sometimes with the naming fix, sometimes without, because names were being tracked in two separate meta blocks. Fix this by always redirecting parameter naming to the original base variable as necessary.
2018-08-27 07:59:55 +00:00
decl += to_expression(name_id);
Fix passing arrays of arrays to functions in MSL.
2018-01-29 09:57:52 +00:00
}
else
{
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
if (!address_space.empty())
decl = join(address_space, " ", decl);
Fix passing arrays of arrays to functions in MSL.
2018-01-29 09:57:52 +00:00
decl += " ";
MSL: Fix naming issue of aliased global variables. When the name of an alias global variable collides with a global declaration, MSL would emit inconsistent names, sometimes with the naming fix, sometimes without, because names were being tracked in two separate meta blocks. Fix this by always redirecting parameter naming to the original base variable as necessary.
2018-08-27 07:59:55 +00:00
decl += to_expression(name_id);
Fix passing arrays of arrays to functions in MSL.
2018-01-29 09:57:52 +00:00
}
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Emulate texture2D atomic operations
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
auto *backing_var = maybe_get_backing_variable(name_id);
MSL: Minor cleanups for texture atomic emulation. Storing pointers to internal objects is generally not done, IDs are preferred.
2019-10-24 09:30:20 +00:00
if (backing_var && atomic_image_vars.count(backing_var->self))
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
{
decl += ", device atomic_" + type_to_glsl(get<SPIRType>(var_type.image.type), 0);
decl += "* " + to_expression(name_id) + "_atomic";
}
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
MSL: Add a workaround path to force native arrays for everything.
2020-02-24 11:47:14 +00:00
is_using_builtin_array = false;
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
return decl;
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
MSL support global input vars as automatic function args. Add Decoration qualified_alias element. Virualize Compiler to_name() function. MSL use qualified_alias instead of alias when inside entry-point function.
2016-07-08 16:39:22 +00:00
// If we're currently in the entry point function, and the object
// has a qualified name, use it, otherwise use the standard name.
Make use of explicit locations in HLSL.
2017-03-07 12:27:04 +00:00
string CompilerMSL::to_name(uint32_t id, bool allow_alias) const
MSL support global input vars as automatic function args. Add Decoration qualified_alias element. Virualize Compiler to_name() function. MSL use qualified_alias instead of alias when inside entry-point function.
2016-07-08 16:39:22 +00:00
{
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
if (current_function && (current_function->self == ir.default_entry_point))
Run clang-format.
2016-10-24 13:24:24 +00:00
{
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
auto *m = ir.find_meta(id);
if (m && !m->decoration.qualified_alias.empty())
return m->decoration.qualified_alias;
Run clang-format.
2016-10-24 13:24:24 +00:00
}
return Compiler::to_name(id, allow_alias);
MSL support global input vars as automatic function args. Add Decoration qualified_alias element. Virualize Compiler to_name() function. MSL use qualified_alias instead of alias when inside entry-point function.
2016-07-08 16:39:22 +00:00
}
When flattening global structs for MSL, don't qualify names of built-in members.
2016-11-11 02:07:50 +00:00
// Returns a name that combines the name of the struct with the name of the member, except for Builtins
MoltenVK shader converter handle missing names. Use entry point name if no function name provided. When flattening in/out structs, qualify member names with struct name. Fix issue when determining declared size of struct types. Refactor use of m_ name prefix. Identify header defines in MSL code.
2016-10-24 01:42:54 +00:00
string CompilerMSL::to_qualified_member_name(const SPIRType &type, uint32_t index)
{
When flattening global structs for MSL, don't qualify names of built-in members.
2016-11-11 02:07:50 +00:00
// Don't qualify Builtin names because they are unique and are treated as such when building expressions
MSL: Support composites inside I/O blocks I had to refactor the existing add_interface_block as it was getting extremely large. Now it's all split up into different readable functions.
2019-01-08 10:03:59 +00:00
BuiltIn builtin = BuiltInMax;
Add support for the BuiltInClipDistance builtin for MSL. CompilerGLSL builtin_to_glsl() function outputs gl_ClipDistance for BuiltInClipDistance builtin, and includes builtin code in output when handling unknown builtin code. CompilerMSL uses type ID instead of type object where appropriate to support array types, where type.self is not consistent with actual type ID, plus support array stride calc even when not explicitly set by SPIR-V code. For output consistency, CompilerMSL prefers use of standard builtin names over specified names, and output builtins qualified with output struct while in entry function.
2016-12-17 22:07:53 +00:00
if (is_member_builtin(type, index, &builtin))
Add support for SampleId/SampleMask/SamplePosition builtins.
2017-07-24 08:07:02 +00:00
return builtin_to_glsl(builtin, type.storage);
When flattening global structs for MSL, don't qualify names of built-in members.
2016-11-11 02:07:50 +00:00
// Strip any underscore prefix from member name
Add support for the BuiltInClipDistance builtin for MSL. CompilerGLSL builtin_to_glsl() function outputs gl_ClipDistance for BuiltInClipDistance builtin, and includes builtin code in output when handling unknown builtin code. CompilerMSL uses type ID instead of type object where appropriate to support array types, where type.self is not consistent with actual type ID, plus support array stride calc even when not explicitly set by SPIR-V code. For output consistency, CompilerMSL prefers use of standard builtin names over specified names, and output builtins qualified with output struct while in entry function.
2016-12-17 22:07:53 +00:00
string mbr_name = to_member_name(type, index);
Run clang-format.
2016-10-24 13:24:24 +00:00
size_t startPos = mbr_name.find_first_not_of("_");
MSL fixes from review of PR 134. Remove unnecessary use of std:: prefix in spirv_msl.cpp. Use typedef instead of #define. spirv-cross deprecate --metal CLI option and replace with --msl option.
2017-03-20 01:06:21 +00:00
mbr_name = (startPos != string::npos) ? mbr_name.substr(startPos) : "";
Run clang-format.
2016-10-24 13:24:24 +00:00
return join(to_name(type.self), "_", mbr_name);
MoltenVK shader converter handle missing names. Use entry point name if no function name provided. When flattening in/out structs, qualify member names with struct name. Fix issue when determining declared size of struct types. Refactor use of m_ name prefix. Identify header defines in MSL code.
2016-10-24 01:42:54 +00:00
}
CompilerMSL supports promoting unnamed global vars to function args. CompilerMSL use correct MSL type name for 3D textures.
2016-11-27 20:00:06 +00:00
// Ensures that the specified name is permanently usable by prepending a prefix
// if the first chars are _ and a digit, which indicate a transient name.
string CompilerMSL::ensure_valid_name(string name, string pfx)
MoltenVK shader converter handle missing names. Use entry point name if no function name provided. When flattening in/out structs, qualify member names with struct name. Fix issue when determining declared size of struct types. Refactor use of m_ name prefix. Identify header defines in MSL code.
2016-10-24 01:42:54 +00:00
{
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
return (name.size() >= 2 && name[0] == '_' && isdigit(name[1])) ? (pfx + name) : name;
}
// Replace all names that match MSL keywords or Metal Standard Library functions.
void CompilerMSL::replace_illegal_names()
{
Add more illegal name replacement in MSL.
2018-04-03 13:36:35 +00:00
// FIXME: MSL and GLSL are doing two different things here.
// Agree on convention and remove this override.
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
static const unordered_set<string> keywords = {
MSL: Add more illegal identifiers. Add most macros from the Metal standard library headers that aren't in the reserved namespace (i.e. those that don't start with `_`).
2019-01-13 00:38:31 +00:00
"kernel",
"vertex",
"fragment",
"compute",
"bias",
"assert",
"VARIABLE_TRACEPOINT",
"STATIC_DATA_TRACEPOINT",
"STATIC_DATA_TRACEPOINT_V",
"METAL_ALIGN",
"METAL_ASM",
"METAL_CONST",
"METAL_DEPRECATED",
"METAL_ENABLE_IF",
"METAL_FUNC",
"METAL_INTERNAL",
"METAL_NON_NULL_RETURN",
"METAL_NORETURN",
"METAL_NOTHROW",
"METAL_PURE",
"METAL_UNAVAILABLE",
"METAL_IMPLICIT",
"METAL_EXPLICIT",
"METAL_CONST_ARG",
"METAL_ARG_UNIFORM",
"METAL_ZERO_ARG",
"METAL_VALID_LOD_ARG",
"METAL_VALID_LEVEL_ARG",
"METAL_VALID_STORE_ORDER",
"METAL_VALID_LOAD_ORDER",
"METAL_VALID_COMPARE_EXCHANGE_FAILURE_ORDER",
"METAL_COMPATIBLE_COMPARE_EXCHANGE_ORDERS",
"METAL_VALID_RENDER_TARGET",
"is_function_constant_defined",
"CHAR_BIT",
"SCHAR_MAX",
"SCHAR_MIN",
"UCHAR_MAX",
"CHAR_MAX",
"CHAR_MIN",
"USHRT_MAX",
"SHRT_MAX",
"SHRT_MIN",
"UINT_MAX",
"INT_MAX",
"INT_MIN",
"FLT_DIG",
"FLT_MANT_DIG",
"FLT_MAX_10_EXP",
"FLT_MAX_EXP",
"FLT_MIN_10_EXP",
"FLT_MIN_EXP",
"FLT_RADIX",
"FLT_MAX",
"FLT_MIN",
"FLT_EPSILON",
"FP_ILOGB0",
"FP_ILOGBNAN",
"MAXFLOAT",
"HUGE_VALF",
"INFINITY",
"NAN",
"M_E_F",
"M_LOG2E_F",
"M_LOG10E_F",
"M_LN2_F",
"M_LN10_F",
"M_PI_F",
"M_PI_2_F",
"M_PI_4_F",
"M_1_PI_F",
"M_2_PI_F",
"M_2_SQRTPI_F",
"M_SQRT2_F",
"M_SQRT1_2_F",
"HALF_DIG",
"HALF_MANT_DIG",
"HALF_MAX_10_EXP",
"HALF_MAX_EXP",
"HALF_MIN_10_EXP",
"HALF_MIN_EXP",
"HALF_RADIX",
"HALF_MAX",
"HALF_MIN",
"HALF_EPSILON",
"MAXHALF",
"HUGE_VALH",
"M_E_H",
"M_LOG2E_H",
"M_LOG10E_H",
"M_LN2_H",
"M_LN10_H",
"M_PI_H",
"M_PI_2_H",
"M_PI_4_H",
"M_1_PI_H",
"M_2_PI_H",
"M_2_SQRTPI_H",
"M_SQRT2_H",
"M_SQRT1_2_H",
"DBL_DIG",
"DBL_MANT_DIG",
"DBL_MAX_10_EXP",
"DBL_MAX_EXP",
"DBL_MIN_10_EXP",
"DBL_MIN_EXP",
"DBL_RADIX",
"DBL_MAX",
"DBL_MIN",
"DBL_EPSILON",
"HUGE_VAL",
"M_E",
"M_LOG2E",
"M_LOG10E",
"M_LN2",
"M_LN10",
"M_PI",
"M_PI_2",
"M_PI_4",
"M_1_PI",
"M_2_PI",
"M_2_SQRTPI",
"M_SQRT2",
"M_SQRT1_2",
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
"quad_broadcast",
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
};
static const unordered_set<string> illegal_func_names = {
Fixups for PR #353.
2017-12-05 08:58:12 +00:00
"main",
"saturate",
MSL: Add more illegal identifiers. Add most macros from the Metal standard library headers that aren't in the reserved namespace (i.e. those that don't start with `_`).
2019-01-13 00:38:31 +00:00
"assert",
"VARIABLE_TRACEPOINT",
"STATIC_DATA_TRACEPOINT",
"STATIC_DATA_TRACEPOINT_V",
"METAL_ALIGN",
"METAL_ASM",
"METAL_CONST",
"METAL_DEPRECATED",
"METAL_ENABLE_IF",
"METAL_FUNC",
"METAL_INTERNAL",
"METAL_NON_NULL_RETURN",
"METAL_NORETURN",
"METAL_NOTHROW",
"METAL_PURE",
"METAL_UNAVAILABLE",
"METAL_IMPLICIT",
"METAL_EXPLICIT",
"METAL_CONST_ARG",
"METAL_ARG_UNIFORM",
"METAL_ZERO_ARG",
"METAL_VALID_LOD_ARG",
"METAL_VALID_LEVEL_ARG",
"METAL_VALID_STORE_ORDER",
"METAL_VALID_LOAD_ORDER",
"METAL_VALID_COMPARE_EXCHANGE_FAILURE_ORDER",
"METAL_COMPATIBLE_COMPARE_EXCHANGE_ORDERS",
"METAL_VALID_RENDER_TARGET",
"is_function_constant_defined",
"CHAR_BIT",
"SCHAR_MAX",
"SCHAR_MIN",
"UCHAR_MAX",
"CHAR_MAX",
"CHAR_MIN",
"USHRT_MAX",
"SHRT_MAX",
"SHRT_MIN",
"UINT_MAX",
"INT_MAX",
"INT_MIN",
"FLT_DIG",
"FLT_MANT_DIG",
"FLT_MAX_10_EXP",
"FLT_MAX_EXP",
"FLT_MIN_10_EXP",
"FLT_MIN_EXP",
"FLT_RADIX",
"FLT_MAX",
"FLT_MIN",
"FLT_EPSILON",
"FP_ILOGB0",
"FP_ILOGBNAN",
"MAXFLOAT",
"HUGE_VALF",
"INFINITY",
"NAN",
"M_E_F",
"M_LOG2E_F",
"M_LOG10E_F",
"M_LN2_F",
"M_LN10_F",
"M_PI_F",
"M_PI_2_F",
"M_PI_4_F",
"M_1_PI_F",
"M_2_PI_F",
"M_2_SQRTPI_F",
"M_SQRT2_F",
"M_SQRT1_2_F",
"HALF_DIG",
"HALF_MANT_DIG",
"HALF_MAX_10_EXP",
"HALF_MAX_EXP",
"HALF_MIN_10_EXP",
"HALF_MIN_EXP",
"HALF_RADIX",
"HALF_MAX",
"HALF_MIN",
"HALF_EPSILON",
"MAXHALF",
"HUGE_VALH",
"M_E_H",
"M_LOG2E_H",
"M_LOG10E_H",
"M_LN2_H",
"M_LN10_H",
"M_PI_H",
"M_PI_2_H",
"M_PI_4_H",
"M_1_PI_H",
"M_2_PI_H",
"M_2_SQRTPI_H",
"M_SQRT2_H",
"M_SQRT1_2_H",
"DBL_DIG",
"DBL_MANT_DIG",
"DBL_MAX_10_EXP",
"DBL_MAX_EXP",
"DBL_MIN_10_EXP",
"DBL_MIN_EXP",
"DBL_RADIX",
"DBL_MAX",
"DBL_MIN",
"DBL_EPSILON",
"HUGE_VAL",
"M_E",
"M_LOG2E",
"M_LOG10E",
"M_LN2",
"M_LN10",
"M_PI",
"M_PI_2",
"M_PI_4",
"M_1_PI",
"M_2_PI",
"M_2_SQRTPI",
"M_SQRT2",
"M_SQRT1_2",
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
};
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
ir.for_each_typed_id<SPIRVariable>([&](uint32_t self, SPIRVariable &) {
Deal with illegal names in types as well. - Fixes issue with clip_distance flattening in MSL where member to flatten from would come from to_member_name, where it should have used the builtin name directly. This member name was modified by this patch and broke clip distance test shaders. - Some cleanups with ir.meta, use ir.find_meta instead to not create unnecessary hashmap nodes.
2020-01-16 09:28:54 +00:00
auto *meta = ir.find_meta(self);
if (!meta)
return;
auto &dec = meta->decoration;
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
if (keywords.find(dec.alias) != end(keywords))
dec.alias += "0";
});
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
ir.for_each_typed_id<SPIRFunction>([&](uint32_t self, SPIRFunction &) {
Deal with illegal names in types as well. - Fixes issue with clip_distance flattening in MSL where member to flatten from would come from to_member_name, where it should have used the builtin name directly. This member name was modified by this patch and broke clip distance test shaders. - Some cleanups with ir.meta, use ir.find_meta instead to not create unnecessary hashmap nodes.
2020-01-16 09:28:54 +00:00
auto *meta = ir.find_meta(self);
if (!meta)
return;
auto &dec = meta->decoration;
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
if (illegal_func_names.find(dec.alias) != end(illegal_func_names))
dec.alias += "0";
});
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
ir.for_each_typed_id<SPIRType>([&](uint32_t self, SPIRType &) {
Deal with illegal names in types as well. - Fixes issue with clip_distance flattening in MSL where member to flatten from would come from to_member_name, where it should have used the builtin name directly. This member name was modified by this patch and broke clip distance test shaders. - Some cleanups with ir.meta, use ir.find_meta instead to not create unnecessary hashmap nodes.
2020-01-16 09:28:54 +00:00
auto *meta = ir.find_meta(self);
if (!meta)
return;
for (auto &mbr_dec : meta->members)
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
if (keywords.find(mbr_dec.alias) != end(keywords))
mbr_dec.alias += "0";
});
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
for (auto &entry : ir.entry_points)
Format code
2017-01-15 15:39:03 +00:00
{
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
// Change both the entry point name and the alias, to keep them synced.
string &ep_name = entry.second.name;
if (illegal_func_names.find(ep_name) != end(illegal_func_names))
ep_name += "0";
Add support for renaming entry points.
2017-11-13 12:49:11 +00:00
// Always write this because entry point might have been renamed earlier.
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
ir.meta[entry.first].decoration.alias = ep_name;
Format code
2017-01-15 15:39:03 +00:00
}
Add more illegal name replacement in MSL.
2018-04-03 13:36:35 +00:00
CompilerGLSL::replace_illegal_names();
MoltenVK shader converter handle missing names. Use entry point name if no function name provided. When flattening in/out structs, qualify member names with struct name. Fix issue when determining declared size of struct types. Refactor use of m_ name prefix. Identify header defines in MSL code.
2016-10-24 01:42:54 +00:00
}
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
string CompilerMSL::to_member_reference(uint32_t base, const SPIRType &type, uint32_t index, bool ptr_chain)
MSL: Expand arrays of buffers passed as input. Even as of Metal 2.1, MSL still doesn't support arrays of buffers directly. Therefore, we must manually expand them. In the prologue, we define arrays holding the argument pointers; these arrays are what the transpiled code ends up referencing. We might be able to do similar things for textures and samplers prior to MSL 2.0. Speaking of which, also enable texture arrays on iOS MSL 1.2.
2018-09-27 01:06:05 +00:00
{
MSL: Redirect member indices when buffer has been sorted by Offset. If a buffer rewrites its Offsets, all member references to that struct are invalidated, and must be redirected, do so in to_member_reference, but there might be other places where this is needed. Fix as required. SPIR-V code relying on this is somewhat questionable, but seems to be in-spec.
2020-04-30 09:48:53 +00:00
if (index < uint32_t(type.member_type_index_redirection.size()))
index = type.member_type_index_redirection[index];
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
auto *var = maybe_get<SPIRVariable>(base);
MSL: Expand arrays of buffers passed as input. Even as of Metal 2.1, MSL still doesn't support arrays of buffers directly. Therefore, we must manually expand them. In the prologue, we define arrays holding the argument pointers; these arrays are what the transpiled code ends up referencing. We might be able to do similar things for textures and samplers prior to MSL 2.0. Speaking of which, also enable texture arrays on iOS MSL 1.2.
2018-09-27 01:06:05 +00:00
// If this is a buffer array, we have to dereference the buffer pointers.
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
// Otherwise, if this is a pointer expression, dereference it.
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
bool declared_as_pointer = false;
if (var)
{
MSL: Fix access chain for deep struct hierarchy on array of buffers.
2020-03-31 12:09:36 +00:00
// Only allow -> dereference for block types. This is so we get expressions like
// buffer[i]->first_member.second_member, rather than buffer[i]->first->second.
bool is_block = has_decoration(type.self, DecorationBlock) || has_decoration(type.self, DecorationBufferBlock);
bool is_buffer_variable =
is_block && (var->storage == StorageClassUniform || var->storage == StorageClassStorageBuffer);
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
declared_as_pointer = is_buffer_variable && is_array(get<SPIRType>(var->basetype));
}
if (declared_as_pointer || (!ptr_chain && should_dereference(base)))
MSL: Expand arrays of buffers passed as input. Even as of Metal 2.1, MSL still doesn't support arrays of buffers directly. Therefore, we must manually expand them. In the prologue, we define arrays holding the argument pointers; these arrays are what the transpiled code ends up referencing. We might be able to do similar things for textures and samplers prior to MSL 2.0. Speaking of which, also enable texture arrays on iOS MSL 1.2.
2018-09-27 01:06:05 +00:00
return join("->", to_member_name(type, index));
Minor cleanups. Throw an error for cases we don't support. Add a blank line after each local array declaration.
2018-09-27 16:01:46 +00:00
else
return join(".", to_member_name(type, index));
MSL: Expand arrays of buffers passed as input. Even as of Metal 2.1, MSL still doesn't support arrays of buffers directly. Therefore, we must manually expand them. In the prologue, we define arrays holding the argument pointers; these arrays are what the transpiled code ends up referencing. We might be able to do similar things for textures and samplers prior to MSL 2.0. Speaking of which, also enable texture arrays on iOS MSL 1.2.
2018-09-27 01:06:05 +00:00
}
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
string CompilerMSL::to_qualifiers_glsl(uint32_t id)
{
string quals;
auto &type = expression_type(id);
if (type.storage == StorageClassWorkgroup)
quals += "threadgroup ";
return quals;
}
Support emitting SPIR-V type declarations tuned for specified SPIR-V objects. CompilerGLSL type_to_glsl() and image_type_glsl() functions support optional object ID. Add SPIRType::Image::access member to support SPIR-V OpTypeImage access qualifier. Remove SPIRType::Image::is_read and ::is_written members. Use DecorationNonReadable and DecorationNonWritable to mark read/write access for image variables. CompilerMSL emit access qualifiers per image variable, instead of per image type. CompilerGLSL and CompilerHLSL behaviour is unchanged.
2017-05-30 00:45:05 +00:00
// The optional id parameter indicates the object whose type we are trying
// to find the description for. It is optional. Most type descriptions do not
// depend on a specific object's use of that type.
string CompilerMSL::type_to_glsl(const SPIRType &type, uint32_t id)
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
{
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
string type_name;
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
// Pointer?
if (type.pointer)
{
MSL: Handle coherent, volatile, and restrict. This maps them to their MSL equivalents. I've mapped `Coherent` to `volatile` since MSL doesn't have anything weaker than `volatile` but stronger than nothing. As part of this, I had to remove the implicit `volatile` added for atomic operation casts. If the buffer is already `coherent` or `volatile`, then we would add a second `volatile`, which would be redundant. I think this is OK even when the buffer *doesn't* have `coherent`: `T *` is implicitly convertible to `volatile T *`, but not vice-versa. It seems to compile OK at any rate. (Note that the non-`volatile` overloads of the atomic functions documented in the spec aren't present in the MSL 2.2 stdlib headers.) `restrict` is tricky, because in MSL, as in C++, it needs to go *after* the asterisk or ampersand for the pointer type it's modifying. Another issue is that, in the `Simple`, `GLSL450`, and `Vulkan` memory models, `Restrict` is the default (i.e. does not need to be specified); but MSL likely follows the `OpenCL` model where `Aliased` is the default. We probably need to implicitly set either `Restrict` or `Aliased` depending on the module's declared memory model.
2019-07-10 16:17:40 +00:00
const char *restrict_kw;
MSL: Emit correct SSBO constness for argument buffers.
2019-03-15 11:05:35 +00:00
type_name = join(get_type_address_space(type, id), " ", type_to_glsl(get<SPIRType>(type.parent_type), id));
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
switch (type.basetype)
{
case SPIRType::Image:
case SPIRType::SampledImage:
case SPIRType::Sampler:
// These are handles.
break;
default:
// Anything else can be a raw pointer.
type_name += "*";
MSL: Handle coherent, volatile, and restrict. This maps them to their MSL equivalents. I've mapped `Coherent` to `volatile` since MSL doesn't have anything weaker than `volatile` but stronger than nothing. As part of this, I had to remove the implicit `volatile` added for atomic operation casts. If the buffer is already `coherent` or `volatile`, then we would add a second `volatile`, which would be redundant. I think this is OK even when the buffer *doesn't* have `coherent`: `T *` is implicitly convertible to `volatile T *`, but not vice-versa. It seems to compile OK at any rate. (Note that the non-`volatile` overloads of the atomic functions documented in the spec aren't present in the MSL 2.2 stdlib headers.) `restrict` is tricky, because in MSL, as in C++, it needs to go *after* the asterisk or ampersand for the pointer type it's modifying. Another issue is that, in the `Simple`, `GLSL450`, and `Vulkan` memory models, `Restrict` is the default (i.e. does not need to be specified); but MSL likely follows the `OpenCL` model where `Aliased` is the default. We probably need to implicitly set either `Restrict` or `Aliased` depending on the module's declared memory model.
2019-07-10 16:17:40 +00:00
restrict_kw = to_restrict(id);
if (*restrict_kw)
{
type_name += " ";
type_name += restrict_kw;
}
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
break;
}
return type_name;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
switch (type.basetype)
{
case SPIRType::Struct:
// Need OpName lookup here to get a "sensible" name for a struct.
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
// Allow Metal to use the array<T> template to make arrays a value type
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
type_name = to_name(type.self);
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case SPIRType::Image:
case SPIRType::SampledImage:
Support emitting SPIR-V type declarations tuned for specified SPIR-V objects. CompilerGLSL type_to_glsl() and image_type_glsl() functions support optional object ID. Add SPIRType::Image::access member to support SPIR-V OpTypeImage access qualifier. Remove SPIRType::Image::is_read and ::is_written members. Use DecorationNonReadable and DecorationNonWritable to mark read/write access for image variables. CompilerMSL emit access qualifiers per image variable, instead of per image type. CompilerGLSL and CompilerHLSL behaviour is unchanged.
2017-05-30 00:45:05 +00:00
return image_type_glsl(type, id);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case SPIRType::Sampler:
Support array of images and samplers in MSL.
2018-04-03 12:00:34 +00:00
return sampler_type(type);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case SPIRType::Void:
return "void";
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case SPIRType::AtomicCounter:
return "atomic_uint";
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
case SPIRType::ControlPointArray:
return join("patch_control_point<", type_to_glsl(get<SPIRType>(type.parent_type), id), ">");
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
// Scalars
case SPIRType::Boolean:
type_name = "bool";
break;
case SPIRType::Char:
Use specific base types for 8- and 16-bit integers.
2018-11-01 22:20:07 +00:00
case SPIRType::SByte:
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
type_name = "char";
break;
Use specific base types for 8- and 16-bit integers.
2018-11-01 22:20:07 +00:00
case SPIRType::UByte:
type_name = "uchar";
break;
case SPIRType::Short:
type_name = "short";
break;
case SPIRType::UShort:
type_name = "ushort";
break;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case SPIRType::Int:
Use specific base types for 8- and 16-bit integers.
2018-11-01 22:20:07 +00:00
type_name = "int";
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
break;
case SPIRType::UInt:
Use specific base types for 8- and 16-bit integers.
2018-11-01 22:20:07 +00:00
type_name = "uint";
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
break;
case SPIRType::Int64:
MSL: Support 64-bit integers.
2019-06-11 08:45:22 +00:00
if (!msl_options.supports_msl_version(2, 2))
SPIRV_CROSS_THROW("64-bit integers are only supported in MSL 2.2 and above.");
type_name = "long";
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
break;
case SPIRType::UInt64:
MSL: Support 64-bit integers.
2019-06-11 08:45:22 +00:00
if (!msl_options.supports_msl_version(2, 2))
SPIRV_CROSS_THROW("64-bit integers are only supported in MSL 2.2 and above.");
type_name = "ulong";
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
break;
Some compat fixes for MSL and Half.
2018-03-06 16:07:59 +00:00
case SPIRType::Half:
type_name = "half";
break;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case SPIRType::Float:
Some compat fixes for MSL and Half.
2018-03-06 16:07:59 +00:00
type_name = "float";
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
break;
case SPIRType::Double:
type_name = "double"; // Currently unsupported
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
default:
return "unknown_type";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
// Matrix?
if (type.columns > 1)
type_name += to_string(type.columns) + "x";
// Vector or Matrix?
if (type.vecsize > 1)
type_name += to_string(type.vecsize);
MSL: Add a workaround path to force native arrays for everything.
2020-02-24 11:47:14 +00:00
if (type.array.empty() || using_builtin_array())
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
{
return type_name;
}
else
{
MSL: Do not declare array of UBO/SSBO as spvUnsafeArray<T>. There is no need for these to be copied, and cuts down on template stamping bloat.
2019-10-24 11:57:05 +00:00
// Allow Metal to use the array<T> template to make arrays a value type
add_spv_func_and_recompile(SPVFuncImplUnsafeArray);
string res;
string sizes;
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
MSL: Fix array of array declaration. Arrays-of-arrays were declared in wrong order.
2019-10-26 13:40:56 +00:00
for (uint32_t i = 0; i < uint32_t(type.array.size()); i++)
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
{
MSL: Do not declare array of UBO/SSBO as spvUnsafeArray<T>. There is no need for these to be copied, and cuts down on template stamping bloat.
2019-10-24 11:57:05 +00:00
res += "spvUnsafeArray<";
sizes += ", ";
MSL: Fix array of array declaration. Arrays-of-arrays were declared in wrong order.
2019-10-26 13:40:56 +00:00
sizes += to_array_size(type, i);
MSL: Do not declare array of UBO/SSBO as spvUnsafeArray<T>. There is no need for these to be copied, and cuts down on template stamping bloat.
2019-10-24 11:57:05 +00:00
sizes += ">";
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
}
MSL: Do not declare array of UBO/SSBO as spvUnsafeArray<T>. There is no need for these to be copied, and cuts down on template stamping bloat.
2019-10-24 11:57:05 +00:00
res += type_name + sizes;
return res;
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
}
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
string CompilerMSL::type_to_array_glsl(const SPIRType &type)
{
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Allow Metal to use the array<T> template to make arrays a value type
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
switch (type.basetype)
{
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
case SPIRType::AtomicCounter:
case SPIRType::ControlPointArray:
{
return CompilerGLSL::type_to_array_glsl(type);
}
default:
{
MSL: Add a workaround path to force native arrays for everything.
2020-02-24 11:47:14 +00:00
if (using_builtin_array())
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
return CompilerGLSL::type_to_array_glsl(type);
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
else
return "";
}
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
}
}
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Threadgroup arrays can't have a wrapper type
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
std::string CompilerMSL::variable_decl(const SPIRVariable &variable)
{
if (variable.storage == StorageClassWorkgroup)
{
MSL: Add a workaround path to force native arrays for everything.
2020-02-24 11:47:14 +00:00
is_using_builtin_array = true;
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
}
std::string expr = CompilerGLSL::variable_decl(variable);
if (variable.storage == StorageClassWorkgroup)
{
MSL: Add a workaround path to force native arrays for everything.
2020-02-24 11:47:14 +00:00
is_using_builtin_array = false;
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
}
return expr;
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
Further updates for pull request #1162; also added two test cases for spvCubemapTo2DArrayFace function and added '--msl-framebuffer-fetch'/ '--msl-emulate-cube-array' compiler options.
2019-09-27 19:49:54 +00:00
// GCC workaround of lambdas calling protected funcs
std::string CompilerMSL::variable_decl(const SPIRType &type, const std::string &name, uint32_t id)
{
return CompilerGLSL::variable_decl(type, name, id);
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
Support array of images and samplers in MSL.
2018-04-03 12:00:34 +00:00
std::string CompilerMSL::sampler_type(const SPIRType &type)
{
if (!type.array.empty())
{
Add test for sampler image arrays.
2018-04-03 12:26:24 +00:00
if (!msl_options.supports_msl_version(2))
SPIRV_CROSS_THROW("MSL 2.0 or greater is required for arrays of samplers.");
Minor cleanups. Throw an error for cases we don't support. Add a blank line after each local array declaration.
2018-09-27 16:01:46 +00:00
if (type.array.size() > 1)
SPIRV_CROSS_THROW("Arrays of arrays of samplers are not supported in MSL.");
Support array of images and samplers in MSL.
2018-04-03 12:00:34 +00:00
// Arrays of samplers in MSL must be declared with a special array<T, N> syntax ala C++11 std::array.
Deal with OpSpecConstantOp used as array size. When trying to validate buffer sizes, we usually need to bail out when using SpecConstantOps, but for some very specific cases where we allow unsized arrays currently, we can safely allow "unknown" sized arrays as well. This is probably the best we can do, when we have even more difficult cases than this, we throw a more sensible error message.
2018-11-01 13:56:25 +00:00
uint32_t array_size = to_array_size_literal(type);
Support array of images and samplers in MSL.
2018-04-03 12:00:34 +00:00
if (array_size == 0)
SPIRV_CROSS_THROW("Unsized array of samplers is not supported in MSL.");
CompilerMSL pass builtin struct members into functions. Add and use Compiler::get_non_pointer_type() convenience functions.
2018-06-24 19:06:12 +00:00
Rename get_non_pointer_type() methods. This better reflects their purpose now.
2019-01-08 18:54:40 +00:00
auto &parent = get<SPIRType>(get_pointee_type(type).parent_type);
CompilerMSL pass builtin struct members into functions. Add and use Compiler::get_non_pointer_type() convenience functions.
2018-06-24 19:06:12 +00:00
return join("array<", sampler_type(parent), ", ", array_size, ">");
Support array of images and samplers in MSL.
2018-04-03 12:00:34 +00:00
}
else
return "sampler";
}
CompilerMSL vertex entry point return void when rasterization disabled. Add CompilerMSL::Options::disable_rasterization input/output API flag. Disable rasterization via API flag or when writing to textures. Disable rasterization when shader declares no output. Add test shaders for vertex no output and write texture forcing void output.
2018-07-26 04:50:33 +00:00
// Returns an MSL string describing the SPIR-V image type
Support emitting SPIR-V type declarations tuned for specified SPIR-V objects. CompilerGLSL type_to_glsl() and image_type_glsl() functions support optional object ID. Add SPIRType::Image::access member to support SPIR-V OpTypeImage access qualifier. Remove SPIRType::Image::is_read and ::is_written members. Use DecorationNonReadable and DecorationNonWritable to mark read/write access for image variables. CompilerMSL emit access qualifiers per image variable, instead of per image type. CompilerGLSL and CompilerHLSL behaviour is unchanged.
2017-05-30 00:45:05 +00:00
string CompilerMSL::image_type_glsl(const SPIRType &type, uint32_t id)
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
{
Fix depth compare textures when used in functions without argument.
2018-04-10 10:31:13 +00:00
auto *var = maybe_get<SPIRVariable>(id);
if (var && var->basevariable)
{
// For comparison images, check against the base variable,
// and not the fake ID which might have been generated for this variable.
id = var->basevariable;
}
Support array of images and samplers in MSL.
2018-04-03 12:00:34 +00:00
if (!type.array.empty())
{
MSL: Expand arrays of buffers passed as input. Even as of Metal 2.1, MSL still doesn't support arrays of buffers directly. Therefore, we must manually expand them. In the prologue, we define arrays holding the argument pointers; these arrays are what the transpiled code ends up referencing. We might be able to do similar things for textures and samplers prior to MSL 2.0. Speaking of which, also enable texture arrays on iOS MSL 1.2.
2018-09-27 01:06:05 +00:00
uint32_t major = 2, minor = 0;
if (msl_options.is_ios())
{
major = 1;
minor = 2;
}
if (!msl_options.supports_msl_version(major, minor))
Minor cleanups. Throw an error for cases we don't support. Add a blank line after each local array declaration.
2018-09-27 16:01:46 +00:00
{
if (msl_options.is_ios())
SPIRV_CROSS_THROW("MSL 1.2 or greater is required for arrays of textures.");
else
SPIRV_CROSS_THROW("MSL 2.0 or greater is required for arrays of textures.");
}
if (type.array.size() > 1)
SPIRV_CROSS_THROW("Arrays of arrays of textures are not supported in MSL.");
Add test for sampler image arrays.
2018-04-03 12:26:24 +00:00
Support array of images and samplers in MSL.
2018-04-03 12:00:34 +00:00
// Arrays of images in MSL must be declared with a special array<T, N> syntax ala C++11 std::array.
Deal with OpSpecConstantOp used as array size. When trying to validate buffer sizes, we usually need to bail out when using SpecConstantOps, but for some very specific cases where we allow unsized arrays currently, we can safely allow "unknown" sized arrays as well. This is probably the best we can do, when we have even more difficult cases than this, we throw a more sensible error message.
2018-11-01 13:56:25 +00:00
uint32_t array_size = to_array_size_literal(type);
Support array of images and samplers in MSL.
2018-04-03 12:00:34 +00:00
if (array_size == 0)
SPIRV_CROSS_THROW("Unsized array of images is not supported in MSL.");
CompilerMSL pass builtin struct members into functions. Add and use Compiler::get_non_pointer_type() convenience functions.
2018-06-24 19:06:12 +00:00
Rename get_non_pointer_type() methods. This better reflects their purpose now.
2019-01-08 18:54:40 +00:00
auto &parent = get<SPIRType>(get_pointee_type(type).parent_type);
CompilerMSL pass builtin struct members into functions. Add and use Compiler::get_non_pointer_type() convenience functions.
2018-06-24 19:06:12 +00:00
return join("array<", image_type_glsl(parent, id), ", ", array_size, ">");
Support array of images and samplers in MSL.
2018-04-03 12:00:34 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
string img_type_name;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
// Bypass pointers because we need the real image struct
auto &img_type = get<SPIRType>(type.self).image;
Support OpTypeImage with depth == 2 (unknown) properly. Track which OpSampledImages are ever used with Dref opcodes.
2018-07-04 12:25:10 +00:00
if (image_is_comparison(type, id))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
switch (img_type.dim)
{
Fix issue #239: compilation of shaders-msl/frag/texture-proj-shadow.frag. Remove unsupported sampler1DShadow from shaders-msl/frag/texture-proj-shadow.frag. Improve error message response from unsupported depth texture formats. Fix several integer cast warnings in unrelated code. Run ./format_all.sh on unrelated files.
2017-08-11 18:54:58 +00:00
case Dim1D:
MSL: Avoid some fallthrough warnings.
2019-10-28 14:20:38 +00:00
case Dim2D:
if (img_type.dim == Dim1D && !msl_options.texture_1D_as_2D)
MSL: Support option for treating 1D textures as 2D textures of height 1. Add CompilerMSL::Options::texture_1D_as_2D. Metal imposes significant restrictions on 1D textures, including not being renderable, clearable, or permitting mipmaps. This option allows SPIR-V 1D textures to be treated as 2D textures to permit this additional behaviour. App must of course supply the textures to Metal as 2D textures.
2019-10-24 16:31:20 +00:00
{
// Use a native Metal 1D texture
img_type_name += "depth1d_unsupported_by_metal";
break;
}
MSL: Avoid some fallthrough warnings.
2019-10-28 14:20:38 +00:00
MSL: Throw error on multisampled array textures.
2018-09-03 08:21:59 +00:00
if (img_type.ms && img_type.arrayed)
MSL: Support texture2d_ms_array.
2018-09-03 09:02:31 +00:00
{
if (!msl_options.supports_msl_version(2, 1))
SPIRV_CROSS_THROW("Multisampled array textures are supported from 2.1.");
img_type_name += "depth2d_ms_array";
}
else if (img_type.ms)
img_type_name += "depth2d_ms";
else if (img_type.arrayed)
img_type_name += "depth2d_array";
else
img_type_name += "depth2d";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Fix issue #239: compilation of shaders-msl/frag/texture-proj-shadow.frag. Remove unsupported sampler1DShadow from shaders-msl/frag/texture-proj-shadow.frag. Improve error message response from unsupported depth texture formats. Fix several integer cast warnings in unrelated code. Run ./format_all.sh on unrelated files.
2017-08-11 18:54:58 +00:00
case Dim3D:
img_type_name += "depth3d_unsupported_by_metal";
break;
Support emitting SPIR-V type declarations tuned for specified SPIR-V objects. CompilerGLSL type_to_glsl() and image_type_glsl() functions support optional object ID. Add SPIRType::Image::access member to support SPIR-V OpTypeImage access qualifier. Remove SPIRType::Image::is_read and ::is_written members. Use DecorationNonReadable and DecorationNonWritable to mark read/write access for image variables. CompilerMSL emit access qualifiers per image variable, instead of per image type. CompilerGLSL and CompilerHLSL behaviour is unchanged.
2017-05-30 00:45:05 +00:00
case DimCube:
Added a new 'emulate_cube_array' option to SPIRV-Cross to cope with translating TextureCubeArray into texture2d_array for iOS where this type is not available. (Original Author: Mark Satterthwaite)
2019-09-13 21:24:27 +00:00
if (!msl_options.emulate_cube_array)
img_type_name += (img_type.arrayed ? "depthcube_array" : "depthcube");
else
img_type_name += (img_type.arrayed ? "depth2d_array" : "depthcube");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
default:
img_type_name += "unknown_depth_texture_type";
break;
}
}
else
{
switch (img_type.dim)
{
Support emitting SPIR-V type declarations tuned for specified SPIR-V objects. CompilerGLSL type_to_glsl() and image_type_glsl() functions support optional object ID. Add SPIRType::Image::access member to support SPIR-V OpTypeImage access qualifier. Remove SPIRType::Image::is_read and ::is_written members. Use DecorationNonReadable and DecorationNonWritable to mark read/write access for image variables. CompilerMSL emit access qualifiers per image variable, instead of per image type. CompilerGLSL and CompilerHLSL behaviour is unchanged.
2017-05-30 00:45:05 +00:00
case DimBuffer:
MSL: Support native texture_buffer type, throw error on atomics. Atomics are not supported on images or texture_buffers in MSL. Properly throw an error if OpImageTexelPointer is used (since it can only be used for atomic operations anyways).
2019-04-23 10:17:21 +00:00
if (img_type.ms || img_type.arrayed)
SPIRV_CROSS_THROW("Cannot use texel buffers with multisampling or array layers.");
if (msl_options.texture_buffer_native)
{
if (!msl_options.supports_msl_version(2, 1))
SPIRV_CROSS_THROW("Native texture_buffer type is only supported in MSL 2.1.");
img_type_name = "texture_buffer";
}
else
img_type_name += "texture2d";
break;
MSL: Support option for treating 1D textures as 2D textures of height 1. Add CompilerMSL::Options::texture_1D_as_2D. Metal imposes significant restrictions on 1D textures, including not being renderable, clearable, or permitting mipmaps. This option allows SPIR-V 1D textures to be treated as 2D textures to permit this additional behaviour. App must of course supply the textures to Metal as 2D textures.
2019-10-24 16:31:20 +00:00
case Dim1D:
MSL: Avoid some fallthrough warnings.
2019-10-28 14:20:38 +00:00
case Dim2D:
case DimSubpassData:
MSL: Support layered input attachments. These need to use arrayed texture types, or Metal will complain when binding the resource. The target layer is addressed relative to the Layer output by the vertex pipeline, or to the ViewIndex if in a multiview pipeline. Unlike with the s/t coordinates, Vulkan does not forbid non-zero layer coordinates here, though this cannot be expressed in Vulkan GLSL. Supporting 3D textures will require additional work. Part of the problem is that Metal does not allow texture views to subset a 3D texture, so we need some way to pass the base depth to the shader.
2020-08-28 00:24:20 +00:00
{
bool subpass_array =
img_type.dim == DimSubpassData && (msl_options.multiview || msl_options.arrayed_subpass_input);
MSL: Avoid some fallthrough warnings.
2019-10-28 14:20:38 +00:00
if (img_type.dim == Dim1D && !msl_options.texture_1D_as_2D)
MSL: Support option for treating 1D textures as 2D textures of height 1. Add CompilerMSL::Options::texture_1D_as_2D. Metal imposes significant restrictions on 1D textures, including not being renderable, clearable, or permitting mipmaps. This option allows SPIR-V 1D textures to be treated as 2D textures to permit this additional behaviour. App must of course supply the textures to Metal as 2D textures.
2019-10-24 16:31:20 +00:00
{
// Use a native Metal 1D texture
img_type_name += (img_type.arrayed ? "texture1d_array" : "texture1d");
break;
}
MSL: Avoid some fallthrough warnings.
2019-10-28 14:20:38 +00:00
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Use Metal's native frame-buffer fetch API for subpass inputs.
MSL: Fix case where subpassInput is passed to leaf functions.
2020-04-27 09:23:24 +00:00
if (type_is_msl_framebuffer_fetch(type))
Further updates for pull request #1162; also added two test cases for spvCubemapTo2DArrayFace function and added '--msl-framebuffer-fetch'/ '--msl-emulate-cube-array' compiler options.
2019-09-27 19:49:54 +00:00
{
MSL: Fix case where subpassInput is passed to leaf functions.
2020-04-27 09:23:24 +00:00
auto img_type_4 = get<SPIRType>(img_type.type);
img_type_4.vecsize = 4;
return type_to_glsl(img_type_4);
Further updates for pull request #1162; also added two test cases for spvCubemapTo2DArrayFace function and added '--msl-framebuffer-fetch'/ '--msl-emulate-cube-array' compiler options.
2019-09-27 19:49:54 +00:00
}
MSL: Support layered input attachments. These need to use arrayed texture types, or Metal will complain when binding the resource. The target layer is addressed relative to the Layer output by the vertex pipeline, or to the ViewIndex if in a multiview pipeline. Unlike with the s/t coordinates, Vulkan does not forbid non-zero layer coordinates here, though this cannot be expressed in Vulkan GLSL. Supporting 3D textures will require additional work. Part of the problem is that Metal does not allow texture views to subset a 3D texture, so we need some way to pass the base depth to the shader.
2020-08-28 00:24:20 +00:00
if (img_type.ms && (img_type.arrayed || subpass_array))
MSL: Support texture2d_ms_array.
2018-09-03 09:02:31 +00:00
{
if (!msl_options.supports_msl_version(2, 1))
SPIRV_CROSS_THROW("Multisampled array textures are supported from 2.1.");
img_type_name += "texture2d_ms_array";
}
else if (img_type.ms)
img_type_name += "texture2d_ms";
MSL: Support layered input attachments. These need to use arrayed texture types, or Metal will complain when binding the resource. The target layer is addressed relative to the Layer output by the vertex pipeline, or to the ViewIndex if in a multiview pipeline. Unlike with the s/t coordinates, Vulkan does not forbid non-zero layer coordinates here, though this cannot be expressed in Vulkan GLSL. Supporting 3D textures will require additional work. Part of the problem is that Metal does not allow texture views to subset a 3D texture, so we need some way to pass the base depth to the shader.
2020-08-28 00:24:20 +00:00
else if (img_type.arrayed || subpass_array)
MSL: Support texture2d_ms_array.
2018-09-03 09:02:31 +00:00
img_type_name += "texture2d_array";
else
img_type_name += "texture2d";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
MSL: Support layered input attachments. These need to use arrayed texture types, or Metal will complain when binding the resource. The target layer is addressed relative to the Layer output by the vertex pipeline, or to the ViewIndex if in a multiview pipeline. Unlike with the s/t coordinates, Vulkan does not forbid non-zero layer coordinates here, though this cannot be expressed in Vulkan GLSL. Supporting 3D textures will require additional work. Part of the problem is that Metal does not allow texture views to subset a 3D texture, so we need some way to pass the base depth to the shader.
2020-08-28 00:24:20 +00:00
}
Support emitting SPIR-V type declarations tuned for specified SPIR-V objects. CompilerGLSL type_to_glsl() and image_type_glsl() functions support optional object ID. Add SPIRType::Image::access member to support SPIR-V OpTypeImage access qualifier. Remove SPIRType::Image::is_read and ::is_written members. Use DecorationNonReadable and DecorationNonWritable to mark read/write access for image variables. CompilerMSL emit access qualifiers per image variable, instead of per image type. CompilerGLSL and CompilerHLSL behaviour is unchanged.
2017-05-30 00:45:05 +00:00
case Dim3D:
CompilerMSL supports promoting unnamed global vars to function args. CompilerMSL use correct MSL type name for 3D textures.
2016-11-27 20:00:06 +00:00
img_type_name += "texture3d";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Support emitting SPIR-V type declarations tuned for specified SPIR-V objects. CompilerGLSL type_to_glsl() and image_type_glsl() functions support optional object ID. Add SPIRType::Image::access member to support SPIR-V OpTypeImage access qualifier. Remove SPIRType::Image::is_read and ::is_written members. Use DecorationNonReadable and DecorationNonWritable to mark read/write access for image variables. CompilerMSL emit access qualifiers per image variable, instead of per image type. CompilerGLSL and CompilerHLSL behaviour is unchanged.
2017-05-30 00:45:05 +00:00
case DimCube:
Added a new 'emulate_cube_array' option to SPIRV-Cross to cope with translating TextureCubeArray into texture2d_array for iOS where this type is not available. (Original Author: Mark Satterthwaite)
2019-09-13 21:24:27 +00:00
if (!msl_options.emulate_cube_array)
img_type_name += (img_type.arrayed ? "texturecube_array" : "texturecube");
else
img_type_name += (img_type.arrayed ? "texture2d_array" : "texturecube");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
default:
img_type_name += "unknown_texture_type";
break;
}
}
// Append the pixel type
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
img_type_name += "<";
Support emitting SPIR-V type declarations tuned for specified SPIR-V objects. CompilerGLSL type_to_glsl() and image_type_glsl() functions support optional object ID. Add SPIRType::Image::access member to support SPIR-V OpTypeImage access qualifier. Remove SPIRType::Image::is_read and ::is_written members. Use DecorationNonReadable and DecorationNonWritable to mark read/write access for image variables. CompilerMSL emit access qualifiers per image variable, instead of per image type. CompilerGLSL and CompilerHLSL behaviour is unchanged.
2017-05-30 00:45:05 +00:00
img_type_name += type_to_glsl(get<SPIRType>(img_type.type));
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
Support emitting SPIR-V type declarations tuned for specified SPIR-V objects. CompilerGLSL type_to_glsl() and image_type_glsl() functions support optional object ID. Add SPIRType::Image::access member to support SPIR-V OpTypeImage access qualifier. Remove SPIRType::Image::is_read and ::is_written members. Use DecorationNonReadable and DecorationNonWritable to mark read/write access for image variables. CompilerMSL emit access qualifiers per image variable, instead of per image type. CompilerGLSL and CompilerHLSL behaviour is unchanged.
2017-05-30 00:45:05 +00:00
// For unsampled images, append the sample/read/write access qualifier.
// For kernel images, the access qualifier my be supplied directly by SPIR-V.
// Otherwise it may be set based on whether the image is read from or written to within the shader.
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
if (type.basetype == SPIRType::Image && type.image.sampled == 2 && type.image.dim != DimSubpassData)
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
{
Support emitting SPIR-V type declarations tuned for specified SPIR-V objects. CompilerGLSL type_to_glsl() and image_type_glsl() functions support optional object ID. Add SPIRType::Image::access member to support SPIR-V OpTypeImage access qualifier. Remove SPIRType::Image::is_read and ::is_written members. Use DecorationNonReadable and DecorationNonWritable to mark read/write access for image variables. CompilerMSL emit access qualifiers per image variable, instead of per image type. CompilerGLSL and CompilerHLSL behaviour is unchanged.
2017-05-30 00:45:05 +00:00
switch (img_type.access)
{
case AccessQualifierReadOnly:
img_type_name += ", access::read";
break;
case AccessQualifierWriteOnly:
img_type_name += ", access::write";
break;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
Support emitting SPIR-V type declarations tuned for specified SPIR-V objects. CompilerGLSL type_to_glsl() and image_type_glsl() functions support optional object ID. Add SPIRType::Image::access member to support SPIR-V OpTypeImage access qualifier. Remove SPIRType::Image::is_read and ::is_written members. Use DecorationNonReadable and DecorationNonWritable to mark read/write access for image variables. CompilerMSL emit access qualifiers per image variable, instead of per image type. CompilerGLSL and CompilerHLSL behaviour is unchanged.
2017-05-30 00:45:05 +00:00
case AccessQualifierReadWrite:
img_type_name += ", access::read_write";
break;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
Support emitting SPIR-V type declarations tuned for specified SPIR-V objects. CompilerGLSL type_to_glsl() and image_type_glsl() functions support optional object ID. Add SPIRType::Image::access member to support SPIR-V OpTypeImage access qualifier. Remove SPIRType::Image::is_read and ::is_written members. Use DecorationNonReadable and DecorationNonWritable to mark read/write access for image variables. CompilerMSL emit access qualifiers per image variable, instead of per image type. CompilerGLSL and CompilerHLSL behaviour is unchanged.
2017-05-30 00:45:05 +00:00
default:
{
auto *p_var = maybe_get_backing_variable(id);
MSL improvements: - pack/unpack nested constant buffer structs - support for write-only textures (only global ones for now) - better rt index support for msl generator
2017-12-06 17:51:23 +00:00
if (p_var && p_var->basevariable)
p_var = maybe_get<SPIRVariable>(p_var->basevariable);
Support emitting SPIR-V type declarations tuned for specified SPIR-V objects. CompilerGLSL type_to_glsl() and image_type_glsl() functions support optional object ID. Add SPIRType::Image::access member to support SPIR-V OpTypeImage access qualifier. Remove SPIRType::Image::is_read and ::is_written members. Use DecorationNonReadable and DecorationNonWritable to mark read/write access for image variables. CompilerMSL emit access qualifiers per image variable, instead of per image type. CompilerGLSL and CompilerHLSL behaviour is unchanged.
2017-05-30 00:45:05 +00:00
if (p_var && !has_decoration(p_var->self, DecorationNonWritable))
{
img_type_name += ", access::";
if (!has_decoration(p_var->self, DecorationNonReadable))
img_type_name += "read_";
img_type_name += "write";
}
break;
}
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
}
img_type_name += ">";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return img_type_name;
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
void CompilerMSL::emit_subgroup_op(const Instruction &i)
{
const uint32_t *ops = stream(i);
auto op = static_cast<Op>(i.op);
// Metal 2.0 is required. iOS only supports quad ops. macOS only supports
// broadcast and shuffle on 10.13 (2.0), with full support in 10.14 (2.1).
// Note that iOS makes no distinction between a quad-group and a subgroup;
// all subgroups are quad-groups there.
if (!msl_options.supports_msl_version(2))
SPIRV_CROSS_THROW("Subgroups are only supported in Metal 2.0 and up.");
MSL: Deal with sign on wave min/max.
2020-01-09 11:28:16 +00:00
// If we need to do implicit bitcasts, make sure we do it with the correct type.
uint32_t integer_width = get_integer_width_for_instruction(i);
auto int_type = to_signed_basetype(integer_width);
auto uint_type = to_unsigned_basetype(integer_width);
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
if (msl_options.is_ios())
{
switch (op)
{
default:
SPIRV_CROSS_THROW("iOS only supports quad-group operations.");
case OpGroupNonUniformBroadcast:
case OpGroupNonUniformShuffle:
case OpGroupNonUniformShuffleXor:
case OpGroupNonUniformShuffleUp:
case OpGroupNonUniformShuffleDown:
case OpGroupNonUniformQuadSwap:
case OpGroupNonUniformQuadBroadcast:
break;
}
}
if (msl_options.is_macos() && !msl_options.supports_msl_version(2, 1))
{
switch (op)
{
default:
MSL: Deal with sign on wave min/max.
2020-01-09 11:28:16 +00:00
SPIRV_CROSS_THROW("Subgroup ops beyond broadcast and shuffle on macOS require Metal 2.1 and up.");
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
case OpGroupNonUniformBroadcast:
case OpGroupNonUniformShuffle:
case OpGroupNonUniformShuffleXor:
case OpGroupNonUniformShuffleUp:
case OpGroupNonUniformShuffleDown:
break;
}
}
uint32_t result_type = ops[0];
uint32_t id = ops[1];
Implement a simple evaluator of specialization constants. In some cases, we need to get a literal value from a spec constant op. Mostly relevant when emitting buffers, so implement a 32-bit integer scalar subset of the evaluator. Can be extended as needed to support evaluating any specialization constant operation.
2020-09-14 08:42:31 +00:00
auto scope = static_cast<Scope>(evaluate_constant_u32(ops[2]));
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
if (scope != ScopeSubgroup)
SPIRV_CROSS_THROW("Only subgroup scope is supported.");
switch (op)
{
case OpGroupNonUniformElect:
Remove fallback for OpGroupNonUniformElect. It's not safe to enable subgroup support without this actually working correctly.
2019-05-16 18:42:09 +00:00
emit_op(result_type, id, "simd_is_first()", true);
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
break;
case OpGroupNonUniformBroadcast:
emit_binary_func_op(result_type, id, ops[3], ops[4],
msl_options.is_ios() ? "quad_broadcast" : "simd_broadcast");
break;
case OpGroupNonUniformBroadcastFirst:
emit_unary_func_op(result_type, id, ops[3], "simd_broadcast_first");
break;
case OpGroupNonUniformBallot:
emit_unary_func_op(result_type, id, ops[3], "spvSubgroupBallot");
break;
case OpGroupNonUniformInverseBallot:
emit_binary_func_op(result_type, id, ops[3], builtin_subgroup_invocation_id_id, "spvSubgroupBallotBitExtract");
break;
case OpGroupNonUniformBallotBitExtract:
emit_binary_func_op(result_type, id, ops[3], ops[4], "spvSubgroupBallotBitExtract");
break;
case OpGroupNonUniformBallotFindLSB:
emit_unary_func_op(result_type, id, ops[3], "spvSubgroupBallotFindLSB");
break;
case OpGroupNonUniformBallotFindMSB:
emit_unary_func_op(result_type, id, ops[3], "spvSubgroupBallotFindMSB");
break;
case OpGroupNonUniformBallotBitCount:
{
auto operation = static_cast<GroupOperation>(ops[3]);
if (operation == GroupOperationReduce)
emit_unary_func_op(result_type, id, ops[4], "spvSubgroupBallotBitCount");
else if (operation == GroupOperationInclusiveScan)
emit_binary_func_op(result_type, id, ops[4], builtin_subgroup_invocation_id_id,
"spvSubgroupBallotInclusiveBitCount");
else if (operation == GroupOperationExclusiveScan)
emit_binary_func_op(result_type, id, ops[4], builtin_subgroup_invocation_id_id,
"spvSubgroupBallotExclusiveBitCount");
else
SPIRV_CROSS_THROW("Invalid BitCount operation.");
break;
}
case OpGroupNonUniformShuffle:
emit_binary_func_op(result_type, id, ops[3], ops[4], msl_options.is_ios() ? "quad_shuffle" : "simd_shuffle");
break;
case OpGroupNonUniformShuffleXor:
emit_binary_func_op(result_type, id, ops[3], ops[4],
msl_options.is_ios() ? "quad_shuffle_xor" : "simd_shuffle_xor");
break;
case OpGroupNonUniformShuffleUp:
emit_binary_func_op(result_type, id, ops[3], ops[4],
msl_options.is_ios() ? "quad_shuffle_up" : "simd_shuffle_up");
break;
case OpGroupNonUniformShuffleDown:
emit_binary_func_op(result_type, id, ops[3], ops[4],
msl_options.is_ios() ? "quad_shuffle_down" : "simd_shuffle_down");
break;
case OpGroupNonUniformAll:
emit_unary_func_op(result_type, id, ops[3], "simd_all");
break;
case OpGroupNonUniformAny:
emit_unary_func_op(result_type, id, ops[3], "simd_any");
break;
case OpGroupNonUniformAllEqual:
emit_unary_func_op(result_type, id, ops[3], "spvSubgroupAllEqual");
break;
// clang-format off
#define MSL_GROUP_OP(op, msl_op) \
case OpGroupNonUniform##op: \
{ \
auto operation = static_cast<GroupOperation>(ops[3]); \
if (operation == GroupOperationReduce) \
emit_unary_func_op(result_type, id, ops[4], "simd_" #msl_op); \
else if (operation == GroupOperationInclusiveScan) \
emit_unary_func_op(result_type, id, ops[4], "simd_prefix_inclusive_" #msl_op); \
else if (operation == GroupOperationExclusiveScan) \
emit_unary_func_op(result_type, id, ops[4], "simd_prefix_exclusive_" #msl_op); \
else if (operation == GroupOperationClusteredReduce) \
{ \
/* Only cluster sizes of 4 are supported. */ \
Implement a simple evaluator of specialization constants. In some cases, we need to get a literal value from a spec constant op. Mostly relevant when emitting buffers, so implement a 32-bit integer scalar subset of the evaluator. Can be extended as needed to support evaluating any specialization constant operation.
2020-09-14 08:42:31 +00:00
uint32_t cluster_size = evaluate_constant_u32(ops[5]); \
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
if (cluster_size != 4) \
SPIRV_CROSS_THROW("Metal only supports quad ClusteredReduce."); \
emit_unary_func_op(result_type, id, ops[4], "quad_" #msl_op); \
} \
else \
SPIRV_CROSS_THROW("Invalid group operation."); \
break; \
}
MSL_GROUP_OP(FAdd, sum)
MSL_GROUP_OP(FMul, product)
MSL_GROUP_OP(IAdd, sum)
MSL_GROUP_OP(IMul, product)
#undef MSL_GROUP_OP
// The others, unfortunately, don't support InclusiveScan or ExclusiveScan.
MSL: Deal with sign on wave min/max.
2020-01-09 11:28:16 +00:00
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
#define MSL_GROUP_OP(op, msl_op) \
case OpGroupNonUniform##op: \
{ \
auto operation = static_cast<GroupOperation>(ops[3]); \
if (operation == GroupOperationReduce) \
emit_unary_func_op(result_type, id, ops[4], "simd_" #msl_op); \
else if (operation == GroupOperationInclusiveScan) \
SPIRV_CROSS_THROW("Metal doesn't support InclusiveScan for OpGroupNonUniform" #op "."); \
else if (operation == GroupOperationExclusiveScan) \
SPIRV_CROSS_THROW("Metal doesn't support ExclusiveScan for OpGroupNonUniform" #op "."); \
else if (operation == GroupOperationClusteredReduce) \
{ \
/* Only cluster sizes of 4 are supported. */ \
Implement a simple evaluator of specialization constants. In some cases, we need to get a literal value from a spec constant op. Mostly relevant when emitting buffers, so implement a 32-bit integer scalar subset of the evaluator. Can be extended as needed to support evaluating any specialization constant operation.
2020-09-14 08:42:31 +00:00
uint32_t cluster_size = evaluate_constant_u32(ops[5]); \
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
if (cluster_size != 4) \
SPIRV_CROSS_THROW("Metal only supports quad ClusteredReduce."); \
emit_unary_func_op(result_type, id, ops[4], "quad_" #msl_op); \
} \
else \
SPIRV_CROSS_THROW("Invalid group operation."); \
break; \
}
MSL: Deal with sign on wave min/max.
2020-01-09 11:28:16 +00:00
#define MSL_GROUP_OP_CAST(op, msl_op, type) \
case OpGroupNonUniform##op: \
{ \
auto operation = static_cast<GroupOperation>(ops[3]); \
if (operation == GroupOperationReduce) \
emit_unary_func_op_cast(result_type, id, ops[4], "simd_" #msl_op, type, type); \
else if (operation == GroupOperationInclusiveScan) \
SPIRV_CROSS_THROW("Metal doesn't support InclusiveScan for OpGroupNonUniform" #op "."); \
else if (operation == GroupOperationExclusiveScan) \
SPIRV_CROSS_THROW("Metal doesn't support ExclusiveScan for OpGroupNonUniform" #op "."); \
else if (operation == GroupOperationClusteredReduce) \
{ \
/* Only cluster sizes of 4 are supported. */ \
Implement a simple evaluator of specialization constants. In some cases, we need to get a literal value from a spec constant op. Mostly relevant when emitting buffers, so implement a 32-bit integer scalar subset of the evaluator. Can be extended as needed to support evaluating any specialization constant operation.
2020-09-14 08:42:31 +00:00
uint32_t cluster_size = evaluate_constant_u32(ops[5]); \
MSL: Deal with sign on wave min/max.
2020-01-09 11:28:16 +00:00
if (cluster_size != 4) \
SPIRV_CROSS_THROW("Metal only supports quad ClusteredReduce."); \
emit_unary_func_op_cast(result_type, id, ops[4], "quad_" #msl_op, type, type); \
} \
else \
SPIRV_CROSS_THROW("Invalid group operation."); \
break; \
}
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
MSL_GROUP_OP(FMin, min)
MSL_GROUP_OP(FMax, max)
MSL: Deal with sign on wave min/max.
2020-01-09 11:28:16 +00:00
MSL_GROUP_OP_CAST(SMin, min, int_type)
MSL_GROUP_OP_CAST(SMax, max, int_type)
MSL_GROUP_OP_CAST(UMin, min, uint_type)
MSL_GROUP_OP_CAST(UMax, max, uint_type)
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
MSL_GROUP_OP(BitwiseAnd, and)
MSL_GROUP_OP(BitwiseOr, or)
MSL_GROUP_OP(BitwiseXor, xor)
MSL_GROUP_OP(LogicalAnd, and)
MSL_GROUP_OP(LogicalOr, or)
MSL_GROUP_OP(LogicalXor, xor)
// clang-format on
MSL: Deal with sign on wave min/max.
2020-01-09 11:28:16 +00:00
#undef MSL_GROUP_OP
#undef MSL_GROUP_OP_CAST
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
case OpGroupNonUniformQuadSwap:
{
// We can implement this easily based on the following table giving
// the target lane ID from the direction and current lane ID:
// Direction
// | 0 | 1 | 2 |
// ---+---+---+---+
// L 0 | 1 2 3
// a 1 | 0 3 2
// n 2 | 3 0 1
// e 3 | 2 1 0
// Notice that target = source ^ (direction + 1).
Implement a simple evaluator of specialization constants. In some cases, we need to get a literal value from a spec constant op. Mostly relevant when emitting buffers, so implement a 32-bit integer scalar subset of the evaluator. Can be extended as needed to support evaluating any specialization constant operation.
2020-09-14 08:42:31 +00:00
uint32_t mask = evaluate_constant_u32(ops[4]) + 1;
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
uint32_t mask_id = ir.increase_bound_by(1);
set<SPIRConstant>(mask_id, expression_type_id(ops[4]), mask, false);
emit_binary_func_op(result_type, id, ops[3], mask_id, "quad_shuffle_xor");
break;
}
case OpGroupNonUniformQuadBroadcast:
emit_binary_func_op(result_type, id, ops[3], ops[4], "quad_broadcast");
break;
default:
SPIRV_CROSS_THROW("Invalid opcode for subgroup.");
}
register_control_dependent_expression(id);
}
CompilerMSL add support for MSL specialization function constants. CompilerMSL add emit_custom_functions() function. CompilerMSL restrict use of as_type<> cast to necessary conditions. CompilerMSL refactor get_declared_struct_member_size() and get_declared_struct_member_alignment() functions, and remove unnecessary get_declared_type_size() functions. Add test shaders-msl/vulkan/frag/spec-constant.vk.frag.
2017-06-15 19:24:22 +00:00
string CompilerMSL::bitcast_glsl_op(const SPIRType &out_type, const SPIRType &in_type)
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
{
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
if (out_type.basetype == in_type.basetype)
return "";
CompilerMSL add support for MSL specialization function constants. CompilerMSL add emit_custom_functions() function. CompilerMSL restrict use of as_type<> cast to necessary conditions. CompilerMSL refactor get_declared_struct_member_size() and get_declared_struct_member_alignment() functions, and remove unnecessary get_declared_type_size() functions. Add test shaders-msl/vulkan/frag/spec-constant.vk.frag.
2017-06-15 19:24:22 +00:00
Move assertions after the check for equal types. `bitcast_glsl_op()` is sometimes called for `Boolean` types, e.g. for specialization constants. We don't want the assert to trip if this is going to be a no-op anyway.
2019-01-31 02:19:05 +00:00
assert(out_type.basetype != SPIRType::Boolean);
assert(in_type.basetype != SPIRType::Boolean);
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
bool integral_cast = type_is_integral(out_type) && type_is_integral(in_type);
bool same_size_cast = out_type.width == in_type.width;
if (integral_cast && same_size_cast)
{
// Trivial bitcast case, casts between integers.
return type_to_glsl(out_type);
}
else
{
// Fall back to the catch-all bitcast in MSL.
return "as_type<" + type_to_glsl(out_type) + ">";
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
}
GLSL: Support f16x2 <-> f32 bitcast. There is no native formulation, so introduce a concept of a "complex" bitcast to handle odd-ball cases which have no native unary operation.
2020-04-21 21:27:33 +00:00
bool CompilerMSL::emit_complex_bitcast(uint32_t, uint32_t, uint32_t)
{
return false;
}
Add support for the BuiltInClipDistance builtin for MSL. CompilerGLSL builtin_to_glsl() function outputs gl_ClipDistance for BuiltInClipDistance builtin, and includes builtin code in output when handling unknown builtin code. CompilerMSL uses type ID instead of type object where appropriate to support array types, where type.self is not consistent with actual type ID, plus support array stride calc even when not explicitly set by SPIR-V code. For output consistency, CompilerMSL prefers use of standard builtin names over specified names, and output builtins qualified with output struct while in entry function.
2016-12-17 22:07:53 +00:00
// Returns an MSL string identifying the name of a SPIR-V builtin.
// Output builtins are qualified with the name of the stage out structure.
Add support for SampleId/SampleMask/SamplePosition builtins.
2017-07-24 08:07:02 +00:00
string CompilerMSL::builtin_to_glsl(BuiltIn builtin, StorageClass storage)
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
switch (builtin)
{
Add support for the BuiltInClipDistance builtin for MSL. CompilerGLSL builtin_to_glsl() function outputs gl_ClipDistance for BuiltInClipDistance builtin, and includes builtin code in output when handling unknown builtin code. CompilerMSL uses type ID instead of type object where appropriate to support array types, where type.self is not consistent with actual type ID, plus support array stride calc even when not explicitly set by SPIR-V code. For output consistency, CompilerMSL prefers use of standard builtin names over specified names, and output builtins qualified with output struct while in entry function.
2016-12-17 22:07:53 +00:00
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Handle HLSL-style 0-based vertex/instance index.
Add support for the BuiltInClipDistance builtin for MSL. CompilerGLSL builtin_to_glsl() function outputs gl_ClipDistance for BuiltInClipDistance builtin, and includes builtin code in output when handling unknown builtin code. CompilerMSL uses type ID instead of type object where appropriate to support array types, where type.self is not consistent with actual type ID, plus support array stride calc even when not explicitly set by SPIR-V code. For output consistency, CompilerMSL prefers use of standard builtin names over specified names, and output builtins qualified with output struct while in entry function.
2016-12-17 22:07:53 +00:00
// Override GLSL compiler strictness
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case BuiltInVertexId:
Fixed false-positive optimization of builtin variables (may happen when 'spvOut' is emitted).
2019-09-19 18:44:30 +00:00
ensure_builtin(StorageClassInput, BuiltInVertexId);
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
if (msl_options.enable_base_index_zero && msl_options.supports_msl_version(1, 1) &&
(msl_options.ios_support_base_vertex_instance || msl_options.is_macos()))
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
{
if (builtin_declaration)
{
MSL: Be a little clearer how needs_base_vertex_idx is implemented. There is an implicit tristate with {-1, 0, +1} values, but it was not obvious how this was supposed to work before studying the implementation, so refactor into a tristate enum class.
2019-10-24 10:41:37 +00:00
if (needs_base_vertex_arg != TriState::No)
needs_base_vertex_arg = TriState::Yes;
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
return "gl_VertexID";
}
else
{
Fixed false-positive optimization of builtin variables (may happen when 'spvOut' is emitted).
2019-09-19 18:44:30 +00:00
ensure_builtin(StorageClassInput, BuiltInBaseVertex);
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
return "(gl_VertexID - gl_BaseVertex)";
}
}
else
{
return "gl_VertexID";
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case BuiltInInstanceId:
Fixed false-positive optimization of builtin variables (may happen when 'spvOut' is emitted).
2019-09-19 18:44:30 +00:00
ensure_builtin(StorageClassInput, BuiltInInstanceId);
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
if (msl_options.enable_base_index_zero && msl_options.supports_msl_version(1, 1) &&
(msl_options.ios_support_base_vertex_instance || msl_options.is_macos()))
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
{
if (builtin_declaration)
{
MSL: Be a little clearer how needs_base_vertex_idx is implemented. There is an implicit tristate with {-1, 0, +1} values, but it was not obvious how this was supposed to work before studying the implementation, so refactor into a tristate enum class.
2019-10-24 10:41:37 +00:00
if (needs_base_instance_arg != TriState::No)
needs_base_instance_arg = TriState::Yes;
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
return "gl_InstanceID";
}
else
{
Fixed false-positive optimization of builtin variables (may happen when 'spvOut' is emitted).
2019-09-19 18:44:30 +00:00
ensure_builtin(StorageClassInput, BuiltInBaseInstance);
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
return "(gl_InstanceID - gl_BaseInstance)";
}
}
else
{
return "gl_InstanceID";
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case BuiltInVertexIndex:
Fixed false-positive optimization of builtin variables (may happen when 'spvOut' is emitted).
2019-09-19 18:44:30 +00:00
ensure_builtin(StorageClassInput, BuiltInVertexIndex);
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
if (msl_options.enable_base_index_zero && msl_options.supports_msl_version(1, 1) &&
(msl_options.ios_support_base_vertex_instance || msl_options.is_macos()))
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
{
if (builtin_declaration)
{
MSL: Be a little clearer how needs_base_vertex_idx is implemented. There is an implicit tristate with {-1, 0, +1} values, but it was not obvious how this was supposed to work before studying the implementation, so refactor into a tristate enum class.
2019-10-24 10:41:37 +00:00
if (needs_base_vertex_arg != TriState::No)
needs_base_vertex_arg = TriState::Yes;
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
return "gl_VertexIndex";
}
else
{
Fixed false-positive optimization of builtin variables (may happen when 'spvOut' is emitted).
2019-09-19 18:44:30 +00:00
ensure_builtin(StorageClassInput, BuiltInBaseVertex);
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
return "(gl_VertexIndex - gl_BaseVertex)";
}
}
else
{
return "gl_VertexIndex";
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case BuiltInInstanceIndex:
Fixed false-positive optimization of builtin variables (may happen when 'spvOut' is emitted).
2019-09-19 18:44:30 +00:00
ensure_builtin(StorageClassInput, BuiltInInstanceIndex);
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
if (msl_options.enable_base_index_zero && msl_options.supports_msl_version(1, 1) &&
(msl_options.ios_support_base_vertex_instance || msl_options.is_macos()))
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
{
if (builtin_declaration)
{
MSL: Be a little clearer how needs_base_vertex_idx is implemented. There is an implicit tristate with {-1, 0, +1} values, but it was not obvious how this was supposed to work before studying the implementation, so refactor into a tristate enum class.
2019-10-24 10:41:37 +00:00
if (needs_base_instance_arg != TriState::No)
needs_base_instance_arg = TriState::Yes;
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
return "gl_InstanceIndex";
}
else
{
Fixed false-positive optimization of builtin variables (may happen when 'spvOut' is emitted).
2019-09-19 18:44:30 +00:00
ensure_builtin(StorageClassInput, BuiltInBaseInstance);
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
return "(gl_InstanceIndex - gl_BaseInstance)";
}
}
else
{
return "gl_InstanceIndex";
}
Support the shader_draw_parameters extension.
2018-08-28 18:47:29 +00:00
case BuiltInBaseVertex:
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
if (msl_options.supports_msl_version(1, 1) &&
(msl_options.ios_support_base_vertex_instance || msl_options.is_macos()))
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
{
MSL: Be a little clearer how needs_base_vertex_idx is implemented. There is an implicit tristate with {-1, 0, +1} values, but it was not obvious how this was supposed to work before studying the implementation, so refactor into a tristate enum class.
2019-10-24 10:41:37 +00:00
needs_base_vertex_arg = TriState::No;
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
return "gl_BaseVertex";
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
}
else
{
SPIRV_CROSS_THROW("BaseVertex requires Metal 1.1 and Mac or Apple A9+ hardware.");
}
Support the shader_draw_parameters extension.
2018-08-28 18:47:29 +00:00
case BuiltInBaseInstance:
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
if (msl_options.supports_msl_version(1, 1) &&
(msl_options.ios_support_base_vertex_instance || msl_options.is_macos()))
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
{
MSL: Be a little clearer how needs_base_vertex_idx is implemented. There is an implicit tristate with {-1, 0, +1} values, but it was not obvious how this was supposed to work before studying the implementation, so refactor into a tristate enum class.
2019-10-24 10:41:37 +00:00
needs_base_instance_arg = TriState::No;
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
return "gl_BaseInstance";
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
}
else
{
SPIRV_CROSS_THROW("BaseInstance requires Metal 1.1 and Mac or Apple A9+ hardware.");
}
Support the shader_draw_parameters extension.
2018-08-28 18:47:29 +00:00
case BuiltInDrawIndex:
Throw an exception anytime we try to compile DrawIndex to MSL.
2018-08-29 17:05:33 +00:00
SPIRV_CROSS_THROW("DrawIndex is not supported in MSL.");
Add support for the BuiltInClipDistance builtin for MSL. CompilerGLSL builtin_to_glsl() function outputs gl_ClipDistance for BuiltInClipDistance builtin, and includes builtin code in output when handling unknown builtin code. CompilerMSL uses type ID instead of type object where appropriate to support array types, where type.self is not consistent with actual type ID, plus support array stride calc even when not explicitly set by SPIR-V code. For output consistency, CompilerMSL prefers use of standard builtin names over specified names, and output builtins qualified with output struct while in entry function.
2016-12-17 22:07:53 +00:00
CompilerMSL enhancements. Support BuiltInFragDepth. Emit interface block for StorageClassUniformConstant. Throw exception when output or fragment input structs contain matrix or array. Dynamically created interface structs sorted by location number instead of alphabetically. Add Compiler::is_array() function.
2017-06-30 23:10:46 +00:00
// When used in the entry function, output builtins are qualified with output struct name.
CompilerMSL support gl_SampleMask and convert it to scalar uint from array.
2018-02-13 19:44:40 +00:00
// Test storage class as NOT Input, as output builtins might be part of generic type.
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
// Also don't do this for tessellation control shaders.
MSL: Handle the ViewportIndex builtin. This requires MSL 2.0+. Also, force `ViewportIndex` and `Layer` to be defined as the correct type, which is always `uint` in MSL. Since Metal doesn't yet have geometry shaders, the vertex shader (or tessellation evaluation shader == "post-tessellation vertex shader" in Metal jargon) is the only kind of shader that can set this output. This currently requires an extension to Vulkan, which causes validation of the SPIR-V binaries for the test cases to fail. Therefore, the test cases are marked "invalid", even though they're actually perfectly valid SPIR-V--they just won't work without the `SPV_EXT_shader_viewport_index_layer` extension.
2018-09-12 23:00:17 +00:00
case BuiltInViewportIndex:
if (!msl_options.supports_msl_version(2, 0))
SPIRV_CROSS_THROW("ViewportIndex requires Metal 2.0.");
/* fallthrough */
MSL: Add options to control emission of fragment outputs. Like with `point_size` when not rendering points, Metal complains when writing to a variable using the `[[depth]]` qualifier when no depth buffer be attached. In that case, we must avoid emitting `FragDepth`, just like with `PointSize`. I assume it will also complain if there be no stencil attachment and the shader write to `[[stencil]]`, or it write to `[[color(n)]]` but there be no color attachment at n.
2020-04-10 06:13:33 +00:00
case BuiltInFragDepth:
case BuiltInFragStencilRefEXT:
if ((builtin == BuiltInFragDepth && !msl_options.enable_frag_depth_builtin) ||
(builtin == BuiltInFragStencilRefEXT && !msl_options.enable_frag_stencil_ref_builtin))
break;
/* fallthrough */
Add support for the BuiltInClipDistance builtin for MSL. CompilerGLSL builtin_to_glsl() function outputs gl_ClipDistance for BuiltInClipDistance builtin, and includes builtin code in output when handling unknown builtin code. CompilerMSL uses type ID instead of type object where appropriate to support array types, where type.self is not consistent with actual type ID, plus support array stride calc even when not explicitly set by SPIR-V code. For output consistency, CompilerMSL prefers use of standard builtin names over specified names, and output builtins qualified with output struct while in entry function.
2016-12-17 22:07:53 +00:00
case BuiltInPosition:
case BuiltInPointSize:
case BuiltInClipDistance:
Revert to not forcing gl_in/gl_out block for MSL, and add MSL gl_ClipDistance tests.
2018-01-08 21:18:34 +00:00
case BuiltInCullDistance:
move BuiltInLayer to vertex out function block
2017-12-13 10:02:03 +00:00
case BuiltInLayer:
CompilerMSL support gl_SampleMask and convert it to scalar uint from array.
2018-02-13 19:44:40 +00:00
case BuiltInSampleMask:
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
if (get_execution_model() == ExecutionModelTessellationControl)
break;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
if (storage != StorageClassInput && current_function && (current_function->self == ir.default_entry_point))
Add support for SampleId/SampleMask/SamplePosition builtins.
2017-07-24 08:07:02 +00:00
return stage_out_var_name + "." + CompilerGLSL::builtin_to_glsl(builtin, storage);
CompilerMSL support gl_SampleMask and convert it to scalar uint from array.
2018-02-13 19:44:40 +00:00
break;
Add support for the BuiltInClipDistance builtin for MSL. CompilerGLSL builtin_to_glsl() function outputs gl_ClipDistance for BuiltInClipDistance builtin, and includes builtin code in output when handling unknown builtin code. CompilerMSL uses type ID instead of type object where appropriate to support array types, where type.self is not consistent with actual type ID, plus support array stride calc even when not explicitly set by SPIR-V code. For output consistency, CompilerMSL prefers use of standard builtin names over specified names, and output builtins qualified with output struct while in entry function.
2016-12-17 22:07:53 +00:00
MSL: Support PrimitiveID in fragment and barycentrics.
2019-06-13 09:33:40 +00:00
case BuiltInBaryCoordNV:
case BuiltInBaryCoordNoPerspNV:
if (storage == StorageClassInput && current_function && (current_function->self == ir.default_entry_point))
return stage_in_var_name + "." + CompilerGLSL::builtin_to_glsl(builtin, storage);
break;
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
case BuiltInTessLevelOuter:
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
if (get_execution_model() == ExecutionModelTessellationEvaluation)
MSL: Use vectors for the tessellation level builtins in tese shaders. The tessellation levels in Metal are stored as a densely-packed array of half-precision floating point values. But, stage-in attributes in Metal have to have offsets and strides aligned to a multiple of four, so we can't add them individually. Luckily for us, the arrays have lengths less than 4. So, let's use vectors for them! Triangles get a single attribute with a `float4`, where the outer levels are in `.xyz` and the inner levels are in `.w`. The arrays are unpacked as though we had added the elements individually. Quads get two: a `float4` with the outer levels and a `float2` with the inner levels. Further, since vectors can be indexed as arrays, there's no need to unpack them in this case. This also saves on precious vertex attributes. Before, we were using up to 6 of them. Now we need two at most.
2019-02-22 18:11:17 +00:00
{
if (storage != StorageClassOutput && !get_entry_point().flags.get(ExecutionModeTriangles) &&
current_function && (current_function->self == ir.default_entry_point))
return join(patch_stage_in_var_name, ".", CompilerGLSL::builtin_to_glsl(builtin, storage));
else
break;
}
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
if (storage != StorageClassInput && current_function && (current_function->self == ir.default_entry_point))
return join(tess_factor_buffer_var_name, "[", to_expression(builtin_primitive_id_id),
"].edgeTessellationFactor");
break;
case BuiltInTessLevelInner:
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
if (get_execution_model() == ExecutionModelTessellationEvaluation)
MSL: Use vectors for the tessellation level builtins in tese shaders. The tessellation levels in Metal are stored as a densely-packed array of half-precision floating point values. But, stage-in attributes in Metal have to have offsets and strides aligned to a multiple of four, so we can't add them individually. Luckily for us, the arrays have lengths less than 4. So, let's use vectors for them! Triangles get a single attribute with a `float4`, where the outer levels are in `.xyz` and the inner levels are in `.w`. The arrays are unpacked as though we had added the elements individually. Quads get two: a `float4` with the outer levels and a `float2` with the inner levels. Further, since vectors can be indexed as arrays, there's no need to unpack them in this case. This also saves on precious vertex attributes. Before, we were using up to 6 of them. Now we need two at most.
2019-02-22 18:11:17 +00:00
{
if (storage != StorageClassOutput && !get_entry_point().flags.get(ExecutionModeTriangles) &&
current_function && (current_function->self == ir.default_entry_point))
return join(patch_stage_in_var_name, ".", CompilerGLSL::builtin_to_glsl(builtin, storage));
else
break;
}
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
if (storage != StorageClassInput && current_function && (current_function->self == ir.default_entry_point))
return join(tess_factor_buffer_var_name, "[", to_expression(builtin_primitive_id_id),
"].insideTessellationFactor");
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
default:
CompilerMSL support gl_SampleMask and convert it to scalar uint from array.
2018-02-13 19:44:40 +00:00
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
CompilerMSL support gl_SampleMask and convert it to scalar uint from array.
2018-02-13 19:44:40 +00:00
return CompilerGLSL::builtin_to_glsl(builtin, storage);
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
// Returns an MSL string attribute qualifer for a SPIR-V builtin
string CompilerMSL::builtin_qualifier(BuiltIn builtin)
{
Add support for multiple entry points. - Only consider I/O variables if part of OpEntryPoint. - Keep a safe fallback if #entry-points is 1 to avoid potentially breaking previously working shaders.
2016-07-28 09:16:02 +00:00
auto &execution = get_entry_point();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
switch (builtin)
{
// Vertex function in
case BuiltInVertexId:
return "vertex_id";
case BuiltInVertexIndex:
return "vertex_id";
Support the shader_draw_parameters extension.
2018-08-28 18:47:29 +00:00
case BuiltInBaseVertex:
return "base_vertex";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case BuiltInInstanceId:
return "instance_id";
case BuiltInInstanceIndex:
return "instance_id";
Support the shader_draw_parameters extension.
2018-08-28 18:47:29 +00:00
case BuiltInBaseInstance:
return "base_instance";
case BuiltInDrawIndex:
Punt on DrawIndex in MSL for now. Metal doesn't properly support this.
2018-08-29 15:18:32 +00:00
SPIRV_CROSS_THROW("DrawIndex is not supported in MSL.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Vertex function out
case BuiltInClipDistance:
return "clip_distance";
case BuiltInPointSize:
return "point_size";
case BuiltInPosition:
MSL: Support Invariant qualifier on position.
2019-06-11 09:31:29 +00:00
if (position_invariant)
{
if (!msl_options.supports_msl_version(2, 1))
SPIRV_CROSS_THROW("Invariant position is only supported on MSL 2.1 and up.");
return "position, invariant";
}
else
return "position";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case BuiltInLayer:
return "render_target_array_index";
MSL: Handle the ViewportIndex builtin. This requires MSL 2.0+. Also, force `ViewportIndex` and `Layer` to be defined as the correct type, which is always `uint` in MSL. Since Metal doesn't yet have geometry shaders, the vertex shader (or tessellation evaluation shader == "post-tessellation vertex shader" in Metal jargon) is the only kind of shader that can set this output. This currently requires an extension to Vulkan, which causes validation of the SPIR-V binaries for the test cases to fail. Therefore, the test cases are marked "invalid", even though they're actually perfectly valid SPIR-V--they just won't work without the `SPV_EXT_shader_viewport_index_layer` extension.
2018-09-12 23:00:17 +00:00
case BuiltInViewportIndex:
if (!msl_options.supports_msl_version(2, 0))
SPIRV_CROSS_THROW("ViewportIndex requires Metal 2.0.");
return "viewport_array_index";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
// Tess. control function in
case BuiltInInvocationId:
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (msl_options.multi_patch_workgroup)
{
// Shouldn't be reached.
SPIRV_CROSS_THROW("InvocationId is computed manually with multi-patch workgroups in MSL.");
}
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
return "thread_index_in_threadgroup";
case BuiltInPatchVertices:
// Shouldn't be reached.
SPIRV_CROSS_THROW("PatchVertices is derived from the auxiliary buffer in MSL.");
case BuiltInPrimitiveId:
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
switch (execution.model)
{
case ExecutionModelTessellationControl:
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
if (msl_options.multi_patch_workgroup)
{
// Shouldn't be reached.
SPIRV_CROSS_THROW("PrimitiveId is computed manually with multi-patch workgroups in MSL.");
}
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
return "threadgroup_position_in_grid";
case ExecutionModelTessellationEvaluation:
return "patch_id";
MSL: Support PrimitiveID in fragment and barycentrics.
2019-06-13 09:33:40 +00:00
case ExecutionModelFragment:
if (msl_options.is_ios())
SPIRV_CROSS_THROW("PrimitiveId is not supported in fragment on iOS.");
else if (msl_options.is_macos() && !msl_options.supports_msl_version(2, 2))
SPIRV_CROSS_THROW("PrimitiveId on macOS requires MSL 2.2.");
return "primitive_id";
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
default:
SPIRV_CROSS_THROW("PrimitiveId is not supported in this execution model.");
}
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
// Tess. control function out
case BuiltInTessLevelOuter:
case BuiltInTessLevelInner:
// Shouldn't be reached.
SPIRV_CROSS_THROW("Tessellation levels are handled specially in MSL.");
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
// Tess. evaluation function in
case BuiltInTessCoord:
return "position_in_patch";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Fragment function in
case BuiltInFrontFacing:
return "front_facing";
case BuiltInPointCoord:
return "point_coord";
Add support for BuiltInFragCoord (changed from BuiltInSamplePosition).
2016-07-04 15:49:46 +00:00
case BuiltInFragCoord:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return "position";
case BuiltInSampleId:
return "sample_id";
case BuiltInSampleMask:
return "sample_mask";
MSL: Handle the SamplePosition builtin. This is somewhat tricky, because in MSL this value is obtained through a function, `get_sample_position()`. Since the call expression is an rvalue, it can't be passed by reference, so functions get a copy instead. This was the last piece preventing us from turning on sample-rate shading support in MoltenVK.
2018-09-12 19:05:52 +00:00
case BuiltInSamplePosition:
// Shouldn't be reached.
SPIRV_CROSS_THROW("Sample position is retrieved by a function in MSL.");
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
case BuiltInViewIndex:
if (execution.model != ExecutionModelFragment)
SPIRV_CROSS_THROW("ViewIndex is handled specially outside fragment shaders.");
// The ViewIndex was implicitly used in the prior stages to set the render_target_array_index,
// so we can get it from there.
return "render_target_array_index";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Fragment function out
case BuiltInFragDepth:
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModeDepthGreater))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return "depth(greater)";
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
else if (execution.flags.get(ExecutionModeDepthLess))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return "depth(less)";
Fix fallthrough warning.
2017-06-17 07:35:42 +00:00
else
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return "depth(any)";
MSL: Support stencil export.
2019-06-12 08:06:59 +00:00
case BuiltInFragStencilRefEXT:
return "stencil";
msl: Handle writable SSBO in function arguments
2017-01-27 00:40:56 +00:00
// Compute function in
spirv_msl: Add support for gl_GlobalInvocationId
2017-01-22 18:09:04 +00:00
case BuiltInGlobalInvocationId:
return "thread_position_in_grid";
Add WorkGroupID/NumWorkGroups to MSL. Fix block name alias.
2017-09-29 10:16:53 +00:00
case BuiltInWorkgroupId:
return "threadgroup_position_in_grid";
case BuiltInNumWorkgroups:
return "threadgroups_per_grid";
msl: Add support for gl_LocalInvocationID and gl_LocalInvocationIndex
2017-01-27 01:22:31 +00:00
case BuiltInLocalInvocationId:
return "thread_position_in_threadgroup";
case BuiltInLocalInvocationIndex:
return "thread_index_in_threadgroup";
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
case BuiltInSubgroupSize:
MSL: Add support for SubgroupSize / SubgroupInvocationID in fragment.
2019-06-24 10:31:54 +00:00
if (execution.model == ExecutionModelFragment)
{
if (!msl_options.supports_msl_version(2, 2))
SPIRV_CROSS_THROW("threads_per_simdgroup requires Metal 2.2 in fragment shaders.");
return "threads_per_simdgroup";
}
else
{
// thread_execution_width is an alias for threads_per_simdgroup, and it's only available since 1.0,
// but not in fragment.
return "thread_execution_width";
}
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
case BuiltInNumSubgroups:
if (!msl_options.supports_msl_version(2))
SPIRV_CROSS_THROW("Subgroup builtins require Metal 2.0.");
return msl_options.is_ios() ? "quadgroups_per_threadgroup" : "simdgroups_per_threadgroup";
case BuiltInSubgroupId:
if (!msl_options.supports_msl_version(2))
SPIRV_CROSS_THROW("Subgroup builtins require Metal 2.0.");
return msl_options.is_ios() ? "quadgroup_index_in_threadgroup" : "simdgroup_index_in_threadgroup";
case BuiltInSubgroupLocalInvocationId:
MSL: Add support for SubgroupSize / SubgroupInvocationID in fragment.
2019-06-24 10:31:54 +00:00
if (execution.model == ExecutionModelFragment)
{
if (!msl_options.supports_msl_version(2, 2))
SPIRV_CROSS_THROW("thread_index_in_simdgroup requires Metal 2.2 in fragment shaders.");
return "thread_index_in_simdgroup";
}
else
{
if (!msl_options.supports_msl_version(2))
SPIRV_CROSS_THROW("Subgroup builtins require Metal 2.0.");
return msl_options.is_ios() ? "thread_index_in_quadgroup" : "thread_index_in_simdgroup";
}
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
case BuiltInSubgroupEqMask:
case BuiltInSubgroupGeMask:
case BuiltInSubgroupGtMask:
case BuiltInSubgroupLeMask:
case BuiltInSubgroupLtMask:
// Shouldn't be reached.
SPIRV_CROSS_THROW("Subgroup ballot masks are handled specially in MSL.");
MSL: Support PrimitiveID in fragment and barycentrics.
2019-06-13 09:33:40 +00:00
case BuiltInBaryCoordNV:
// TODO: AMD barycentrics as well? Seem to have different swizzle and 2 components rather than 3.
if (msl_options.is_ios())
SPIRV_CROSS_THROW("Barycentrics not supported on iOS.");
else if (!msl_options.supports_msl_version(2, 2))
SPIRV_CROSS_THROW("Barycentrics are only supported in MSL 2.2 and above on macOS.");
return "barycentric_coord, center_perspective";
case BuiltInBaryCoordNoPerspNV:
// TODO: AMD barycentrics as well? Seem to have different swizzle and 2 components rather than 3.
if (msl_options.is_ios())
SPIRV_CROSS_THROW("Barycentrics not supported on iOS.");
else if (!msl_options.supports_msl_version(2, 2))
SPIRV_CROSS_THROW("Barycentrics are only supported in MSL 2.2 and above on macOS.");
return "barycentric_coord, center_no_perspective";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
default:
return "unsupported-built-in";
}
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
// Returns an MSL string type declaration for a SPIR-V builtin
MSL: Support PrimitiveID in fragment and barycentrics.
2019-06-13 09:33:40 +00:00
string CompilerMSL::builtin_type_decl(BuiltIn builtin, uint32_t id)
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
{
MSL: Use vectors for the tessellation level builtins in tese shaders. The tessellation levels in Metal are stored as a densely-packed array of half-precision floating point values. But, stage-in attributes in Metal have to have offsets and strides aligned to a multiple of four, so we can't add them individually. Luckily for us, the arrays have lengths less than 4. So, let's use vectors for them! Triangles get a single attribute with a `float4`, where the outer levels are in `.xyz` and the inner levels are in `.w`. The arrays are unpacked as though we had added the elements individually. Quads get two: a `float4` with the outer levels and a `float2` with the inner levels. Further, since vectors can be indexed as arrays, there's no need to unpack them in this case. This also saves on precious vertex attributes. Before, we were using up to 6 of them. Now we need two at most.
2019-02-22 18:11:17 +00:00
const SPIREntryPoint &execution = get_entry_point();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
switch (builtin)
{
// Vertex function in
case BuiltInVertexId:
return "uint";
case BuiltInVertexIndex:
return "uint";
Support the shader_draw_parameters extension.
2018-08-28 18:47:29 +00:00
case BuiltInBaseVertex:
return "uint";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case BuiltInInstanceId:
return "uint";
case BuiltInInstanceIndex:
return "uint";
Support the shader_draw_parameters extension.
2018-08-28 18:47:29 +00:00
case BuiltInBaseInstance:
return "uint";
case BuiltInDrawIndex:
Punt on DrawIndex in MSL for now. Metal doesn't properly support this.
2018-08-29 15:18:32 +00:00
SPIRV_CROSS_THROW("DrawIndex is not supported in MSL.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Vertex function out
case BuiltInClipDistance:
return "float";
case BuiltInPointSize:
return "float";
case BuiltInPosition:
return "float4";
move BuiltInLayer to vertex out function block
2017-12-13 10:02:03 +00:00
case BuiltInLayer:
return "uint";
MSL: Handle the ViewportIndex builtin. This requires MSL 2.0+. Also, force `ViewportIndex` and `Layer` to be defined as the correct type, which is always `uint` in MSL. Since Metal doesn't yet have geometry shaders, the vertex shader (or tessellation evaluation shader == "post-tessellation vertex shader" in Metal jargon) is the only kind of shader that can set this output. This currently requires an extension to Vulkan, which causes validation of the SPIR-V binaries for the test cases to fail. Therefore, the test cases are marked "invalid", even though they're actually perfectly valid SPIR-V--they just won't work without the `SPV_EXT_shader_viewport_index_layer` extension.
2018-09-12 23:00:17 +00:00
case BuiltInViewportIndex:
if (!msl_options.supports_msl_version(2, 0))
SPIRV_CROSS_THROW("ViewportIndex requires Metal 2.0.");
return "uint";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
// Tess. control function in
case BuiltInInvocationId:
return "uint";
case BuiltInPatchVertices:
return "uint";
case BuiltInPrimitiveId:
return "uint";
// Tess. control function out
case BuiltInTessLevelInner:
MSL: Use vectors for the tessellation level builtins in tese shaders. The tessellation levels in Metal are stored as a densely-packed array of half-precision floating point values. But, stage-in attributes in Metal have to have offsets and strides aligned to a multiple of four, so we can't add them individually. Luckily for us, the arrays have lengths less than 4. So, let's use vectors for them! Triangles get a single attribute with a `float4`, where the outer levels are in `.xyz` and the inner levels are in `.w`. The arrays are unpacked as though we had added the elements individually. Quads get two: a `float4` with the outer levels and a `float2` with the inner levels. Further, since vectors can be indexed as arrays, there's no need to unpack them in this case. This also saves on precious vertex attributes. Before, we were using up to 6 of them. Now we need two at most.
2019-02-22 18:11:17 +00:00
if (execution.model == ExecutionModelTessellationEvaluation)
return !execution.flags.get(ExecutionModeTriangles) ? "float2" : "float";
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
return "half";
case BuiltInTessLevelOuter:
MSL: Use vectors for the tessellation level builtins in tese shaders. The tessellation levels in Metal are stored as a densely-packed array of half-precision floating point values. But, stage-in attributes in Metal have to have offsets and strides aligned to a multiple of four, so we can't add them individually. Luckily for us, the arrays have lengths less than 4. So, let's use vectors for them! Triangles get a single attribute with a `float4`, where the outer levels are in `.xyz` and the inner levels are in `.w`. The arrays are unpacked as though we had added the elements individually. Quads get two: a `float4` with the outer levels and a `float2` with the inner levels. Further, since vectors can be indexed as arrays, there's no need to unpack them in this case. This also saves on precious vertex attributes. Before, we were using up to 6 of them. Now we need two at most.
2019-02-22 18:11:17 +00:00
if (execution.model == ExecutionModelTessellationEvaluation)
return !execution.flags.get(ExecutionModeTriangles) ? "float4" : "float";
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
return "half";
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
// Tess. evaluation function in
case BuiltInTessCoord:
MSL: Use vectors for the tessellation level builtins in tese shaders. The tessellation levels in Metal are stored as a densely-packed array of half-precision floating point values. But, stage-in attributes in Metal have to have offsets and strides aligned to a multiple of four, so we can't add them individually. Luckily for us, the arrays have lengths less than 4. So, let's use vectors for them! Triangles get a single attribute with a `float4`, where the outer levels are in `.xyz` and the inner levels are in `.w`. The arrays are unpacked as though we had added the elements individually. Quads get two: a `float4` with the outer levels and a `float2` with the inner levels. Further, since vectors can be indexed as arrays, there's no need to unpack them in this case. This also saves on precious vertex attributes. Before, we were using up to 6 of them. Now we need two at most.
2019-02-22 18:11:17 +00:00
return execution.flags.get(ExecutionModeTriangles) ? "float3" : "float2";
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Fragment function in
case BuiltInFrontFacing:
return "bool";
case BuiltInPointCoord:
return "float2";
Add support for BuiltInFragCoord (changed from BuiltInSamplePosition).
2016-07-04 15:49:46 +00:00
case BuiltInFragCoord:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return "float4";
case BuiltInSampleId:
return "uint";
case BuiltInSampleMask:
return "uint";
MSL: Handle the SamplePosition builtin. This is somewhat tricky, because in MSL this value is obtained through a function, `get_sample_position()`. Since the call expression is an rvalue, it can't be passed by reference, so functions get a copy instead. This was the last piece preventing us from turning on sample-rate shading support in MoltenVK.
2018-09-12 19:05:52 +00:00
case BuiltInSamplePosition:
return "float2";
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
case BuiltInViewIndex:
return "uint";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Support the SPV_KHR_device_group extension. The only piece added by this extension is the `DeviceIndex` builtin, which tells the shader which device in a grouped logical device it is running on. Metal's pipeline state objects are owned by the `MTLDevice` that created them. Since Metal doesn't support logical grouping of devices the way Vulkan does, we'll thus have to create a pipeline state for each device in a grouped logical device. The upcoming peer group support in Metal 3 will not change this. For this reason, for Metal, the device index is supplied as a constant at pipeline compile time. There's an interaction between `VK_KHR_device_group` and `VK_KHR_multiview` in the `VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT`, which defines the view index to be the same as the device index. The new `view_index_from_device_index` MSL option supports this functionality.
2019-07-13 02:50:50 +00:00
case BuiltInHelperInvocation:
return "bool";
case BuiltInBaryCoordNV:
case BuiltInBaryCoordNoPerspNV:
// Use the type as declared, can be 1, 2 or 3 components.
return type_to_glsl(get_variable_data_type(get<SPIRVariable>(id)));
[MSL] Give the FragDepth builtin a type of float.
2018-08-28 18:47:50 +00:00
// Fragment function out
case BuiltInFragDepth:
return "float";
MSL: Support stencil export.
2019-06-12 08:06:59 +00:00
case BuiltInFragStencilRefEXT:
return "uint";
spirv_msl: Add support for gl_GlobalInvocationId
2017-01-22 18:09:04 +00:00
// Compute function in
case BuiltInGlobalInvocationId:
msl: Add support for gl_LocalInvocationID and gl_LocalInvocationIndex
2017-01-27 01:22:31 +00:00
case BuiltInLocalInvocationId:
Add WorkGroupID/NumWorkGroups to MSL. Fix block name alias.
2017-09-29 10:16:53 +00:00
case BuiltInNumWorkgroups:
case BuiltInWorkgroupId:
msl: Add support for gl_LocalInvocationID and gl_LocalInvocationIndex
2017-01-27 01:22:31 +00:00
return "uint3";
case BuiltInLocalInvocationIndex:
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
case BuiltInNumSubgroups:
case BuiltInSubgroupId:
case BuiltInSubgroupSize:
case BuiltInSubgroupLocalInvocationId:
msl: Add support for gl_LocalInvocationID and gl_LocalInvocationIndex
2017-01-27 01:22:31 +00:00
return "uint";
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
case BuiltInSubgroupEqMask:
case BuiltInSubgroupGeMask:
case BuiltInSubgroupGtMask:
case BuiltInSubgroupLeMask:
case BuiltInSubgroupLtMask:
return "uint4";
spirv_msl: Add support for gl_GlobalInvocationId
2017-01-22 18:09:04 +00:00
Support the SPV_KHR_device_group extension. The only piece added by this extension is the `DeviceIndex` builtin, which tells the shader which device in a grouped logical device it is running on. Metal's pipeline state objects are owned by the `MTLDevice` that created them. Since Metal doesn't support logical grouping of devices the way Vulkan does, we'll thus have to create a pipeline state for each device in a grouped logical device. The upcoming peer group support in Metal 3 will not change this. For this reason, for Metal, the device index is supplied as a constant at pipeline compile time. There's an interaction between `VK_KHR_device_group` and `VK_KHR_multiview` in the `VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT`, which defines the view index to be the same as the device index. The new `view_index_from_device_index` MSL option supports this functionality.
2019-07-13 02:50:50 +00:00
case BuiltInDeviceIndex:
return "int";
MSL: Support PrimitiveID in fragment and barycentrics.
2019-06-13 09:33:40 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
default:
return "unsupported-built-in-type";
}
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
CompilerMSL support separate indexed MTLBuffers for stage_in containing matrices. Add DecorationBinding to Compiler::get_member_decoration()/set_member_decoration().
2017-01-29 18:28:20 +00:00
// Returns the declaration of a built-in argument to a function
string CompilerMSL::built_in_func_arg(BuiltIn builtin, bool prefix_comma)
{
string bi_arg;
if (prefix_comma)
bi_arg += ", ";
Add support for SampleId/SampleMask/SamplePosition builtins.
2017-07-24 08:07:02 +00:00
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Handle HLSL-style 0-based vertex/instance index.
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
builtin_declaration = true;
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
bi_arg += builtin_type_decl(builtin);
Add support for SampleId/SampleMask/SamplePosition builtins.
2017-07-24 08:07:02 +00:00
bi_arg += " " + builtin_to_glsl(builtin, StorageClassInput);
CompilerMSL support separate indexed MTLBuffers for stage_in containing matrices. Add DecorationBinding to Compiler::get_member_decoration()/set_member_decoration().
2017-01-29 18:28:20 +00:00
bi_arg += " [[" + builtin_qualifier(builtin) + "]]";
Work-around HLSL using zero-based InstanceID and VertexID variables, but SPIRV, like Metal, includes BaseInstance & BaseVertex. Until this can be fixed in DXC, which is really the proper place to solve this, we can decrement InstanceID & VertexID when the source is HLSL. Made in two parts. 1. Handle HLSL-style 0-based vertex/instance index. 2. We zero-base the InstanceID & VertexID variables for HLSL emulation elsewhere, so don't do it twice.
2019-08-14 14:50:36 +00:00
builtin_declaration = false;
CompilerMSL fix detection of input struct assignments.
2017-09-04 02:55:54 +00:00
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
return bi_arg;
CompilerMSL support separate indexed MTLBuffers for stage_in containing matrices. Add DecorationBinding to Compiler::get_member_decoration()/set_member_decoration().
2017-01-29 18:28:20 +00:00
}
Reintroduce struct_member_* MSL queries. Need to remap to physical type + packed qualifier, and this is handy to do in a helper function.
2019-07-18 11:48:27 +00:00
const SPIRType &CompilerMSL::get_physical_member_type(const SPIRType &type, uint32_t index) const
{
if (member_is_remapped_physical_type(type, index))
return get<SPIRType>(get_extended_member_decoration(type.self, index, SPIRVCrossDecorationPhysicalTypeID));
else
return get<SPIRType>(type.member_types[index]);
}
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
SPIRType CompilerMSL::get_presumed_input_type(const SPIRType &ib_type, uint32_t index) const
{
SPIRType type = get_physical_member_type(ib_type, index);
uint32_t loc = get_member_decoration(ib_type.self, index, DecorationLocation);
if (inputs_by_location.count(loc))
{
if (inputs_by_location.at(loc).vecsize > type.vecsize)
type.vecsize = inputs_by_location.at(loc).vecsize;
}
return type;
}
Run format_all.sh.
2019-07-23 10:23:41 +00:00
uint32_t CompilerMSL::get_declared_type_array_stride_msl(const SPIRType &type, bool is_packed, bool row_major) const
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
{
// Array stride in MSL is always size * array_size. sizeof(float3) == 16,
// unlike GLSL and HLSL where array stride would be 16 and size 12.
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
// We could use parent type here and recurse, but that makes creating physical type remappings
// far more complicated. We'd rather just create the final type, and ignore having to create the entire type
// hierarchy in order to compute this value, so make a temporary type on the stack.
auto basic_type = type;
basic_type.array.clear();
basic_type.array_size_literal.clear();
uint32_t value_size = get_declared_type_size_msl(basic_type, is_packed, row_major);
Fix some warnings when building in MoltenVK.
2019-07-23 14:39:13 +00:00
uint32_t dimensions = uint32_t(type.array.size());
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
assert(dimensions > 0);
dimensions--;
// Multiply together every dimension, except the last one.
for (uint32_t dim = 0; dim < dimensions; dim++)
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
{
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
uint32_t array_size = to_array_size_literal(type, dim);
value_size *= max(array_size, 1u);
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
}
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
return value_size;
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
}
Reintroduce struct_member_* MSL queries. Need to remap to physical type + packed qualifier, and this is handy to do in a helper function.
2019-07-18 11:48:27 +00:00
uint32_t CompilerMSL::get_declared_struct_member_array_stride_msl(const SPIRType &type, uint32_t index) const
{
return get_declared_type_array_stride_msl(get_physical_member_type(type, index),
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
member_is_packed_physical_type(type, index),
has_member_decoration(type.self, index, DecorationRowMajor));
Reintroduce struct_member_* MSL queries. Need to remap to physical type + packed qualifier, and this is handy to do in a helper function.
2019-07-18 11:48:27 +00:00
}
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
uint32_t CompilerMSL::get_declared_input_array_stride_msl(const SPIRType &type, uint32_t index) const
{
return get_declared_type_array_stride_msl(get_presumed_input_type(type, index), false,
has_member_decoration(type.self, index, DecorationRowMajor));
}
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
uint32_t CompilerMSL::get_declared_type_matrix_stride_msl(const SPIRType &type, bool packed, bool row_major) const
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
{
// For packed matrices, we just use the size of the vector type.
// Otherwise, MatrixStride == alignment, which is the size of the underlying vector type.
if (packed)
MSL: Support edge case with DX layout in scalar block layout. DX may emit ArrayStride and MatrixStride of 16, but the size of the object does not align with that and expect to pack other members inside its last member. The workaround is to emit array size/col/row one less than we expect and rely on padding to carve out a "dead zone" for the last member.
2020-04-20 09:02:20 +00:00
return (type.width / 8) * ((row_major && type.columns > 1) ? type.columns : type.vecsize);
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
else
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
return get_declared_type_alignment_msl(type, false, row_major);
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
}
Reintroduce struct_member_* MSL queries. Need to remap to physical type + packed qualifier, and this is handy to do in a helper function.
2019-07-18 11:48:27 +00:00
uint32_t CompilerMSL::get_declared_struct_member_matrix_stride_msl(const SPIRType &type, uint32_t index) const
{
return get_declared_type_matrix_stride_msl(get_physical_member_type(type, index),
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
member_is_packed_physical_type(type, index),
has_member_decoration(type.self, index, DecorationRowMajor));
Reintroduce struct_member_* MSL queries. Need to remap to physical type + packed qualifier, and this is handy to do in a helper function.
2019-07-18 11:48:27 +00:00
}
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
uint32_t CompilerMSL::get_declared_input_matrix_stride_msl(const SPIRType &type, uint32_t index) const
{
return get_declared_type_matrix_stride_msl(get_presumed_input_type(type, index), false,
has_member_decoration(type.self, index, DecorationRowMajor));
}
Run format_all.sh.
2019-07-23 10:23:41 +00:00
uint32_t CompilerMSL::get_declared_struct_size_msl(const SPIRType &struct_type, bool ignore_alignment,
bool ignore_padding) const
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
{
Tests run clean.
2019-07-22 08:23:39 +00:00
// If we have a target size, that is the declared size as well.
if (!ignore_padding && has_extended_decoration(struct_type.self, SPIRVCrossDecorationPaddingTarget))
return get_extended_decoration(struct_type.self, SPIRVCrossDecorationPaddingTarget);
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
if (struct_type.member_types.empty())
return 0;
Fix some warnings when building in MoltenVK.
2019-07-23 14:39:13 +00:00
uint32_t mbr_cnt = uint32_t(struct_type.member_types.size());
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
// In MSL, a struct's alignment is equal to the maximum alignment of any of its members.
uint32_t alignment = 1;
Tests run clean.
2019-07-22 08:23:39 +00:00
if (!ignore_alignment)
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
{
Tests run clean.
2019-07-22 08:23:39 +00:00
for (uint32_t i = 0; i < mbr_cnt; i++)
{
uint32_t mbr_alignment = get_declared_struct_member_alignment_msl(struct_type, i);
alignment = max(alignment, mbr_alignment);
}
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
}
Add support for the BuiltInClipDistance builtin for MSL. CompilerGLSL builtin_to_glsl() function outputs gl_ClipDistance for BuiltInClipDistance builtin, and includes builtin code in output when handling unknown builtin code. CompilerMSL uses type ID instead of type object where appropriate to support array types, where type.self is not consistent with actual type ID, plus support array stride calc even when not explicitly set by SPIR-V code. For output consistency, CompilerMSL prefers use of standard builtin names over specified names, and output builtins qualified with output struct while in entry function.
2016-12-17 22:07:53 +00:00
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
// Last member will always be matched to the final Offset decoration, but size of struct in MSL now depends
// on physical size in MSL, and the size of the struct itself is then aligned to struct alignment.
uint32_t spirv_offset = type_struct_member_offset(struct_type, mbr_cnt - 1);
Reintroduce struct_member_* MSL queries. Need to remap to physical type + packed qualifier, and this is handy to do in a helper function.
2019-07-18 11:48:27 +00:00
uint32_t msl_size = spirv_offset + get_declared_struct_member_size_msl(struct_type, mbr_cnt - 1);
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
msl_size = (msl_size + alignment - 1) & ~(alignment - 1);
return msl_size;
}
// Returns the byte size of a struct member.
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
uint32_t CompilerMSL::get_declared_type_size_msl(const SPIRType &type, bool is_packed, bool row_major) const
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
{
Run clang-format.
2016-10-24 13:24:24 +00:00
switch (type.basetype)
{
case SPIRType::Unknown:
case SPIRType::Void:
case SPIRType::AtomicCounter:
case SPIRType::Image:
case SPIRType::SampledImage:
case SPIRType::Sampler:
spirv_msl only add padding structure members if required by member alignment.
2017-03-06 16:00:23 +00:00
SPIRV_CROSS_THROW("Querying size of opaque object.");
Run clang-format.
2016-10-24 13:24:24 +00:00
default:
spirv_msl only add padding structure members if required by member alignment.
2017-03-06 16:00:23 +00:00
{
if (!type.array.empty())
Support spec constant array size in blocks. Won't really be correct if the spec constant is changed outside SPIRV-Cross, but nothing we can do about that, really.
2018-02-23 14:09:28 +00:00
{
Deal with OpSpecConstantOp used as array size. When trying to validate buffer sizes, we usually need to bail out when using SpecConstantOps, but for some very specific cases where we allow unsized arrays currently, we can safely allow "unknown" sized arrays as well. This is probably the best we can do, when we have even more difficult cases than this, we throw a more sensible error message.
2018-11-01 13:56:25 +00:00
uint32_t array_size = to_array_size_literal(type);
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
return get_declared_type_array_stride_msl(type, is_packed, row_major) * max(array_size, 1u);
Support spec constant array size in blocks. Won't really be correct if the spec constant is changed outside SPIRV-Cross, but nothing we can do about that, really.
2018-02-23 14:09:28 +00:00
}
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
if (type.basetype == SPIRType::Struct)
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
return get_declared_struct_size_msl(type);
if (is_packed)
MSL: Use correct size for structs. Need to align the size of structs to the natural alignment.
2019-01-28 13:39:05 +00:00
{
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
return type.vecsize * type.columns * (type.width / 8);
MSL: Use correct size for structs. Need to align the size of structs to the natural alignment.
2019-01-28 13:39:05 +00:00
}
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
else
{
// An unpacked 3-element vector or matrix column is the same memory size as a 4-element.
uint32_t vecsize = type.vecsize;
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
uint32_t columns = type.columns;
MSL: Support edge case with DX layout in scalar block layout. DX may emit ArrayStride and MatrixStride of 16, but the size of the object does not align with that and expect to pack other members inside its last member. The workaround is to emit array size/col/row one less than we expect and rely on padding to carve out a "dead zone" for the last member.
2020-04-20 09:02:20 +00:00
if (row_major && columns > 1)
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
swap(vecsize, columns);
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
if (vecsize == 3)
vecsize = 4;
spirv_msl only add padding structure members if required by member alignment.
2017-03-06 16:00:23 +00:00
Deal with all forms of matrix writes ...
2019-07-19 10:53:10 +00:00
return vecsize * columns * (type.width / 8);
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
}
spirv_msl only add padding structure members if required by member alignment.
2017-03-06 16:00:23 +00:00
}
Run clang-format.
2016-10-24 13:24:24 +00:00
}
spirv_msl only add padding structure members if required by member alignment.
2017-03-06 16:00:23 +00:00
}
Reintroduce struct_member_* MSL queries. Need to remap to physical type + packed qualifier, and this is handy to do in a helper function.
2019-07-18 11:48:27 +00:00
uint32_t CompilerMSL::get_declared_struct_member_size_msl(const SPIRType &type, uint32_t index) const
{
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
return get_declared_type_size_msl(get_physical_member_type(type, index),
member_is_packed_physical_type(type, index),
has_member_decoration(type.self, index, DecorationRowMajor));
Reintroduce struct_member_* MSL queries. Need to remap to physical type + packed qualifier, and this is handy to do in a helper function.
2019-07-18 11:48:27 +00:00
}
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
uint32_t CompilerMSL::get_declared_input_size_msl(const SPIRType &type, uint32_t index) const
{
return get_declared_type_size_msl(get_presumed_input_type(type, index), false,
has_member_decoration(type.self, index, DecorationRowMajor));
}
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
// Returns the byte alignment of a type.
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
uint32_t CompilerMSL::get_declared_type_alignment_msl(const SPIRType &type, bool is_packed, bool row_major) const
spirv_msl only add padding structure members if required by member alignment.
2017-03-06 16:00:23 +00:00
{
switch (type.basetype)
Run clang-format.
2016-10-24 13:24:24 +00:00
{
spirv_msl only add padding structure members if required by member alignment.
2017-03-06 16:00:23 +00:00
case SPIRType::Unknown:
case SPIRType::Void:
case SPIRType::AtomicCounter:
case SPIRType::Image:
case SPIRType::SampledImage:
case SPIRType::Sampler:
SPIRV_CROSS_THROW("Querying alignment of opaque object.");
Add support for the BuiltInClipDistance builtin for MSL. CompilerGLSL builtin_to_glsl() function outputs gl_ClipDistance for BuiltInClipDistance builtin, and includes builtin code in output when handling unknown builtin code. CompilerMSL uses type ID instead of type object where appropriate to support array types, where type.self is not consistent with actual type ID, plus support array stride calc even when not explicitly set by SPIR-V code. For output consistency, CompilerMSL prefers use of standard builtin names over specified names, and output builtins qualified with output struct while in entry function.
2016-12-17 22:07:53 +00:00
MSL: Error out on int64_t/uint64_t buffer members. Not supported for whatever reason.
2019-06-19 08:11:10 +00:00
case SPIRType::Int64:
SPIRV_CROSS_THROW("long types are not supported in buffers in MSL.");
case SPIRType::UInt64:
SPIRV_CROSS_THROW("ulong types are not supported in buffers in MSL.");
case SPIRType::Double:
SPIRV_CROSS_THROW("double types are not supported in buffers in MSL.");
spirv_msl only add padding structure members if required by member alignment.
2017-03-06 16:00:23 +00:00
case SPIRType::Struct:
MSL: Use correct alignment rule for whole structs. Structs are aligned as you would expect in MSL (maximum member alignment), and it is not minimum 16 bytes like in std140. Also rename the dummy "pad" members to a reserved naming scheme.
2019-01-28 10:02:28 +00:00
{
// In MSL, a struct's alignment is equal to the maximum alignment of any of its members.
uint32_t alignment = 1;
for (uint32_t i = 0; i < type.member_types.size(); i++)
Reintroduce struct_member_* MSL queries. Need to remap to physical type + packed qualifier, and this is handy to do in a helper function.
2019-07-18 11:48:27 +00:00
alignment = max(alignment, uint32_t(get_declared_struct_member_alignment_msl(type, i)));
MSL: Use correct alignment rule for whole structs. Structs are aligned as you would expect in MSL (maximum member alignment), and it is not minimum 16 bytes like in std140. Also rename the dummy "pad" members to a reserved naming scheme.
2019-01-28 10:02:28 +00:00
return alignment;
}
spirv_msl only add padding structure members if required by member alignment.
2017-03-06 16:00:23 +00:00
default:
spirv_msl auto-alignment of members of MSL uniform structs. spirv_msl optionally add padding and packing to allow MSL struct members to align with SPIR-V struct alignments. spirv_cross add convenience methods for testing Decorations. spirv_glsl replace member_decl() function with new emit_stuct_member(). Allow struct member types to be marked as packed via DecorationCPacked decoration.
2017-03-01 02:44:36 +00:00
{
CompilerMSL support smaller offsets for 3-row row-major matrices. Support MSL typedefs to declare 3-row row-major matrices as 3-column matrices. Allow those matrices to be decorated as packed. Support transposing those matrices when used. Modify how member alignments are calculated.
2018-02-11 21:52:57 +00:00
// Alignment of packed type is the same as the underlying component or column size.
// Alignment of unpacked type is the same as the vector size.
// Alignment of 3-elements vector is the same as 4-elements (including packed using column).
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
if (is_packed)
{
// If we have packed_T and friends, the alignment is always scalar.
return type.width / 8;
MSL: Use correct size for structs. Need to align the size of structs to the natural alignment.
2019-01-28 13:39:05 +00:00
}
spirv_msl only add padding structure members if required by member alignment.
2017-03-06 16:00:23 +00:00
else
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
{
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
// This is the general rule for MSL. Size == alignment.
MSL: Support edge case with DX layout in scalar block layout. DX may emit ArrayStride and MatrixStride of 16, but the size of the object does not align with that and expect to pack other members inside its last member. The workaround is to emit array size/col/row one less than we expect and rely on padding to carve out a "dead zone" for the last member.
2020-04-20 09:02:20 +00:00
uint32_t vecsize = (row_major && type.columns > 1) ? type.columns : type.vecsize;
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
return (type.width / 8) * (vecsize == 3 ? 4 : vecsize);
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
}
spirv_msl auto-alignment of members of MSL uniform structs. spirv_msl optionally add padding and packing to allow MSL struct members to align with SPIR-V struct alignments. spirv_cross add convenience methods for testing Decorations. spirv_glsl replace member_decl() function with new emit_stuct_member(). Allow struct member types to be marked as packed via DecorationCPacked decoration.
2017-03-01 02:44:36 +00:00
}
Run clang-format.
2016-10-24 13:24:24 +00:00
}
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
Reintroduce struct_member_* MSL queries. Need to remap to physical type + packed qualifier, and this is handy to do in a helper function.
2019-07-18 11:48:27 +00:00
uint32_t CompilerMSL::get_declared_struct_member_alignment_msl(const SPIRType &type, uint32_t index) const
{
Deal more cleanly with matrices and row-major.
2019-07-18 14:39:25 +00:00
return get_declared_type_alignment_msl(get_physical_member_type(type, index),
member_is_packed_physical_type(type, index),
has_member_decoration(type.self, index, DecorationRowMajor));
Reintroduce struct_member_* MSL queries. Need to remap to physical type + packed qualifier, and this is handy to do in a helper function.
2019-07-18 11:48:27 +00:00
}
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
uint32_t CompilerMSL::get_declared_input_alignment_msl(const SPIRType &type, uint32_t index) const
{
return get_declared_type_alignment_msl(get_presumed_input_type(type, index), false,
has_member_decoration(type.self, index, DecorationRowMajor));
}
Fix separate sampler images in MSL.
2017-05-07 10:36:14 +00:00
bool CompilerMSL::skip_argument(uint32_t) const
{
return false;
}
Don't override Compiler::analyze_image_and_sampler_usage(). Just add our own separate function for analyzing sampled image usage.
2018-09-24 17:10:27 +00:00
void CompilerMSL::analyze_sampled_image_usage()
Pass the swizzle constants as a buffer. It'll be useful to have an "auxiliary buffer" for other builtins--e.g. `DrawIndex` (which should be easier to implement now), or `ViewIndex` when someone gets around to implementing multiview. Pass this buffer to leaf functions as well. Test that we handle this for integer textures as well.
2018-09-23 00:36:11 +00:00
{
if (msl_options.swizzle_texture_samples)
{
SampledImageScanner scanner(*this);
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
traverse_all_reachable_opcodes(get<SPIRFunction>(ir.default_entry_point), scanner);
Pass the swizzle constants as a buffer. It'll be useful to have an "auxiliary buffer" for other builtins--e.g. `DrawIndex` (which should be easier to implement now), or `ViewIndex` when someone gets around to implementing multiview. Pass this buffer to leaf functions as well. Test that we handle this for integer textures as well.
2018-09-23 00:36:11 +00:00
}
}
bool CompilerMSL::SampledImageScanner::handle(spv::Op opcode, const uint32_t *args, uint32_t length)
{
switch (opcode)
{
case OpLoad:
case OpImage:
case OpSampledImage:
{
if (length < 3)
return false;
uint32_t result_type = args[0];
auto &type = compiler.get<SPIRType>(result_type);
if ((type.basetype != SPIRType::Image && type.basetype != SPIRType::SampledImage) || type.image.sampled != 1)
return true;
uint32_t id = args[1];
compiler.set<SPIRExpression>(id, "", result_type, true);
break;
}
case OpImageSampleExplicitLod:
case OpImageSampleProjExplicitLod:
case OpImageSampleDrefExplicitLod:
case OpImageSampleProjDrefExplicitLod:
case OpImageSampleImplicitLod:
case OpImageSampleProjImplicitLod:
case OpImageSampleDrefImplicitLod:
case OpImageSampleProjDrefImplicitLod:
case OpImageFetch:
case OpImageGather:
MSL: Swizzle gathers on depth textures as well. Might as well.
2018-09-29 14:52:26 +00:00
case OpImageDrefGather:
Use GL_EXT_samplerless_texture_functions in Vulkan GLSL.
2018-09-27 11:36:38 +00:00
compiler.has_sampled_images =
compiler.has_sampled_images || compiler.is_sampled_image_type(compiler.expression_type(args[2]));
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
compiler.needs_swizzle_buffer_def = compiler.needs_swizzle_buffer_def || compiler.has_sampled_images;
Pass the swizzle constants as a buffer. It'll be useful to have an "auxiliary buffer" for other builtins--e.g. `DrawIndex` (which should be easier to implement now), or `ViewIndex` when someone gets around to implementing multiview. Pass this buffer to leaf functions as well. Test that we handle this for integer textures as well.
2018-09-23 00:36:11 +00:00
break;
default:
break;
}
return true;
}
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
// If a needed custom function wasn't added before, add it and force a recompile.
void CompilerMSL::add_spv_func_and_recompile(SPVFuncImpl spv_func)
{
if (spv_function_implementations.count(spv_func) == 0)
{
spv_function_implementations.insert(spv_func);
suppress_missing_prototypes = true;
force_recompile();
}
}
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
bool CompilerMSL::OpCodePreprocessor::handle(Op opcode, const uint32_t *args, uint32_t length)
CompilerMSL fixes to support pull-request feedback. Make Compiler::OpcodeHandler and Compiler::traverse_all_reachable_opcodes protected instead of private, for use by subclasses. Add CompilerMSL::CustomFunctionHandler and traverse_all_reachable_opcodes() to detect active opcodes that require the output of a custom function. CompilerMSL::custom_function_ops use std::set to retain ordering to improve testability.
2016-12-21 21:31:13 +00:00
{
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
// Since MSL exists in a single execution scope, function prototype declarations are not
// needed, and clutter the output. If secondary functions are output (either as a SPIR-V
// function implementation or as indicated by the presence of OpFunctionCall), then set
// suppress_missing_prototypes to suppress compiler warnings of missing function prototypes.
// Mark if the input requires the implementation of an SPIR-V function that does not exist in Metal.
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
SPVFuncImpl spv_func = get_spv_func_impl(opcode, args);
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
if (spv_func != SPVFuncImplNone)
{
compiler.spv_function_implementations.insert(spv_func);
suppress_missing_prototypes = true;
}
CompilerMSL fixes to support pull-request feedback. Make Compiler::OpcodeHandler and Compiler::traverse_all_reachable_opcodes protected instead of private, for use by subclasses. Add CompilerMSL::CustomFunctionHandler and traverse_all_reachable_opcodes() to detect active opcodes that require the output of a custom function. CompilerMSL::custom_function_ops use std::set to retain ordering to improve testability.
2016-12-21 21:31:13 +00:00
switch (opcode)
{
Run style formatter.
2017-01-20 16:33:59 +00:00
case OpFunctionCall:
suppress_missing_prototypes = true;
CompilerMSL fixes to support pull-request feedback. Make Compiler::OpcodeHandler and Compiler::traverse_all_reachable_opcodes protected instead of private, for use by subclasses. Add CompilerMSL::CustomFunctionHandler and traverse_all_reachable_opcodes() to detect active opcodes that require the output of a custom function. CompilerMSL::custom_function_ops use std::set to retain ordering to improve testability.
2016-12-21 21:31:13 +00:00
break;
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Emulate texture2D atomic operations
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
case OpImageTexelPointer:
{
auto *var = compiler.maybe_get_backing_variable(args[2]);
MSL: Minor cleanups for texture atomic emulation. Storing pointers to internal objects is generally not done, IDs are preferred.
2019-10-24 09:30:20 +00:00
image_pointers[args[1]] = var ? var->self : ID(0);
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
break;
}
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
CompilerMSL vertex entry point return void when rasterization disabled. Add CompilerMSL::Options::disable_rasterization input/output API flag. Disable rasterization via API flag or when writing to textures. Disable rasterization when shader declares no output. Add test shaders for vertex no output and write texture forcing void output.
2018-07-26 04:50:33 +00:00
case OpImageWrite:
CompilerMSL disable rasterization on buffer writes in vertex shader.
2018-07-27 20:53:36 +00:00
uses_resource_write = true;
break;
case OpStore:
check_resource_write(args[0]);
CompilerMSL vertex entry point return void when rasterization disabled. Add CompilerMSL::Options::disable_rasterization input/output API flag. Disable rasterization via API flag or when writing to textures. Disable rasterization when shader declares no output. Add test shaders for vertex no output and write texture forcing void output.
2018-07-26 04:50:33 +00:00
break;
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Emulate texture2D atomic operations
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpAtomicExchange:
case OpAtomicCompareExchange:
case OpAtomicCompareExchangeWeak:
case OpAtomicIIncrement:
case OpAtomicIDecrement:
case OpAtomicIAdd:
case OpAtomicISub:
case OpAtomicSMin:
case OpAtomicUMin:
case OpAtomicSMax:
case OpAtomicUMax:
case OpAtomicAnd:
case OpAtomicOr:
case OpAtomicXor:
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
{
CompilerMSL disable rasterization on buffer writes in vertex shader.
2018-07-27 20:53:36 +00:00
uses_atomics = true;
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
auto it = image_pointers.find(args[2]);
if (it != image_pointers.end())
{
MSL: Minor cleanups for texture atomic emulation. Storing pointers to internal objects is generally not done, IDs are preferred.
2019-10-24 09:30:20 +00:00
compiler.atomic_image_vars.insert(it->second);
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
}
CompilerMSL disable rasterization on buffer writes in vertex shader.
2018-07-27 20:53:36 +00:00
check_resource_write(args[2]);
break;
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
}
case OpAtomicStore:
{
uses_atomics = true;
auto it = image_pointers.find(args[0]);
if (it != image_pointers.end())
{
MSL: Minor cleanups for texture atomic emulation. Storing pointers to internal objects is generally not done, IDs are preferred.
2019-10-24 09:30:20 +00:00
compiler.atomic_image_vars.insert(it->second);
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
}
check_resource_write(args[0]);
break;
}
CompilerMSL disable rasterization on buffer writes in vertex shader.
2018-07-27 20:53:36 +00:00
case OpAtomicLoad:
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
{
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
uses_atomics = true;
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
auto it = image_pointers.find(args[2]);
if (it != image_pointers.end())
{
MSL: Minor cleanups for texture atomic emulation. Storing pointers to internal objects is generally not done, IDs are preferred.
2019-10-24 09:30:20 +00:00
compiler.atomic_image_vars.insert(it->second);
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
break;
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
case OpGroupNonUniformInverseBallot:
needs_subgroup_invocation_id = true;
break;
case OpGroupNonUniformBallotBitCount:
if (args[3] != GroupOperationReduce)
needs_subgroup_invocation_id = true;
break;
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
case OpArrayLength:
{
auto *var = compiler.maybe_get_backing_variable(args[2]);
if (var)
compiler.buffers_requiring_array_length.insert(var->self);
break;
}
case OpInBoundsAccessChain:
case OpAccessChain:
case OpPtrAccessChain:
{
// OpArrayLength might want to know if taking ArrayLength of an array of SSBOs.
uint32_t result_type = args[0];
uint32_t id = args[1];
uint32_t ptr = args[2];
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
compiler.set<SPIRExpression>(id, "", result_type, true);
compiler.register_read(id, ptr, true);
compiler.ir.ids[id].set_allow_type_rewrite();
break;
}
CompilerMSL fixes to support pull-request feedback. Make Compiler::OpcodeHandler and Compiler::traverse_all_reachable_opcodes protected instead of private, for use by subclasses. Add CompilerMSL::CustomFunctionHandler and traverse_all_reachable_opcodes() to detect active opcodes that require the output of a custom function. CompilerMSL::custom_function_ops use std::set to retain ordering to improve testability.
2016-12-21 21:31:13 +00:00
default:
break;
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
CompilerMSL fix bad cast error on result type derivation.
2018-01-05 02:13:38 +00:00
// If it has one, keep track of the instruction's result type, mapped by ID
Fix CFG for forwarded temporaries. Forwarded temporaries would never declare a temporary. Figure out all result types ahead of time so we can deal with those temporaries as well.
2018-01-18 11:07:10 +00:00
uint32_t result_type, result_id;
if (compiler.instruction_to_result_type(result_type, result_id, opcode, args, length))
result_types[result_id] = result_type;
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
CompilerMSL fixes to support pull-request feedback. Make Compiler::OpcodeHandler and Compiler::traverse_all_reachable_opcodes protected instead of private, for use by subclasses. Add CompilerMSL::CustomFunctionHandler and traverse_all_reachable_opcodes() to detect active opcodes that require the output of a custom function. CompilerMSL::custom_function_ops use std::set to retain ordering to improve testability.
2016-12-21 21:31:13 +00:00
return true;
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
CompilerMSL disable rasterization on buffer writes in vertex shader.
2018-07-27 20:53:36 +00:00
// If the variable is a Uniform or StorageBuffer, mark that a resource has been written to.
void CompilerMSL::OpCodePreprocessor::check_resource_write(uint32_t var_id)
{
auto *p_var = compiler.maybe_get_backing_variable(var_id);
StorageClass sc = p_var ? p_var->storage : StorageClassMax;
if (sc == StorageClassUniform || sc == StorageClassStorageBuffer)
uses_resource_write = true;
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
// Returns an enumeration of a SPIR-V function that needs to be output for certain Op codes.
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
CompilerMSL::SPVFuncImpl CompilerMSL::OpCodePreprocessor::get_spv_func_impl(Op opcode, const uint32_t *args)
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
{
switch (opcode)
{
case OpFMod:
return SPVFuncImplMod;
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
case OpFAdd:
if (compiler.msl_options.invariant_float_math)
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
{
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
return SPVFuncImplFAdd;
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
}
CompilerMSL support larger texel buffers by using 2D Metal textures. Add CompilerMSL::Options::texture_width_max. Emit and use spvTexelBufferCoord() function to convert 1D texel buffer coordinates to 2D Metal texture coordinates.
2018-06-26 21:30:21 +00:00
break;
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
case OpFMul:
case OpOuterProduct:
case OpMatrixTimesVector:
case OpVectorTimesMatrix:
case OpMatrixTimesMatrix:
if (compiler.msl_options.invariant_float_math)
MSL cannot declare inline arrays except in certain cases.
2018-02-08 12:06:29 +00:00
{
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
return SPVFuncImplFMul;
MSL cannot declare inline arrays except in certain cases.
2018-02-08 12:06:29 +00:00
}
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
break;
MSL cannot declare inline arrays except in certain cases.
2018-02-08 12:06:29 +00:00
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
case OpTypeArray:
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
{
// Allow Metal to use the array<T> template to make arrays a value type
Avoid emitting 'spvUnsafeArray<>', 'spvFMul*', and 'spvFAdd' custom functions if they are not needed.
2019-09-17 19:10:39 +00:00
return SPVFuncImplUnsafeArray;
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
}
Remove some redundant spvArrayCopy declarations.
2018-07-05 12:43:12 +00:00
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Emulate texture2D atomic operations
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
case OpAtomicExchange:
case OpAtomicCompareExchange:
case OpAtomicCompareExchangeWeak:
case OpAtomicIIncrement:
case OpAtomicIDecrement:
case OpAtomicIAdd:
case OpAtomicISub:
case OpAtomicSMin:
case OpAtomicUMin:
case OpAtomicSMax:
case OpAtomicUMax:
case OpAtomicAnd:
case OpAtomicOr:
case OpAtomicXor:
case OpAtomicLoad:
case OpAtomicStore:
{
auto it = image_pointers.find(args[opcode == OpAtomicStore ? 0 : 2]);
if (it != image_pointers.end())
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
{
MSL: Minor cleanups for texture atomic emulation. Storing pointers to internal objects is generally not done, IDs are preferred.
2019-10-24 09:30:20 +00:00
uint32_t tid = compiler.get<SPIRVariable>(it->second).basetype;
Emulate texture atomics in Metal by binding the underlying buffer that backs the resource to a separate binding point and using that for Metal's atomic operations. This will work with texture_buffer and texture2d created from an MTLBuffer, so is perfect for emulating HLSL atomics on RWBuffer and sufficient, but not ideal, for RWTexture2D with some restrictions (limited format support and can't be used for render-targets).
2019-08-14 14:44:54 +00:00
if (tid && compiler.get<SPIRType>(tid).image.dim == Dim2D)
return SPVFuncImplImage2DAtomicCoords;
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
}
CompilerMSL support larger texel buffers by using 2D Metal textures. Add CompilerMSL::Options::texture_width_max. Emit and use spvTexelBufferCoord() function to convert 1D texel buffer coordinates to 2D Metal texture coordinates.
2018-06-26 21:30:21 +00:00
break;
}
case OpImageFetch:
Add spvTexelBufferCoord for buffer image reads, too. I should've caught this when I fixed this for writes.
2018-09-23 19:35:25 +00:00
case OpImageRead:
MSL: Emit spvTexelBufferCoord() on ImageWrite to a Buffer as well. This is necessary to get the coordinates to give to the texture's `write()` method.
2018-09-01 06:52:23 +00:00
case OpImageWrite:
CompilerMSL support larger texel buffers by using 2D Metal textures. Add CompilerMSL::Options::texture_width_max. Emit and use spvTexelBufferCoord() function to convert 1D texel buffer coordinates to 2D Metal texture coordinates.
2018-06-26 21:30:21 +00:00
{
// Retrieve the image type, and if it's a Buffer, emit a texel coordinate function
MSL: Emit spvTexelBufferCoord() on ImageWrite to a Buffer as well. This is necessary to get the coordinates to give to the texture's `write()` method.
2018-09-01 06:52:23 +00:00
uint32_t tid = result_types[args[opcode == OpImageWrite ? 0 : 2]];
MSL: Support native texture_buffer type, throw error on atomics. Atomics are not supported on images or texture_buffers in MSL. Properly throw an error if OpImageTexelPointer is used (since it can only be used for atomic operations anyways).
2019-04-23 10:17:21 +00:00
if (tid && compiler.get<SPIRType>(tid).image.dim == DimBuffer && !compiler.msl_options.texture_buffer_native)
CompilerMSL support larger texel buffers by using 2D Metal textures. Add CompilerMSL::Options::texture_width_max. Emit and use spvTexelBufferCoord() function to convert 1D texel buffer coordinates to 2D Metal texture coordinates.
2018-06-26 21:30:21 +00:00
return SPVFuncImplTexelBufferCoords;
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
break;
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpExtInst:
{
uint32_t extension_set = args[2];
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
if (compiler.get<SPIRExtension>(extension_set).ext == SPIRExtension::GLSL)
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
{
MSL/HLSL: Support scalar reflect and refract.
2019-07-03 10:24:58 +00:00
auto op_450 = static_cast<GLSLstd450>(args[3]);
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
switch (op_450)
{
case GLSLstd450Radians:
return SPVFuncImplRadians;
case GLSLstd450Degrees:
return SPVFuncImplDegrees;
case GLSLstd450FindILsb:
return SPVFuncImplFindILsb;
case GLSLstd450FindSMsb:
return SPVFuncImplFindSMsb;
case GLSLstd450FindUMsb:
return SPVFuncImplFindUMsb;
MSL: Emit wrapper for SSign (sign() for int types) Metal does not define the sign() function for integer types, only floating-point types.
2018-11-07 12:24:21 +00:00
case GLSLstd450SSign:
return SPVFuncImplSSign;
MSL/HLSL: Support scalar reflect and refract.
2019-07-03 10:24:58 +00:00
case GLSLstd450Reflect:
{
auto &type = compiler.get<SPIRType>(args[0]);
if (type.vecsize == 1)
return SPVFuncImplReflectScalar;
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
break;
MSL/HLSL: Support scalar reflect and refract.
2019-07-03 10:24:58 +00:00
}
case GLSLstd450Refract:
{
auto &type = compiler.get<SPIRType>(args[0]);
if (type.vecsize == 1)
return SPVFuncImplRefractScalar;
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
break;
MSL/HLSL: Support scalar reflect and refract.
2019-07-03 10:24:58 +00:00
}
Test glsl.std450 more exhaustively. Make sure to test everything with scalar as well to catch any weird edge cases. Not all opcodes are covered here, just the arithmetic ones. FP64 packing is also ignored.
2019-07-17 09:24:31 +00:00
case GLSLstd450FaceForward:
{
auto &type = compiler.get<SPIRType>(args[0]);
if (type.vecsize == 1)
return SPVFuncImplFaceForwardScalar;
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
break;
Test glsl.std450 more exhaustively. Make sure to test everything with scalar as well to catch any weird edge cases. Not all opcodes are covered here, just the arithmetic ones. FP64 packing is also ignored.
2019-07-17 09:24:31 +00:00
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case GLSLstd450MatrixInverse:
{
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
auto &mat_type = compiler.get<SPIRType>(args[0]);
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
switch (mat_type.columns)
{
case 2:
return SPVFuncImplInverse2x2;
case 3:
return SPVFuncImplInverse3x3;
case 4:
return SPVFuncImplInverse4x4;
default:
break;
}
break;
}
default:
break;
}
}
break;
}
MSL: Add support for subgroup operations. Some support for subgroups is present starting in Metal 2.0 on both iOS and macOS. macOS gains more complete support in 10.14 (Metal 2.1). Some restrictions are present. On iOS and on macOS 10.13, the implementation of `OpGroupNonUniformElect` is incorrect: if thread 0 has already terminated or is not executing a conditional branch, the first thread that *is* will falsely believe itself not to be. Unfortunately, this operation is part of the "basic" feature set; without it, subgroups cannot be supported at all. The `SubgroupSize` and `SubgroupLocalInvocationId` builtins are only available in compute shaders (and, by extension, tessellation control shaders), despite SPIR-V making them available in all stages. This limits the usefulness of some of the subgroup operations in fragment shaders. Although Metal on macOS supports some clustered, inclusive, and exclusive operations, it does not support them all. In particular, inclusive and exclusive min, max, and, or, and xor; as well as cluster sizes other than 4 are not supported. If this becomes a problem, they could be emulated, but at a significant performance cost due to the need for non-uniform operations.
2019-05-15 21:03:30 +00:00
case OpGroupNonUniformBallot:
return SPVFuncImplSubgroupBallot;
case OpGroupNonUniformInverseBallot:
case OpGroupNonUniformBallotBitExtract:
return SPVFuncImplSubgroupBallotBitExtract;
case OpGroupNonUniformBallotFindLSB:
return SPVFuncImplSubgroupBallotFindLSB;
case OpGroupNonUniformBallotFindMSB:
return SPVFuncImplSubgroupBallotFindMSB;
case OpGroupNonUniformBallotBitCount:
return SPVFuncImplSubgroupBallotBitCount;
case OpGroupNonUniformAllEqual:
return SPVFuncImplSubgroupAllEqual;
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
default:
break;
}
return SPVFuncImplNone;
}
CompilerMSL enhancements to handling of in/out variables. CompilerMSL sort in/out attributes by attribute number (location). Sort inputs in reverse order. CompilerMSL propagate incoming vertex attribute offset values. CompilerMSL elide unused in/out variables. CompilerMSL replace use of sets with unordered_sets.
2016-12-18 23:48:15 +00:00
// Sort both type and meta member content based on builtin status (put builtins at end),
// then by the required sorting aspect.
CompilerMSL fixes to support pull-request feedback. Make Compiler::OpcodeHandler and Compiler::traverse_all_reachable_opcodes protected instead of private, for use by subclasses. Add CompilerMSL::CustomFunctionHandler and traverse_all_reachable_opcodes() to detect active opcodes that require the output of a custom function. CompilerMSL::custom_function_ops use std::set to retain ordering to improve testability.
2016-12-21 21:31:13 +00:00
void CompilerMSL::MemberSorter::sort()
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
{
CompilerMSL uses std::set where order matters for consistent regression testing.
2017-01-31 16:02:44 +00:00
// Create a temporary array of consecutive member indices and sort it based on how
CompilerMSL enhancements to handling of in/out variables. CompilerMSL sort in/out attributes by attribute number (location). Sort inputs in reverse order. CompilerMSL propagate incoming vertex attribute offset values. CompilerMSL elide unused in/out variables. CompilerMSL replace use of sets with unordered_sets.
2016-12-18 23:48:15 +00:00
// the members should be reordered, based on builtin and sorting aspect meta info.
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
size_t mbr_cnt = type.member_types.size();
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
SmallVector<uint32_t> mbr_idxs(mbr_cnt);
MSL: Redirect member indices when buffer has been sorted by Offset. If a buffer rewrites its Offsets, all member references to that struct are invalidated, and must be redirected, do so in to_member_reference, but there might be other places where this is needed. Fix as required. SPIR-V code relying on this is somewhat questionable, but seems to be in-spec.
2020-04-30 09:48:53 +00:00
std::iota(mbr_idxs.begin(), mbr_idxs.end(), 0); // Fill with consecutive indices
MSL: Support ClipDistance as an input stage variable. MSL does not support this, so we have to emulate it by passing it around as a varying between stages. We use a special "user(clipN)" attribute for this rather than locN which is used for user varyings.
2019-12-02 11:13:15 +00:00
std::stable_sort(mbr_idxs.begin(), mbr_idxs.end(), *this); // Sort member indices based on sorting aspect
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
MSL: Redirect member indices when buffer has been sorted by Offset. If a buffer rewrites its Offsets, all member references to that struct are invalidated, and must be redirected, do so in to_member_reference, but there might be other places where this is needed. Fix as required. SPIR-V code relying on this is somewhat questionable, but seems to be in-spec.
2020-04-30 09:48:53 +00:00
bool sort_is_identity = true;
for (uint32_t mbr_idx = 0; mbr_idx < mbr_cnt; mbr_idx++)
{
if (mbr_idx != mbr_idxs[mbr_idx])
{
sort_is_identity = false;
break;
}
}
if (sort_is_identity)
return;
if (meta.members.size() < type.member_types.size())
{
// This should never trigger in normal circumstances, but to be safe.
meta.members.resize(type.member_types.size());
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Move type and meta member info to the order defined by the sorted member indices.
// This is done by creating temporary copies of both member types and meta, and then
// copying back to the original content at the sorted indices.
auto mbr_types_cpy = type.member_types;
auto mbr_meta_cpy = meta.members;
for (uint32_t mbr_idx = 0; mbr_idx < mbr_cnt; mbr_idx++)
{
type.member_types[mbr_idx] = mbr_types_cpy[mbr_idxs[mbr_idx]];
meta.members[mbr_idx] = mbr_meta_cpy[mbr_idxs[mbr_idx]];
}
MSL: Redirect member indices when buffer has been sorted by Offset. If a buffer rewrites its Offsets, all member references to that struct are invalidated, and must be redirected, do so in to_member_reference, but there might be other places where this is needed. Fix as required. SPIR-V code relying on this is somewhat questionable, but seems to be in-spec.
2020-04-30 09:48:53 +00:00
if (sort_aspect == SortAspect::Offset)
{
// If we're sorting by Offset, this might affect user code which accesses a buffer block.
// We will need to redirect member indices from one index to sorted index.
type.member_type_index_redirection = std::move(mbr_idxs);
}
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
CompilerMSL enhancements to handling of in/out variables. CompilerMSL sort in/out attributes by attribute number (location). Sort inputs in reverse order. CompilerMSL propagate incoming vertex attribute offset values. CompilerMSL elide unused in/out variables. CompilerMSL replace use of sets with unordered_sets.
2016-12-18 23:48:15 +00:00
// Sort first by builtin status (put builtins at end), then by the sorting aspect.
CompilerMSL fixes to support pull-request feedback. Make Compiler::OpcodeHandler and Compiler::traverse_all_reachable_opcodes protected instead of private, for use by subclasses. Add CompilerMSL::CustomFunctionHandler and traverse_all_reachable_opcodes() to detect active opcodes that require the output of a custom function. CompilerMSL::custom_function_ops use std::set to retain ordering to improve testability.
2016-12-21 21:31:13 +00:00
bool CompilerMSL::MemberSorter::operator()(uint32_t mbr_idx1, uint32_t mbr_idx2)
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto &mbr_meta1 = meta.members[mbr_idx1];
auto &mbr_meta2 = meta.members[mbr_idx2];
if (mbr_meta1.builtin != mbr_meta2.builtin)
return mbr_meta2.builtin;
else
MSL sort interface struct members by offset instead of location. MSL support OpFMod as fmod() function. Remove SPIRType::is_packed member.
2016-12-04 17:32:58 +00:00
switch (sort_aspect)
{
case Location:
return mbr_meta1.location < mbr_meta2.location;
CompilerMSL enhancements to handling of in/out variables. CompilerMSL sort in/out attributes by attribute number (location). Sort inputs in reverse order. CompilerMSL propagate incoming vertex attribute offset values. CompilerMSL elide unused in/out variables. CompilerMSL replace use of sets with unordered_sets.
2016-12-18 23:48:15 +00:00
case LocationReverse:
return mbr_meta1.location > mbr_meta2.location;
MSL sort interface struct members by offset instead of location. MSL support OpFMod as fmod() function. Remove SPIRType::is_packed member.
2016-12-04 17:32:58 +00:00
case Offset:
return mbr_meta1.offset < mbr_meta2.offset;
CompilerMSL enhancements to handling of in/out variables. CompilerMSL sort in/out attributes by attribute number (location). Sort inputs in reverse order. CompilerMSL propagate incoming vertex attribute offset values. CompilerMSL elide unused in/out variables. CompilerMSL replace use of sets with unordered_sets.
2016-12-18 23:48:15 +00:00
case OffsetThenLocationReverse:
return (mbr_meta1.offset < mbr_meta2.offset) ||
((mbr_meta1.offset == mbr_meta2.offset) && (mbr_meta1.location > mbr_meta2.location));
Merge with KhronosGroup/SPIRV-Cross
2017-01-15 15:14:21 +00:00
case Alphabetical:
CompilerMSL enhancements. Support BuiltInFragDepth. Emit interface block for StorageClassUniformConstant. Throw exception when output or fragment input structs contain matrix or array. Dynamically created interface structs sorted by location number instead of alphabetically. Add Compiler::is_array() function.
2017-06-30 23:10:46 +00:00
return mbr_meta1.alias < mbr_meta2.alias;
MSL sort interface struct members by offset instead of location. MSL support OpFMod as fmod() function. Remove SPIRType::is_packed member.
2016-12-04 17:32:58 +00:00
default:
return false;
}
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
spirv_msl auto-alignment of members of MSL uniform structs. spirv_msl optionally add padding and packing to allow MSL struct members to align with SPIR-V struct alignments. spirv_cross add convenience methods for testing Decorations. spirv_glsl replace member_decl() function with new emit_stuct_member(). Allow struct member types to be marked as packed via DecorationCPacked decoration.
2017-03-01 02:44:36 +00:00
CompilerMSL::MemberSorter::MemberSorter(SPIRType &t, Meta &m, SortAspect sa)
: type(t)
, meta(m)
, sort_aspect(sa)
{
// Ensure enough meta info is available
meta.members.resize(max(type.member_types.size(), meta.members.size()));
}
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
void CompilerMSL::remap_constexpr_sampler(VariableID id, const MSLConstexprSampler &sampler)
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
{
auto &type = get<SPIRType>(get<SPIRVariable>(id).basetype);
if (type.basetype != SPIRType::SampledImage && type.basetype != SPIRType::Sampler)
SPIRV_CROSS_THROW("Can only remap SampledImage and Sampler type.");
Check for array of samplers.
2018-04-17 15:47:15 +00:00
if (!type.array.empty())
SPIRV_CROSS_THROW("Can not remap array of samplers.");
MSL: Support remapping constexpr samplers by set/binding. Older API was oriented around IDs which are not available unless you're doing full reflection, which is awkward for certain use cases which know their set/bindings up front. Optimize resource bindings to be hashmap rather than doing linear seeks all the time.
2019-06-10 13:41:36 +00:00
constexpr_samplers_by_id[id] = sampler;
}
Run format_all.sh.
2019-06-21 14:02:22 +00:00
void CompilerMSL::remap_constexpr_sampler_by_binding(uint32_t desc_set, uint32_t binding,
const MSLConstexprSampler &sampler)
MSL: Support remapping constexpr samplers by set/binding. Older API was oriented around IDs which are not available unless you're doing full reflection, which is awkward for certain use cases which know their set/bindings up front. Optimize resource bindings to be hashmap rather than doing linear seeks all the time.
2019-06-10 13:41:36 +00:00
{
constexpr_samplers_by_binding[{ desc_set, binding }] = sampler;
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
}
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
Use bitcast_to_builtin_load() instead of hacking to_expression(). This only affects the builtin when it is used, and not when it's passed to a function. It's a lot cleaner than the way I was doing it before. Remove the `to_expression()` hack.
2018-09-11 16:15:17 +00:00
void CompilerMSL::bitcast_from_builtin_load(uint32_t source_id, std::string &expr, const SPIRType &expr_type)
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
{
Use bitcast_to_builtin_load() instead of hacking to_expression(). This only affects the builtin when it is used, and not when it's passed to a function. It's a lot cleaner than the way I was doing it before. Remove the `to_expression()` hack.
2018-09-11 16:15:17 +00:00
auto *var = maybe_get_backing_variable(source_id);
if (var)
source_id = var->self;
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
Use bitcast_to_builtin_load() instead of hacking to_expression(). This only affects the builtin when it is used, and not when it's passed to a function. It's a lot cleaner than the way I was doing it before. Remove the `to_expression()` hack.
2018-09-11 16:15:17 +00:00
// Only interested in standalone builtin variables.
if (!has_decoration(source_id, DecorationBuiltIn))
return;
auto builtin = static_cast<BuiltIn>(get_decoration(source_id, DecorationBuiltIn));
auto expected_type = expr_type.basetype;
switch (builtin)
{
case BuiltInGlobalInvocationId:
case BuiltInLocalInvocationId:
case BuiltInWorkgroupId:
case BuiltInLocalInvocationIndex:
case BuiltInWorkgroupSize:
case BuiltInNumWorkgroups:
Cast uses of Layer and ViewportIndex to the expected type.
2018-09-19 14:13:30 +00:00
case BuiltInLayer:
case BuiltInViewportIndex:
MSL: Support stencil export.
2019-06-12 08:06:59 +00:00
case BuiltInFragStencilRefEXT:
MSL: Support PrimitiveID in fragment and barycentrics.
2019-06-13 09:33:40 +00:00
case BuiltInPrimitiveId:
MSL: Add support for SubgroupSize / SubgroupInvocationID in fragment.
2019-06-24 10:31:54 +00:00
case BuiltInSubgroupSize:
case BuiltInSubgroupLocalInvocationId:
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
case BuiltInViewIndex:
MSL: Add {Base,}{Vertex,Instance}Index to bitcast_from_builtin_load. Totally missed these, so float(index) would not work correctly for negative numbers.
2019-08-29 11:56:37 +00:00
case BuiltInVertexIndex:
case BuiltInInstanceIndex:
case BuiltInBaseInstance:
case BuiltInBaseVertex:
Use bitcast_to_builtin_load() instead of hacking to_expression(). This only affects the builtin when it is used, and not when it's passed to a function. It's a lot cleaner than the way I was doing it before. Remove the `to_expression()` hack.
2018-09-11 16:15:17 +00:00
expected_type = SPIRType::UInt;
break;
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
case BuiltInTessLevelInner:
case BuiltInTessLevelOuter:
MSL: Use vectors for the tessellation level builtins in tese shaders. The tessellation levels in Metal are stored as a densely-packed array of half-precision floating point values. But, stage-in attributes in Metal have to have offsets and strides aligned to a multiple of four, so we can't add them individually. Luckily for us, the arrays have lengths less than 4. So, let's use vectors for them! Triangles get a single attribute with a `float4`, where the outer levels are in `.xyz` and the inner levels are in `.w`. The arrays are unpacked as though we had added the elements individually. Quads get two: a `float4` with the outer levels and a `float2` with the inner levels. Further, since vectors can be indexed as arrays, there's no need to unpack them in this case. This also saves on precious vertex attributes. Before, we were using up to 6 of them. Now we need two at most.
2019-02-22 18:11:17 +00:00
if (get_execution_model() == ExecutionModelTessellationControl)
expected_type = SPIRType::Half;
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
break;
Use bitcast_to_builtin_load() instead of hacking to_expression(). This only affects the builtin when it is used, and not when it's passed to a function. It's a lot cleaner than the way I was doing it before. Remove the `to_expression()` hack.
2018-09-11 16:15:17 +00:00
default:
break;
}
if (expected_type != expr_type.basetype)
expr = bitcast_expression(expr_type, expected_type, expr);
MSL: Expand quad gl_TessCoord to a float3. This is the actual SPIR-V type of the builtin. We forced to a `float2` in the declaration because that's what Metal wants.
2019-02-19 22:56:43 +00:00
if (builtin == BuiltInTessCoord && get_entry_point().flags.get(ExecutionModeQuads) && expr_type.vecsize == 3)
{
// In SPIR-V, this is always a vec3, even for quads. In Metal, though, it's a float2 for quads.
// The code is expecting a float3, so we need to widen this.
expr = join("float3(", expr, ", 0)");
}
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
}
Cast uses of Layer and ViewportIndex to the expected type.
2018-09-19 14:13:30 +00:00
void CompilerMSL::bitcast_to_builtin_store(uint32_t target_id, std::string &expr, const SPIRType &expr_type)
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
{
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
auto *var = maybe_get_backing_variable(target_id);
if (var)
target_id = var->self;
Cast uses of Layer and ViewportIndex to the expected type.
2018-09-19 14:13:30 +00:00
// Only interested in standalone builtin variables.
if (!has_decoration(target_id, DecorationBuiltIn))
return;
auto builtin = static_cast<BuiltIn>(get_decoration(target_id, DecorationBuiltIn));
auto expected_type = expr_type.basetype;
switch (builtin)
{
case BuiltInLayer:
case BuiltInViewportIndex:
MSL: Support stencil export.
2019-06-12 08:06:59 +00:00
case BuiltInFragStencilRefEXT:
MSL: Support PrimitiveID in fragment and barycentrics.
2019-06-13 09:33:40 +00:00
case BuiltInPrimitiveId:
MSL: Support SPV_KHR_multiview. This is needed to support `VK_KHR_multiview`, which is in turn needed for Vulkan 1.1 support. Unfortunately, Metal provides no native support for this, and Apple is once again less than forthcoming, so we have to implement it all ourselves. Tessellation and geometry shaders are deliberately unsupported for now. The problem is that the current implementation encodes the `ViewIndex` as part of the `InstanceIndex`, which in the SPIR-V environment at least only exists in the vertex shader. So we need to work out a way to pass the view index along to the later stages. This implementation runs vertex shaders for all views up to the highest bit set in the view mask, even those whose bits are clear. The fragments for the inactive views are then discarded. Avoiding this is difficult: calculating the view indices becomes far more complicated if we can only run for those views which are set in the mask.
2019-05-31 17:06:20 +00:00
case BuiltInViewIndex:
Cast uses of Layer and ViewportIndex to the expected type.
2018-09-19 14:13:30 +00:00
expected_type = SPIRType::UInt;
break;
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
case BuiltInTessLevelInner:
case BuiltInTessLevelOuter:
expected_type = SPIRType::Half;
break;
Cast uses of Layer and ViewportIndex to the expected type.
2018-09-19 14:13:30 +00:00
default:
break;
}
if (expected_type != expr_type.basetype)
{
MSL: Add support for tessellation control shaders. These are transpiled to kernel functions that write the output of the shader to three buffers: one for per-vertex varyings, one for per-patch varyings, and one for the tessellation levels. This structure is mandated by the way Metal works, where the tessellation factors are supplied to the draw method in their own buffer, while the per-patch and per-vertex varyings are supplied as though they were vertex attributes; since they have different step rates, they must be in separate buffers. The kernel is expected to be run in a workgroup whose size is the greater of the number of input or output control points. It uses Metal's support for vertex-style stage input to a compute shader to get the input values; therefore, at least one instance must run per input point. Meanwhile, Vulkan mandates that it run at least once per output point. Overrunning the output array is a concern, but any values written should either be discarded or overwritten by subsequent patches. I'm probably going to put some slop space in the buffer when I integrate this into MoltenVK to be on the safe side.
2019-02-04 05:58:46 +00:00
if (expected_type == SPIRType::Half && expr_type.basetype == SPIRType::Float)
{
// These are of different widths, so we cannot do a straight bitcast.
expr = join("half(", expr, ")");
}
else
{
auto type = expr_type;
type.basetype = expected_type;
expr = bitcast_expression(type, expr_type.basetype, expr);
}
Cast uses of Layer and ViewportIndex to the expected type.
2018-09-19 14:13:30 +00:00
}
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
}
Deal with composite constants in variable initializer.
2018-07-05 13:29:49 +00:00
Add support for forcefully zero-initialized variables. Useful to better support certain platforms which require all variables to be initialized to something.
2020-03-26 10:21:23 +00:00
string CompilerMSL::to_initializer_expression(const SPIRVariable &var)
Deal with composite constants in variable initializer.
2018-07-05 13:29:49 +00:00
{
// We risk getting an array initializer here with MSL. If we have an array.
// FIXME: We cannot handle non-constant arrays being initialized.
// We will need to inject spvArrayCopy here somehow ...
auto &type = get<SPIRType>(var.basetype);
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
string expr;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
if (ir.ids[var.initializer].get_type() == TypeConstant &&
(!type.array.empty() || type.basetype == SPIRType::Struct))
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
expr = constant_expression(get<SPIRConstant>(var.initializer));
Deal with composite constants in variable initializer.
2018-07-05 13:29:49 +00:00
else
MSL: Add support for processing more than one patch per workgroup. This should hopefully reduce underutilization of the GPU, especially on GPUs where the thread execution width is greater than the number of control points. This also simplifies initialization by reading the buffer directly instead of using Metal's vertex-attribute-in-compute support. It turns out the only way in which shader stages are allowed to differ in their interfaces is in the number of components per vector; the base type must be the same. Since we are using the raw buffer instead of attributes, we can now also emit arrays and matrices directly into the buffer, instead of flattening them and then unpacking them. Structs are still flattened, however; this is due to the need to handle vectors with fewer components than were output, and I think handling this while also directly emitting structs could get ugly. Another advantage of this scheme is that the extra invocations needed to read the attributes when there were more input than output points are now no more. The number of threads per workgroup is now lcm(SIMD-size, output control points). This should ensure we always process a whole number of patches per workgroup. To avoid complexity handling indices in the tessellation control shader, I've also changed the way vertex shaders for tessellation are handled. They are now compute kernels using Metal's support for vertex-style stage input. This lets us always emit vertices into the buffer in order of vertex shader execution. Now we no longer have to deal with indexing in the tessellation control shader. This also fixes a long-standing issue where if an index were greater than the number of vertices to draw, the vertex shader would wind up writing outside the buffer, and the vertex would be lost. This is a breaking change, and I know SPIRV-Cross has other clients, so I've hidden this behind an option for now. In the future, I want to remove this option and make it the default.
2020-02-21 03:38:28 +00:00
expr = CompilerGLSL::to_initializer_expression(var);
// If the initializer has more vector components than the variable, add a swizzle.
// FIXME: This can't handle arrays or structs.
auto &init_type = expression_type(var.initializer);
if (type.array.empty() && type.basetype != SPIRType::Struct && init_type.vecsize > type.vecsize)
expr = enclose_expression(expr + vector_swizzle(type.vecsize, 0));
return expr;
Deal with composite constants in variable initializer.
2018-07-05 13:29:49 +00:00
}
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
Add support for forcefully zero-initialized variables. Useful to better support certain platforms which require all variables to be initialized to something.
2020-03-26 10:21:23 +00:00
string CompilerMSL::to_zero_initialized_expression(uint32_t)
{
return "{}";
}
MSL: Support VK_KHR_push_descriptor. If we have argument buffers, we also need to support using plain descriptor sets for certain cases where API wants it.
2019-03-15 13:07:03 +00:00
bool CompilerMSL::descriptor_set_is_argument_buffer(uint32_t desc_set) const
{
if (!msl_options.argument_buffers)
return false;
if (desc_set >= kMaxArgumentBuffers)
return false;
Rename "push descriptor set" to "discrete descriptor set". Check for case where iOS doesn't support writable argument buffer textures.
2019-03-15 20:53:21 +00:00
return (argument_buffer_discrete_mask & (1u << desc_set)) == 0;
MSL: Support VK_KHR_push_descriptor. If we have argument buffers, we also need to support using plain descriptor sets for certain cases where API wants it.
2019-03-15 13:07:03 +00:00
}
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
void CompilerMSL::analyze_argument_buffers()
{
// Gather all used resources and sort them out into argument buffers.
// Each argument buffer corresponds to a descriptor set in SPIR-V.
// The [[id(N)]] values used correspond to the resource mapping we have for MSL.
// Otherwise, the binding number is used, but this is generally not safe some types like
// combined image samplers and arrays of resources. Metal needs different indices here,
// while SPIR-V can have one descriptor set binding. To use argument buffers in practice,
// you will need to use the remapping from the API.
for (auto &id : argument_buffer_ids)
id = 0;
// Output resources, sorted by resource index & type.
struct Resource
{
SPIRVariable *var;
string name;
SPIRType::BaseType basetype;
uint32_t index;
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
uint32_t plane;
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
};
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
SmallVector<Resource> resources_in_set[kMaxArgumentBuffers];
MSL: Move inline uniform blocks to the end of the argument buffer. Limit inline blocks to one per descriptor set. This should avoid the need for complicated code to calculate the argument buffer ID stride of an inline uniform block. If there's demand for more inline blocks, we can revisit this.
2020-01-25 19:40:51 +00:00
SmallVector<uint32_t> inline_block_vars;
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
bool set_needs_swizzle_buffer[kMaxArgumentBuffers] = {};
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
bool set_needs_buffer_sizes[kMaxArgumentBuffers] = {};
bool needs_buffer_sizes = false;
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
ir.for_each_typed_id<SPIRVariable>([&](uint32_t self, SPIRVariable &var) {
if ((var.storage == StorageClassUniform || var.storage == StorageClassUniformConstant ||
var.storage == StorageClassStorageBuffer) &&
!is_hidden_variable(var))
{
uint32_t desc_set = get_decoration(self, DecorationDescriptorSet);
MSL: Support VK_KHR_push_descriptor. If we have argument buffers, we also need to support using plain descriptor sets for certain cases where API wants it.
2019-03-15 13:07:03 +00:00
// Ignore if it's part of a push descriptor set.
if (!descriptor_set_is_argument_buffer(desc_set))
return;
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
uint32_t var_id = var.self;
auto &type = get_variable_data_type(var);
if (desc_set >= kMaxArgumentBuffers)
SPIRV_CROSS_THROW("Descriptor set index is out of range.");
MSL: Support remapping constexpr samplers by set/binding. Older API was oriented around IDs which are not available unless you're doing full reflection, which is awkward for certain use cases which know their set/bindings up front. Optimize resource bindings to be hashmap rather than doing linear seeks all the time.
2019-06-10 13:41:36 +00:00
const MSLConstexprSampler *constexpr_sampler = nullptr;
if (type.basetype == SPIRType::SampledImage || type.basetype == SPIRType::Sampler)
{
constexpr_sampler = find_constexpr_sampler(var_id);
if (constexpr_sampler)
{
// Mark this ID as a constexpr sampler for later in case it came from set/bindings.
constexpr_samplers_by_id[var_id] = *constexpr_sampler;
}
}
MSL: Move inline uniform blocks to the end of the argument buffer. Limit inline blocks to one per descriptor set. This should avoid the need for complicated code to calculate the argument buffer ID stride of an inline uniform block. If there's demand for more inline blocks, we can revisit this.
2020-01-25 19:40:51 +00:00
uint32_t binding = get_decoration(var_id, DecorationBinding);
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
if (type.basetype == SPIRType::SampledImage)
{
add_resource_name(var_id);
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
uint32_t plane_count = 1;
if (constexpr_sampler && constexpr_sampler->ycbcr_conversion_enable)
plane_count = constexpr_sampler->planes;
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
for (uint32_t i = 0; i < plane_count; i++)
{
uint32_t image_resource_index = get_metal_resource_index(var, SPIRType::Image, i);
resources_in_set[desc_set].push_back(
{ &var, to_name(var_id), SPIRType::Image, image_resource_index, i });
}
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
MSL: Support remapping constexpr samplers by set/binding. Older API was oriented around IDs which are not available unless you're doing full reflection, which is awkward for certain use cases which know their set/bindings up front. Optimize resource bindings to be hashmap rather than doing linear seeks all the time.
2019-06-10 13:41:36 +00:00
if (type.image.dim != DimBuffer && !constexpr_sampler)
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
{
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
uint32_t sampler_resource_index = get_metal_resource_index(var, SPIRType::Sampler);
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
resources_in_set[desc_set].push_back(
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
{ &var, to_sampler_expression(var_id), SPIRType::Sampler, sampler_resource_index, 0 });
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
}
}
MSL: Move inline uniform blocks to the end of the argument buffer. Limit inline blocks to one per descriptor set. This should avoid the need for complicated code to calculate the argument buffer ID stride of an inline uniform block. If there's demand for more inline blocks, we can revisit this.
2020-01-25 19:40:51 +00:00
else if (inline_uniform_blocks.count(SetBindingPair{ desc_set, binding }))
{
inline_block_vars.push_back(var_id);
}
MSL: Support remapping constexpr samplers by set/binding. Older API was oriented around IDs which are not available unless you're doing full reflection, which is awkward for certain use cases which know their set/bindings up front. Optimize resource bindings to be hashmap rather than doing linear seeks all the time.
2019-06-10 13:41:36 +00:00
else if (!constexpr_sampler)
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
{
// constexpr samplers are not declared as resources.
MSL: Move inline uniform blocks to the end of the argument buffer. Limit inline blocks to one per descriptor set. This should avoid the need for complicated code to calculate the argument buffer ID stride of an inline uniform block. If there's demand for more inline blocks, we can revisit this.
2020-01-25 19:40:51 +00:00
// Inline uniform blocks are always emitted at the end.
MSL: Force storage images on iOS to use discrete descriptors. Writable textures cannot use argument buffers on iOS. They must be passed as arguments directly to the shader function. Since we won't know if a given storage image will have the `NonWritable` decoration at the time we encode the argument buffer, we must therefore pass all storage images as discrete arguments. Previously, we were throwing an error if we encountered an argument buffer with a writable texture in it on iOS.
2019-09-04 18:57:17 +00:00
if (!msl_options.is_ios() || type.basetype != SPIRType::Image || type.image.sampled != 2)
{
add_resource_name(var_id);
resources_in_set[desc_set].push_back(
{ &var, to_name(var_id), type.basetype, get_metal_resource_index(var, type.basetype), 0 });
MSL: Support atomic access to images from argument buffers. This was not added when Epic contributed atomic image support. Fixes #1484.
2020-10-13 07:33:06 +00:00
// Emulate texture2D atomic operations
if (atomic_image_vars.count(var.self))
{
uint32_t buffer_resource_index = get_metal_resource_index(var, SPIRType::AtomicCounter, 0);
resources_in_set[desc_set].push_back(
MSL: Fix calculation of atomic image buffer address. Fix reversed coordinates: `y` should be used to calculate the row address. Align row address to the row stride. I've made the row alignment a function constant; this makes it possible to override it at pipeline compile time. Honestly, I don't know how this worked at all for Epic. It definitely didn't work in the CTS prior to this.
2020-10-13 18:20:49 +00:00
{ &var, to_name(var_id) + "_atomic", SPIRType::Struct, buffer_resource_index, 0 });
MSL: Support atomic access to images from argument buffers. This was not added when Epic contributed atomic image support. Fixes #1484.
2020-10-13 07:33:06 +00:00
}
MSL: Force storage images on iOS to use discrete descriptors. Writable textures cannot use argument buffers on iOS. They must be passed as arguments directly to the shader function. Since we won't know if a given storage image will have the `NonWritable` decoration at the time we encode the argument buffer, we must therefore pass all storage images as discrete arguments. Previously, we were throwing an error if we encountered an argument buffer with a writable texture in it on iOS.
2019-09-04 18:57:17 +00:00
}
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
}
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
// Check if this descriptor set needs a swizzle buffer.
if (needs_swizzle_buffer_def && is_sampled_image_type(type))
set_needs_swizzle_buffer[desc_set] = true;
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
else if (buffers_requiring_array_length.count(var_id) != 0)
{
set_needs_buffer_sizes[desc_set] = true;
needs_buffer_sizes = true;
}
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
}
});
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
if (needs_swizzle_buffer_def || needs_buffer_sizes)
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
{
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
uint32_t uint_ptr_type_id = 0;
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
// We might have to add a swizzle buffer resource to the set.
for (uint32_t desc_set = 0; desc_set < kMaxArgumentBuffers; desc_set++)
{
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
if (!set_needs_swizzle_buffer[desc_set] && !set_needs_buffer_sizes[desc_set])
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
continue;
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
if (uint_ptr_type_id == 0)
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
{
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint_ptr_type_id = ir.increase_bound_by(1);
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
// Create a buffer to hold extra data, including the swizzle constants.
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
SPIRType uint_type_pointer = get_uint_type();
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
uint_type_pointer.pointer = true;
uint_type_pointer.pointer_depth = 1;
MSL: Factor creating a uint type into its own method. This is so common for artificially created variables that it's worth it to create it once and save it for later use.
2020-07-22 21:25:10 +00:00
uint_type_pointer.parent_type = get_uint_type_id();
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
uint_type_pointer.storage = StorageClassUniform;
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
set<SPIRType>(uint_ptr_type_id, uint_type_pointer);
set_decoration(uint_ptr_type_id, DecorationArrayStride, 4);
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
}
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
if (set_needs_swizzle_buffer[desc_set])
{
uint32_t var_id = ir.increase_bound_by(1);
auto &var = set<SPIRVariable>(var_id, uint_ptr_type_id, StorageClassUniformConstant);
set_name(var_id, "spvSwizzleConstants");
set_decoration(var_id, DecorationDescriptorSet, desc_set);
set_decoration(var_id, DecorationBinding, kSwizzleBufferBinding);
resources_in_set[desc_set].push_back(
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
{ &var, to_name(var_id), SPIRType::UInt, get_metal_resource_index(var, SPIRType::UInt), 0 });
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
}
if (set_needs_buffer_sizes[desc_set])
{
uint32_t var_id = ir.increase_bound_by(1);
auto &var = set<SPIRVariable>(var_id, uint_ptr_type_id, StorageClassUniformConstant);
set_name(var_id, "spvBufferSizeConstants");
set_decoration(var_id, DecorationDescriptorSet, desc_set);
set_decoration(var_id, DecorationBinding, kBufferSizeBufferBinding);
resources_in_set[desc_set].push_back(
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
{ &var, to_name(var_id), SPIRType::UInt, get_metal_resource_index(var, SPIRType::UInt), 0 });
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
}
MSL: Support argument buffers and image swizzling. Change aux buffer to swizzle buffer. There is no good reason to expand the aux buffer, so name it appropriately. Make the code cleaner by emitting a straight pointer to uint rather than a dummy struct which only contains a single unsized array member anyways. This will also end up being very similar to how we implement swizzle buffers for argument buffers. Do not use implied binding if it overflows int32_t.
2019-05-09 10:15:45 +00:00
}
}
MSL: Move inline uniform blocks to the end of the argument buffer. Limit inline blocks to one per descriptor set. This should avoid the need for complicated code to calculate the argument buffer ID stride of an inline uniform block. If there's demand for more inline blocks, we can revisit this.
2020-01-25 19:40:51 +00:00
// Now add inline uniform blocks.
for (uint32_t var_id : inline_block_vars)
{
auto &var = get<SPIRVariable>(var_id);
uint32_t desc_set = get_decoration(var_id, DecorationDescriptorSet);
add_resource_name(var_id);
resources_in_set[desc_set].push_back(
{ &var, to_name(var_id), SPIRType::Struct, get_metal_resource_index(var, SPIRType::Struct), 0 });
}
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
for (uint32_t desc_set = 0; desc_set < kMaxArgumentBuffers; desc_set++)
{
auto &resources = resources_in_set[desc_set];
if (resources.empty())
continue;
MSL: Support VK_KHR_push_descriptor. If we have argument buffers, we also need to support using plain descriptor sets for certain cases where API wants it.
2019-03-15 13:07:03 +00:00
assert(descriptor_set_is_argument_buffer(desc_set));
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
uint32_t next_id = ir.increase_bound_by(3);
uint32_t type_id = next_id + 1;
uint32_t ptr_type_id = next_id + 2;
argument_buffer_ids[desc_set] = next_id;
auto &buffer_type = set<SPIRType>(type_id);
MSL: Add opt-in support for huge IABs. If there are enough members in an IAB, we cannot use the constant address space as MSL compiler complains about there being too many members. Support emitting the device address space instead.
2019-10-14 10:51:48 +00:00
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
buffer_type.basetype = SPIRType::Struct;
MSL: Add opt-in support for huge IABs. If there are enough members in an IAB, we cannot use the constant address space as MSL compiler complains about there being too many members. Support emitting the device address space instead.
2019-10-14 10:51:48 +00:00
if ((argument_buffer_device_storage_mask & (1u << desc_set)) != 0)
{
buffer_type.storage = StorageClassStorageBuffer;
// Make sure the argument buffer gets marked as const device.
set_decoration(next_id, DecorationNonWritable);
// Need to mark the type as a Block to enable this.
set_decoration(type_id, DecorationBlock);
}
else
buffer_type.storage = StorageClassUniform;
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
set_name(type_id, join("spvDescriptorSetBuffer", desc_set));
auto &ptr_type = set<SPIRType>(ptr_type_id);
ptr_type = buffer_type;
ptr_type.pointer = true;
ptr_type.pointer_depth = 1;
ptr_type.parent_type = type_id;
uint32_t buffer_variable_id = next_id;
set<SPIRVariable>(buffer_variable_id, ptr_type_id, StorageClassUniform);
set_name(buffer_variable_id, join("spvDescriptorSet", desc_set));
// Ids must be emitted in ID order.
sort(begin(resources), end(resources), [&](const Resource &lhs, const Resource &rhs) -> bool {
return tie(lhs.index, lhs.basetype) < tie(rhs.index, rhs.basetype);
});
uint32_t member_index = 0;
for (auto &resource : resources)
{
auto &var = *resource.var;
auto &type = get_variable_data_type(var);
string mbr_name = ensure_valid_name(resource.name, "m");
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
if (resource.plane > 0)
mbr_name += join(plane_name_suffix, resource.plane);
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
set_member_name(buffer_type.self, member_index, mbr_name);
if (resource.basetype == SPIRType::Sampler && type.basetype != SPIRType::Sampler)
{
// Have to synthesize a sampler type here.
bool type_is_array = !type.array.empty();
uint32_t sampler_type_id = ir.increase_bound_by(type_is_array ? 2 : 1);
auto &new_sampler_type = set<SPIRType>(sampler_type_id);
new_sampler_type.basetype = SPIRType::Sampler;
new_sampler_type.storage = StorageClassUniformConstant;
if (type_is_array)
{
uint32_t sampler_type_array_id = sampler_type_id + 1;
auto &sampler_type_array = set<SPIRType>(sampler_type_array_id);
sampler_type_array = new_sampler_type;
sampler_type_array.array = type.array;
sampler_type_array.array_size_literal = type.array_size_literal;
sampler_type_array.parent_type = sampler_type_id;
buffer_type.member_types.push_back(sampler_type_array_id);
}
else
buffer_type.member_types.push_back(sampler_type_id);
}
else
{
MSL: Support dynamic offsets for buffers in argument buffers. Vulkan has two types of buffer descriptors, `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` and `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC`, which allow the client to offset the buffers by an amount given when the descriptor set is bound to a pipeline. Metal provides no direct support for this when the buffer in question is in an argument buffer, so once again we're on our own. These offsets cannot be stored or associated in any way with the argument buffer itself, because they are set at bind time. Different pipelines may have different offsets set. Therefore, we must use a separate buffer, not in any argument buffer, to hold these offsets. Then the shader must manually offset the buffer pointer. This change fully supports arrays, including arrays of arrays, even though Vulkan forbids them. It does not, however, support runtime arrays. Perhaps later.
2019-09-06 04:14:12 +00:00
uint32_t binding = get_decoration(var.self, DecorationBinding);
SetBindingPair pair = { desc_set, binding };
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
if (resource.basetype == SPIRType::Image || resource.basetype == SPIRType::Sampler ||
resource.basetype == SPIRType::SampledImage)
{
// Drop pointer information when we emit the resources into a struct.
buffer_type.member_types.push_back(get_variable_data_type_id(var));
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
if (resource.plane == 0)
set_qualified_name(var.self, join(to_name(buffer_variable_id), ".", mbr_name));
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
}
MSL: Support dynamic offsets for buffers in argument buffers. Vulkan has two types of buffer descriptors, `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` and `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC`, which allow the client to offset the buffers by an amount given when the descriptor set is bound to a pipeline. Metal provides no direct support for this when the buffer in question is in an argument buffer, so once again we're on our own. These offsets cannot be stored or associated in any way with the argument buffer itself, because they are set at bind time. Different pipelines may have different offsets set. Therefore, we must use a separate buffer, not in any argument buffer, to hold these offsets. Then the shader must manually offset the buffer pointer. This change fully supports arrays, including arrays of arrays, even though Vulkan forbids them. It does not, however, support runtime arrays. Perhaps later.
2019-09-06 04:14:12 +00:00
else if (buffers_requiring_dynamic_offset.count(pair))
{
// Don't set the qualified name here; we'll define a variable holding the corrected buffer address later.
buffer_type.member_types.push_back(var.basetype);
buffers_requiring_dynamic_offset[pair].second = var.self;
}
MSL: Support inline uniform blocks in argument buffers. Here, the inline uniform block is explicit: we instantiate the buffer block itself in the argument buffer, instead of a pointer to the buffer. I just hope this will work with the `MTLArgumentDescriptor` API... Note that Metal recursively assigns individual members of embedded structs IDs. This means for automatic assignment that we have to calculate the binding stride for a given buffer block. For MoltenVK, we'll simply increment the ID by the size of the inline uniform block. Then the later IDs will never conflict with the inline uniform block. We can get away with this because Metal doesn't require that IDs be contiguous, only monotonically increasing.
2019-12-17 04:58:16 +00:00
else if (inline_uniform_blocks.count(pair))
{
// Put the buffer block itself into the argument buffer.
buffer_type.member_types.push_back(get_variable_data_type_id(var));
set_qualified_name(var.self, join(to_name(buffer_variable_id), ".", mbr_name));
}
MSL: Support atomic access to images from argument buffers. This was not added when Epic contributed atomic image support. Fixes #1484.
2020-10-13 07:33:06 +00:00
else if (atomic_image_vars.count(var.self))
{
// Emulate texture2D atomic operations.
// Don't set the qualified name: it's already set for this variable,
// and the code that references the buffer manually appends "_atomic"
// to the name.
uint32_t offset = ir.increase_bound_by(2);
uint32_t atomic_type_id = offset;
uint32_t type_ptr_id = offset + 1;
SPIRType atomic_type;
atomic_type.basetype = SPIRType::AtomicCounter;
atomic_type.width = 32;
atomic_type.vecsize = 1;
set<SPIRType>(atomic_type_id, atomic_type);
atomic_type.pointer = true;
atomic_type.parent_type = atomic_type_id;
atomic_type.storage = StorageClassStorageBuffer;
auto &atomic_ptr_type = set<SPIRType>(type_ptr_id, atomic_type);
atomic_ptr_type.self = atomic_type_id;
buffer_type.member_types.push_back(type_ptr_id);
}
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
else
{
// Resources will be declared as pointers not references, so automatically dereference as appropriate.
buffer_type.member_types.push_back(var.basetype);
if (type.array.empty())
set_qualified_name(var.self, join("(*", to_name(buffer_variable_id), ".", mbr_name, ")"));
else
set_qualified_name(var.self, join(to_name(buffer_variable_id), ".", mbr_name));
}
}
MSL: Rewrite how resource indices are fallback-assigned. We used to use the Binding decoration for this, but this method is hopelessly broken. If no explicit MSL resource remapping exists, we remap automatically in a manner which should always "just work".
2019-06-21 10:44:33 +00:00
set_extended_member_decoration(buffer_type.self, member_index, SPIRVCrossDecorationResourceIndexPrimary,
MSL: Implement Metal 2.0 indirect argument buffers.
2019-03-14 09:29:34 +00:00
resource.index);
set_extended_member_decoration(buffer_type.self, member_index, SPIRVCrossDecorationInterfaceOrigID,
var.self);
member_index++;
}
}
}
MSL: Add support for force-activating IAB resources. Important for ABI compatibility on MSL in certain cases.
2020-01-16 10:07:30 +00:00
void CompilerMSL::activate_argument_buffer_resources()
{
// For ABI compatibility, force-enable all resources which are part of argument buffers.
ir.for_each_typed_id<SPIRVariable>([&](uint32_t self, const SPIRVariable &) {
if (!has_decoration(self, DecorationDescriptorSet))
return;
uint32_t desc_set = get_decoration(self, DecorationDescriptorSet);
if (descriptor_set_is_argument_buffer(desc_set))
active_interface_variables.insert(self);
});
}
MSL: Add a workaround path to force native arrays for everything.
2020-02-24 11:47:14 +00:00
bool CompilerMSL::using_builtin_array() const
{
return msl_options.force_native_arrays || is_using_builtin_array;
}
Reference in New Issue Copy Permalink