mirror of https://github.com/bkaradzic/bgfx
Updated spirv-cross.
This commit is contained in:
Бранимир Караџић
parent
82aeae981b
commit
3ae6bcf37e
|
|
@ -136,6 +136,25 @@ struct CLIParser
|
|||
return uint32_t(val);
|
||||
}
|
||||
|
||||
uint32_t next_hex_uint()
|
||||
{
|
||||
if (!argc)
|
||||
{
|
||||
THROW("Tried to parse uint, but nothing left in arguments");
|
||||
}
|
||||
|
||||
uint64_t val = stoul(*argv, nullptr, 16);
|
||||
if (val > numeric_limits<uint32_t>::max())
|
||||
{
|
||||
THROW("next_uint() out of range");
|
||||
}
|
||||
|
||||
argc--;
|
||||
argv++;
|
||||
|
||||
return uint32_t(val);
|
||||
}
|
||||
|
||||
double next_double()
|
||||
{
|
||||
if (!argc)
|
||||
|
|
@ -535,6 +554,10 @@ struct CLIArguments
|
|||
bool msl_decoration_binding = false;
|
||||
bool msl_force_active_argument_buffer_resources = false;
|
||||
bool msl_force_native_arrays = false;
|
||||
bool msl_enable_frag_depth_builtin = true;
|
||||
bool msl_enable_frag_stencil_ref_builtin = true;
|
||||
uint32_t msl_enable_frag_output_mask = 0xffffffff;
|
||||
bool msl_enable_clip_distance_user_varying = true;
|
||||
bool glsl_emit_push_constant_as_ubo = false;
|
||||
bool glsl_emit_ubo_as_plain_uniforms = false;
|
||||
SmallVector<pair<uint32_t, uint32_t>> glsl_ext_framebuffer_fetch;
|
||||
|
|
@ -638,6 +661,10 @@ static void print_help()
|
|||
"\t[--msl-decoration-binding]\n"
|
||||
"\t[--msl-force-active-argument-buffer-resources]\n"
|
||||
"\t[--msl-force-native-arrays]\n"
|
||||
"\t[--msl-disable-frag-depth-builtin]\n"
|
||||
"\t[--msl-disable-frag-stencil-ref-builtin]\n"
|
||||
"\t[--msl-enable-frag-output-mask <mask>]\n"
|
||||
"\t[--msl-no-clip-distance-user-varying]\n"
|
||||
"\t[--hlsl]\n"
|
||||
"\t[--reflect]\n"
|
||||
"\t[--shader-model]\n"
|
||||
|
|
@ -831,6 +858,10 @@ static string compile_iteration(const CLIArguments &args, std::vector<uint32_t>
|
|||
msl_opts.enable_decoration_binding = args.msl_decoration_binding;
|
||||
msl_opts.force_active_argument_buffer_resources = args.msl_force_active_argument_buffer_resources;
|
||||
msl_opts.force_native_arrays = args.msl_force_native_arrays;
|
||||
msl_opts.enable_frag_depth_builtin = args.msl_enable_frag_depth_builtin;
|
||||
msl_opts.enable_frag_stencil_ref_builtin = args.msl_enable_frag_stencil_ref_builtin;
|
||||
msl_opts.enable_frag_output_mask = args.msl_enable_frag_output_mask;
|
||||
msl_opts.enable_clip_distance_user_varying = args.msl_enable_clip_distance_user_varying;
|
||||
msl_comp->set_msl_options(msl_opts);
|
||||
for (auto &v : args.msl_discrete_descriptor_sets)
|
||||
msl_comp->add_discrete_descriptor_set(v);
|
||||
|
|
@ -1213,6 +1244,13 @@ static int main_inner(int argc, char *argv[])
|
|||
args.msl_inline_uniform_blocks.push_back(make_pair(desc_set, binding));
|
||||
});
|
||||
cbs.add("--msl-force-native-arrays", [&args](CLIParser &) { args.msl_force_native_arrays = true; });
|
||||
cbs.add("--msl-disable-frag-depth-builtin", [&args](CLIParser &) { args.msl_enable_frag_depth_builtin = false; });
|
||||
cbs.add("--msl-disable-frag-stencil-ref-builtin",
|
||||
[&args](CLIParser &) { args.msl_enable_frag_stencil_ref_builtin = false; });
|
||||
cbs.add("--msl-enable-frag-output-mask",
|
||||
[&args](CLIParser &parser) { args.msl_enable_frag_output_mask = parser.next_hex_uint(); });
|
||||
cbs.add("--msl-no-clip-distance-user-varying",
|
||||
[&args](CLIParser &) { args.msl_enable_clip_distance_user_varying = false; });
|
||||
cbs.add("--extension", [&args](CLIParser &parser) { args.extensions.push_back(parser.next_string()); });
|
||||
cbs.add("--rename-entry-point", [&args](CLIParser &parser) {
|
||||
auto old_name = parser.next_string();
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** Copyright (c) 2014-2019 The Khronos Group Inc.
|
||||
** Copyright (c) 2014-2020 The Khronos Group Inc.
|
||||
**
|
||||
** Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
** of this software and/or associated documentation files (the "Materials"),
|
||||
|
|
@ -57,7 +57,7 @@ typedef unsigned int SpvId;
|
|||
#define SPV_REVISION 1
|
||||
|
||||
static const unsigned int SpvMagicNumber = 0x07230203;
|
||||
static const unsigned int SpvVersion = 0x00010400;
|
||||
static const unsigned int SpvVersion = 0x00010500;
|
||||
static const unsigned int SpvRevision = 1;
|
||||
static const unsigned int SpvOpCodeMask = 0xffff;
|
||||
static const unsigned int SpvWordCountShift = 16;
|
||||
|
|
@ -82,11 +82,17 @@ typedef enum SpvExecutionModel_ {
|
|||
SpvExecutionModelKernel = 6,
|
||||
SpvExecutionModelTaskNV = 5267,
|
||||
SpvExecutionModelMeshNV = 5268,
|
||||
SpvExecutionModelRayGenerationKHR = 5313,
|
||||
SpvExecutionModelRayGenerationNV = 5313,
|
||||
SpvExecutionModelIntersectionKHR = 5314,
|
||||
SpvExecutionModelIntersectionNV = 5314,
|
||||
SpvExecutionModelAnyHitKHR = 5315,
|
||||
SpvExecutionModelAnyHitNV = 5315,
|
||||
SpvExecutionModelClosestHitKHR = 5316,
|
||||
SpvExecutionModelClosestHitNV = 5316,
|
||||
SpvExecutionModelMissKHR = 5317,
|
||||
SpvExecutionModelMissNV = 5317,
|
||||
SpvExecutionModelCallableKHR = 5318,
|
||||
SpvExecutionModelCallableNV = 5318,
|
||||
SpvExecutionModelMax = 0x7fffffff,
|
||||
} SpvExecutionModel;
|
||||
|
|
@ -183,11 +189,17 @@ typedef enum SpvStorageClass_ {
|
|||
SpvStorageClassAtomicCounter = 10,
|
||||
SpvStorageClassImage = 11,
|
||||
SpvStorageClassStorageBuffer = 12,
|
||||
SpvStorageClassCallableDataKHR = 5328,
|
||||
SpvStorageClassCallableDataNV = 5328,
|
||||
SpvStorageClassIncomingCallableDataKHR = 5329,
|
||||
SpvStorageClassIncomingCallableDataNV = 5329,
|
||||
SpvStorageClassRayPayloadKHR = 5338,
|
||||
SpvStorageClassRayPayloadNV = 5338,
|
||||
SpvStorageClassHitAttributeKHR = 5339,
|
||||
SpvStorageClassHitAttributeNV = 5339,
|
||||
SpvStorageClassIncomingRayPayloadKHR = 5342,
|
||||
SpvStorageClassIncomingRayPayloadNV = 5342,
|
||||
SpvStorageClassShaderRecordBufferKHR = 5343,
|
||||
SpvStorageClassShaderRecordBufferNV = 5343,
|
||||
SpvStorageClassPhysicalStorageBuffer = 5349,
|
||||
SpvStorageClassPhysicalStorageBufferEXT = 5349,
|
||||
|
|
@ -562,20 +574,35 @@ typedef enum SpvBuiltIn_ {
|
|||
SpvBuiltInFragmentSizeNV = 5292,
|
||||
SpvBuiltInFragInvocationCountEXT = 5293,
|
||||
SpvBuiltInInvocationsPerPixelNV = 5293,
|
||||
SpvBuiltInLaunchIdKHR = 5319,
|
||||
SpvBuiltInLaunchIdNV = 5319,
|
||||
SpvBuiltInLaunchSizeKHR = 5320,
|
||||
SpvBuiltInLaunchSizeNV = 5320,
|
||||
SpvBuiltInWorldRayOriginKHR = 5321,
|
||||
SpvBuiltInWorldRayOriginNV = 5321,
|
||||
SpvBuiltInWorldRayDirectionKHR = 5322,
|
||||
SpvBuiltInWorldRayDirectionNV = 5322,
|
||||
SpvBuiltInObjectRayOriginKHR = 5323,
|
||||
SpvBuiltInObjectRayOriginNV = 5323,
|
||||
SpvBuiltInObjectRayDirectionKHR = 5324,
|
||||
SpvBuiltInObjectRayDirectionNV = 5324,
|
||||
SpvBuiltInRayTminKHR = 5325,
|
||||
SpvBuiltInRayTminNV = 5325,
|
||||
SpvBuiltInRayTmaxKHR = 5326,
|
||||
SpvBuiltInRayTmaxNV = 5326,
|
||||
SpvBuiltInInstanceCustomIndexKHR = 5327,
|
||||
SpvBuiltInInstanceCustomIndexNV = 5327,
|
||||
SpvBuiltInObjectToWorldKHR = 5330,
|
||||
SpvBuiltInObjectToWorldNV = 5330,
|
||||
SpvBuiltInWorldToObjectKHR = 5331,
|
||||
SpvBuiltInWorldToObjectNV = 5331,
|
||||
SpvBuiltInHitTKHR = 5332,
|
||||
SpvBuiltInHitTNV = 5332,
|
||||
SpvBuiltInHitKindKHR = 5333,
|
||||
SpvBuiltInHitKindNV = 5333,
|
||||
SpvBuiltInIncomingRayFlagsKHR = 5351,
|
||||
SpvBuiltInIncomingRayFlagsNV = 5351,
|
||||
SpvBuiltInRayGeometryIndexKHR = 5352,
|
||||
SpvBuiltInWarpsPerSMNV = 5374,
|
||||
SpvBuiltInSMCountNV = 5375,
|
||||
SpvBuiltInWarpIDNV = 5376,
|
||||
|
|
@ -713,6 +740,7 @@ typedef enum SpvScope_ {
|
|||
SpvScopeInvocation = 4,
|
||||
SpvScopeQueueFamily = 5,
|
||||
SpvScopeQueueFamilyKHR = 5,
|
||||
SpvScopeShaderCallKHR = 6,
|
||||
SpvScopeMax = 0x7fffffff,
|
||||
} SpvScope;
|
||||
|
||||
|
|
@ -837,6 +865,8 @@ typedef enum SpvCapability_ {
|
|||
SpvCapabilitySignedZeroInfNanPreserve = 4466,
|
||||
SpvCapabilityRoundingModeRTE = 4467,
|
||||
SpvCapabilityRoundingModeRTZ = 4468,
|
||||
SpvCapabilityRayQueryProvisionalKHR = 4471,
|
||||
SpvCapabilityRayTraversalPrimitiveCullingProvisionalKHR = 4478,
|
||||
SpvCapabilityFloat16ImageAMD = 5008,
|
||||
SpvCapabilityImageGatherBiasLodAMD = 5009,
|
||||
SpvCapabilityFragmentMaskAMD = 5010,
|
||||
|
|
@ -890,6 +920,7 @@ typedef enum SpvCapability_ {
|
|||
SpvCapabilityPhysicalStorageBufferAddresses = 5347,
|
||||
SpvCapabilityPhysicalStorageBufferAddressesEXT = 5347,
|
||||
SpvCapabilityComputeDerivativeGroupLinearNV = 5350,
|
||||
SpvCapabilityRayTracingProvisionalKHR = 5353,
|
||||
SpvCapabilityCooperativeMatrixNV = 5357,
|
||||
SpvCapabilityFragmentShaderSampleInterlockEXT = 5363,
|
||||
SpvCapabilityFragmentShaderShadingRateInterlockEXT = 5372,
|
||||
|
|
@ -907,6 +938,53 @@ typedef enum SpvCapability_ {
|
|||
SpvCapabilityMax = 0x7fffffff,
|
||||
} SpvCapability;
|
||||
|
||||
typedef enum SpvRayFlagsShift_ {
|
||||
SpvRayFlagsOpaqueKHRShift = 0,
|
||||
SpvRayFlagsNoOpaqueKHRShift = 1,
|
||||
SpvRayFlagsTerminateOnFirstHitKHRShift = 2,
|
||||
SpvRayFlagsSkipClosestHitShaderKHRShift = 3,
|
||||
SpvRayFlagsCullBackFacingTrianglesKHRShift = 4,
|
||||
SpvRayFlagsCullFrontFacingTrianglesKHRShift = 5,
|
||||
SpvRayFlagsCullOpaqueKHRShift = 6,
|
||||
SpvRayFlagsCullNoOpaqueKHRShift = 7,
|
||||
SpvRayFlagsSkipTrianglesKHRShift = 8,
|
||||
SpvRayFlagsSkipAABBsKHRShift = 9,
|
||||
SpvRayFlagsMax = 0x7fffffff,
|
||||
} SpvRayFlagsShift;
|
||||
|
||||
typedef enum SpvRayFlagsMask_ {
|
||||
SpvRayFlagsMaskNone = 0,
|
||||
SpvRayFlagsOpaqueKHRMask = 0x00000001,
|
||||
SpvRayFlagsNoOpaqueKHRMask = 0x00000002,
|
||||
SpvRayFlagsTerminateOnFirstHitKHRMask = 0x00000004,
|
||||
SpvRayFlagsSkipClosestHitShaderKHRMask = 0x00000008,
|
||||
SpvRayFlagsCullBackFacingTrianglesKHRMask = 0x00000010,
|
||||
SpvRayFlagsCullFrontFacingTrianglesKHRMask = 0x00000020,
|
||||
SpvRayFlagsCullOpaqueKHRMask = 0x00000040,
|
||||
SpvRayFlagsCullNoOpaqueKHRMask = 0x00000080,
|
||||
SpvRayFlagsSkipTrianglesKHRMask = 0x00000100,
|
||||
SpvRayFlagsSkipAABBsKHRMask = 0x00000200,
|
||||
} SpvRayFlagsMask;
|
||||
|
||||
typedef enum SpvRayQueryIntersection_ {
|
||||
SpvRayQueryIntersectionRayQueryCandidateIntersectionKHR = 0,
|
||||
SpvRayQueryIntersectionRayQueryCommittedIntersectionKHR = 1,
|
||||
SpvRayQueryIntersectionMax = 0x7fffffff,
|
||||
} SpvRayQueryIntersection;
|
||||
|
||||
typedef enum SpvRayQueryCommittedIntersectionType_ {
|
||||
SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR = 0,
|
||||
SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR = 1,
|
||||
SpvRayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR = 2,
|
||||
SpvRayQueryCommittedIntersectionTypeMax = 0x7fffffff,
|
||||
} SpvRayQueryCommittedIntersectionType;
|
||||
|
||||
typedef enum SpvRayQueryCandidateIntersectionType_ {
|
||||
SpvRayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR = 0,
|
||||
SpvRayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR = 1,
|
||||
SpvRayQueryCandidateIntersectionTypeMax = 0x7fffffff,
|
||||
} SpvRayQueryCandidateIntersectionType;
|
||||
|
||||
typedef enum SpvOp_ {
|
||||
SpvOpNop = 0,
|
||||
SpvOpUndef = 1,
|
||||
|
|
@ -1258,6 +1336,13 @@ typedef enum SpvOp_ {
|
|||
SpvOpSubgroupAnyKHR = 4429,
|
||||
SpvOpSubgroupAllEqualKHR = 4430,
|
||||
SpvOpSubgroupReadInvocationKHR = 4432,
|
||||
SpvOpTypeRayQueryProvisionalKHR = 4472,
|
||||
SpvOpRayQueryInitializeKHR = 4473,
|
||||
SpvOpRayQueryTerminateKHR = 4474,
|
||||
SpvOpRayQueryGenerateIntersectionKHR = 4475,
|
||||
SpvOpRayQueryConfirmIntersectionKHR = 4476,
|
||||
SpvOpRayQueryProceedKHR = 4477,
|
||||
SpvOpRayQueryGetIntersectionTypeKHR = 4479,
|
||||
SpvOpGroupIAddNonUniformAMD = 5000,
|
||||
SpvOpGroupFAddNonUniformAMD = 5001,
|
||||
SpvOpGroupFMinNonUniformAMD = 5002,
|
||||
|
|
@ -1272,11 +1357,17 @@ typedef enum SpvOp_ {
|
|||
SpvOpImageSampleFootprintNV = 5283,
|
||||
SpvOpGroupNonUniformPartitionNV = 5296,
|
||||
SpvOpWritePackedPrimitiveIndices4x8NV = 5299,
|
||||
SpvOpReportIntersectionKHR = 5334,
|
||||
SpvOpReportIntersectionNV = 5334,
|
||||
SpvOpIgnoreIntersectionKHR = 5335,
|
||||
SpvOpIgnoreIntersectionNV = 5335,
|
||||
SpvOpTerminateRayKHR = 5336,
|
||||
SpvOpTerminateRayNV = 5336,
|
||||
SpvOpTraceNV = 5337,
|
||||
SpvOpTraceRayKHR = 5337,
|
||||
SpvOpTypeAccelerationStructureKHR = 5341,
|
||||
SpvOpTypeAccelerationStructureNV = 5341,
|
||||
SpvOpExecuteCallableKHR = 5344,
|
||||
SpvOpExecuteCallableNV = 5344,
|
||||
SpvOpTypeCooperativeMatrixNV = 5358,
|
||||
SpvOpCooperativeMatrixLoadNV = 5359,
|
||||
|
|
@ -1433,6 +1524,23 @@ typedef enum SpvOp_ {
|
|||
SpvOpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814,
|
||||
SpvOpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815,
|
||||
SpvOpSubgroupAvcSicGetInterRawSadsINTEL = 5816,
|
||||
SpvOpRayQueryGetRayTMinKHR = 6016,
|
||||
SpvOpRayQueryGetRayFlagsKHR = 6017,
|
||||
SpvOpRayQueryGetIntersectionTKHR = 6018,
|
||||
SpvOpRayQueryGetIntersectionInstanceCustomIndexKHR = 6019,
|
||||
SpvOpRayQueryGetIntersectionInstanceIdKHR = 6020,
|
||||
SpvOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = 6021,
|
||||
SpvOpRayQueryGetIntersectionGeometryIndexKHR = 6022,
|
||||
SpvOpRayQueryGetIntersectionPrimitiveIndexKHR = 6023,
|
||||
SpvOpRayQueryGetIntersectionBarycentricsKHR = 6024,
|
||||
SpvOpRayQueryGetIntersectionFrontFaceKHR = 6025,
|
||||
SpvOpRayQueryGetIntersectionCandidateAABBOpaqueKHR = 6026,
|
||||
SpvOpRayQueryGetIntersectionObjectRayDirectionKHR = 6027,
|
||||
SpvOpRayQueryGetIntersectionObjectRayOriginKHR = 6028,
|
||||
SpvOpRayQueryGetWorldRayDirectionKHR = 6029,
|
||||
SpvOpRayQueryGetWorldRayOriginKHR = 6030,
|
||||
SpvOpRayQueryGetIntersectionObjectToWorldKHR = 6031,
|
||||
SpvOpRayQueryGetIntersectionWorldToObjectKHR = 6032,
|
||||
SpvOpMax = 0x7fffffff,
|
||||
} SpvOp;
|
||||
|
||||
|
|
@ -1810,6 +1918,30 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy
|
|||
case SpvOpTerminateRayNV: *hasResult = false; *hasResultType = false; break;
|
||||
case SpvOpTraceNV: *hasResult = false; *hasResultType = false; break;
|
||||
case SpvOpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break;
|
||||
case SpvOpTypeRayQueryProvisionalKHR: *hasResult = true; *hasResultType = false; break;
|
||||
case SpvOpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break;
|
||||
case SpvOpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break;
|
||||
case SpvOpRayQueryGenerateIntersectionKHR: *hasResult = false; *hasResultType = false; break;
|
||||
case SpvOpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break;
|
||||
case SpvOpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case SpvOpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case SpvOpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case SpvOpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case SpvOpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case SpvOpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case SpvOpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case SpvOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case SpvOpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case SpvOpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case SpvOpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case SpvOpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case SpvOpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case SpvOpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case SpvOpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case SpvOpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case SpvOpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case SpvOpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case SpvOpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case SpvOpExecuteCallableNV: *hasResult = false; *hasResultType = false; break;
|
||||
case SpvOpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break;
|
||||
case SpvOpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break;
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
// Copyright (c) 2014-2019 The Khronos Group Inc.
|
||||
// Copyright (c) 2014-2020 The Khronos Group Inc.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and/or associated documentation files (the "Materials"),
|
||||
|
|
@ -53,7 +53,7 @@ typedef unsigned int Id;
|
|||
#define SPV_REVISION 1
|
||||
|
||||
static const unsigned int MagicNumber = 0x07230203;
|
||||
static const unsigned int Version = 0x00010400;
|
||||
static const unsigned int Version = 0x00010500;
|
||||
static const unsigned int Revision = 1;
|
||||
static const unsigned int OpCodeMask = 0xffff;
|
||||
static const unsigned int WordCountShift = 16;
|
||||
|
|
@ -78,11 +78,17 @@ enum ExecutionModel {
|
|||
ExecutionModelKernel = 6,
|
||||
ExecutionModelTaskNV = 5267,
|
||||
ExecutionModelMeshNV = 5268,
|
||||
ExecutionModelRayGenerationKHR = 5313,
|
||||
ExecutionModelRayGenerationNV = 5313,
|
||||
ExecutionModelIntersectionKHR = 5314,
|
||||
ExecutionModelIntersectionNV = 5314,
|
||||
ExecutionModelAnyHitKHR = 5315,
|
||||
ExecutionModelAnyHitNV = 5315,
|
||||
ExecutionModelClosestHitKHR = 5316,
|
||||
ExecutionModelClosestHitNV = 5316,
|
||||
ExecutionModelMissKHR = 5317,
|
||||
ExecutionModelMissNV = 5317,
|
||||
ExecutionModelCallableKHR = 5318,
|
||||
ExecutionModelCallableNV = 5318,
|
||||
ExecutionModelMax = 0x7fffffff,
|
||||
};
|
||||
|
|
@ -179,11 +185,17 @@ enum StorageClass {
|
|||
StorageClassAtomicCounter = 10,
|
||||
StorageClassImage = 11,
|
||||
StorageClassStorageBuffer = 12,
|
||||
StorageClassCallableDataKHR = 5328,
|
||||
StorageClassCallableDataNV = 5328,
|
||||
StorageClassIncomingCallableDataKHR = 5329,
|
||||
StorageClassIncomingCallableDataNV = 5329,
|
||||
StorageClassRayPayloadKHR = 5338,
|
||||
StorageClassRayPayloadNV = 5338,
|
||||
StorageClassHitAttributeKHR = 5339,
|
||||
StorageClassHitAttributeNV = 5339,
|
||||
StorageClassIncomingRayPayloadKHR = 5342,
|
||||
StorageClassIncomingRayPayloadNV = 5342,
|
||||
StorageClassShaderRecordBufferKHR = 5343,
|
||||
StorageClassShaderRecordBufferNV = 5343,
|
||||
StorageClassPhysicalStorageBuffer = 5349,
|
||||
StorageClassPhysicalStorageBufferEXT = 5349,
|
||||
|
|
@ -558,20 +570,35 @@ enum BuiltIn {
|
|||
BuiltInFragmentSizeNV = 5292,
|
||||
BuiltInFragInvocationCountEXT = 5293,
|
||||
BuiltInInvocationsPerPixelNV = 5293,
|
||||
BuiltInLaunchIdKHR = 5319,
|
||||
BuiltInLaunchIdNV = 5319,
|
||||
BuiltInLaunchSizeKHR = 5320,
|
||||
BuiltInLaunchSizeNV = 5320,
|
||||
BuiltInWorldRayOriginKHR = 5321,
|
||||
BuiltInWorldRayOriginNV = 5321,
|
||||
BuiltInWorldRayDirectionKHR = 5322,
|
||||
BuiltInWorldRayDirectionNV = 5322,
|
||||
BuiltInObjectRayOriginKHR = 5323,
|
||||
BuiltInObjectRayOriginNV = 5323,
|
||||
BuiltInObjectRayDirectionKHR = 5324,
|
||||
BuiltInObjectRayDirectionNV = 5324,
|
||||
BuiltInRayTminKHR = 5325,
|
||||
BuiltInRayTminNV = 5325,
|
||||
BuiltInRayTmaxKHR = 5326,
|
||||
BuiltInRayTmaxNV = 5326,
|
||||
BuiltInInstanceCustomIndexKHR = 5327,
|
||||
BuiltInInstanceCustomIndexNV = 5327,
|
||||
BuiltInObjectToWorldKHR = 5330,
|
||||
BuiltInObjectToWorldNV = 5330,
|
||||
BuiltInWorldToObjectKHR = 5331,
|
||||
BuiltInWorldToObjectNV = 5331,
|
||||
BuiltInHitTKHR = 5332,
|
||||
BuiltInHitTNV = 5332,
|
||||
BuiltInHitKindKHR = 5333,
|
||||
BuiltInHitKindNV = 5333,
|
||||
BuiltInIncomingRayFlagsKHR = 5351,
|
||||
BuiltInIncomingRayFlagsNV = 5351,
|
||||
BuiltInRayGeometryIndexKHR = 5352,
|
||||
BuiltInWarpsPerSMNV = 5374,
|
||||
BuiltInSMCountNV = 5375,
|
||||
BuiltInWarpIDNV = 5376,
|
||||
|
|
@ -709,6 +736,7 @@ enum Scope {
|
|||
ScopeInvocation = 4,
|
||||
ScopeQueueFamily = 5,
|
||||
ScopeQueueFamilyKHR = 5,
|
||||
ScopeShaderCallKHR = 6,
|
||||
ScopeMax = 0x7fffffff,
|
||||
};
|
||||
|
||||
|
|
@ -833,6 +861,8 @@ enum Capability {
|
|||
CapabilitySignedZeroInfNanPreserve = 4466,
|
||||
CapabilityRoundingModeRTE = 4467,
|
||||
CapabilityRoundingModeRTZ = 4468,
|
||||
CapabilityRayQueryProvisionalKHR = 4471,
|
||||
CapabilityRayTraversalPrimitiveCullingProvisionalKHR = 4478,
|
||||
CapabilityFloat16ImageAMD = 5008,
|
||||
CapabilityImageGatherBiasLodAMD = 5009,
|
||||
CapabilityFragmentMaskAMD = 5010,
|
||||
|
|
@ -886,6 +916,7 @@ enum Capability {
|
|||
CapabilityPhysicalStorageBufferAddresses = 5347,
|
||||
CapabilityPhysicalStorageBufferAddressesEXT = 5347,
|
||||
CapabilityComputeDerivativeGroupLinearNV = 5350,
|
||||
CapabilityRayTracingProvisionalKHR = 5353,
|
||||
CapabilityCooperativeMatrixNV = 5357,
|
||||
CapabilityFragmentShaderSampleInterlockEXT = 5363,
|
||||
CapabilityFragmentShaderShadingRateInterlockEXT = 5372,
|
||||
|
|
@ -903,6 +934,53 @@ enum Capability {
|
|||
CapabilityMax = 0x7fffffff,
|
||||
};
|
||||
|
||||
enum RayFlagsShift {
|
||||
RayFlagsOpaqueKHRShift = 0,
|
||||
RayFlagsNoOpaqueKHRShift = 1,
|
||||
RayFlagsTerminateOnFirstHitKHRShift = 2,
|
||||
RayFlagsSkipClosestHitShaderKHRShift = 3,
|
||||
RayFlagsCullBackFacingTrianglesKHRShift = 4,
|
||||
RayFlagsCullFrontFacingTrianglesKHRShift = 5,
|
||||
RayFlagsCullOpaqueKHRShift = 6,
|
||||
RayFlagsCullNoOpaqueKHRShift = 7,
|
||||
RayFlagsSkipTrianglesKHRShift = 8,
|
||||
RayFlagsSkipAABBsKHRShift = 9,
|
||||
RayFlagsMax = 0x7fffffff,
|
||||
};
|
||||
|
||||
enum RayFlagsMask {
|
||||
RayFlagsMaskNone = 0,
|
||||
RayFlagsOpaqueKHRMask = 0x00000001,
|
||||
RayFlagsNoOpaqueKHRMask = 0x00000002,
|
||||
RayFlagsTerminateOnFirstHitKHRMask = 0x00000004,
|
||||
RayFlagsSkipClosestHitShaderKHRMask = 0x00000008,
|
||||
RayFlagsCullBackFacingTrianglesKHRMask = 0x00000010,
|
||||
RayFlagsCullFrontFacingTrianglesKHRMask = 0x00000020,
|
||||
RayFlagsCullOpaqueKHRMask = 0x00000040,
|
||||
RayFlagsCullNoOpaqueKHRMask = 0x00000080,
|
||||
RayFlagsSkipTrianglesKHRMask = 0x00000100,
|
||||
RayFlagsSkipAABBsKHRMask = 0x00000200,
|
||||
};
|
||||
|
||||
enum RayQueryIntersection {
|
||||
RayQueryIntersectionRayQueryCandidateIntersectionKHR = 0,
|
||||
RayQueryIntersectionRayQueryCommittedIntersectionKHR = 1,
|
||||
RayQueryIntersectionMax = 0x7fffffff,
|
||||
};
|
||||
|
||||
enum RayQueryCommittedIntersectionType {
|
||||
RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR = 0,
|
||||
RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR = 1,
|
||||
RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR = 2,
|
||||
RayQueryCommittedIntersectionTypeMax = 0x7fffffff,
|
||||
};
|
||||
|
||||
enum RayQueryCandidateIntersectionType {
|
||||
RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR = 0,
|
||||
RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR = 1,
|
||||
RayQueryCandidateIntersectionTypeMax = 0x7fffffff,
|
||||
};
|
||||
|
||||
enum Op {
|
||||
OpNop = 0,
|
||||
OpUndef = 1,
|
||||
|
|
@ -1254,6 +1332,13 @@ enum Op {
|
|||
OpSubgroupAnyKHR = 4429,
|
||||
OpSubgroupAllEqualKHR = 4430,
|
||||
OpSubgroupReadInvocationKHR = 4432,
|
||||
OpTypeRayQueryProvisionalKHR = 4472,
|
||||
OpRayQueryInitializeKHR = 4473,
|
||||
OpRayQueryTerminateKHR = 4474,
|
||||
OpRayQueryGenerateIntersectionKHR = 4475,
|
||||
OpRayQueryConfirmIntersectionKHR = 4476,
|
||||
OpRayQueryProceedKHR = 4477,
|
||||
OpRayQueryGetIntersectionTypeKHR = 4479,
|
||||
OpGroupIAddNonUniformAMD = 5000,
|
||||
OpGroupFAddNonUniformAMD = 5001,
|
||||
OpGroupFMinNonUniformAMD = 5002,
|
||||
|
|
@ -1268,11 +1353,17 @@ enum Op {
|
|||
OpImageSampleFootprintNV = 5283,
|
||||
OpGroupNonUniformPartitionNV = 5296,
|
||||
OpWritePackedPrimitiveIndices4x8NV = 5299,
|
||||
OpReportIntersectionKHR = 5334,
|
||||
OpReportIntersectionNV = 5334,
|
||||
OpIgnoreIntersectionKHR = 5335,
|
||||
OpIgnoreIntersectionNV = 5335,
|
||||
OpTerminateRayKHR = 5336,
|
||||
OpTerminateRayNV = 5336,
|
||||
OpTraceNV = 5337,
|
||||
OpTraceRayKHR = 5337,
|
||||
OpTypeAccelerationStructureKHR = 5341,
|
||||
OpTypeAccelerationStructureNV = 5341,
|
||||
OpExecuteCallableKHR = 5344,
|
||||
OpExecuteCallableNV = 5344,
|
||||
OpTypeCooperativeMatrixNV = 5358,
|
||||
OpCooperativeMatrixLoadNV = 5359,
|
||||
|
|
@ -1429,6 +1520,23 @@ enum Op {
|
|||
OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814,
|
||||
OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815,
|
||||
OpSubgroupAvcSicGetInterRawSadsINTEL = 5816,
|
||||
OpRayQueryGetRayTMinKHR = 6016,
|
||||
OpRayQueryGetRayFlagsKHR = 6017,
|
||||
OpRayQueryGetIntersectionTKHR = 6018,
|
||||
OpRayQueryGetIntersectionInstanceCustomIndexKHR = 6019,
|
||||
OpRayQueryGetIntersectionInstanceIdKHR = 6020,
|
||||
OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = 6021,
|
||||
OpRayQueryGetIntersectionGeometryIndexKHR = 6022,
|
||||
OpRayQueryGetIntersectionPrimitiveIndexKHR = 6023,
|
||||
OpRayQueryGetIntersectionBarycentricsKHR = 6024,
|
||||
OpRayQueryGetIntersectionFrontFaceKHR = 6025,
|
||||
OpRayQueryGetIntersectionCandidateAABBOpaqueKHR = 6026,
|
||||
OpRayQueryGetIntersectionObjectRayDirectionKHR = 6027,
|
||||
OpRayQueryGetIntersectionObjectRayOriginKHR = 6028,
|
||||
OpRayQueryGetWorldRayDirectionKHR = 6029,
|
||||
OpRayQueryGetWorldRayOriginKHR = 6030,
|
||||
OpRayQueryGetIntersectionObjectToWorldKHR = 6031,
|
||||
OpRayQueryGetIntersectionWorldToObjectKHR = 6032,
|
||||
OpMax = 0x7fffffff,
|
||||
};
|
||||
|
||||
|
|
@ -1806,6 +1914,30 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
|
|||
case OpTerminateRayNV: *hasResult = false; *hasResultType = false; break;
|
||||
case OpTraceNV: *hasResult = false; *hasResultType = false; break;
|
||||
case OpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break;
|
||||
case OpTypeRayQueryProvisionalKHR: *hasResult = true; *hasResultType = false; break;
|
||||
case OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break;
|
||||
case OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break;
|
||||
case OpRayQueryGenerateIntersectionKHR: *hasResult = false; *hasResultType = false; break;
|
||||
case OpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break;
|
||||
case OpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break;
|
||||
case OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break;
|
||||
case OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break;
|
||||
case OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break;
|
||||
|
|
@ -1974,6 +2106,7 @@ inline FunctionControlMask operator|(FunctionControlMask a, FunctionControlMask
|
|||
inline MemorySemanticsMask operator|(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) | unsigned(b)); }
|
||||
inline MemoryAccessMask operator|(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) | unsigned(b)); }
|
||||
inline KernelProfilingInfoMask operator|(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) | unsigned(b)); }
|
||||
inline RayFlagsMask operator|(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) | unsigned(b)); }
|
||||
|
||||
} // end namespace spv
|
||||
|
||||
|
|
|
|||
|
|
@ -530,7 +530,8 @@ struct SPIRType : IVariant
|
|||
Image,
|
||||
SampledImage,
|
||||
Sampler,
|
||||
AccelerationStructureNV,
|
||||
AccelerationStructure,
|
||||
RayQuery,
|
||||
|
||||
// Keep internal types at the end.
|
||||
ControlPointArray,
|
||||
|
|
|
|||
|
|
@ -871,7 +871,7 @@ ShaderResources Compiler::get_shader_resources(const unordered_set<VariableID> *
|
|||
res.atomic_counters.push_back({ var.self, var.basetype, type.self, get_name(var.self) });
|
||||
}
|
||||
// Acceleration structures
|
||||
else if (type.storage == StorageClassUniformConstant && type.basetype == SPIRType::AccelerationStructureNV)
|
||||
else if (type.storage == StorageClassUniformConstant && type.basetype == SPIRType::AccelerationStructure)
|
||||
{
|
||||
res.acceleration_structures.push_back({ var.self, var.basetype, type.self, get_name(var.self) });
|
||||
}
|
||||
|
|
|
|||
|
|
@ -615,6 +615,22 @@ spvc_result spvc_compiler_options_set_uint(spvc_compiler_options options, spvc_c
|
|||
case SPVC_COMPILER_OPTION_MSL_FORCE_NATIVE_ARRAYS:
|
||||
options->msl.force_native_arrays = value != 0;
|
||||
break;
|
||||
|
||||
case SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_OUTPUT_MASK:
|
||||
options->msl.enable_frag_output_mask = value;
|
||||
break;
|
||||
|
||||
case SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_DEPTH_BUILTIN:
|
||||
options->msl.enable_frag_depth_builtin = value != 0;
|
||||
break;
|
||||
|
||||
case SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_STENCIL_REF_BUILTIN:
|
||||
options->msl.enable_frag_stencil_ref_builtin = value != 0;
|
||||
break;
|
||||
|
||||
case SPVC_COMPILER_OPTION_MSL_ENABLE_CLIP_DISTANCE_USER_VARYING:
|
||||
options->msl.enable_clip_distance_user_varying = value != 0;
|
||||
break;
|
||||
#endif
|
||||
|
||||
default:
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@ extern "C" {
|
|||
/* Bumped if ABI or API breaks backwards compatibility. */
|
||||
#define SPVC_C_API_VERSION_MAJOR 0
|
||||
/* Bumped if APIs or enumerations are added in a backwards compatible way. */
|
||||
#define SPVC_C_API_VERSION_MINOR 30
|
||||
#define SPVC_C_API_VERSION_MINOR 33
|
||||
/* Bumped if internal implementation details change. */
|
||||
#define SPVC_C_API_VERSION_PATCH 0
|
||||
|
||||
|
|
@ -210,6 +210,7 @@ typedef enum spvc_resource_type
|
|||
SPVC_RESOURCE_TYPE_SEPARATE_IMAGE = 10,
|
||||
SPVC_RESOURCE_TYPE_SEPARATE_SAMPLERS = 11,
|
||||
SPVC_RESOURCE_TYPE_ACCELERATION_STRUCTURE = 12,
|
||||
SPVC_RESOURCE_TYPE_RAY_QUERY = 13,
|
||||
SPVC_RESOURCE_TYPE_INT_MAX = 0x7fffffff
|
||||
} spvc_resource_type;
|
||||
|
||||
|
|
@ -582,6 +583,11 @@ typedef enum spvc_compiler_option
|
|||
|
||||
SPVC_COMPILER_OPTION_HLSL_NONWRITABLE_UAV_TEXTURE_AS_SRV = 55 | SPVC_COMPILER_OPTION_HLSL_BIT,
|
||||
|
||||
SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_OUTPUT_MASK = 56 | SPVC_COMPILER_OPTION_MSL_BIT,
|
||||
SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_DEPTH_BUILTIN = 57 | SPVC_COMPILER_OPTION_MSL_BIT,
|
||||
SPVC_COMPILER_OPTION_MSL_ENABLE_FRAG_STENCIL_REF_BUILTIN = 58 | SPVC_COMPILER_OPTION_MSL_BIT,
|
||||
SPVC_COMPILER_OPTION_MSL_ENABLE_CLIP_DISTANCE_USER_VARYING = 59 | SPVC_COMPILER_OPTION_MSL_BIT,
|
||||
|
||||
SPVC_COMPILER_OPTION_INT_MAX = 0x7fffffff
|
||||
} spvc_compiler_option;
|
||||
|
||||
|
|
|
|||
|
|
@ -501,6 +501,11 @@ void CompilerGLSL::find_static_extensions()
|
|||
switch (cap)
|
||||
{
|
||||
case CapabilityShaderNonUniformEXT:
|
||||
if (!options.vulkan_semantics)
|
||||
require_extension_internal("GL_NV_gpu_shader5");
|
||||
else
|
||||
require_extension_internal("GL_EXT_nonuniform_qualifier");
|
||||
break;
|
||||
case CapabilityRuntimeDescriptorArrayEXT:
|
||||
if (!options.vulkan_semantics)
|
||||
SPIRV_CROSS_THROW("GL_EXT_nonuniform_qualifier is only supported in Vulkan GLSL.");
|
||||
|
|
@ -525,6 +530,11 @@ string CompilerGLSL::compile()
|
|||
{
|
||||
if (options.vulkan_semantics)
|
||||
backend.allow_precision_qualifiers = true;
|
||||
else
|
||||
{
|
||||
// only NV_gpu_shader5 supports divergent indexing on OpenGL, and it does so without extra qualifiers
|
||||
backend.nonuniform_qualifier = "";
|
||||
}
|
||||
backend.force_gl_in_out_block = true;
|
||||
backend.supports_extensions = true;
|
||||
backend.use_array_constructor = true;
|
||||
|
|
@ -4626,6 +4636,26 @@ SPIRType CompilerGLSL::binary_op_bitcast_helper(string &cast_op0, string &cast_o
|
|||
return expected_type;
|
||||
}
|
||||
|
||||
bool CompilerGLSL::emit_complex_bitcast(uint32_t result_type, uint32_t id, uint32_t op0)
|
||||
{
|
||||
// Some bitcasts may require complex casting sequences, and are implemented here.
|
||||
// Otherwise a simply unary function will do with bitcast_glsl_op.
|
||||
|
||||
auto &output_type = get<SPIRType>(result_type);
|
||||
auto &input_type = expression_type(op0);
|
||||
string expr;
|
||||
|
||||
if (output_type.basetype == SPIRType::Half && input_type.basetype == SPIRType::Float && input_type.vecsize == 1)
|
||||
expr = join("unpackFloat2x16(floatBitsToUint(", to_unpacked_expression(op0), "))");
|
||||
else if (output_type.basetype == SPIRType::Float && input_type.basetype == SPIRType::Half && input_type.vecsize == 2)
|
||||
expr = join("uintBitsToFloat(packFloat2x16(", to_unpacked_expression(op0), "))");
|
||||
else
|
||||
return false;
|
||||
|
||||
emit_op(result_type, id, expr, should_forward(op0));
|
||||
return true;
|
||||
}
|
||||
|
||||
void CompilerGLSL::emit_binary_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1,
|
||||
const char *op, SPIRType::BaseType input_type, bool skip_cast_if_equal_type)
|
||||
{
|
||||
|
|
@ -6683,6 +6713,8 @@ string CompilerGLSL::bitcast_glsl_op(const SPIRType &out_type, const SPIRType &i
|
|||
// And finally, some even more special purpose casts.
|
||||
if (out_type.basetype == SPIRType::UInt64 && in_type.basetype == SPIRType::UInt && in_type.vecsize == 2)
|
||||
return "packUint2x32";
|
||||
else if (out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::UInt64 && out_type.vecsize == 2)
|
||||
return "unpackUint2x32";
|
||||
else if (out_type.basetype == SPIRType::Half && in_type.basetype == SPIRType::UInt && in_type.vecsize == 1)
|
||||
return "unpackFloat2x16";
|
||||
else if (out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::Half && in_type.vecsize == 2)
|
||||
|
|
@ -8545,7 +8577,7 @@ void CompilerGLSL::emit_instruction(const Instruction &instruction)
|
|||
if (expr.expression_dependencies.empty())
|
||||
forwarded_temporaries.erase(ops[1]);
|
||||
|
||||
if (has_decoration(ops[1], DecorationNonUniformEXT) || has_decoration(ops[2], DecorationNonUniformEXT))
|
||||
if (has_decoration(ops[1], DecorationNonUniformEXT))
|
||||
propagate_nonuniform_qualifier(ops[1]);
|
||||
|
||||
break;
|
||||
|
|
@ -9562,8 +9594,11 @@ void CompilerGLSL::emit_instruction(const Instruction &instruction)
|
|||
uint32_t id = ops[1];
|
||||
uint32_t arg = ops[2];
|
||||
|
||||
auto op = bitcast_glsl_op(get<SPIRType>(result_type), expression_type(arg));
|
||||
emit_unary_func_op(result_type, id, arg, op.c_str());
|
||||
if (!emit_complex_bitcast(result_type, id, arg))
|
||||
{
|
||||
auto op = bitcast_glsl_op(get<SPIRType>(result_type), expression_type(arg));
|
||||
emit_unary_func_op(result_type, id, arg, op.c_str());
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -11486,7 +11521,7 @@ string CompilerGLSL::type_to_glsl(const SPIRType &type, uint32_t id)
|
|||
// this distinction into the type system.
|
||||
return comparison_ids.count(id) ? "samplerShadow" : "sampler";
|
||||
|
||||
case SPIRType::AccelerationStructureNV:
|
||||
case SPIRType::AccelerationStructure:
|
||||
return "accelerationStructureNV";
|
||||
|
||||
case SPIRType::Void:
|
||||
|
|
@ -11908,10 +11943,19 @@ void CompilerGLSL::emit_function(SPIRFunction &func, const Bitset &return_flags)
|
|||
// If we don't declare the variable when it is assigned we're forced to go through a helper function
|
||||
// which copies elements one by one.
|
||||
add_local_variable_name(var.self);
|
||||
auto &dominated = entry_block.dominated_variables;
|
||||
if (find(begin(dominated), end(dominated), var.self) == end(dominated))
|
||||
entry_block.dominated_variables.push_back(var.self);
|
||||
var.deferred_declaration = true;
|
||||
|
||||
if (var.initializer)
|
||||
{
|
||||
statement(variable_decl(var), ";");
|
||||
var.deferred_declaration = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
auto &dominated = entry_block.dominated_variables;
|
||||
if (find(begin(dominated), end(dominated), var.self) == end(dominated))
|
||||
entry_block.dominated_variables.push_back(var.self);
|
||||
var.deferred_declaration = true;
|
||||
}
|
||||
}
|
||||
else if (var.storage == StorageClassFunction && var.remapped_variable && var.static_expression)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -514,6 +514,8 @@ protected:
|
|||
SPIRType binary_op_bitcast_helper(std::string &cast_op0, std::string &cast_op1, SPIRType::BaseType &input_type,
|
||||
uint32_t op0, uint32_t op1, bool skip_cast_if_equal_type);
|
||||
|
||||
virtual bool emit_complex_bitcast(uint32_t result_type, uint32_t id, uint32_t op0);
|
||||
|
||||
std::string to_ternary_expression(const SPIRType &result_type, uint32_t select, uint32_t true_value,
|
||||
uint32_t false_value);
|
||||
|
||||
|
|
|
|||
|
|
@ -401,8 +401,12 @@ string CompilerHLSL::type_to_glsl(const SPIRType &type, uint32_t id)
|
|||
case SPIRType::Double:
|
||||
return "double";
|
||||
case SPIRType::Int64:
|
||||
if (hlsl_options.shader_model < 60)
|
||||
SPIRV_CROSS_THROW("64-bit integers only supported in SM 6.0.");
|
||||
return "int64_t";
|
||||
case SPIRType::UInt64:
|
||||
if (hlsl_options.shader_model < 60)
|
||||
SPIRV_CROSS_THROW("64-bit integers only supported in SM 6.0.");
|
||||
return "uint64_t";
|
||||
default:
|
||||
return "???";
|
||||
|
|
@ -1499,6 +1503,24 @@ void CompilerHLSL::emit_resources()
|
|||
statement("");
|
||||
}
|
||||
|
||||
if (requires_uint2_packing)
|
||||
{
|
||||
statement("uint64_t SPIRV_Cross_packUint2x32(uint2 value)");
|
||||
begin_scope();
|
||||
statement("return (uint64_t(value.y) << 32) | uint64_t(value.x);");
|
||||
end_scope();
|
||||
statement("");
|
||||
|
||||
statement("uint2 SPIRV_Cross_unpackUint2x32(uint64_t value)");
|
||||
begin_scope();
|
||||
statement("uint2 Unpacked;");
|
||||
statement("Unpacked.x = uint(value & 0xffffffff);");
|
||||
statement("Unpacked.y = uint(value >> 32);");
|
||||
statement("return Unpacked;");
|
||||
end_scope();
|
||||
statement("");
|
||||
}
|
||||
|
||||
if (requires_explicit_fp16_packing)
|
||||
{
|
||||
// HLSL does not pack into a single word sadly :(
|
||||
|
|
@ -3194,6 +3216,11 @@ void CompilerHLSL::emit_uniform(const SPIRVariable &var)
|
|||
emit_legacy_uniform(var);
|
||||
}
|
||||
|
||||
bool CompilerHLSL::emit_complex_bitcast(uint32_t, uint32_t, uint32_t)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
string CompilerHLSL::bitcast_glsl_op(const SPIRType &out_type, const SPIRType &in_type)
|
||||
{
|
||||
if (out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::Int)
|
||||
|
|
@ -4046,7 +4073,7 @@ void CompilerHLSL::emit_access_chain(const Instruction &instruction)
|
|||
add_implied_read_expression(e, ops[i]);
|
||||
}
|
||||
|
||||
if (has_decoration(ops[1], DecorationNonUniformEXT) || has_decoration(ops[2], DecorationNonUniformEXT))
|
||||
if (has_decoration(ops[1], DecorationNonUniformEXT))
|
||||
propagate_nonuniform_qualifier(ops[1]);
|
||||
}
|
||||
else
|
||||
|
|
@ -4372,6 +4399,27 @@ void CompilerHLSL::emit_instruction(const Instruction &instruction)
|
|||
emit_access_chain(instruction);
|
||||
break;
|
||||
}
|
||||
case OpBitcast:
|
||||
{
|
||||
auto bitcast_type = get_bitcast_type(ops[0], ops[2]);
|
||||
if (bitcast_type == CompilerHLSL::TypeNormal)
|
||||
CompilerGLSL::emit_instruction(instruction);
|
||||
else
|
||||
{
|
||||
if (!requires_uint2_packing)
|
||||
{
|
||||
requires_uint2_packing = true;
|
||||
force_recompile();
|
||||
}
|
||||
|
||||
if (bitcast_type == CompilerHLSL::TypePackUint2x32)
|
||||
emit_unary_func_op(ops[0], ops[1], ops[2], "SPIRV_Cross_packUint2x32");
|
||||
else
|
||||
emit_unary_func_op(ops[0], ops[1], ops[2], "SPIRV_Cross_unpackUint2x32");
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case OpStore:
|
||||
{
|
||||
|
|
@ -5350,3 +5398,18 @@ bool CompilerHLSL::is_hlsl_resource_binding_used(ExecutionModel model, uint32_t
|
|||
auto itr = resource_bindings.find(tuple);
|
||||
return itr != end(resource_bindings) && itr->second.second;
|
||||
}
|
||||
|
||||
CompilerHLSL::BitcastType CompilerHLSL::get_bitcast_type(uint32_t result_type, uint32_t op0)
|
||||
{
|
||||
auto &rslt_type = get<SPIRType>(result_type);
|
||||
auto &expr_type = expression_type(op0);
|
||||
|
||||
if (rslt_type.basetype == SPIRType::BaseType::UInt64 && expr_type.basetype == SPIRType::BaseType::UInt &&
|
||||
expr_type.vecsize == 2)
|
||||
return BitcastType::TypePackUint2x32;
|
||||
else if (rslt_type.basetype == SPIRType::BaseType::UInt && rslt_type.vecsize == 2 &&
|
||||
expr_type.basetype == SPIRType::BaseType::UInt64)
|
||||
return BitcastType::TypeUnpackUint64;
|
||||
|
||||
return BitcastType::TypeNormal;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -216,6 +216,7 @@ private:
|
|||
std::string layout_for_member(const SPIRType &type, uint32_t index) override;
|
||||
std::string to_interpolation_qualifiers(const Bitset &flags) override;
|
||||
std::string bitcast_glsl_op(const SPIRType &result_type, const SPIRType &argument_type) override;
|
||||
bool emit_complex_bitcast(uint32_t result_type, uint32_t id, uint32_t op0) override;
|
||||
std::string to_func_call_arg(const SPIRFunction::Parameter &arg, uint32_t id) override;
|
||||
std::string to_sampler_expression(uint32_t id);
|
||||
std::string to_resource_binding(const SPIRVariable &var);
|
||||
|
|
@ -249,6 +250,7 @@ private:
|
|||
// TODO: Refactor this to be more similar to MSL, maybe have some common system in place?
|
||||
bool requires_op_fmod = false;
|
||||
bool requires_fp16_packing = false;
|
||||
bool requires_uint2_packing = false;
|
||||
bool requires_explicit_fp16_packing = false;
|
||||
bool requires_unorm8_packing = false;
|
||||
bool requires_snorm8_packing = false;
|
||||
|
|
@ -288,6 +290,15 @@ private:
|
|||
QueryTypeCount = 3
|
||||
};
|
||||
|
||||
enum BitcastType
|
||||
{
|
||||
TypeNormal,
|
||||
TypePackUint2x32,
|
||||
TypeUnpackUint64
|
||||
};
|
||||
|
||||
BitcastType get_bitcast_type(uint32_t result_type, uint32_t op0);
|
||||
|
||||
void emit_builtin_variables();
|
||||
bool require_output = false;
|
||||
bool require_input = false;
|
||||
|
|
|
|||
|
|
@ -965,6 +965,16 @@ void CompilerMSL::emit_entry_point_declarations()
|
|||
}
|
||||
// For some reason, without this, we end up emitting the arrays twice.
|
||||
buffer_arrays.clear();
|
||||
|
||||
// Emit disabled fragment outputs.
|
||||
std::sort(disabled_frag_outputs.begin(), disabled_frag_outputs.end());
|
||||
for (uint32_t var_id : disabled_frag_outputs)
|
||||
{
|
||||
auto &var = get<SPIRVariable>(var_id);
|
||||
add_local_variable_name(var_id);
|
||||
statement(variable_decl(var), ";");
|
||||
var.deferred_declaration = false;
|
||||
}
|
||||
}
|
||||
|
||||
string CompilerMSL::compile()
|
||||
|
|
@ -1742,6 +1752,9 @@ void CompilerMSL::add_composite_variable_to_interface_block(StorageClass storage
|
|||
// When we flatten, we flatten directly from the "out" struct,
|
||||
// not from a function variable.
|
||||
flatten_from_ib_var = true;
|
||||
|
||||
if (!msl_options.enable_clip_distance_user_varying)
|
||||
return;
|
||||
}
|
||||
else if (!meta.strip_array)
|
||||
{
|
||||
|
|
@ -1947,6 +1960,9 @@ void CompilerMSL::add_composite_member_variable_to_interface_block(StorageClass
|
|||
// When we flatten, we flatten directly from the "out" struct,
|
||||
// not from a function variable.
|
||||
flatten_from_ib_var = true;
|
||||
|
||||
if (!msl_options.enable_clip_distance_user_varying)
|
||||
return;
|
||||
}
|
||||
|
||||
for (uint32_t i = 0; i < elem_cnt; i++)
|
||||
|
|
@ -2442,6 +2458,7 @@ uint32_t CompilerMSL::add_interface_block(StorageClass storage, bool patch)
|
|||
|
||||
bool is_builtin = is_builtin_variable(var);
|
||||
auto bi_type = BuiltIn(get_decoration(var_id, DecorationBuiltIn));
|
||||
uint32_t location = get_decoration(var_id, DecorationLocation);
|
||||
|
||||
// These builtins are part of the stage in/out structs.
|
||||
bool is_interface_block_builtin =
|
||||
|
|
@ -2467,6 +2484,21 @@ uint32_t CompilerMSL::add_interface_block(StorageClass storage, bool patch)
|
|||
if (bi_type == BuiltInClipDistance)
|
||||
hidden = false;
|
||||
|
||||
// It's not enough to simply avoid marking fragment outputs if the pipeline won't
|
||||
// accept them. We can't put them in the struct at all, or otherwise the compiler
|
||||
// complains that the outputs weren't explicitly marked.
|
||||
if (get_execution_model() == ExecutionModelFragment && storage == StorageClassOutput && !patch &&
|
||||
((is_builtin && ((bi_type == BuiltInFragDepth && !msl_options.enable_frag_depth_builtin) ||
|
||||
(bi_type == BuiltInFragStencilRefEXT && !msl_options.enable_frag_stencil_ref_builtin))) ||
|
||||
(!is_builtin && !(msl_options.enable_frag_output_mask & (1 << location)))))
|
||||
{
|
||||
hidden = true;
|
||||
disabled_frag_outputs.push_back(var_id);
|
||||
// If a builtin, force it to have the proper name.
|
||||
if (is_builtin)
|
||||
set_name(var_id, builtin_to_glsl(bi_type, StorageClassFunction));
|
||||
}
|
||||
|
||||
// Barycentric inputs must be emitted in stage-in, because they can have interpolation arguments.
|
||||
if (is_active && (bi_type == BuiltInBaryCoordNV || bi_type == BuiltInBaryCoordNoPerspNV))
|
||||
{
|
||||
|
|
@ -2496,7 +2528,6 @@ uint32_t CompilerMSL::add_interface_block(StorageClass storage, bool patch)
|
|||
SPIRV_CROSS_THROW("Component decoration is not supported in tessellation shaders.");
|
||||
else if (pack_components)
|
||||
{
|
||||
uint32_t location = get_decoration(var_id, DecorationLocation);
|
||||
auto &location_meta = meta.location_meta[location];
|
||||
location_meta.num_components = std::max(location_meta.num_components, component + type.vecsize);
|
||||
}
|
||||
|
|
@ -3055,10 +3086,20 @@ bool CompilerMSL::validate_member_packing_rules_msl(const SPIRType &type, uint32
|
|||
if (!mbr_type.array.empty())
|
||||
{
|
||||
// If we have an array type, array stride must match exactly with SPIR-V.
|
||||
uint32_t spirv_array_stride = type_struct_member_array_stride(type, index);
|
||||
uint32_t msl_array_stride = get_declared_struct_member_array_stride_msl(type, index);
|
||||
if (spirv_array_stride != msl_array_stride)
|
||||
return false;
|
||||
|
||||
// An exception to this requirement is if we have one array element and a packed decoration.
|
||||
// This comes from DX scalar layout workaround.
|
||||
// If app tries to be cheeky and access the member out of bounds, this will not work, but this is the best we can do.
|
||||
bool relax_array_stride = has_extended_member_decoration(type.self, index, SPIRVCrossDecorationPhysicalTypePacked) &&
|
||||
mbr_type.array.back() == 1 && mbr_type.array_size_literal.back();
|
||||
|
||||
if (!relax_array_stride)
|
||||
{
|
||||
uint32_t spirv_array_stride = type_struct_member_array_stride(type, index);
|
||||
uint32_t msl_array_stride = get_declared_struct_member_array_stride_msl(type, index);
|
||||
if (spirv_array_stride != msl_array_stride)
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (is_matrix(mbr_type))
|
||||
|
|
@ -3170,6 +3211,77 @@ void CompilerMSL::ensure_member_packing_rules_msl(SPIRType &ib_type, uint32_t in
|
|||
else
|
||||
unset_extended_member_decoration(ib_type.self, index, SPIRVCrossDecorationPhysicalTypePacked);
|
||||
}
|
||||
else
|
||||
SPIRV_CROSS_THROW("Found a buffer packing case which we cannot represent in MSL.");
|
||||
|
||||
// Try validating again, now with physical type remapping.
|
||||
if (validate_member_packing_rules_msl(ib_type, index))
|
||||
return;
|
||||
|
||||
// We might have a particular odd scalar layout case where the last element of an array
|
||||
// does not take up as much space as the ArrayStride or MatrixStride. This can happen with DX cbuffers.
|
||||
// The "proper" workaround for this is extremely painful and essentially impossible in the edge case of float3[],
|
||||
// so we hack around it by declaring the offending array or matrix with one less array size/col/row,
|
||||
// and rely on padding to get the correct value. We will technically access arrays out of bounds into the padding region,
|
||||
// but it should spill over gracefully without too much trouble. We rely on behavior like this for unsized arrays anyways.
|
||||
|
||||
// E.g. we might observe a physical layout of:
|
||||
// { float2 a[2]; float b; } in cbuffer layout where ArrayStride of a is 16, but offset of b is 24, packed right after a[1] ...
|
||||
uint32_t type_id = get_extended_member_decoration(ib_type.self, index, SPIRVCrossDecorationPhysicalTypeID);
|
||||
auto &type = get<SPIRType>(type_id);
|
||||
|
||||
// Modify the physical type in-place. This is safe since each physical type workaround is a copy.
|
||||
if (is_array(type))
|
||||
{
|
||||
if (type.array.back() > 1)
|
||||
{
|
||||
if (!type.array_size_literal.back())
|
||||
SPIRV_CROSS_THROW("Cannot apply scalar layout workaround with spec constant array size.");
|
||||
type.array.back() -= 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
// We have an array of size 1, so we cannot decrement that. Our only option now is to
|
||||
// force a packed layout instead, and drop the physical type remap since ArrayStride is meaningless now.
|
||||
unset_extended_member_decoration(ib_type.self, index, SPIRVCrossDecorationPhysicalTypeID);
|
||||
set_extended_member_decoration(ib_type.self, index, SPIRVCrossDecorationPhysicalTypePacked);
|
||||
}
|
||||
}
|
||||
else if (is_matrix(type))
|
||||
{
|
||||
bool row_major = has_member_decoration(ib_type.self, index, DecorationRowMajor);
|
||||
if (!row_major)
|
||||
{
|
||||
// Slice off one column. If we only have 2 columns, this might turn the matrix into a vector with one array element instead.
|
||||
if (type.columns > 2)
|
||||
{
|
||||
type.columns--;
|
||||
}
|
||||
else if (type.columns == 2)
|
||||
{
|
||||
type.columns = 1;
|
||||
assert(type.array.empty());
|
||||
type.array.push_back(1);
|
||||
type.array_size_literal.push_back(true);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Slice off one row. If we only have 2 rows, this might turn the matrix into a vector with one array element instead.
|
||||
if (type.vecsize > 2)
|
||||
{
|
||||
type.vecsize--;
|
||||
}
|
||||
else if (type.vecsize == 2)
|
||||
{
|
||||
type.vecsize = type.columns;
|
||||
type.columns = 1;
|
||||
assert(type.array.empty());
|
||||
type.array.push_back(1);
|
||||
type.array_size_literal.push_back(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// This better validate now, or we must fail gracefully.
|
||||
if (!validate_member_packing_rules_msl(ib_type, index))
|
||||
|
|
@ -8877,12 +8989,23 @@ string CompilerMSL::member_attribute_qualifier(const SPIRType &type, uint32_t in
|
|||
switch (builtin)
|
||||
{
|
||||
case BuiltInFragStencilRefEXT:
|
||||
// Similar to PointSize, only mark FragStencilRef if there's a stencil buffer.
|
||||
// Some shaders may include a FragStencilRef builtin even when used to render
|
||||
// without a stencil attachment, and Metal will reject this builtin
|
||||
// when compiling the shader into a render pipeline that does not set
|
||||
// stencilAttachmentPixelFormat.
|
||||
if (!msl_options.enable_frag_stencil_ref_builtin)
|
||||
return "";
|
||||
if (!msl_options.supports_msl_version(2, 1))
|
||||
SPIRV_CROSS_THROW("Stencil export only supported in MSL 2.1 and up.");
|
||||
return string(" [[") + builtin_qualifier(builtin) + "]]";
|
||||
|
||||
case BuiltInSampleMask:
|
||||
case BuiltInFragDepth:
|
||||
// Ditto FragDepth.
|
||||
if (!msl_options.enable_frag_depth_builtin)
|
||||
return "";
|
||||
/* fallthrough */
|
||||
case BuiltInSampleMask:
|
||||
return string(" [[") + builtin_qualifier(builtin) + "]]";
|
||||
|
||||
default:
|
||||
|
|
@ -8890,6 +9013,9 @@ string CompilerMSL::member_attribute_qualifier(const SPIRType &type, uint32_t in
|
|||
}
|
||||
}
|
||||
uint32_t locn = get_ordered_member_location(type.self, index);
|
||||
// Metal will likely complain about missing color attachments, too.
|
||||
if (locn != k_unknown_location && !(msl_options.enable_frag_output_mask & (1 << locn)))
|
||||
return "";
|
||||
if (locn != k_unknown_location && has_member_decoration(type.self, index, DecorationIndex))
|
||||
return join(" [[color(", locn, "), index(", get_member_decoration(type.self, index, DecorationIndex),
|
||||
")]]");
|
||||
|
|
@ -11220,6 +11346,11 @@ string CompilerMSL::bitcast_glsl_op(const SPIRType &out_type, const SPIRType &in
|
|||
}
|
||||
}
|
||||
|
||||
bool CompilerMSL::emit_complex_bitcast(uint32_t, uint32_t, uint32_t)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// Returns an MSL string identifying the name of a SPIR-V builtin.
|
||||
// Output builtins are qualified with the name of the stage out structure.
|
||||
string CompilerMSL::builtin_to_glsl(BuiltIn builtin, StorageClass storage)
|
||||
|
|
@ -11345,13 +11476,17 @@ string CompilerMSL::builtin_to_glsl(BuiltIn builtin, StorageClass storage)
|
|||
if (!msl_options.supports_msl_version(2, 0))
|
||||
SPIRV_CROSS_THROW("ViewportIndex requires Metal 2.0.");
|
||||
/* fallthrough */
|
||||
case BuiltInFragDepth:
|
||||
case BuiltInFragStencilRefEXT:
|
||||
if ((builtin == BuiltInFragDepth && !msl_options.enable_frag_depth_builtin) ||
|
||||
(builtin == BuiltInFragStencilRefEXT && !msl_options.enable_frag_stencil_ref_builtin))
|
||||
break;
|
||||
/* fallthrough */
|
||||
case BuiltInPosition:
|
||||
case BuiltInPointSize:
|
||||
case BuiltInClipDistance:
|
||||
case BuiltInCullDistance:
|
||||
case BuiltInLayer:
|
||||
case BuiltInFragDepth:
|
||||
case BuiltInFragStencilRefEXT:
|
||||
case BuiltInSampleMask:
|
||||
if (get_execution_model() == ExecutionModelTessellationControl)
|
||||
break;
|
||||
|
|
@ -11775,7 +11910,7 @@ uint32_t CompilerMSL::get_declared_type_matrix_stride_msl(const SPIRType &type,
|
|||
// For packed matrices, we just use the size of the vector type.
|
||||
// Otherwise, MatrixStride == alignment, which is the size of the underlying vector type.
|
||||
if (packed)
|
||||
return (type.width / 8) * (row_major ? type.columns : type.vecsize);
|
||||
return (type.width / 8) * ((row_major && type.columns > 1) ? type.columns : type.vecsize);
|
||||
else
|
||||
return get_declared_type_alignment_msl(type, false, row_major);
|
||||
}
|
||||
|
|
@ -11853,7 +11988,7 @@ uint32_t CompilerMSL::get_declared_type_size_msl(const SPIRType &type, bool is_p
|
|||
uint32_t vecsize = type.vecsize;
|
||||
uint32_t columns = type.columns;
|
||||
|
||||
if (row_major)
|
||||
if (row_major && columns > 1)
|
||||
swap(vecsize, columns);
|
||||
|
||||
if (vecsize == 3)
|
||||
|
|
@ -11914,7 +12049,7 @@ uint32_t CompilerMSL::get_declared_type_alignment_msl(const SPIRType &type, bool
|
|||
else
|
||||
{
|
||||
// This is the general rule for MSL. Size == alignment.
|
||||
uint32_t vecsize = row_major ? type.columns : type.vecsize;
|
||||
uint32_t vecsize = (row_major && type.columns > 1) ? type.columns : type.vecsize;
|
||||
return (type.width / 8) * (vecsize == 3 ? 4 : vecsize);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -268,7 +268,10 @@ public:
|
|||
uint32_t dynamic_offsets_buffer_index = 23;
|
||||
uint32_t shader_input_wg_index = 0;
|
||||
uint32_t device_index = 0;
|
||||
uint32_t enable_frag_output_mask = 0xffffffff;
|
||||
bool enable_point_size_builtin = true;
|
||||
bool enable_frag_depth_builtin = true;
|
||||
bool enable_frag_stencil_ref_builtin = true;
|
||||
bool disable_rasterization = false;
|
||||
bool capture_output_to_buffer = false;
|
||||
bool swizzle_texture_samples = false;
|
||||
|
|
@ -317,6 +320,10 @@ public:
|
|||
// May reduce performance in scenarios where arrays are copied around as value-types.
|
||||
bool force_native_arrays = false;
|
||||
|
||||
// If a shader writes clip distance, also emit user varyings which
|
||||
// can be read in subsequent stages.
|
||||
bool enable_clip_distance_user_varying = true;
|
||||
|
||||
bool is_ios()
|
||||
{
|
||||
return platform == iOS;
|
||||
|
|
@ -628,6 +635,7 @@ protected:
|
|||
bool builtin_translates_to_nonarray(spv::BuiltIn builtin) const override;
|
||||
|
||||
std::string bitcast_glsl_op(const SPIRType &result_type, const SPIRType &argument_type) override;
|
||||
bool emit_complex_bitcast(uint32_t result_id, uint32_t id, uint32_t op0) override;
|
||||
bool skip_argument(uint32_t id) const override;
|
||||
std::string to_member_reference(uint32_t base, const SPIRType &type, uint32_t index, bool ptr_chain) override;
|
||||
std::string to_qualifiers_glsl(uint32_t id) override;
|
||||
|
|
@ -870,6 +878,8 @@ protected:
|
|||
// Must be ordered since array is in a specific order.
|
||||
std::map<SetBindingPair, std::pair<uint32_t, uint32_t>> buffers_requiring_dynamic_offset;
|
||||
|
||||
SmallVector<uint32_t> disabled_frag_outputs;
|
||||
|
||||
std::unordered_set<SetBindingPair, InternalHasher> inline_uniform_blocks;
|
||||
|
||||
uint32_t argument_buffer_ids[kMaxArgumentBuffers];
|
||||
|
|
|
|||
|
|
@ -683,11 +683,19 @@ void Parser::parse(const Instruction &instruction)
|
|||
break;
|
||||
}
|
||||
|
||||
case OpTypeAccelerationStructureNV:
|
||||
case OpTypeAccelerationStructureKHR:
|
||||
{
|
||||
uint32_t id = ops[0];
|
||||
auto &type = set<SPIRType>(id);
|
||||
type.basetype = SPIRType::AccelerationStructureNV;
|
||||
type.basetype = SPIRType::AccelerationStructure;
|
||||
break;
|
||||
}
|
||||
|
||||
case OpTypeRayQueryProvisionalKHR:
|
||||
{
|
||||
uint32_t id = ops[0];
|
||||
auto &type = set<SPIRType>(id);
|
||||
type.basetype = SPIRType::RayQuery;
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -601,6 +601,7 @@ void CompilerReflection::emit_specialization_constants()
|
|||
auto &c = get<SPIRConstant>(spec_const.id);
|
||||
auto type = get<SPIRType>(c.constant_type);
|
||||
json_stream->begin_json_object();
|
||||
json_stream->emit_json_key_value("name", get_name(spec_const.id));
|
||||
json_stream->emit_json_key_value("id", spec_const.constant_id);
|
||||
json_stream->emit_json_key_value("type", type_to_glsl(type));
|
||||
json_stream->emit_json_key_value("variable_id", spec_const.id);
|
||||
|
|
|
|||
Loading…
Reference in New Issue