AuroraMiddleware/SPIRV-Cross-Vulnerable
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Cross.git synced 2024-11-15 16:30:08 +00:00
Code Issues Projects Releases Wiki Activity
1fb27b4cda
SPIRV-Cross-Vulnerable/spirv_msl.cpp

5213 lines
161 KiB
C++
Raw Normal View History

Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
/*
Update copyright dates to 2018 in main files.
2018-01-31 22:08:43 +00:00
* Copyright 2016-2018 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;
using namespace spirv_cross;
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;
Some compat fixes for MSL and Half.
2018-03-06 16:07:59 +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
static const uint32_t k_aux_mbr_idx_swizzle_const = 0u;
CompilerMSL vectorless constructor uses vectorless attribute and resource bindings.
2017-04-04 20:38:17 +00:00
CompilerMSL::CompilerMSL(vector<uint32_t> spirv_, vector<MSLVertexAttr> *p_vtx_attrs,
vector<MSLResourceBinding> *p_res_bindings)
: 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
{
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
if (p_vtx_attrs)
for (auto &va : *p_vtx_attrs)
vtx_attrs_by_location[va.location] = &va;
if (p_res_bindings)
for (auto &rb : *p_res_bindings)
resource_bindings.push_back(&rb);
Add clean_func_name() to support overrides to function names.
2017-01-08 03:15:58 +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
CompilerMSL::CompilerMSL(const uint32_t *ir_, size_t word_count, MSLVertexAttr *p_vtx_attrs, size_t vtx_attrs_count,
CompilerMSL vectorless constructor uses vectorless attribute and resource bindings.
2017-04-04 20:38:17 +00:00
MSLResourceBinding *p_res_bindings, size_t res_bindings_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)
{
if (p_vtx_attrs)
for (size_t i = 0; i < vtx_attrs_count; i++)
vtx_attrs_by_location[p_vtx_attrs[i].location] = &p_vtx_attrs[i];
if (p_res_bindings)
for (size_t i = 0; i < res_bindings_count; i++)
resource_bindings.push_back(&p_res_bindings[i]);
}
CompilerMSL::CompilerMSL(const ParsedIR &ir_, MSLVertexAttr *p_vtx_attrs, size_t vtx_attrs_count,
MSLResourceBinding *p_res_bindings, size_t res_bindings_count)
: CompilerGLSL(ir_)
{
if (p_vtx_attrs)
for (size_t i = 0; i < vtx_attrs_count; i++)
vtx_attrs_by_location[p_vtx_attrs[i].location] = &p_vtx_attrs[i];
if (p_res_bindings)
for (size_t i = 0; i < res_bindings_count; i++)
resource_bindings.push_back(&p_res_bindings[i]);
}
CompilerMSL::CompilerMSL(ParsedIR &&ir_, MSLVertexAttr *p_vtx_attrs, size_t vtx_attrs_count,
MSLResourceBinding *p_res_bindings, size_t res_bindings_count)
: CompilerGLSL(std::move(ir_))
Add vector-less IR construction to subclasses as well.
2017-04-01 14:08:19 +00:00
{
CompilerMSL vectorless constructor uses vectorless attribute and resource bindings.
2017-04-04 20:38:17 +00:00
if (p_vtx_attrs)
for (size_t i = 0; i < vtx_attrs_count; i++)
vtx_attrs_by_location[p_vtx_attrs[i].location] = &p_vtx_attrs[i];
if (p_res_bindings)
for (size_t i = 0; i < res_bindings_count; i++)
resource_bindings.push_back(&p_res_bindings[i]);
Add vector-less IR construction to subclasses as well.
2017-04-01 14:08:19 +00:00
}
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);
if (need_subpass_input || need_sample_pos)
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;
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +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 &id : ir.ids)
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
{
if (id.get_type() != TypeVariable)
continue;
auto &var = id.get<SPIRVariable>();
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 (need_subpass_input && var.storage == StorageClassInput && ir.meta[var.self].decoration.builtin &&
ir.meta[var.self].decoration.builtin_type == BuiltInFragCoord)
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
{
Support passing implicit frag_coord arguments down to functions.
2018-02-09 11:13:33 +00:00
builtin_frag_coord_id = var.self;
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
has_frag_coord = true;
break;
}
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
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 (need_sample_pos && var.storage == StorageClassInput && ir.meta[var.self].decoration.builtin &&
ir.meta[var.self].decoration.builtin_type == 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;
has_sample_id = true;
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
if (!has_frag_coord && need_subpass_input)
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +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 offset = ir.increase_bound_by(3);
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
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;
CompilerMSL support gl_SampleMask and convert it to scalar uint from array.
2018-02-13 19:44:40 +00:00
vec4_type.width = 32;
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
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);
Support passing implicit frag_coord arguments down to functions.
2018-02-09 11:13:33 +00:00
ptr_type.self = type_id;
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
set<SPIRVariable>(var_id, type_ptr_id, StorageClassInput);
set_decoration(var_id, DecorationBuiltIn, BuiltInFragCoord);
Support passing implicit frag_coord arguments down to functions.
2018-02-09 11:13:33 +00:00
builtin_frag_coord_id = 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)
{
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 offset = ir.increase_bound_by(3);
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
uint32_t type_id = offset;
uint32_t type_ptr_id = offset + 1;
uint32_t var_id = offset + 2;
// Create gl_SampleID.
SPIRType uint_type;
uint_type.basetype = SPIRType::UInt;
uint_type.width = 32;
set<SPIRType>(type_id, uint_type);
SPIRType uint_type_ptr;
uint_type_ptr = uint_type;
uint_type_ptr.pointer = true;
uint_type_ptr.parent_type = type_id;
uint_type_ptr.storage = StorageClassInput;
auto &ptr_type = set<SPIRType>(type_ptr_id, uint_type_ptr);
ptr_type.self = type_id;
set<SPIRVariable>(var_id, type_ptr_id, StorageClassInput);
set_decoration(var_id, DecorationBuiltIn, BuiltInSampleId);
builtin_sample_id_id = 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
if (msl_options.swizzle_texture_samples && has_sampled_images)
{
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 offset = ir.increase_bound_by(5);
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
uint32_t type_id = offset;
uint32_t type_arr_id = offset + 1;
uint32_t struct_id = offset + 2;
uint32_t struct_ptr_id = offset + 3;
uint32_t var_id = offset + 4;
// Create a buffer to hold the swizzle constants.
SPIRType uint_type;
uint_type.basetype = SPIRType::UInt;
uint_type.width = 32;
set<SPIRType>(type_id, uint_type);
SPIRType uint_type_arr = uint_type;
uint_type_arr.array.push_back(0);
uint_type_arr.array_size_literal.push_back(true);
uint_type_arr.parent_type = type_id;
set<SPIRType>(type_arr_id, uint_type_arr);
set_decoration(type_arr_id, DecorationArrayStride, 4);
SPIRType struct_type;
struct_type.basetype = SPIRType::Struct;
struct_type.member_types.push_back(type_arr_id);
auto &type = set<SPIRType>(struct_id, struct_type);
type.self = struct_id;
set_decoration(struct_id, DecorationBlock);
set_name(struct_id, "spvAux");
set_member_name(struct_id, 0, "swizzleConst");
set_member_decoration(struct_id, 0, DecorationOffset, 0);
SPIRType struct_type_ptr = struct_type;
struct_type_ptr.pointer = true;
struct_type_ptr.parent_type = struct_id;
struct_type_ptr.storage = StorageClassUniform;
auto &ptr_type = set<SPIRType>(struct_ptr_id, struct_type_ptr);
ptr_type.self = struct_id;
set<SPIRVariable>(var_id, struct_ptr_id, StorageClassUniform);
set_name(var_id, "spvAuxBuffer");
// This should never match anything.
set_decoration(var_id, DecorationDescriptorSet, 0xFFFFFFFE);
set_decoration(var_id, DecorationBinding, msl_options.aux_buffer_index);
aux_buffer_id = 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.");
}
}
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 ...
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
// Emit constexpr samplers here.
for (auto &samp : constexpr_samplers)
{
auto &var = get<SPIRVariable>(samp.first);
auto &type = get<SPIRType>(var.basetype);
if (type.basetype == SPIRType::Sampler)
add_resource_name(samp.first);
vector<string> args;
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
{
args.push_back(
join("lod_clamp(", convert_to_string(s.lod_clamp_min), ", ", convert_to_string(s.lod_clamp_max), ")"));
}
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
statement("constexpr sampler ",
type.basetype == SPIRType::SampledImage ? to_sampler_expression(samp.first) : to_name(samp.first),
"(", merge(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
// Emit buffer arrays here.
for (uint32_t array_id : buffer_arrays)
{
const auto &var = get<SPIRVariable>(array_id);
const auto &type = get<SPIRType>(var.basetype);
string name = get_name(array_id);
statement(get_argument_address_space(var) + " " + type_to_glsl(type) + "* " + name + "[] =");
begin_scope();
for (uint32_t i = 0; i < type.array[0]; ++i)
statement(name + "_" + convert_to_string(i) + ",");
end_scope_decl();
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
statement("");
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();
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
{
Use the classic locale when converting floats to string
2017-01-11 14:57:05 +00:00
// Force a classic "C" locale, reverts when function returns
ClassicLocale classic_locale;
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;
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;
Some compat fixes for MSL and Half.
2018-03-06 16:07:59 +00:00
backend.half_literal_suffix = "h";
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.uint32_t_literal_suffix = true;
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()";
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;
backend.flexible_member_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;
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
backend.can_return_array = false;
Support passing implicit frag_coord arguments down to functions.
2018-02-09 11:13:33 +00:00
backend.boolean_mix_support = 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: Support array-of-arrays composite construction.
2018-09-12 08:25:51 +00:00
backend.array_is_value_type = false;
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
Add CompilerMSL::get_is_rasterization_disabled() to manage rasterization status.
2018-07-26 20:40:32 +00:00
is_rasterization_disabled = msl_options.disable_rasterization;
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();
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
struct_member_padding.clear();
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
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();
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());
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 (aux_buffer_id)
active_interface_variables.insert(aux_buffer_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
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
// Preprocess OpCodes to extract the need to output additional header content
preprocess_op_codes();
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
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);
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);
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
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();
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();
Reset MSL sequential resource binding EACH pass
2016-09-17 09:30:58 +00:00
next_metal_resource_index = MSLResourceBinding(); // Start bindings at zero
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 ...
buffer = unique_ptr<ostringstream>(new ostringstream());
emit_header();
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_specialization_constants();
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++;
} while (force_recompile);
return buffer->str();
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
}
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
string CompilerMSL::compile(vector<MSLVertexAttr> *p_vtx_attrs, vector<MSLResourceBinding> *p_res_bindings)
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +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
if (p_vtx_attrs)
{
vtx_attrs_by_location.clear();
for (auto &va : *p_vtx_attrs)
vtx_attrs_by_location[va.location] = &va;
}
if (p_res_bindings)
{
resource_bindings.clear();
for (auto &rb : *p_res_bindings)
resource_bindings.push_back(&rb);
}
return compile();
}
string CompilerMSL::compile(MSLConfiguration &msl_cfg, vector<MSLVertexAttr> *p_vtx_attrs,
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
vector<MSLResourceBinding> *p_res_bindings)
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
{
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
msl_options = msl_cfg;
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
return compile(p_vtx_attrs, p_res_bindings);
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
Run style formatter.
2017-01-20 16:33:59 +00:00
if (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
add_pragma_line("#pragma clang diagnostic ignored \"-Wmissing-prototypes\"");
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;
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
{
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
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;
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 &id : ir.ids)
Run clang-format.
2016-10-24 13:24:24 +00:00
{
if (id.get_type() == TypeVariable)
{
auto &var = id.get<SPIRVariable>();
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 (var.storage == StorageClassInput || var.storage == StorageClassOutput ||
var.storage == StorageClassUniform || var.storage == StorageClassUniformConstant ||
var.storage == StorageClassPushConstant || var.storage == StorageClassStorageBuffer)
Format code
2017-01-15 15:39:03 +00:00
{
Run clang-format.
2016-10-24 13:24:24 +00:00
global_var_ids.insert(var.self);
Add function global variables
2017-01-09 15:23:58 +00:00
}
Run clang-format.
2016-10-24 13:24:24 +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:
{
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
Support passing implicit frag_coord arguments down to functions.
2018-02-09 11:13:33 +00:00
auto &type = get<SPIRType>(ops[0]);
Also check that type we load is an image.
2018-02-10 10:12:05 +00:00
if (type.basetype == SPIRType::Image && type.image.dim == DimSubpassData)
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: Swizzle gathers on depth textures as well. Might as well.
2018-09-29 14:52:26 +00:00
if (msl_options.swizzle_texture_samples && has_sampled_images && is_sampled_image_type(type))
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
{
// Implicitly reads spvAuxBuffer.
assert(aux_buffer_id != 0);
added_arg_ids.insert(aux_buffer_id);
}
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);
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
{
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);
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
if (is_builtin_variable(var) && p_type->basetype == SPIRType::Struct)
{
// Get the non-pointer type
type_id = get_non_pointer_type_id(type_id);
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)
{
BuiltIn builtin;
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;
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()
{
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 &id : ir.ids)
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 (id.get_type() == TypeVariable)
{
auto &var = id.get<SPIRVariable>();
if (var.storage != StorageClassFunction && !is_hidden_variable(var))
{
auto &type = get<SPIRType>(var.basetype);
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);
}
}
}
}
// If the specified type is a struct, it and any nested structs
// are marked as packable with the DecorationCPacked decoration,
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)
{
set_decoration(type.self, DecorationCPacked);
// Recurse
size_t mbr_cnt = type.member_types.size();
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
}
}
}
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
// If a vertex attribute exists at the location, it is marked as being used by this shader
void CompilerMSL::mark_location_as_used_by_shader(uint32_t location, StorageClass storage)
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +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
MSLVertexAttr *p_va;
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 ((get_entry_point().model == ExecutionModelVertex) && (storage == StorageClassInput) &&
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
(p_va = vtx_attrs_by_location[location]))
p_va->used_by_shader = true;
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +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.
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
uint32_t CompilerMSL::add_interface_block(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
// Accumulate the variables that should appear in the interface struct
vector<SPIRVariable *> vars;
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
bool incl_builtins = (storage == StorageClassOutput);
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 &id : ir.ids)
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 (id.get_type() == TypeVariable)
{
auto &var = id.get<SPIRVariable>();
auto &type = get<SPIRType>(var.basetype);
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
if (var.storage == storage && interface_variable_exists_in_entry_point(var.self) &&
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
!is_hidden_variable(var, incl_builtins) && type.pointer)
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
{
vars.push_back(&var);
}
}
}
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 no variables qualify, leave
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 (vars.empty())
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;
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 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
ib_var_ref = stage_in_var_name;
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
{
ib_var_ref = stage_out_var_name;
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;
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
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)
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
blk.return_value = rtn_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
}
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
vars_needing_early_declaration.push_back(ib_var_id);
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);
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);
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
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 p_var : vars)
{
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
uint32_t type_id = p_var->basetype;
auto &type = get<SPIRType>(type_id);
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
Run clang-format.
2016-10-24 13:24:24 +00:00
if (type.basetype == SPIRType::Struct)
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 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
if (!is_builtin_type(type))
{
// 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(p_var->self);
vars_needing_early_declaration.push_back(p_var->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
// Flatten the struct members into the interface struct
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
uint32_t mbr_idx = 0;
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
for (auto &mbr_type_id : type.member_types)
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 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
BuiltIn builtin;
bool is_builtin = is_member_builtin(type, mbr_idx, &builtin);
Handle interpolation qualifiers on the entire struct, too.
2018-09-06 17:29:42 +00:00
bool is_flat = has_member_decoration(type.self, mbr_idx, DecorationFlat) ||
has_decoration(p_var->self, DecorationFlat);
bool is_noperspective = has_member_decoration(type.self, mbr_idx, DecorationNoPerspective) ||
has_decoration(p_var->self, DecorationNoPerspective);
bool is_centroid = has_member_decoration(type.self, mbr_idx, DecorationCentroid) ||
has_decoration(p_var->self, DecorationCentroid);
bool is_sample = has_member_decoration(type.self, mbr_idx, DecorationSample) ||
has_decoration(p_var->self, DecorationSample);
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
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 (!is_builtin || has_active_builtin(builtin, storage))
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
{
// Add a reference to the member to the interface struct.
uint32_t ib_mbr_idx = uint32_t(ib_type.member_types.size());
CompilerMSL support gl_SampleMask and convert it to scalar uint from array.
2018-02-13 19:44:40 +00:00
mbr_type_id = ensure_correct_builtin_type(mbr_type_id, builtin);
type.member_types[mbr_idx] = mbr_type_id;
ib_type.member_types.push_back(mbr_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
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
// Give the member a name
string mbr_name = ensure_valid_name(to_qualified_member_name(type, mbr_idx), "m");
set_member_name(ib_type_id, ib_mbr_idx, mbr_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 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
// Update the original variable reference to include the structure reference
string qual_var_name = ib_var_ref + "." + mbr_name;
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
if (is_builtin)
{
// For the builtin gl_PerVertex, we cannot treat it as a block anyways,
// so redirect to qualified name.
set_member_qualified_name(type_id, mbr_idx, qual_var_name);
}
else
{
// Unflatten or flatten from [[stage_in]] or [[stage_out]] as appropriate.
switch (storage)
{
case StorageClassInput:
Make fixup_hooks more flexible. No reason why it needs to return a string. Callbacks can just do one or more statements themselves.
2018-09-17 12:04:55 +00:00
entry_func.fixup_hooks_in.push_back([=]() {
statement(to_name(p_var->self), ".", to_member_name(type, mbr_idx), " = ",
qual_var_name, ";");
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
});
break;
case StorageClassOutput:
Make fixup_hooks more flexible. No reason why it needs to return a string. Callbacks can just do one or more statements themselves.
2018-09-17 12:04:55 +00:00
entry_func.fixup_hooks_out.push_back([=]() {
statement(qual_var_name, " = ", to_name(p_var->self), ".",
to_member_name(type, mbr_idx), ";");
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
});
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 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
// Copy the variable location from the original variable to the member
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 (has_member_decoration(type_id, mbr_idx, DecorationLocation))
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
{
uint32_t locn = get_member_decoration(type_id, mbr_idx, DecorationLocation);
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationLocation, locn);
mark_location_as_used_by_shader(locn, storage);
Assign block locations to members in MSL.
2017-06-21 07:55:46 +00:00
}
else if (has_decoration(p_var->self, DecorationLocation))
{
// The block itself might have a location and in this case, all members of the block
// receive incrementing locations.
uint32_t locn = get_decoration(p_var->self, DecorationLocation) + mbr_idx;
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationLocation, locn);
mark_location_as_used_by_shader(locn, storage);
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
}
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: 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
// Copy the component location, if present.
if (has_member_decoration(type_id, mbr_idx, DecorationComponent))
{
uint32_t comp = get_member_decoration(type_id, mbr_idx, DecorationComponent);
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationComponent, 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
// Mark the member as builtin if needed
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
if (is_builtin)
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
{
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationBuiltIn, builtin);
if (builtin == BuiltInPosition)
qual_pos_var_name = qual_var_name;
}
MSL: Handle interpolation qualifiers.
2018-09-04 21:08:22 +00:00
// Copy interpolation decorations if needed
if (is_flat)
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationFlat);
if (is_noperspective)
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationNoPerspective);
if (is_centroid)
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationCentroid);
if (is_sample)
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationSample);
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
mbr_idx++;
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
}
}
Format code
2017-01-15 15:39:03 +00:00
else if (type.basetype == SPIRType::Boolean || type.basetype == SPIRType::Char ||
type.basetype == SPIRType::Int || type.basetype == SPIRType::UInt ||
type.basetype == SPIRType::Int64 || type.basetype == SPIRType::UInt64 ||
Run format_all.sh.
2018-03-07 09:29:20 +00:00
type_is_floating_point(type) || type.basetype == SPIRType::Boolean)
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 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
bool is_builtin = is_builtin_variable(*p_var);
BuiltIn builtin = BuiltIn(get_decoration(p_var->self, DecorationBuiltIn));
MSL: Handle interpolation qualifiers.
2018-09-04 21:08:22 +00:00
bool is_flat = has_decoration(p_var->self, DecorationFlat);
bool is_noperspective = has_decoration(p_var->self, DecorationNoPerspective);
bool is_centroid = has_decoration(p_var->self, DecorationCentroid);
bool is_sample = has_decoration(p_var->self, DecorationSample);
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
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 (!is_builtin || has_active_builtin(builtin, storage))
Attempt MRT-as-array in MSL.
2018-03-13 12:17:17 +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
// MSL does not allow matrices or arrays in input or output variables, so need to handle it specially.
if (!is_builtin && (storage == StorageClassInput || storage == StorageClassOutput) &&
(is_matrix(type) || is_array(type)))
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
{
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
uint32_t elem_cnt = 0;
if (is_matrix(type))
{
if (is_array(type))
SPIRV_CROSS_THROW("MSL cannot emit arrays-of-matrices in input and output variables.");
elem_cnt = type.columns;
}
else if (is_array(type))
{
if (type.array.size() != 1)
SPIRV_CROSS_THROW("MSL cannot emit arrays-of-arrays in input and output variables.");
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 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
elem_cnt = to_array_size_literal(type);
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
}
Properly flatten MRT outputs in MSL.
2018-03-13 13:03:35 +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 *usable_type = &type;
while (is_array(*usable_type) || is_matrix(*usable_type))
usable_type = &get<SPIRType>(usable_type->parent_type);
Properly flatten MRT outputs in MSL.
2018-03-13 13:03:35 +00:00
entry_func.add_local_variable(p_var->self);
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
// We need to declare the variable early and at entry-point scope.
vars_needing_early_declaration.push_back(p_var->self);
for (uint32_t i = 0; i < elem_cnt; i++)
Properly flatten MRT outputs in MSL.
2018-03-13 13:03:35 +00:00
{
// Add a reference to the variable type to the interface struct.
uint32_t ib_mbr_idx = uint32_t(ib_type.member_types.size());
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
ib_type.member_types.push_back(usable_type->self);
Properly flatten MRT outputs in MSL.
2018-03-13 13:03:35 +00:00
// Give the member a name
string mbr_name = ensure_valid_name(join(to_expression(p_var->self), "_", i), "m");
set_member_name(ib_type_id, ib_mbr_idx, mbr_name);
// There is no qualified alias since we need to flatten the internal array on return.
if (get_decoration_bitset(p_var->self).get(DecorationLocation))
{
uint32_t locn = get_decoration(p_var->self, DecorationLocation) + i;
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationLocation, locn);
mark_location_as_used_by_shader(locn, storage);
}
Support dual-source blending on GLSL and MSL.
2018-04-03 13:56:22 +00:00
if (get_decoration_bitset(p_var->self).get(DecorationIndex))
{
uint32_t index = get_decoration(p_var->self, DecorationIndex);
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationIndex, index);
}
MSL: Handle interpolation qualifiers.
2018-09-04 21:08:22 +00:00
// Copy interpolation decorations if needed
if (is_flat)
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationFlat);
if (is_noperspective)
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationNoPerspective);
if (is_centroid)
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationCentroid);
if (is_sample)
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationSample);
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
switch (storage)
{
case StorageClassInput:
Make fixup_hooks more flexible. No reason why it needs to return a string. Callbacks can just do one or more statements themselves.
2018-09-17 12:04:55 +00:00
entry_func.fixup_hooks_in.push_back([=]() {
statement(to_name(p_var->self), "[", i, "] = ", ib_var_ref, ".", mbr_name, ";");
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
});
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
break;
case StorageClassOutput:
Make fixup_hooks more flexible. No reason why it needs to return a string. Callbacks can just do one or more statements themselves.
2018-09-17 12:04:55 +00:00
entry_func.fixup_hooks_out.push_back([=]() {
statement(ib_var_ref, ".", mbr_name, " = ", to_name(p_var->self), "[", i, "];");
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
});
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
break;
default:
break;
}
Properly flatten MRT outputs in MSL.
2018-03-13 13:03:35 +00:00
}
}
else
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
{
Properly flatten MRT outputs in MSL.
2018-03-13 13:03:35 +00:00
// Add a reference to the variable type to the interface struct.
uint32_t ib_mbr_idx = uint32_t(ib_type.member_types.size());
type_id = ensure_correct_builtin_type(type_id, builtin);
p_var->basetype = type_id;
ib_type.member_types.push_back(type_id);
// Give the member a name
string mbr_name = ensure_valid_name(to_expression(p_var->self), "m");
set_member_name(ib_type_id, ib_mbr_idx, mbr_name);
// Update the original variable reference to include the structure reference
string qual_var_name = ib_var_ref + "." + mbr_name;
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[p_var->self].decoration.qualified_alias = qual_var_name;
Properly flatten MRT outputs in MSL.
2018-03-13 13:03:35 +00:00
// Copy the variable location from the original variable to the member
if (get_decoration_bitset(p_var->self).get(DecorationLocation))
{
uint32_t locn = get_decoration(p_var->self, DecorationLocation);
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationLocation, locn);
mark_location_as_used_by_shader(locn, storage);
}
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 (get_decoration_bitset(p_var->self).get(DecorationComponent))
{
uint32_t comp = get_decoration(p_var->self, DecorationComponent);
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationComponent, comp);
}
Support dual-source blending on GLSL and MSL.
2018-04-03 13:56:22 +00:00
if (get_decoration_bitset(p_var->self).get(DecorationIndex))
{
uint32_t index = get_decoration(p_var->self, DecorationIndex);
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationIndex, index);
}
Properly flatten MRT outputs in MSL.
2018-03-13 13:03:35 +00:00
// Mark the member as builtin if needed
if (is_builtin)
{
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationBuiltIn, builtin);
if (builtin == BuiltInPosition)
qual_pos_var_name = qual_var_name;
}
MSL: Handle interpolation qualifiers.
2018-09-04 21:08:22 +00:00
// Copy interpolation decorations if needed
if (is_flat)
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationFlat);
if (is_noperspective)
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationNoPerspective);
if (is_centroid)
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationCentroid);
if (is_sample)
set_member_decoration(ib_type_id, ib_mbr_idx, DecorationSample);
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
}
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 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
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;
}
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)) ||
((builtin == BuiltInLayer || builtin == BuiltInViewportIndex) && 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;
}
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.
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
void CompilerMSL::align_struct(SPIRType &ib_type)
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 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
uint32_t &ib_type_id = ib_type.self;
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();
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
uint32_t mbr_cnt = uint32_t(ib_type.member_types.size());
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.
// For example...this applies to any 3-element vector that is followed by a scalar.
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 curr_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++)
{
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 (is_member_packable(ib_type, mbr_idx))
set_member_decoration(ib_type_id, mbr_idx, DecorationCPacked);
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
spirv_msl only add padding structure members if required by member alignment.
2017-03-06 16:00:23 +00:00
// Align current offset to the current member's default alignment.
size_t align_mask = get_declared_struct_member_alignment(ib_type, mbr_idx) - 1;
curr_offset = uint32_t((curr_offset + align_mask) & ~align_mask);
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.
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
uint32_t mbr_offset = get_member_decoration(ib_type_id, mbr_idx, DecorationOffset);
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
if (mbr_offset > curr_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
// size rules, we'll pad to standard C-packing rules. If the member is farther
// away than C-packing, expects, add an inert padding member before the the member.
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
MSLStructMemberKey key = get_struct_member_key(ib_type_id, 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
struct_member_padding[key] = mbr_offset - curr_offset;
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
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)
curr_offset = mbr_offset + uint32_t(get_declared_struct_member_size(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
}
}
spirv_msl pack MSL uniform struct members only when size warrants.
2017-03-03 01:57:26 +00:00
// Returns whether the specified struct member supports a packable type
// variation that is smaller than the unpacked variation of that type.
bool CompilerMSL::is_member_packable(SPIRType &ib_type, uint32_t 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
// We've already marked it as packable
if (has_member_decoration(ib_type.self, index, DecorationCPacked))
spirv_msl pack MSL uniform struct members only when size warrants.
2017-03-03 01:57:26 +00:00
return true;
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 &mbr_type = get<SPIRType>(ib_type.member_types[index]);
// Only 3-element vectors or 3-row matrices need to be packed.
if (mbr_type.vecsize != 3)
return false;
// Only row-major matrices need to be packed.
if (is_matrix(mbr_type) && !has_member_decoration(ib_type.self, index, DecorationRowMajor))
return false;
uint32_t component_size = mbr_type.width / 8;
uint32_t unpacked_mbr_size = component_size * (mbr_type.vecsize + 1) * mbr_type.columns;
if (is_array(mbr_type))
{
// If member is an array, and the array stride is larger than the type needs, don't pack it.
// Take into consideration multi-dimentional arrays.
uint32_t md_elem_cnt = 1;
size_t last_elem_idx = mbr_type.array.size() - 1;
for (uint32_t i = 0; i < last_elem_idx; i++)
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
md_elem_cnt *= max(to_array_size_literal(mbr_type, i), 1u);
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
uint32_t unpacked_array_stride = unpacked_mbr_size * md_elem_cnt;
uint32_t array_stride = type_struct_member_array_stride(ib_type, index);
return unpacked_array_stride > array_stride;
}
else
{
// Pack if there is not enough space between this member and next.
// If last member, only pack if it's a row-major matrix.
if (index < ib_type.member_types.size() - 1)
{
uint32_t mbr_offset_curr = get_member_decoration(ib_type.self, index, DecorationOffset);
uint32_t mbr_offset_next = get_member_decoration(ib_type.self, index + 1, DecorationOffset);
return unpacked_mbr_size > mbr_offset_next - mbr_offset_curr;
}
else
return is_matrix(mbr_type);
}
spirv_msl pack MSL uniform struct members only when size warrants.
2017-03-03 01:57:26 +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
// Returns a combination of type ID and member index for use as hash key
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
MSLStructMemberKey CompilerMSL::get_struct_member_key(uint32_t type_id, uint32_t 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
{
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
MSLStructMemberKey k = type_id;
k <<= 32;
k += index;
return k;
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 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.
string CompilerMSL::unpack_expression_type(string expr_str, const SPIRType &type)
{
return join(type_to_glsl(type), "(", expr_str, ")");
}
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
// Emits the file header info
void CompilerMSL::emit_header()
{
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
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 (!pragma_lines.empty())
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)
force_recompile = true;
}
void CompilerMSL::add_typedef_line(const string &line)
{
auto rslt = typedef_lines.insert(line);
if (rslt.second)
force_recompile = 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
}
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.
void CompilerMSL::emit_custom_functions()
{
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
for (uint32_t i = SPVFuncImplArrayCopyMultidimMax; i >= 2; i--)
if (spv_function_implementations.count(static_cast<SPVFuncImpl>(SPVFuncImplArrayCopyMultidimBase + i)))
spv_function_implementations.insert(static_cast<SPVFuncImpl>(SPVFuncImplArrayCopyMultidimBase + i - 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
for (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>");
statement("Tx mod(Tx x, Ty y)");
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>");
statement("T radians(T d)");
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>");
statement("T degrees(T r)");
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>");
statement("T findLSB(T x)");
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>");
statement("T findUMSB(T x)");
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>");
statement("T findSMSB(T x)");
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;
case SPVFuncImplArrayCopy:
statement("// Implementation of an array copy function to cover GLSL's ability to copy an array via "
MSL cannot declare inline arrays except in certain cases.
2018-02-08 12:06:29 +00:00
"assignment.");
Overload on constant storage.
2018-02-08 16:58:46 +00:00
statement("template<typename T, uint N>");
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
statement("void spvArrayCopyFromStack1(thread T (&dst)[N], thread const T (&src)[N])");
Overload on constant storage.
2018-02-08 16:58:46 +00:00
begin_scope();
statement("for (uint i = 0; i < N; dst[i] = src[i], i++);");
end_scope();
statement("");
statement("template<typename T, uint N>");
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
statement("void spvArrayCopyFromConstant1(thread T (&dst)[N], constant T (&src)[N])");
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
begin_scope();
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
statement("for (uint i = 0; i < N; dst[i] = src[i], i++);");
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;
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
case SPVFuncImplArrayOfArrayCopy2Dim:
case SPVFuncImplArrayOfArrayCopy3Dim:
case SPVFuncImplArrayOfArrayCopy4Dim:
case SPVFuncImplArrayOfArrayCopy5Dim:
case SPVFuncImplArrayOfArrayCopy6Dim:
{
static const char *function_name_tags[] = {
"FromStack",
"FromConstant",
};
static const char *src_address_space[] = {
"thread const",
"constant",
};
for (uint32_t variant = 0; variant < 2; variant++)
{
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 += "]";
}
Run format_all.sh.
2018-09-12 08:53:50 +00:00
statement("void spvArrayCopy", function_name_tags[variant], dimensions, "(thread 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();
statement("spvArrayCopy", function_name_tags[variant], dimensions - 1, "(dst[i], src[i]);");
end_scope();
end_scope();
statement("");
}
break;
}
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:
{
Fixes for code review of PR 626.
2018-06-27 14:34:15 +00:00
string tex_width_str = convert_to_string(msl_options.texel_buffer_texture_width);
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
statement("// Returns 2D texture coords corresponding to 1D texel buffer coords");
statement("uint2 spvTexelBufferCoord(uint tc)");
begin_scope();
Fixes for code review of PR 626.
2018-06-27 14:34:15 +00:00
statement(join("return uint2(tc % ", tex_width_str, ", tc / ", tex_width_str, ");"));
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.");
statement("inline float spvDet2x2(float a1, float a2, float b1, float b2)");
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.");
statement("inline float spvDet3x3(float a1, float a2, float a3, float b1, float b2, float b3, float c1, "
"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.");
statement("float4x4 spvInverse4x4(float4x4 m)");
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.");
statement("inline float spvDet2x2(float a1, float a2, float b1, float b2)");
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.");
statement("float3x3 spvInverse3x3(float3x3 m)");
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.");
statement("float2x2 spvInverse2x2(float2x2 m)");
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;
CompilerMSL support conversion of non-square row-major matrices.
2018-01-04 21:33:45 +00:00
case SPVFuncImplRowMajor2x3:
statement("// Implementation of a conversion of matrix content from RowMajor to ColumnMajor organization.");
statement("float2x3 spvConvertFromRowMajor2x3(float2x3 m)");
begin_scope();
statement("return float2x3(float3(m[0][0], m[0][2], m[1][1]), float3(m[0][1], m[1][0], m[1][2]));");
end_scope();
statement("");
break;
case SPVFuncImplRowMajor2x4:
statement("// Implementation of a conversion of matrix content from RowMajor to ColumnMajor organization.");
statement("float2x4 spvConvertFromRowMajor2x4(float2x4 m)");
begin_scope();
statement("return float2x4(float4(m[0][0], m[0][2], m[1][0], m[1][2]), float4(m[0][1], m[0][3], m[1][1], "
"m[1][3]));");
end_scope();
statement("");
break;
case SPVFuncImplRowMajor3x2:
statement("// Implementation of a conversion of matrix content from RowMajor to ColumnMajor organization.");
statement("float3x2 spvConvertFromRowMajor3x2(float3x2 m)");
begin_scope();
statement("return float3x2(float2(m[0][0], m[1][1]), float2(m[0][1], m[2][0]), float2(m[1][0], m[2][1]));");
end_scope();
statement("");
break;
case SPVFuncImplRowMajor3x4:
statement("// Implementation of a conversion of matrix content from RowMajor to ColumnMajor organization.");
statement("float3x4 spvConvertFromRowMajor3x4(float3x4 m)");
begin_scope();
statement("return float3x4(float4(m[0][0], m[0][3], m[1][2], m[2][1]), float4(m[0][1], m[1][0], m[1][3], "
"m[2][2]), float4(m[0][2], m[1][1], m[2][0], m[2][3]));");
end_scope();
statement("");
break;
case SPVFuncImplRowMajor4x2:
statement("// Implementation of a conversion of matrix content from RowMajor to ColumnMajor organization.");
statement("float4x2 spvConvertFromRowMajor4x2(float4x2 m)");
begin_scope();
statement("return float4x2(float2(m[0][0], m[2][0]), float2(m[0][1], m[2][1]), float2(m[1][0], m[3][0]), "
"float2(m[1][1], m[3][1]));");
end_scope();
statement("");
break;
case SPVFuncImplRowMajor4x3:
statement("// Implementation of a conversion of matrix content from RowMajor to ColumnMajor organization.");
statement("float4x3 spvConvertFromRowMajor4x3(float4x3 m)");
begin_scope();
statement("return float4x3(float3(m[0][0], m[1][1], m[2][2]), float3(m[0][1], m[1][2], m[3][0]), "
"float3(m[0][2], m[2][0], m[3][1]), float3(m[1][0], m[2][1], m[3][2]));");
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
case SPVFuncImplTextureSwizzle:
statement("enum class spvSwizzle : uint");
begin_scope();
statement("none = 0,");
statement("zero,");
statement("one,");
statement("red,");
statement("green,");
statement("blue,");
statement("alpha");
Remove extraneous space in enum class decl.
2018-09-21 18:52:20 +00:00
end_scope_decl();
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("");
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("");
statement("template<typename T>");
statement("inline T spvGetSwizzle(vec<T, 4> x, spvSwizzle s)");
begin_scope();
statement("switch (s)");
begin_scope();
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;");
statement("default:");
statement(" break;");
end_scope();
statement("return 0;");
end_scope();
statement("");
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;");
Pack texture component swizzles by bytes.
2018-09-22 03:50:29 +00:00
statement("return vec<T, 4>(spvGetSwizzle(x, spvSwizzle((s >> 0) & 0xFF)), "
"spvGetSwizzle(x, spvSwizzle((s >> 8) & 0xFF)), spvGetSwizzle(x, spvSwizzle((s >> 16) & 0xFF)), "
"spvGetSwizzle(x, 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("");
statement("// Wrapper function that swizzles texture gathers.");
statement("template<typename T, typename Tex, typename... Ts>");
statement("inline vec<T, 4> spvGatherSwizzle(sampler s, thread Tex& t, Ts... params, component c, uint sw) "
"METAL_CONST_ARG(c)");
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: 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.");
statement("template<typename T, typename Tex, typename... Ts>");
statement("inline vec<T, 4> spvGatherCompareSwizzle(sampler s, thread Tex& t, Ts... params, uint sw) ");
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 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
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;
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 &id : ir.ids)
CompilerMSL support and tests for OpUndef.
2017-11-16 03:44:42 +00:00
{
if (id.get_type() == TypeUndef)
{
auto &undef = id.get<SPIRUndef>();
auto &type = get<SPIRType>(undef.basetype);
For MSL, use {} instead of constructors to init OpUndef values.
2017-11-30 20:03:27 +00:00
statement("constant ", variable_decl(type, to_name(undef.self), undef.self), " = {};");
CompilerMSL support and tests for OpUndef.
2017-11-16 03:44:42 +00:00
emitted = true;
}
}
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 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;
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 &id : ir.ids)
MSL cannot declare inline arrays except in certain cases.
2018-02-08 12:06:29 +00:00
{
if (id.get_type() == TypeConstant)
{
auto &c = id.get<SPIRConstant>();
if (c.specialization)
continue;
auto &type = get<SPIRType>(c.constant_type);
if (!type.array.empty())
{
auto name = to_name(c.self);
statement("constant ", variable_decl(type, name), " = ", constant_expression(c), ";");
emitted = true;
}
}
}
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: 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
// Output non-builtin interface structs. These include local function structs
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
// and structs nested within uniform and read-write buffers.
unordered_set<uint32_t> declared_structs;
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 &id : ir.ids)
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 (id.get_type() == TypeType)
{
auto &type = id.get<SPIRType>();
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 type_id = type.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
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 is_struct = (type.basetype == SPIRType::Struct) && type.array.empty();
bool is_block =
has_decoration(type.self, DecorationBlock) || has_decoration(type.self, DecorationBufferBlock);
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 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
bool is_builtin_block = is_block && is_builtin_type(type);
bool is_declarable_struct = is_struct && !is_builtin_block;
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 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
// We'll declare this later.
if (stage_out_var_id && get<SPIRVariable>(stage_out_var_id).basetype == type_id)
is_declarable_struct = false;
if (stage_in_var_id && get<SPIRVariable>(stage_in_var_id).basetype == type_id)
is_declarable_struct = false;
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
// Align and emit declarable structs...but avoid declaring each more than once.
if (is_declarable_struct && declared_structs.count(type_id) == 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
{
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
declared_structs.insert(type_id);
if (has_decoration(type_id, DecorationCPacked))
Add WorkGroupID/NumWorkGroups to MSL. Fix block name alias.
2017-09-29 10:16:53 +00:00
align_struct(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
emit_struct(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
}
}
}
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);
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);
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
void CompilerMSL::emit_specialization_constants()
{
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;
uint32_t 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
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 &id : ir.ids)
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 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.
statement("constant uint3 ", builtin_to_glsl(BuiltInWorkgroupSize, StorageClassWorkgroup), " = ",
constant_expression(get<SPIRConstant>(workgroup_size_id)), ";");
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
}
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);
}
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);
switch (opcode)
{
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:
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:
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:
case OpSGreaterThan:
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:
case OpSGreaterThanEqual:
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:
case OpSLessThan:
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:
case OpSLessThanEqual:
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:
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_QFOP(insert_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 OpBitFieldSExtract:
case OpBitFieldUExtract:
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_TFOP(extract_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 OpBitReverse:
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:
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(popcount);
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 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;
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);
force_recompile = true;
}
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
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
emit_texture_op(instruction);
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
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);
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
force_recompile = true;
}
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);
statement(join(
to_expression(img_id), ".write(", to_expression(texel_id), ", ",
to_function_args(img_id, img_type, true, false, false, coord_id, 0, 0, 0, 0, lod, 0, 0, 0, 0, 0, &forward),
");"));
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)
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()";
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:
SPIRV_CROSS_THROW("MSL does not support textureQueryLod().");
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 &e = emit_op(result_type, id, to_expression(ops[2]), true, true);
auto *var = maybe_get_backing_variable(ops[2]);
if (var)
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;
}
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:
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;
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
case OpVectorTimesMatrix:
case OpMatrixTimesVector:
{
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 the matrix needs transpose and it is square or packed, just flip the multiply order.
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
uint32_t mtx_id = ops[opcode == OpMatrixTimesVector ? 2 : 3];
auto *e = maybe_get<SPIRExpression>(mtx_id);
auto &t = expression_type(mtx_id);
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
bool is_packed = has_decoration(mtx_id, DecorationCPacked);
if (e && e->need_transpose && (t.columns == t.vecsize || is_packed))
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
{
e->need_transpose = false;
Do not unpack transposed matrices.
2018-06-12 07:36:13 +00:00
// This is important for matrices. Packed matrices
// are generally transposed, so unpacking using a constructor argument
// will result in an error.
// The simplest solution for now is to just avoid unpacking the matrix in this operation.
unset_decoration(mtx_id, DecorationCPacked);
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
emit_binary_op(ops[0], ops[1], ops[3], ops[2], "*");
Do not unpack transposed matrices.
2018-06-12 07:36:13 +00:00
if (is_packed)
set_decoration(mtx_id, DecorationCPacked);
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
e->need_transpose = true;
}
else
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(*);
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
break;
}
Fixups for PR #353.
2017-12-05 08:58:12 +00:00
// OpOuterProduct
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 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;
}
void CompilerMSL::emit_barrier(uint32_t id_exe_scope, uint32_t id_mem_scope, uint32_t id_mem_sem)
{
if (get_entry_point().model != ExecutionModelGLCompute)
return;
string bar_stmt = "threadgroup_barrier(mem_flags::";
Build/warning fix on modern GCC.
2017-11-13 08:26:19 +00:00
uint32_t mem_sem = id_mem_sem ? get<SPIRConstant>(id_mem_sem).scalar() : 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
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
if (mem_sem & MemorySemanticsCrossWorkgroupMemoryMask)
bar_stmt += "mem_device";
else if (mem_sem & (MemorySemanticsSubgroupMemoryMask | MemorySemanticsWorkgroupMemoryMask |
MemorySemanticsAtomicCounterMemoryMask))
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 += "mem_threadgroup";
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 if (mem_sem & MemorySemanticsImageMemoryMask)
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 += "mem_texture";
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
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 += "mem_none";
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 (msl_options.is_ios() && msl_options.supports_msl_version(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
{
bar_stmt += ", ";
// Use the wider of the two scopes (smaller value)
Build/warning fix on modern GCC.
2017-11-13 08:26:19 +00:00
uint32_t exe_scope = id_exe_scope ? get<SPIRConstant>(id_exe_scope).scalar() : uint32_t(ScopeInvocation);
uint32_t mem_scope = id_mem_scope ? get<SPIRConstant>(id_mem_scope).scalar() : uint32_t(ScopeInvocation);
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 scope = min(exe_scope, mem_scope);
switch (scope)
{
case ScopeCrossDevice:
case ScopeDevice:
bar_stmt += "memory_scope_device";
break;
case ScopeSubgroup:
case ScopeInvocation:
bar_stmt += "memory_scope_simdgroup";
break;
case ScopeWorkgroup:
default:
bar_stmt += "memory_scope_threadgroup";
break;
}
}
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
}
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
void CompilerMSL::emit_array_copy(const string &lhs, uint32_t rhs_id)
{
// Assignment from an array initializer is fine.
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
auto &type = expression_type(rhs_id);
auto *var = maybe_get_backing_variable(rhs_id);
// Unfortunately, we cannot template on address space in MSL,
// so explicit address space redirection it is ...
bool is_constant = false;
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[rhs_id].get_type() == TypeConstant)
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
{
is_constant = true;
}
else if (var && var->remapped_variable && var->statically_assigned &&
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.ids[var->static_expression].get_type() == TypeConstant)
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
{
is_constant = true;
}
const char *tag = is_constant ? "FromConstant" : "FromStack";
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);
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
emit_array_copy(to_expression(id_lhs), 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
{
forced_temporaries.insert(result_id);
string exp = string(op) + "(";
auto &type = expression_type(obj);
exp += "(volatile ";
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.");
exp += get_argument_address_space(*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
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 only supports the weak atomic compare exchange,
// so emit a CAS loop here.
statement(variable_decl(type, to_name(result_id)), ";");
statement("do");
begin_scope();
statement(to_name(result_id), " = ", to_expression(op1), ";");
end_scope_decl(join("while (!", exp, ")"));
set<SPIRExpression>(result_id, to_name(result_id), result_type, 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
}
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 += ")";
emit_op(result_type, result_id, exp, 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
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)
{
GLSLstd450 op = static_cast<GLSLstd450>(eop);
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;
case GLSLstd450FindSMsb:
emit_unary_func_op(result_type, id, args[0], "findSMSB");
break;
case GLSLstd450FindUMsb:
emit_unary_func_op(result_type, id, args[0], "findUMSB");
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
default:
CompilerGLSL::emit_glsl_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);
auto &ib_type = get<SPIRType>(ib_var.basetype);
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;
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 decl;
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
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
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
if (type.array.empty())
{
decl += func_type_decl(type);
}
else
{
// We cannot return arrays in MSL, so "return" through an out variable.
Fix wrong function declaration in MSL.
2018-02-05 11:51:18 +00:00
decl = "void";
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +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
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 += "(";
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
if (!type.array.empty())
{
// Fake arrays returns by writing to an out array instead.
Implicit return value takes thread storage.
2018-02-05 12:03:40 +00:00
decl += "thread ";
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
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)
{
decl += entry_point_args(!func.arguments.empty());
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);
if (!ed_var.initializer)
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
ed_var.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
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
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
string address_space;
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.
msl: Handle writable SSBO in function arguments
2017-01-27 00:40:56 +00:00
address_space = get_argument_address_space(*var);
Run clang-format.
2016-10-24 13:24:24 +00:00
}
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);
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 (!address_space.empty())
decl += address_space + " ";
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
Run clang-format.
2016-10-24 13:24:24 +00:00
// Manufacture automatic sampler arg for SampledImage texture
auto &arg_type = get<SPIRType>(arg.type);
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
if (arg_type.basetype == SPIRType::SampledImage && arg_type.image.dim != DimBuffer)
Add test for sampler image arrays.
2018-04-03 12:26:24 +00:00
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
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
}
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.
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
string CompilerMSL::to_function_name(uint32_t img, const SPIRType &imgtype, bool is_fetch, bool is_gather, bool, bool,
MSL: Swizzle gathers on depth textures as well. Might as well.
2018-09-29 14:52:26 +00:00
bool has_offset, bool, bool has_dref, uint32_t)
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +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
// Special-case gather. We have to alter the component being looked up
// in the swizzle case.
MSL: Swizzle gathers on depth textures as well. Might as well.
2018-09-29 14:52:26 +00:00
if (msl_options.swizzle_texture_samples && is_gather)
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: Swizzle gathers on depth textures as well. Might as well.
2018-09-29 14:52:26 +00:00
string fname = imgtype.image.depth ? "spvGatherCompareSwizzle" : "spvGatherSwizzle";
fname += "<" + type_to_glsl(get<SPIRType>(imgtype.image.type)) + ", metal::" + type_to_glsl(imgtype);
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
// Add the arg types ourselves. Yes, this sucks, but Clang can't
// deduce template pack parameters in the middle of an argument list.
switch (imgtype.image.dim)
{
case Dim2D:
fname += ", float2";
if (imgtype.image.arrayed)
fname += ", uint";
MSL: Swizzle gathers on depth textures as well. Might as well.
2018-09-29 14:52:26 +00:00
if (imgtype.image.depth)
fname += ", float";
if (!imgtype.image.depth || has_offset)
fname += ", int2";
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
break;
case DimCube:
fname += ", float3";
if (imgtype.image.arrayed)
fname += ", uint";
MSL: Swizzle gathers on depth textures as well. Might as well.
2018-09-29 14:52:26 +00:00
if (imgtype.image.depth)
fname += ", float";
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
break;
default:
SPIRV_CROSS_THROW("Invalid texture dimension for gather op.");
}
fname += ">";
return fname;
}
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
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
string fname = to_expression(combined ? combined->image : img) + ".";
Use is_sampled_image_type() elsewhere.
2018-09-24 17:33:11 +00:00
if (msl_options.swizzle_texture_samples && !is_gather && is_sampled_image_type(imgtype))
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
fname = "spvTextureSwizzle(" + fname;
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 function and sampler
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
if (is_fetch)
fname += "read";
else if (is_gather)
fname += "gather";
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
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 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
if (has_dref)
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;
}
// Returns the function args for a texture sampling function for the specified image and sampling characteristics.
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
string CompilerMSL::to_function_args(uint32_t img, const SPIRType &imgtype, bool is_fetch, bool is_gather, bool is_proj,
Removed names of unused function parameters.
2017-01-07 20:55:04 +00:00
uint32_t coord, uint32_t, uint32_t dref, uint32_t grad_x, uint32_t grad_y,
uint32_t lod, uint32_t coffset, uint32_t offset, uint32_t bias, uint32_t comp,
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
uint32_t sample, 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
{
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;
if (!is_fetch)
farg_str += to_sampler_expression(img);
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: Swizzle gathers on depth textures as well. Might as well.
2018-09-29 14:52:26 +00:00
if (msl_options.swizzle_texture_samples && is_gather)
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
{
if (!farg_str.empty())
farg_str += ", ";
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);
farg_str += to_expression(combined ? combined->image : img);
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
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 forward = should_forward(coord);
Fixes for MSL and strip redundant parens in some places.
2016-12-06 22:03:35 +00:00
auto coord_expr = to_enclosed_expression(coord);
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
auto &coord_type = expression_type(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;
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
const char *alt_coord = "";
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)
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
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 (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) + ")";
alt_coord = ".y";
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 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)
tex_coords += ".x";
Fixes for code review of PR 626.
2018-06-27 14:34:15 +00:00
// Metal texel buffer textures are 2D, so convert 1D coord to 2D.
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 (is_fetch)
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
tex_coords = "spvTexelBufferCoord(" + round_fp_tex_coords(tex_coords, coord_is_fp) + ")";
CompilerMSL round floating point tex coords for read() and tex array index.
2017-04-25 20:32:16 +00:00
alt_coord = ".y";
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
break;
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
case DimSubpassData:
if (imgtype.image.ms)
tex_coords = "uint2(gl_FragCoord.xy)";
else
tex_coords = join("uint2(gl_FragCoord.xy), 0");
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)
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
CompilerMSL remove option to flip fragment coordinates.
2017-04-25 15:25:50 +00:00
if (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) + ")";
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
alt_coord = ".z";
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)
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
CompilerMSL remove option to flip fragment coordinates.
2017-04-25 15:25:50 +00:00
if (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) + ")";
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
alt_coord = ".w";
break;
case DimCube:
CompilerMSL remove option to flip fragment coordinates.
2017-04-25 15:25:50 +00:00
if (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)
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
}
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
alt_coord = ".w";
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;
}
MSL: Fix support for texelFetchOffset. Just apply the offset directly, MSL has no immediate offset parameter.
2018-08-07 13:28:04 +00:00
if (is_fetch && offset)
{
// Fetch offsets must be applied directly to the coordinate.
forward = forward && should_forward(offset);
Need to make sure the fetch expression is uint.
2018-08-07 14:02:17 +00:00
auto &type = expression_type(offset);
if (type.basetype != SPIRType::UInt)
tex_coords += " + " + bitcast_expression(SPIRType::UInt, offset);
else
tex_coords += " + " + to_enclosed_expression(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
}
else if (is_fetch && coffset)
{
// Fetch offsets must be applied directly to the coordinate.
forward = forward && should_forward(coffset);
Need to make sure the fetch expression is uint.
2018-08-07 14:02:17 +00:00
auto &type = expression_type(coffset);
if (type.basetype != SPIRType::UInt)
tex_coords += " + " + bitcast_expression(SPIRType::UInt, coffset);
else
tex_coords += " + " + to_enclosed_expression(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
if (is_proj)
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
tex_coords += " / " + coord_expr + alt_coord;
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
farg_str += tex_coords;
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 fetch from cube, add face explicitly
CompilerMSL round floating point tex coords for read() and tex array index.
2017-04-25 20:32:16 +00:00
if (is_cube_fetch)
Fix image load/store on cube arrays in MSL.
2018-05-25 10:43:25 +00:00
{
// Special case for cube arrays, face and layer are packed in one dimension.
if (imgtype.image.arrayed)
farg_str += ", uint(" + join(coord_expr, ".z) % 6u");
else
farg_str += ", uint(" + round_fp_tex_coords(coord_expr + ".z", 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
// If array, use alt coord
if (imgtype.image.arrayed)
Fix image load/store on cube arrays in MSL.
2018-05-25 10:43:25 +00:00
{
// Special case for cube arrays, face and layer are packed in one dimension.
if (imgtype.image.dim == DimCube && is_fetch)
farg_str += ", uint(" + join(coord_expr, ".z) / 6u");
else
farg_str += ", uint(" + round_fp_tex_coords(coord_expr + alt_coord, 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
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
if (dref)
{
forward = forward && should_forward(dref);
farg_str += ", ";
farg_str += to_expression(dref);
}
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.
if (bias && imgtype.image.dim != Dim1D)
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.
if (lod && imgtype.image.dim != Dim1D)
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 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
if (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
}
}
Deal with OpImageFetch without explicit LOD.
2018-04-30 08:53:21 +00:00
else if (is_fetch && !lod && imgtype.image.dim != Dim1D && imgtype.image.dim != DimBuffer && !imgtype.image.ms &&
imgtype.image.sampled != 2)
{
// 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.
if ((grad_x || grad_y) && imgtype.image.dim != Dim1D)
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:
grad_opt = "cube";
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
}
// Add offsets
string offset_expr;
MSL: Fix support for texelFetchOffset. Just apply the offset directly, MSL has no immediate offset parameter.
2018-08-07 13:28:04 +00:00
if (coffset && !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
{
forward = forward && should_forward(coffset);
offset_expr = to_expression(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
else if (offset && !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
{
forward = forward && should_forward(offset);
offset_expr = to_expression(offset);
}
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;
}
}
if (comp)
{
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)";
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(comp);
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_component_argument(comp);
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 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 (sample)
{
farg_str += ", ";
farg_str += to_expression(sample);
}
MSL: Swizzle gathers on depth textures as well. Might as well.
2018-09-29 14:52:26 +00:00
if (msl_options.swizzle_texture_samples && is_sampled_image_type(imgtype))
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
{
// Add the swizzle constant from the swizzle buffer.
if (!is_gather)
farg_str += ")";
// Get the original input variable for this image.
uint32_t img_var = img;
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_var);
if (combined)
img_var = combined->image;
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
if (auto *var = maybe_get_backing_variable(img_var))
Give up on non-aliased sampled image parameters. This needs extra work to map them back to the original resource.
2018-09-24 17:42:39 +00:00
{
if (var->parameter && !var->parameter->alias_global_variable)
SPIRV_CROSS_THROW("Cannot yet map non-aliased parameter to Metal resource!");
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
img_var = var->self;
Give up on non-aliased sampled image parameters. This needs extra work to map them back to the original resource.
2018-09-24 17:42:39 +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
auto &aux_type = expression_type(aux_buffer_id);
farg_str += ", " + to_name(aux_buffer_id) + "." + to_member_name(aux_type, k_aux_mbr_idx_swizzle_const) + "[" +
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
convert_to_string(get_metal_resource_index(get<SPIRVariable>(img_var), SPIRType::Image)) + "]";
Provide feedback on whether or not the auxiliary buffer is needed.
2018-09-24 18:38:27 +00:00
used_aux_buffer = true;
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
*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)
{
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].get_type() != TypeConstant)
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
{
SPIRV_CROSS_THROW("ID " + to_string(id) + " is not an OpConstant.");
return "component::x";
}
uint32_t component_index = get<SPIRConstant>(id).scalar();
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
}
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.
string CompilerMSL::to_func_call_arg(uint32_t id)
{
Run clang-format.
2016-10-24 13:24:24 +00:00
string arg_str = CompilerGLSL::to_func_call_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
CompilerMSL fix func_call_arg() cast error when not passed SPIRVariable type. CompilerGLSL allow retrieval of partial source if an error occurs.
2016-11-27 17:34:04 +00:00
// Manufacture automatic sampler arg if the arg is a SampledImage texture.
Support array of images and samplers in MSL.
2018-04-03 12:00:34 +00:00
auto &type = expression_type(id);
if (type.basetype == SPIRType::SampledImage && type.image.dim != DimBuffer)
arg_str += ", " + to_sampler_expression(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
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);
auto expr = to_expression(combined ? combined->image : 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
}
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)
{
// Natively supported row-major matrices do not need to be converted.
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
if (backend.native_row_major_matrix)
CompilerMSL support conversion of non-square row-major matrices.
2018-01-04 21:33:45 +00:00
return false;
// Non-matrix or column-major matrix types do not need to be converted.
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.meta[id].decoration.decoration_flags.get(DecorationRowMajor))
CompilerMSL support conversion of non-square row-major matrices.
2018-01-04 21:33:45 +00:00
return false;
// Generate a function that will swap matrix elements from row-major to column-major.
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
// Packed row-matrix should just use transpose() function.
if (!has_decoration(id, DecorationCPacked))
{
const auto type = expression_type(id);
add_convert_row_major_matrix_function(type.columns, type.vecsize);
}
CompilerMSL support conversion of non-square row-major matrices.
2018-01-04 21:33:45 +00:00
return true;
}
// 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)
{
// Natively supported row-major matrices do not need to be converted.
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
if (backend.native_row_major_matrix)
CompilerMSL support conversion of non-square row-major matrices.
2018-01-04 21:33:45 +00:00
return false;
// Non-matrix or column-major matrix types do not need to be converted.
Force recompile if we add row-major transpose functions in MSL.
2018-05-04 07:43:34 +00:00
if (!combined_decoration_for_member(type, index).get(DecorationRowMajor))
CompilerMSL support conversion of non-square row-major matrices.
2018-01-04 21:33:45 +00:00
return false;
// Generate a function that will swap matrix elements from row-major to column-major.
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
// Packed row-matrix should just use transpose() function.
if (!has_member_decoration(type.self, index, DecorationCPacked))
{
const auto mbr_type = get<SPIRType>(type.member_types[index]);
add_convert_row_major_matrix_function(mbr_type.columns, mbr_type.vecsize);
}
CompilerMSL support conversion of non-square row-major matrices.
2018-01-04 21:33:45 +00:00
return true;
}
// Adds a function suitable for converting a non-square row-major matrix to a column-major matrix.
void CompilerMSL::add_convert_row_major_matrix_function(uint32_t cols, uint32_t rows)
{
SPVFuncImpl spv_func;
if (cols == rows) // Square matrix...just use transpose() function
return;
else if (cols == 2 && rows == 3)
spv_func = SPVFuncImplRowMajor2x3;
else if (cols == 2 && rows == 4)
spv_func = SPVFuncImplRowMajor2x4;
else if (cols == 3 && rows == 2)
spv_func = SPVFuncImplRowMajor3x2;
else if (cols == 3 && rows == 4)
spv_func = SPVFuncImplRowMajor3x4;
else if (cols == 4 && rows == 2)
spv_func = SPVFuncImplRowMajor4x2;
else if (cols == 4 && rows == 3)
spv_func = SPVFuncImplRowMajor4x3;
else
SPIRV_CROSS_THROW("Could not convert row-major matrix.");
auto rslt = spv_function_implementations.insert(spv_func);
if (rslt.second)
Force recompile if we add row-major transpose functions in MSL.
2018-05-04 07:43:34 +00:00
{
CompilerMSL emit no-warning pragma when emitting spvConvertFromRowMajorCxR functions.
2018-01-06 05:51:25 +00:00
add_pragma_line("#pragma clang diagnostic ignored \"-Wmissing-prototypes\"");
Force recompile if we add row-major transpose functions in MSL.
2018-05-04 07:43:34 +00:00
force_recompile = true;
}
CompilerMSL support conversion of non-square row-major matrices.
2018-01-04 21:33:45 +00:00
}
// Wraps the expression string in a function call that converts the
// row_major matrix result of the expression to a column_major matrix.
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 CompilerMSL::convert_row_major_matrix(string exp_str, const SPIRType &exp_type, bool is_packed)
CompilerMSL support conversion of non-square row-major matrices.
2018-01-04 21:33:45 +00:00
{
strip_enclosed_expression(exp_str);
string func_name;
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
// Square and packed matrices can just use transpose
if (exp_type.columns == exp_type.vecsize || is_packed)
CompilerMSL support conversion of non-square row-major matrices.
2018-01-04 21:33:45 +00:00
func_name = "transpose";
else
func_name = string("spvConvertFromRowMajor") + to_string(exp_type.columns) + "x" + to_string(exp_type.vecsize);
return join(func_name, "(", exp_str, ")");
}
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()
{
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 ((get_entry_point().model == ExecutionModelVertex) && stage_out_var_id && !qual_pos_var_name.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
{
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
}
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
// Emit a structure member, padding and packing to maintain the correct memeber alignments.
Updates to MSL functionality to support PR review feedback.
2017-03-11 17:17:22 +00:00
void CompilerMSL::emit_struct_member(const SPIRType &type, uint32_t member_type_id, uint32_t index,
hlsl: Support custom root constant layout
2017-11-27 15:00:56 +00:00
const string &qualifier, uint32_t)
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
auto &membertype = get<SPIRType>(member_type_id);
// If this member requires padding to maintain alignment, emit a dummy padding member.
MSLStructMemberKey key = get_struct_member_key(type.self, index);
uint32_t pad_len = struct_member_padding[key];
if (pad_len > 0)
statement("char pad", to_string(index), "[", to_string(pad_len), "];");
// If this member is packed, mark it as so.
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 pack_pfx = "";
if (member_is_packed_type(type, index))
{
pack_pfx = "packed_";
// If we're packing a matrix, output an appropriate typedef
if (membertype.vecsize > 1 && membertype.columns > 1)
{
string base_type = membertype.width == 16 ? "half" : "float";
string td_line = "typedef ";
td_line += base_type + to_string(membertype.vecsize) + "x" + to_string(membertype.columns);
td_line += " " + pack_pfx;
td_line += base_type + to_string(membertype.columns) + "x" + to_string(membertype.vecsize);
td_line += ";";
add_typedef_line(td_line);
}
}
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
statement(pack_pfx, type_to_glsl(membertype), " ", qualifier, to_member_name(type, index),
CompilerMSL add support for MSL qualifiers on gl_ClipDistance and other array-based builtins.
2017-05-23 17:24:41 +00:00
member_attribute_qualifier(type, index), type_to_array_glsl(membertype), ";");
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);
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
BuiltIn builtin;
bool is_builtin = is_member_builtin(type, index, &builtin);
// 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:
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
}
// Vertex function outputs
if (execution.model == ExecutionModelVertex && type.storage == StorageClassOutput)
{
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
case BuiltInClipDistance:
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
}
// Fragment function inputs
if (execution.model == ExecutionModelFragment && type.storage == StorageClassInput)
{
MSL: Handle interpolation qualifiers.
2018-09-04 21:08:22 +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)
{
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: Handle interpolation qualifiers.
2018-09-04 21:08:22 +00:00
quals = 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
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
{
if (comp != k_unknown_component)
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
}
// 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";
}
}
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)
{
case BuiltInSampleMask:
case BuiltInFragDepth:
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);
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:
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
{
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 &m = ir.meta.at(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)
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 &so_var = get<SPIRVariable>(stage_out_var_id);
auto &so_type = get<SPIRType>(so_var.basetype);
Support returning arrays from functions in GLSL/MSL. Not possible in HLSL apparently, need workaround ...
2018-02-05 08:34:54 +00:00
return_type = type_to_glsl(so_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:
entry_type = "vertex";
break;
case ExecutionModelFragment:
Run format_all.sh.
2018-03-13 13:05:33 +00:00
entry_type =
execution.flags.get(ExecutionModeEarlyFragmentTests) ? "fragment [[ early_fragment_tests ]]" : "fragment";
Run clang-format.
2016-10-24 13:24:24 +00:00
break;
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
}
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
// In MSL, address space qualifiers are required for all pointer or reference arguments
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);
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:
return "threadgroup";
case StorageClassStorageBuffer:
Declare read-only SSBOs as const device in MSL.
2018-05-25 08:03:46 +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
bool readonly = ir.get_buffer_block_flags(argument).get(DecorationNonWritable);
CompilerMSL disable rasterization on buffer writes in vertex shader.
2018-07-27 20:53:36 +00:00
return readonly ? "const device" : "device";
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)
Declare read-only SSBOs as const device in MSL.
2018-05-25 08:03:46 +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
bool readonly = ir.get_buffer_block_flags(argument).get(DecorationNonWritable);
Declare read-only SSBOs as const device in MSL.
2018-05-25 08:03:46 +00:00
return readonly ? "const device" : "device";
}
CompilerMSL disable rasterization on buffer writes in vertex shader.
2018-07-27 20:53:36 +00:00
else
return "constant";
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
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:
// No address space for plain values.
return type.pointer ? "thread" : "";
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
}
return "thread";
}
Initial support for Metal Shading Language.
2016-04-06 21:42:27 +00:00
// Returns a string containing a comma-delimited list of args for the entry point function
string CompilerMSL::entry_point_args(bool append_comma)
{
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 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
// Stage-in structure
if (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
{
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
auto &var = get<SPIRVariable>(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
auto &type = get<SPIRType>(var.basetype);
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
ep_args += type_to_glsl(type) + " " + to_name(var.self) + " [[stage_in]]";
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: 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
{
Format spirv_msl.cpp
2018-01-29 14:42:34 +00:00
Variant *id;
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;
};
vector<Resource> resources;
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 &id : ir.ids)
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 (id.get_type() == TypeVariable)
{
auto &var = id.get<SPIRVariable>();
auto &type = get<SPIRType>(var.basetype);
Format code
2017-01-15 15:39:03 +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
uint32_t var_id = var.self;
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
if ((var.storage == StorageClassUniform || var.storage == StorageClassUniformConstant ||
Add basic support for StorageClassStorageBuffer. Needs more testing, but seems to work.
2017-09-28 11:28:44 +00:00
var.storage == StorageClassPushConstant || var.storage == StorageClassStorageBuffer) &&
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
!is_hidden_variable(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: 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 (type.basetype == SPIRType::SampledImage)
Merge branch 'master' of https://github.com/KhronosGroup/SPIRV-Cross into metalcat # Conflicts: # spirv_msl.cpp
2017-01-26 09:19:26 +00:00
{
Format spirv_msl.cpp
2018-01-29 14:42:34 +00:00
resources.push_back(
{ &id, to_name(var_id), SPIRType::Image, get_metal_resource_index(var, SPIRType::Image) });
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
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
if (type.image.dim != DimBuffer && constexpr_samplers.count(var_id) == 0)
{
Format spirv_msl.cpp
2018-01-29 14:42:34 +00:00
resources.push_back({ &id, to_sampler_expression(var_id), SPIRType::Sampler,
get_metal_resource_index(var, SPIRType::Sampler) });
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +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
}
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
else if (constexpr_samplers.count(var_id) == 0)
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
{
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
// constexpr samplers are not declared as resources.
Format spirv_msl.cpp
2018-01-29 14:42:34 +00:00
resources.push_back(
{ &id, to_name(var_id), type.basetype, get_metal_resource_index(var, type.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
}
}
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
}
}
Format spirv_msl.cpp
2018-01-29 14:42:34 +00:00
std::sort(resources.begin(), resources.end(), [](const Resource &lhs, const Resource &rhs) {
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)
{
auto &var = r.id->get<SPIRVariable>();
auto &type = get<SPIRType>(var.basetype);
uint32_t var_id = var.self;
switch (r.basetype)
{
case SPIRType::Struct:
{
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 &m = ir.meta.at(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.");
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 += ", ";
ep_args += get_argument_address_space(var) + " " + type_to_glsl(type) + "* " + r.name + "_" +
convert_to_string(i);
ep_args += " [[buffer(" + convert_to_string(r.index + i) + ")]]";
}
}
else
{
if (!ep_args.empty())
ep_args += ", ";
ep_args += get_argument_address_space(var) + " " + type_to_glsl(type) + "& " + r.name;
ep_args += " [[buffer(" + convert_to_string(r.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
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:
if (!ep_args.empty())
ep_args += ", ";
Add test for sampler image arrays.
2018-04-03 12:26:24 +00:00
ep_args += image_type_glsl(type, var_id) + " " + 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 += " [[texture(" + convert_to_string(r.index) + ")]]";
break;
default:
SPIRV_CROSS_THROW("Unexpected resource type");
break;
}
}
// Builtin 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
for (auto &id : ir.ids)
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 (id.get_type() == TypeVariable)
{
auto &var = id.get<SPIRVariable>();
uint32_t var_id = var.self;
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
BuiltIn bi_type = ir.meta[var_id].decoration.builtin_type;
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: 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
// Don't emit SamplePosition as a separate parameter. In the entry
// point, we get that by calling get_sample_position() on the sample ID.
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
if (var.storage == StorageClassInput && is_builtin_variable(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
{
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
if (bi_type != BuiltInSamplePosition)
{
if (!ep_args.empty())
ep_args += ", ";
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
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
ep_args += builtin_type_decl(bi_type) + " " + to_expression(var_id);
ep_args += " [[" + builtin_qualifier(bi_type) + "]]";
}
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
auto &entry_func = get<SPIRFunction>(ir.default_entry_point);
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
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), ");");
});
}
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 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
// Vertex and instance index built-ins
if (needs_vertex_idx_arg)
ep_args += built_in_func_arg(BuiltInVertexIndex, !ep_args.empty());
if (needs_instance_idx_arg)
ep_args += built_in_func_arg(BuiltInInstanceIndex, !ep_args.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
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
}
// Returns the Metal index of the resource of the specified type as used by the specified variable.
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 CompilerMSL::get_metal_resource_index(SPIRVariable &var, SPIRType::BaseType basetype)
{
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;
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;
// If a matching binding has been specified, find and use it
for (auto p_res_bind : resource_bindings)
{
if (p_res_bind->stage == execution.model && p_res_bind->desc_set == var_desc_set &&
p_res_bind->binding == var_binding)
{
p_res_bind->used_by_shader = true;
switch (basetype)
{
case SPIRType::Struct:
return p_res_bind->msl_buffer;
case SPIRType::Image:
return p_res_bind->msl_texture;
case SPIRType::Sampler:
return p_res_bind->msl_sampler;
default:
return 0;
}
}
}
Use declared binding in SPIR-V as a fallback for explicit MSL binds.
2018-04-04 08:00:37 +00:00
// If there is no explicit mapping of bindings to MSL, use the declared binding.
if (has_decoration(var.self, DecorationBinding))
return get_decoration(var.self, DecorationBinding);
uint32_t binding_stride = 1;
auto &type = get<SPIRType>(var.basetype);
for (uint32_t i = 0; i < uint32_t(type.array.size()); i++)
binding_stride *= type.array_size_literal[i] ? type.array[i] : get<SPIRConstant>(type.array[i]).scalar();
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 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;
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 (basetype)
{
case SPIRType::Struct:
Use declared binding in SPIR-V as a fallback for explicit MSL binds.
2018-04-04 08:00:37 +00:00
resource_index = next_metal_resource_index.msl_buffer;
next_metal_resource_index.msl_buffer += binding_stride;
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:
Use declared binding in SPIR-V as a fallback for explicit MSL binds.
2018-04-04 08:00:37 +00:00
resource_index = next_metal_resource_index.msl_texture;
next_metal_resource_index.msl_texture += binding_stride;
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::Sampler:
Use declared binding in SPIR-V as a fallback for explicit MSL binds.
2018-04-04 08:00:37 +00:00
resource_index = next_metal_resource_index.msl_sampler;
next_metal_resource_index.msl_sampler += binding_stride;
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:
Use declared binding in SPIR-V as a fallback for explicit MSL binds.
2018-04-04 08:00:37 +00:00
resource_index = 0;
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
}
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
}
string CompilerMSL::argument_decl(const SPIRFunction::Parameter &arg)
{
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
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);
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 = expression_type(arg.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
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;
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 constref = !arg.alias_global_variable && type.pointer && arg.write_count == 0;
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 ";
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: 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 (builtin)
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
decl += builtin_type_decl(static_cast<BuiltIn>(get_decoration(arg.id, DecorationBuiltIn)));
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: 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
bool opaque_handle = type.storage == StorageClassUniformConstant;
if (!builtin && !opaque_handle && !type.pointer &&
(type.storage == StorageClassFunction || type.storage == StorageClassGeneric))
{
// If the argument is a pure value and not an opaque type, we will pass by value.
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);
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: 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 (get<SPIRVariable>(name_id).storage == StorageClassUniform ||
get<SPIRVariable>(name_id).storage == StorageClassStorageBuffer)
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 an array of buffers, declare an array of pointers, since we
// can't have an array of references.
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
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
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
{
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: 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
{
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
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
{
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
string qual_name = ir.meta.at(id).decoration.qualified_alias;
Run clang-format.
2016-10-24 13:24:24 +00:00
if (!qual_name.empty())
return qual_name;
}
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
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
BuiltIn builtin;
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 = {
Run format_all.sh.
2018-04-10 10:32:14 +00:00
"kernel", "vertex", "fragment", "compute", "bias",
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",
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 &id : ir.ids)
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
switch (id.get_type())
{
case TypeVariable:
{
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 &dec = ir.meta[id.get_id()].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
if (keywords.find(dec.alias) != end(keywords))
dec.alias += "0";
break;
}
case TypeFunction:
{
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 &dec = ir.meta[id.get_id()].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
if (illegal_func_names.find(dec.alias) != end(illegal_func_names))
dec.alias += "0";
break;
}
case TypeType:
{
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 &mbr_dec : ir.meta[id.get_id()].members)
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 (keywords.find(mbr_dec.alias) != end(keywords))
mbr_dec.alias += "0";
break;
}
default:
break;
}
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
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: 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
string CompilerMSL::to_member_reference(const SPIRVariable *var, const SPIRType &type, uint32_t index)
{
// If this is a buffer array, we have to dereference the buffer pointers.
if (var && (var->storage == StorageClassUniform || var->storage == StorageClassStorageBuffer) &&
!get<SPIRType>(var->basetype).array.empty())
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
{
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 the pointer type since GLSL doesn't have pointers.
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;
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.
return to_name(type.self);
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";
// Scalars
case SPIRType::Boolean:
type_name = "bool";
break;
case SPIRType::Char:
type_name = "char";
break;
case SPIRType::Int:
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
type_name = (type.width == 8 ? "char" : (type.width == 16 ? "short" : "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:
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
type_name = (type.width == 8 ? "uchar" : (type.width == 16 ? "ushort" : "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:
type_name = "long"; // Currently unsupported
break;
case SPIRType::UInt64:
type_name = "size_t";
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);
return type_name;
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
auto &parent = get<SPIRType>(get_non_pointer_type(type).parent_type);
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
auto &parent = get<SPIRType>(get_non_pointer_type(type).parent_type);
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:
img_type_name += "depth1d_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 Dim2D:
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:
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
img_type_name += (img_type.arrayed ? "depthcube_array" : "depthcube");
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 Dim1D:
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
img_type_name += (img_type.arrayed ? "texture1d_array" : "texture1d");
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 DimBuffer:
case Dim2D:
Begin implementing subpassLoad in MSL.
2018-02-09 10:27:23 +00:00
case DimSubpassData:
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 += "texture2d_ms_array";
}
else if (img_type.ms)
img_type_name += "texture2d_ms";
else if (img_type.arrayed)
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;
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:
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
img_type_name += (img_type.arrayed ? "texturecube_array" : "texturecube");
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
}
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
{
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
if ((out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::Int) ||
(out_type.basetype == SPIRType::Int && in_type.basetype == SPIRType::UInt) ||
(out_type.basetype == SPIRType::UInt64 && in_type.basetype == SPIRType::Int64) ||
(out_type.basetype == SPIRType::Int64 && in_type.basetype == SPIRType::UInt64))
return type_to_glsl(out_type);
if ((out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::Float) ||
(out_type.basetype == SPIRType::Int && in_type.basetype == SPIRType::Float) ||
(out_type.basetype == SPIRType::Float && in_type.basetype == SPIRType::UInt) ||
(out_type.basetype == SPIRType::Float && in_type.basetype == SPIRType::Int) ||
(out_type.basetype == SPIRType::Int64 && in_type.basetype == SPIRType::Double) ||
(out_type.basetype == SPIRType::UInt64 && in_type.basetype == SPIRType::Double) ||
(out_type.basetype == SPIRType::Double && in_type.basetype == SPIRType::Int64) ||
Some compat fixes for MSL and Half.
2018-03-06 16:07:59 +00:00
(out_type.basetype == SPIRType::Double && in_type.basetype == SPIRType::UInt64) ||
(out_type.basetype == SPIRType::Half && in_type.basetype == SPIRType::UInt) ||
(out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::Half))
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
return "as_type<" + type_to_glsl(out_type) + ">";
return "";
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
}
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
// 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:
return "gl_VertexID";
case BuiltInInstanceId:
return "gl_InstanceID";
case BuiltInVertexIndex:
return "gl_VertexIndex";
case BuiltInInstanceIndex:
return "gl_InstanceIndex";
Support the shader_draw_parameters extension.
2018-08-28 18:47:29 +00:00
case BuiltInBaseVertex:
return "gl_BaseVertex";
case BuiltInBaseInstance:
return "gl_BaseInstance";
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: 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 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:
and a bit better case placemenent
2017-12-13 10:03:31 +00:00
case BuiltInFragDepth:
CompilerMSL support gl_SampleMask and convert it to scalar uint from array.
2018-02-13 19:44:40 +00:00
case BuiltInSampleMask:
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
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:
return "position";
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
// 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.");
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: 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";
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
string CompilerMSL::builtin_type_decl(BuiltIn 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
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
// 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";
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] Give the FragDepth builtin a type of float.
2018-08-28 18:47:50 +00:00
// Fragment function out
case BuiltInFragDepth:
return "float";
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:
return "uint";
spirv_msl: Add support for gl_GlobalInvocationId
2017-01-22 18:09:04 +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
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) + "]]";
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
}
spirv_msl only add padding structure members if required by member alignment.
2017-03-06 16:00:23 +00:00
// Returns the byte size of a struct 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
size_t CompilerMSL::get_declared_struct_member_size(const SPIRType &struct_type, uint32_t index) const
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
auto &type = get<SPIRType>(struct_type.member_types[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
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
{
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
// For arrays, we can use ArrayStride to get an easy check.
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
// Runtime arrays will have zero size so force to min of one.
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);
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
return type_struct_member_array_stride(struct_type, index) * max(array_size, 1u);
}
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)
return get_declared_struct_size(type);
spirv_msl only add padding structure members if required by member alignment.
2017-03-06 16:00:23 +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
uint32_t component_size = type.width / 8;
uint32_t vecsize = type.vecsize;
uint32_t columns = type.columns;
// An unpacked 3-element vector or matrix column is the same memory size as a 4-element.
if (vecsize == 3 && !has_member_decoration(struct_type.self, index, DecorationCPacked))
vecsize = 4;
spirv_msl only add padding structure members if required by member alignment.
2017-03-06 16:00:23 +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
return component_size * vecsize * columns;
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
}
// Returns the byte alignment of a struct member.
size_t CompilerMSL::get_declared_struct_member_alignment(const SPIRType &struct_type, uint32_t index) const
{
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
auto &type = get<SPIRType>(struct_type.member_types[index]);
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
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
spirv_msl only add padding structure members if required by member alignment.
2017-03-06 16:00:23 +00:00
case SPIRType::Struct:
return 16; // Per Vulkan spec section 14.5.4
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).
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 (member_is_packed_type(struct_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
return (type.width / 8) * (type.columns == 3 ? 4 : type.columns);
spirv_msl only add padding structure members if required by member alignment.
2017-03-06 16:00:23 +00:00
else
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
return (type.width / 8) * (type.vecsize == 3 ? 4 : type.vecsize);
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
}
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]));
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;
}
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;
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;
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:
CompilerMSL disable rasterization on buffer writes in vertex shader.
2018-07-27 20:53:36 +00:00
uses_atomics = true;
check_resource_write(args[2]);
break;
case OpAtomicLoad:
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;
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;
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
case OpFunctionCall:
{
auto &return_type = compiler.get<SPIRType>(args[0]);
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
if (return_type.array.size() > 1)
{
if (return_type.array.size() > SPVFuncImplArrayCopyMultidimMax)
SPIRV_CROSS_THROW("Cannot support this many dimensions for arrays of arrays.");
return static_cast<SPVFuncImpl>(SPVFuncImplArrayCopyMultidimBase + return_type.array.size());
}
else if (return_type.array.size() > 0)
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
return SPVFuncImplArrayCopy;
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;
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
case OpStore:
{
// Get the result type of the RHS. Since this is run as a pre-processing stage,
// we must extract the result type directly from the Instruction, rather than the ID.
Remove some redundant spvArrayCopy declarations.
2018-07-05 12:43:12 +00:00
uint32_t id_lhs = args[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
uint32_t id_rhs = args[1];
MSL cannot declare inline arrays except in certain cases.
2018-02-08 12:06:29 +00:00
const SPIRType *type = nullptr;
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 (compiler.ir.ids[id_rhs].get_type() != TypeNone)
MSL cannot declare inline arrays except in certain cases.
2018-02-08 12:06:29 +00:00
{
// Could be a constant, or similar.
type = &compiler.expression_type(id_rhs);
}
else
{
// Or ... an expression.
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
uint32_t tid = result_types[id_rhs];
if (tid)
type = &compiler.get<SPIRType>(tid);
MSL cannot declare inline arrays except in certain cases.
2018-02-08 12:06:29 +00:00
}
Remove some redundant spvArrayCopy declarations.
2018-07-05 12:43:12 +00:00
auto *var = compiler.maybe_get<SPIRVariable>(id_lhs);
// Are we simply assigning to a statically assigned variable which takes a constant?
// Don't bother emitting this function.
bool static_expression_lhs =
var && var->storage == StorageClassFunction && var->statically_assigned && var->remapped_variable;
if (type && compiler.is_array(*type) && !static_expression_lhs)
MSL: Support copying array of arrays.
2018-09-11 10:58:03 +00:00
{
if (type->array.size() > 1)
{
if (type->array.size() > SPVFuncImplArrayCopyMultidimMax)
SPIRV_CROSS_THROW("Cannot support this many dimensions for arrays of arrays.");
return static_cast<SPVFuncImpl>(SPVFuncImplArrayCopyMultidimBase + type->array.size());
}
else
return SPVFuncImplArrayCopy;
}
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]];
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
if (tid && compiler.get<SPIRType>(tid).image.dim == DimBuffer)
return SPVFuncImplTexelBufferCoords;
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
if (opcode == OpImageFetch && compiler.msl_options.swizzle_texture_samples)
return SPVFuncImplTextureSwizzle;
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;
}
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
case OpImageSampleExplicitLod:
case OpImageSampleProjExplicitLod:
case OpImageSampleDrefExplicitLod:
case OpImageSampleProjDrefExplicitLod:
case OpImageSampleImplicitLod:
case OpImageSampleProjImplicitLod:
case OpImageSampleDrefImplicitLod:
case OpImageSampleProjDrefImplicitLod:
case OpImageGather:
MSL: Swizzle gathers on depth textures as well. Might as well.
2018-09-29 14:52:26 +00:00
case OpImageDrefGather:
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
if (compiler.msl_options.swizzle_texture_samples)
return SPVFuncImplTextureSwizzle;
break;
MSL: Support array-of-arrays composite construction.
2018-09-12 08:25:51 +00:00
case OpCompositeConstruct:
{
auto &type = compiler.get<SPIRType>(args[0]);
if (type.array.size() > 1) // We need to use copies to build the composite.
return static_cast<SPVFuncImpl>(SPVFuncImplArrayCopyMultidimBase + type.array.size() - 1);
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
{
GLSLstd450 op_450 = static_cast<GLSLstd450>(args[3]);
switch (op_450)
{
case GLSLstd450Radians:
return SPVFuncImplRadians;
case GLSLstd450Degrees:
return SPVFuncImplDegrees;
case GLSLstd450FindILsb:
return SPVFuncImplFindILsb;
case GLSLstd450FindSMsb:
return SPVFuncImplFindSMsb;
case GLSLstd450FindUMsb:
return SPVFuncImplFindUMsb;
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;
}
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();
vector<uint32_t> mbr_idxs(mbr_cnt);
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
iota(mbr_idxs.begin(), mbr_idxs.end(), 0); // Fill with consecutive indices
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
std::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
// 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]];
}
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
Deal with composite constants in variable initializer.
2018-07-05 13:29:49 +00:00
void CompilerMSL::remap_constexpr_sampler(uint32_t 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.");
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
constexpr_samplers[id] = sampler;
}
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:
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;
default:
break;
}
if (expected_type != expr_type.basetype)
expr = bitcast_expression(expr_type, expected_type, expr);
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
{
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:
expected_type = SPIRType::UInt;
break;
default:
break;
}
if (expected_type != expr_type.basetype)
{
auto type = expr_type;
type.basetype = expected_type;
expr = bitcast_expression(type, expr_type.basetype, expr);
}
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
std::string CompilerMSL::to_initializer_expression(const SPIRVariable &var)
{
// 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);
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))
Deal with composite constants in variable initializer.
2018-07-05 13:29:49 +00:00
return constant_expression(get<SPIRConstant>(var.initializer));
else
return CompilerGLSL::to_initializer_expression(var);
}
Reference in New Issue Copy Permalink