From 457b455042027dff94f47612fc79f5c6b166edfd Mon Sep 17 00:00:00 2001 From: kotofyt Date: Sun, 12 Apr 2026 14:52:33 +0300 Subject: [PATCH] Shader linking i guess --- .gitmodules | 3 + external/SPIRV-Headers | 1 + funnyassets/shaders/funny_basic_pbr.shader | 14 + funnyassets/shaders/funny_error.shader | 4 +- funnyassets/shaders/funny_shared.hlsl | 10 + funnyassets/shaders/macros.hlsl | 32 +- funnyassets/shaders/mesh_raster.shader | 4 + funnyassets/shaders/mesh_trace.shader | 11 + funnyassets/shaders/mesh_trace_gen.h | 0 game/client/milmoba/player.cpp | 15 - game/client/worldrender.cpp | 12 +- game/server/light.cpp | 23 + game/server/light.h | 27 + game/server/milmoba/player.cpp | 31 +- game/server/milmoba/player.h | 6 +- game/server/pointentity.cpp | 1 + game/shared/datamap.h | 6 +- game/shared/light.h | 10 + game/shared/netmap.h | 10 +- materialsystem/build.cpp | 4 + materialsystem/compiledshader.cpp | 4 + materialsystem/stdshaders/flat.ini | 18 - materialsystem/vulkan/generate.build.cpp | 105 + materialsystem/vulkan/rendercontext.cpp | 22 +- materialsystem/vulkan/rtlinker.cpp | 249 + materialsystem/vulkan/rtlinker.h | 28 + materialsystem/vulkan/rtlinker_gen.cpp | 11197 +++++++++++++++++++ materialsystem/vulkan/rtlinker_gen.h | 5 + materialsystem/vulkan/rtlinker_shared.h | 25 + materialsystem/vulkan/rtshader.cpp | 68 + materialsystem/vulkan/vulkan_state.h | 53 +- minispv/minispv.h | 507 + public/iphysics.h | 8 +- public/materialsystem/imaterialsystem.h | 17 +- rapier/physics.cpp | 14 +- rapier/physics.h | 11 +- rapier/physics.rs | 56 +- shadercompiler/slang/vulkan_spirv.cpp | 37 +- 38 files changed, 12534 insertions(+), 114 deletions(-) create mode 160000 external/SPIRV-Headers create mode 100644 funnyassets/shaders/funny_basic_pbr.shader create mode 100644 funnyassets/shaders/funny_shared.hlsl create mode 100644 funnyassets/shaders/mesh_trace_gen.h create mode 100644 game/server/light.cpp create mode 100644 game/server/light.h create mode 100644 game/shared/light.h delete mode 100644 materialsystem/stdshaders/flat.ini create mode 100644 materialsystem/vulkan/generate.build.cpp create mode 100644 materialsystem/vulkan/rtlinker.cpp create mode 100644 materialsystem/vulkan/rtlinker.h create mode 100644 materialsystem/vulkan/rtlinker_gen.cpp create mode 100644 materialsystem/vulkan/rtlinker_gen.h create mode 100644 materialsystem/vulkan/rtlinker_shared.h create mode 100644 materialsystem/vulkan/rtshader.cpp create mode 100644 minispv/minispv.h diff --git a/.gitmodules b/.gitmodules index 403cafd..0ea64dc 100644 --- a/.gitmodules +++ b/.gitmodules @@ -34,3 +34,6 @@ [submodule "external/SPIRV-Tools"] path = external/SPIRV-Tools url = https://github.com/KoT3isGood/SPIRV-Tools.git +[submodule "external/SPIRV-Headers"] + path = external/SPIRV-Headers + url = https://github.com/KhronosGroup/SPIRV-Headers diff --git a/external/SPIRV-Headers b/external/SPIRV-Headers new file mode 160000 index 0000000..6dd7ba9 --- /dev/null +++ b/external/SPIRV-Headers @@ -0,0 +1 @@ +Subproject commit 6dd7ba990830f7c15ac1345ff3b43ef6ffdad216 diff --git a/funnyassets/shaders/funny_basic_pbr.shader b/funnyassets/shaders/funny_basic_pbr.shader new file mode 100644 index 0000000..f40afb5 --- /dev/null +++ b/funnyassets/shaders/funny_basic_pbr.shader @@ -0,0 +1,14 @@ +#include "macros.hlsl" + +COMMON +{ + +} +CALLABLE +{ + #include "textures.hlsl" + float4 brdfMain() + { + return float4(1); + } +} diff --git a/funnyassets/shaders/funny_error.shader b/funnyassets/shaders/funny_error.shader index 2868b52..f28d341 100644 --- a/funnyassets/shaders/funny_error.shader +++ b/funnyassets/shaders/funny_error.shader @@ -1,8 +1,8 @@ #include "macros.hlsl" -BRDF +CALLABLE { - float4 brdfMain() + float4 CallableMain() { return float4(1); } diff --git a/funnyassets/shaders/funny_shared.hlsl b/funnyassets/shaders/funny_shared.hlsl new file mode 100644 index 0000000..e9ac117 --- /dev/null +++ b/funnyassets/shaders/funny_shared.hlsl @@ -0,0 +1,10 @@ +#ifndef FUNNY_SHARED_HLSL +#define FUNNY_SHARED_HLSL + +struct FunnyShaderInput_t +{ + uint m_uInstance; + float2 m_vTexcoord; +} + +#endif diff --git a/funnyassets/shaders/macros.hlsl b/funnyassets/shaders/macros.hlsl index 4f4e33b..7625fb4 100644 --- a/funnyassets/shaders/macros.hlsl +++ b/funnyassets/shaders/macros.hlsl @@ -16,15 +16,37 @@ #endif #ifdef RAY_SHADER -#define RAY using namespace RAYShader; namespace RAYShader +#define RAY using namespace RayShader; namespace RayShader #else -#define RAY namespace RAYShader_DO_NOT_USE +#define RAY namespace RayShader_DO_NOT_USE #endif -#ifdef BRDF_SHADER -#define BRDF using namespace BRDFShader; namespace BRDFShader +#ifdef CALLABLE_SHADER +#define CALLABLE using namespace CallableShader; namespace CallableShader #else -#define BRDF namespace BRDFShader_DO_NOT_USE +#define CALLABLE namespace CallableShader_DO_NOT_USE #endif +float4 Test() +{ + return float4(1,0.5,1,1); +} + +#ifndef USE_CALLABLE_SHADERS +#define USE_CALLABLE_SHADERS +#endif + +struct RunShaderResult_t +{ + A val; + +}; + +[noinline] +[builtin] +RunShaderResult_t RunShader( uint32_t id, B data ) where optional B +{ + return {}; +} + #endif diff --git a/funnyassets/shaders/mesh_raster.shader b/funnyassets/shaders/mesh_raster.shader index 6ec5759..9e63b08 100644 --- a/funnyassets/shaders/mesh_raster.shader +++ b/funnyassets/shaders/mesh_raster.shader @@ -1,4 +1,8 @@ #include "macros.hlsl" +#include "funny_shared.hlsl" + + +USE_CALLABLE_SHADERS; COMMON { cbuffer CameraInfo diff --git a/funnyassets/shaders/mesh_trace.shader b/funnyassets/shaders/mesh_trace.shader index 2550396..4bcb5f6 100644 --- a/funnyassets/shaders/mesh_trace.shader +++ b/funnyassets/shaders/mesh_trace.shader @@ -5,6 +5,11 @@ struct MeshPayload { float3 m_vColor; } +struct RayPayload +{ + float3 m_vOrigin; + float3 m_vDirection; +}; RAY { @@ -14,8 +19,14 @@ RAY RWTexture2D g_tIndirectImage; + void rayMain() { + RayPayload p = {}; + RunShaderResult_t m = RunShader(0, p); + m.val.m_vColor; + printf("%f\n", m.val.m_vColor.x); + /* uint2 pixel = DispatchRaysIndex().xy; MeshPayload p; diff --git a/funnyassets/shaders/mesh_trace_gen.h b/funnyassets/shaders/mesh_trace_gen.h new file mode 100644 index 0000000..e69de29 diff --git a/game/client/milmoba/player.cpp b/game/client/milmoba/player.cpp index 1659fa2..681d986 100644 --- a/game/client/milmoba/player.cpp +++ b/game/client/milmoba/player.cpp @@ -18,27 +18,12 @@ void C_MOBAPlayer::Spawn() void C_MOBAPlayer::Think( float fDelta ) { -<<<<<<< HEAD - C_MOBAPlayer *pEntity = (C_MOBAPlayer*)UTIL_GetLocalPlayer(); - -<<<<<<< HEAD -======= -======= C_MOBAPlayer *pPlayerEntity = (C_MOBAPlayer*)UTIL_GetLocalPlayer(); -<<<<<<< HEAD ->>>>>>> c251089 (different stuff in physics) ->>>>>>> a2652ed (merges) - m_vMovementVector.z = m_bIsForward - m_bIsBack; - m_vMovementVector.x = m_bIsLeft - m_bIsRight; - - if (pEntity == this) -======= m_vMovementVector.z = m_bIsBack - m_bIsForward; m_vMovementVector.x = m_bIsRight - m_bIsLeft; if (pPlayerEntity == this) ->>>>>>> 83e8198 (different stuff in physics) { Vector vCameraPos; vCameraPos = GetAbsOrigin(); diff --git a/game/client/worldrender.cpp b/game/client/worldrender.cpp index 88fd6b5..c5a31b1 100644 --- a/game/client/worldrender.cpp +++ b/game/client/worldrender.cpp @@ -104,7 +104,7 @@ void CFunnyMeshInstance::Frame() glm_scale_make(m, v); glm_mat4_mul(m_data.m_matTranslation, m, m_data.m_matTranslation); - m_data.m_uAlbedo = 1; + m_data.m_uAlbedo = 0; /* V_printf("AAAAA %f %f %f %f\n", m_data.m_matTranslation[0][0], m_data.m_matTranslation[0][1], m_data.m_matTranslation[0][2], m_data.m_matTranslation[0][3]); V_printf("AAAAA %f %f %f %f\n", m_data.m_matTranslation[1][0], m_data.m_matTranslation[1][1], m_data.m_matTranslation[1][2], m_data.m_matTranslation[1][3]); @@ -213,6 +213,10 @@ void CFunnyWorldRenderer::Init() m_pRasterCommandList = g_pRenderContext->CreateCommandList(); m_pViewBuffer = g_pRenderContext->CreateConstantBuffer(sizeof(ViewBuffer_t)); m_pTextures = g_pRenderContext->CreateTextureArray(); + + IRayTracingShader *prt = g_pRenderContext->CreateRayShader("game/core/shaders/mesh_trace.shader_c"); + prt->AddShader("error", "game/core/shaders/funny_error.shader_c"); + prt->Build(); } void CFunnyWorldRenderer::Tick( float fDelta ) @@ -228,13 +232,7 @@ void CFunnyWorldRenderer::Frame( float fDelta ) glm_mat4_identity(matCamera); glm_mat4_identity(matCamera2); glm_translate(matCamera2, m_vPos); -<<<<<<< HEAD -======= -<<<<<<< HEAD -======= glm_mat4_inv(matCamera2, matCamera2); ->>>>>>> c251089 (different stuff in physics) ->>>>>>> a2652ed (merges) glm_perspective(glm_rad(75), uWidth/(float)uHeight, 0.01, 10000, matCamera); glm_mul(matCamera, matCamera2, matCamera); m_pViewBufferData = (ViewBuffer_t*)m_pViewBuffer->Map(); diff --git a/game/server/light.cpp b/game/server/light.cpp new file mode 100644 index 0000000..ca2e1d7 --- /dev/null +++ b/game/server/light.cpp @@ -0,0 +1,23 @@ +#include "light.h" + +BEGIN_DATADESC(CBaseLight) + DEFINE_KEYFIELD(m_vColor, FIELD_COLOR4, "color") + DEFINE_KEYFIELD(m_fBrightness, FIELD_FLOAT, "brightness") + DEFINE_KEYFIELD(m_fRadius, FIELD_FLOAT, "radius") + DEFINE_KEYFIELD(m_eLightFlags, FIELD_INTEGER, "light_flags") + DEFINE_KEYFIELD(m_bIsEnabled, FIELD_BOOLEAN, "enabled") +END_DATADESC() + +IMPLEMENT_SEND_DT(CBaseLight) + NetPropColor4(m_vColor), + NetPropFloat(m_fBrightness), + NetPropFloat(m_fRadius), + NetPropInt(m_eLightFlags), + NetPropBool(m_bIsEnabled), +END_SEND_DT() + +IMPLEMENT_EMPTY_RECV_DT(CBaseLight) + + + +LINK_ENTITY_TO_CLASS(light_point, CPointLight); diff --git a/game/server/light.h b/game/server/light.h new file mode 100644 index 0000000..184771a --- /dev/null +++ b/game/server/light.h @@ -0,0 +1,27 @@ +#ifndef LIGHT_H +#define LIGHT_H + +#include "pointentity.h" +#include "../shared/light.h" + +class CBaseLight: public CPointEntity +{ +public: + DECLARE_CLASS(CBaseLight, CPointEntity) + DECLARE_DATADESC() + DECLARE_SERVERCLASS() + + ColorAlpha m_vColor; + float m_fBrightness; + float m_fRadius; + int m_eLightFlags; + bool m_bIsEnabled; +}; + +class CPointLight: public CBaseLight +{ +public: + DECLARE_CLASS(CPointLight, CBaseLight); +}; + +#endif diff --git a/game/server/milmoba/player.cpp b/game/server/milmoba/player.cpp index 05a6ca4..4149cfd 100644 --- a/game/server/milmoba/player.cpp +++ b/game/server/milmoba/player.cpp @@ -5,7 +5,8 @@ CMOBAPlayer::CMOBAPlayer() { - m_hCuboid = g_pPhysics->CreateBall({1}); + m_hCuboid = g_pPhysics->CreateCube({1,1,1}); + } CMOBAPlayer::~CMOBAPlayer() @@ -16,25 +17,16 @@ CMOBAPlayer::~CMOBAPlayer() void CMOBAPlayer::Spawn() { CBaseEntity::Spawn(); -<<<<<<< HEAD -======= -<<<<<<< HEAD ->>>>>>> a2652ed (merges) - SetPhysics(k_EPhysics_Static); SetModel("game/core/models/sphere.fmdl"); - SetScale(1); - SetAbsOrigin({0,-14.5, 0}); -<<<<<<< HEAD -======= -======= - SetModel("game/core/models/sphere.fmdl"); - SetScale(1); SetAbsOrigin({0,-11.5, 0}); ->>>>>>> c251089 (different stuff in physics) ->>>>>>> a2652ed (merges) SetThink(Think); }; +bool CMOBAPlayer::CheckMask( HCollider hCollider ) +{ + return true; +}; + void CMOBAPlayer::Think( float fDelta ) { BaseClass::Think(fDelta); @@ -47,18 +39,11 @@ void CMOBAPlayer::Think( float fDelta ) vPosition.x += m_vMovementVector.x*fDelta*5; vPosition.z += m_vMovementVector.z*fDelta*5; -<<<<<<< HEAD - SetAbsOrigin(vPosition); -<<<<<<< HEAD -======= -======= - CastResult_t result = g_pPhysicsWorld->ShapeCast(m_hCuboid, {0,0,0,1}, vPosition, {vPosition.x, vPosition.y, -100}); + CastResult_t result = g_pPhysicsWorld->ShapeCast(m_hCuboid, {0,0,0,1}, vPosition, {vPosition.x, vPosition.y, -100}, CheckMask); if (result.m_bIsHit) SetAbsOrigin(result.m_vCollisionPoint); else SetAbsOrigin(vPosition); ->>>>>>> c251089 (different stuff in physics) ->>>>>>> a2652ed (merges) }; LINK_ENTITY_TO_CLASS(player, CMOBAPlayer) diff --git a/game/server/milmoba/player.h b/game/server/milmoba/player.h index 6f3e12d..2759abd 100644 --- a/game/server/milmoba/player.h +++ b/game/server/milmoba/player.h @@ -3,10 +3,10 @@ #include "physicsprop.h" -class CMOBAPlayer: public CPhysicsProp +class CMOBAPlayer: public CBaseModelEntity { public: - DECLARE_CLASS(CMOBAPlayer, CPhysicsProp); + DECLARE_CLASS(CMOBAPlayer, CBaseModelEntity); DECLARE_DATADESC(); DECLARE_SERVERCLASS() @@ -14,6 +14,8 @@ public: virtual ~CMOBAPlayer(); virtual void Spawn( void ) override; void Think( float fDelta ); + + static bool CheckMask( HCollider hCollider ); private: Vector m_vMovementVector = {}; diff --git a/game/server/pointentity.cpp b/game/server/pointentity.cpp index 6bc3868..22cb4ed 100644 --- a/game/server/pointentity.cpp +++ b/game/server/pointentity.cpp @@ -1 +1,2 @@ #include "pointentity.h" + diff --git a/game/shared/datamap.h b/game/shared/datamap.h index 3198aba..33af661 100644 --- a/game/shared/datamap.h +++ b/game/shared/datamap.h @@ -21,12 +21,14 @@ enum fieldtype_t { FIELD_FLOAT4, FIELD_QUATERNION, FIELD_QUATERNION_QANGLE, - FIELD_COLOR255, - FIELD_COLOR1, + FIELD_COLOR3, + FIELD_COLOR4, FIELD_INTEGER, FIELD_BOOLEAN, FIELD_MAT4x4, + FIELD_FLAGS, + FIELD_MATERIAL, FIELD_TEXTURE, FIELD_MODEL, diff --git a/game/shared/light.h b/game/shared/light.h new file mode 100644 index 0000000..38584a8 --- /dev/null +++ b/game/shared/light.h @@ -0,0 +1,10 @@ +#ifndef SHARED_LIGHT_H +#define SHARED_LIGHT_H + +enum ELightFlags +{ + k_ELight_Shadows = 0x1, + k_ELight_Radiance = 0x2, +}; + +#endif diff --git a/game/shared/netmap.h b/game/shared/netmap.h index 5728a47..577da89 100644 --- a/game/shared/netmap.h +++ b/game/shared/netmap.h @@ -26,7 +26,8 @@ struct netmap_t uint32_t m_uFieldCount; }; -#define NetPropInt(name) { #name, FIELD_INT, _class_offsetof(ThisClass, name), sizeof(name)} +#define NetPropInt(name) { #name, FIELD_INTEGER, _class_offsetof(ThisClass, name), sizeof(name)} +#define NetPropBool(name) { #name, FIELD_BOOLEAN, _class_offsetof(ThisClass, name), sizeof(name)} #define NetPropString(name) { #name, FIELD_STRING, _class_offsetof(ThisClass, name), sizeof(name)} #define NetPropFloat(name) { #name, FIELD_FLOAT, _class_offsetof(ThisClass, name), sizeof(name)} #define NetPropFloat3(name) \ @@ -37,7 +38,12 @@ struct netmap_t NetPropFloat(name.x), \ NetPropFloat(name.y), \ NetPropFloat(name.z), \ - NetPropFloat(name.w) \ + NetPropFloat(name.w) +#define NetPropColor4(name) \ + NetPropFloat(name.r), \ + NetPropFloat(name.g), \ + NetPropFloat(name.b), \ + NetPropFloat(name.a) #define __DECLARE_NETCLASS_NOBASE() \ netmap_t *GetBaseSendMap(); \ diff --git a/materialsystem/build.cpp b/materialsystem/build.cpp index 208ec60..c85e45c 100644 --- a/materialsystem/build.cpp +++ b/materialsystem/build.cpp @@ -9,6 +9,7 @@ ADD_DEPENDENCY_BUILD_FILE(cfg, "../buildcfg.cpp"); ADD_DEPENDENCY_BUILD_FILE(tier0, FUNNYSTDLIB"tier0/build.cpp"); ADD_DEPENDENCY_BUILD_FILE(tier1, FUNNYSTDLIB"tier1/build.cpp"); ADD_DEPENDENCY_BUILD_FILE(tier2, FUNNYSTDLIB"tier2/build.cpp"); +ADD_DEPENDENCY_BUILD_FILE(gen, "vulkan/generate.build.cpp"); CUtlVector MaterialSystem_CompiledFiles = { "materialsystem.cpp", @@ -22,8 +23,11 @@ CUtlVector RenderContextVulkan_CompiledFiles = { "vulkan/rendercommandlist.cpp", "vulkan/material.cpp", "vulkan/shader.cpp", + "vulkan/rtshader.cpp", "vulkan/utils.cpp", "vulkan/vma.cpp", + "vulkan/rtlinker.cpp", + "vulkan/rtlinker_gen.cpp", "vulkan/commands/draw.cpp", "vulkan/commands/transfer.cpp", "vulkan/commands/base.cpp", diff --git a/materialsystem/compiledshader.cpp b/materialsystem/compiledshader.cpp index aeb7ced..18ccd46 100644 --- a/materialsystem/compiledshader.cpp +++ b/materialsystem/compiledshader.cpp @@ -28,8 +28,12 @@ ShaderObject_t *CCompiledShader::AllocateShader() ShaderObject_t *CCompiledShader::FindShaderObject( EShaderBackend eBackend, EShaderStage eStage ) { + V_printf("%i\n", m_objects.GetSize()); + V_printf("%i\n", m_lumps.GetSize()); for ( auto &o: m_objects ) { + V_printf("%i\n", o.m_eBackend); + V_printf("%i\n", o.m_eStage); if ( o.m_eBackend != eBackend ) continue; diff --git a/materialsystem/stdshaders/flat.ini b/materialsystem/stdshaders/flat.ini deleted file mode 100644 index 4829c04..0000000 --- a/materialsystem/stdshaders/flat.ini +++ /dev/null @@ -1,18 +0,0 @@ -[Shaders] - - -[Raster.Input.Triangle] -VertexSize = 20 -Index = RGB32_UINT -Position = RGB32_SFLOAT -UV = RG32_SFLOAT - -[Raster.Parameters] -TextureAtlas = true - -[Raster.Outputs] -Color0 = RGBA16_SRGB -Depth = D32_SFLOAT - -[Shading.Parameters] -TextureAtlas = true diff --git a/materialsystem/vulkan/generate.build.cpp b/materialsystem/vulkan/generate.build.cpp new file mode 100644 index 0000000..ac7fc85 --- /dev/null +++ b/materialsystem/vulkan/generate.build.cpp @@ -0,0 +1,105 @@ +#include "tier2/fileformats/json.h" +#include "tier2/ifilesystem.h" +#include "tier0/commandline.h" +#include "tier0/mem.h" +#include "helper.h" +#define EXTERNAL "../../external/" +#define GRAMMAR EXTERNAL"SPIRV-Headers/include/spirv/unified1/spirv.core.grammar.json" +#define OUTPUT "rtlinker_gen.cpp" + +DECLARE_BUILD_STAGE(SpirvOperandsGen) +{ + if (!filesystem2->ShouldRecompile(GRAMMAR, OUTPUT)) + return 0; + if (!filesystem2->ShouldRecompile(__FILE__, OUTPUT)) + return 0; + + IFileHandle *pHandle = filesystem->Open(GRAMMAR, FILEMODE_READ); + if (pHandle == NULL) + return 0; + + const char *szContents = filesystem->ReadString(pHandle); + filesystem->Close(pHandle); + pHandle = filesystem->Open(OUTPUT, FILEMODE_WRITE); + IJSONValue *pRoot = JSONManager()->ReadString(szContents); + IJSONArray *instructions = pRoot->GetObject()->GetValue("instructions")->GetArray(); + filesystem->PrintF( pHandle, "#include \"rtlinker_gen.h\"\n"); + filesystem->PrintF( pHandle, "int SpvGetOperandCount( int op )\n{\nswitch ( op ) {\n"); + for ( int i = 0; i < instructions->GetCount(); i++) + { + IJSONObject *op = instructions->GetParameter(i)->GetObject(); + if (op->GetValue("operands")) + filesystem->PrintF( pHandle, "case %.0f: return %u;\n", op->GetValue("opcode")->GetNumberValue(), op->GetValue("operands")->GetArray()->GetCount()); + + } + filesystem->PrintF( pHandle, "default: break;\n}\nreturn 0;\n}\n"); + filesystem->PrintF( pHandle, "void SpvGetOperands( int op, ESpirvOperandType *pTypes )\n{\nswitch ( op ) {\n"); + for ( int i = 0; i < instructions->GetCount(); i++) + { + IJSONObject *op = instructions->GetParameter(i)->GetObject(); + if (op->GetValue("operands")) + { + IJSONArray *operands = op->GetValue("operands")->GetArray(); + filesystem->PrintF( pHandle, "case %.0f:\n", op->GetValue("opcode")->GetNumberValue()); + for ( int o = 0; o < operands->GetCount(); o++ ) + { + CUtlString type = operands->GetParameter(o)->GetObject()->GetValue("kind")->GetStringValue(); + if (type == "IdRef") + filesystem->PrintF( pHandle, "pTypes[%u] = k_ESpirv_RefId;\n",o); + else if (type == "IdResult") + filesystem->PrintF( pHandle, "pTypes[%u] = k_ESpirv_ResultId;\n",o); + else if (type == "IdResultType") + filesystem->PrintF( pHandle, "pTypes[%u] = k_ESpirv_ResultTypeId;\n",o); + else if (type == "IdScope") + filesystem->PrintF( pHandle, "pTypes[%u] = k_ESpirv_ScopeId;\n",o); + else if (type == "IdMemorySemantics") + filesystem->PrintF( pHandle, "pTypes[%u] = k_ESpirv_MemorySemanticsId;\n",o); + } + filesystem->PrintF( pHandle, "break;\n"); + + } + + } + filesystem->PrintF( pHandle, "default: break;\n}\n"); + filesystem->PrintF( pHandle, "}\n"); + filesystem->PrintF( pHandle, "void SpvGetOperandFlags( int op, ESpirvOperandFlags *pTypes )\n{\nswitch ( op ) {\n"); + for ( int i = 0; i < instructions->GetCount(); i++) + { + IJSONObject *op = instructions->GetParameter(i)->GetObject(); + if (op->GetValue("operands")) + { + IJSONArray *operands = op->GetValue("operands")->GetArray(); + filesystem->PrintF( pHandle, "case %.0f:\n", op->GetValue("opcode")->GetNumberValue()); + for ( int o = 0; o < operands->GetCount(); o++ ) + { + IJSONValue *q = operands->GetParameter(o)->GetObject()->GetValue("quantifier"); + if (q == 0) + { + filesystem->PrintF( pHandle, "pTypes[%u] = k_ESpirvOperandFlags_None;\n",o); + continue; + } + + CUtlString type = q->GetStringValue(); + if (type == NULL) + filesystem->PrintF( pHandle, "pTypes[%u] = k_ESpirvOperandFlags_None;\n",o); + if (type == "?") + filesystem->PrintF( pHandle, "pTypes[%u] = k_ESpirvOperandFlags_Optional;\n",o); + else if (type == "*") + filesystem->PrintF( pHandle, "pTypes[%u] = k_ESpirvOperandFlags_Array;\n",o); + } + filesystem->PrintF( pHandle, "break;\n"); + + } + + } + filesystem->PrintF( pHandle, "default: break;\n}\n"); + filesystem->PrintF( pHandle, "}\n"); + filesystem->Close( pHandle ); + + V_free((void*)szContents); + + + + return 0; +} + diff --git a/materialsystem/vulkan/rendercontext.cpp b/materialsystem/vulkan/rendercontext.cpp index f5a16dd..bdf4426 100644 --- a/materialsystem/vulkan/rendercontext.cpp +++ b/materialsystem/vulkan/rendercontext.cpp @@ -23,7 +23,7 @@ static const char *s_vkDeviceExtensions[] = { #undef REQUIRED_EXTENSION #undef OPTIONAL_EXTENSION -SupportedVulkanExtensions_t g_vkAvailableExtensions; +SupportedVulkanExtensions_t g_vkAvailableExtensions = {}; uint32_t g_iDrawFamily; @@ -458,7 +458,9 @@ public: IBuffer *CreateBufferAligned( uint32_t nSize, uint32_t nAlignment, VkBufferUsageFlags2 eUsage ); virtual IShader *CreateShader( const char *szName ) override; - virtual void DestroyShader( IShader *pShader ) override; + virtual IRayTracingShader *CreateRayShader( const char *szName ) override; + virtual IComputeShader *CreateComputeShader( const char *szName ) override; + virtual void DestroyShader( IBaseShader *pShader ) override; virtual IMaterial *CreateMaterial( IShader *pShader ) override; virtual void DestroyMaterial( IMaterial *pMaterial ) override; @@ -593,7 +595,21 @@ IShader *CVkRenderContext::CreateShader( const char *szName ) return pShader; } -void CVkRenderContext::DestroyShader( IShader *pShader ) +IRayTracingShader *CVkRenderContext::CreateRayShader( const char *szName ) +{ + CVkRayTracingShader *pShader = new CVkRayTracingShader(); + VkGraphicsPipelineCreateInfo stPipelineCreateInfo = {}; + ICompiledShaderManager *pCompiledShaderManager = (ICompiledShaderManager*)CreateInterface(COMPILED_SHADER_MANAGER_INTERFACE_VERSION, NULL); + pCompiledShaderManager->ReadFromFile(&pShader->m_shader, szName); + pShader->m_hDevice = s_vkDevice; + return pShader; +} + +IComputeShader *CVkRenderContext::CreateComputeShader( const char *szName ) +{ +} + +void CVkRenderContext::DestroyShader( IBaseShader *pShader ) { delete pShader; } diff --git a/materialsystem/vulkan/rtlinker.cpp b/materialsystem/vulkan/rtlinker.cpp new file mode 100644 index 0000000..c1b99ef --- /dev/null +++ b/materialsystem/vulkan/rtlinker.cpp @@ -0,0 +1,249 @@ +#include "rtlinker.h" +#define SPV_ENABLE_UTILITY_CODE +#include "spirv/unified1/spirv.h" +#include "rtlinker_gen.h" +#include "tier2/ifilesystem.h" +#include "tier1/utlstring.h" + +#define MINI_SPIRV_IMPLEMENTATION +#include "../minispv/minispv.h" + +class CSpirvModule +{ + CUtlVector m_capabilities; + CUtlVector m_extensions; + CUtlVector m_instructionImports; + SpvAddressingModel m_addressingModel; + SpvMemoryModel m_memoryModel; + CUtlVector m_entryPoints; + +}; + + +void CVkShaderLinker::SetMainSpirv( uint32_t size, uint32_t *data ) +{ + m_main = (SpirvShader_t){size,data}; +} +void CVkShaderLinker::AddSpirv( uint32_t size, uint32_t *data ) +{ + m_shaders.AppendTail((SpirvShader_t){size,data}); +} + +#define SET_LAST(a) if ( a > last ) last = a; +void CVkShaderLinker::Build() +{ + mspv_module *mod = mspv_read_module(m_main.m_size, m_main.m_data); + uint32_t last = 0; + uint32_t current = 0; + + for ( int i = 0; i < mod->types.count; i++ ) + { + SET_LAST(mod->types.data[i].id); + } + + for ( int i = 0; i < mod->ext_instructions.count; i++ ) + { + SET_LAST(mod->ext_instructions.data[i].id); + } + for ( int i = 0; i < mod->variables.count; i++ ) + { + SET_LAST(mod->variables.data[i].result); + SET_LAST(mod->variables.data[i].resulttype); + } + for ( int i = 0; i < mod->functions.count; i++ ) + { + SET_LAST(mod->functions.data[i].result); + mspv_function &f = mod->functions.data[i]; + for ( int u = 0; u < f.instructions.len; ) + { + SpvOp op = (SpvOp)(f.instructions.data[u]&0xFFFF); + uint32_t uOpLen = f.instructions.data[u]>>16; + uint32_t uOpCount = SpvGetOperandCount(op); + if (uOpCount == 0) + { + u+=uOpLen; + continue; + } + ESpirvOperandType *peOps = (ESpirvOperandType *)V_malloc(uOpCount*sizeof(ESpirvOperandType)); + ESpirvOperandFlags *peFlags = (ESpirvOperandFlags *)V_malloc(uOpCount*sizeof(ESpirvOperandFlags)); + SpvGetOperands(op, peOps); + SpvGetOperandFlags(op, peFlags); + for ( int c = 0, uParam = 0; (c < uOpCount) && (c < uOpLen-1); c++ ) + { + switch (peOps[c]) + { + case k_ESpirv_RefId: + case k_ESpirv_ResultId: + case k_ESpirv_ResultTypeId: + case k_ESpirv_ScopeId: + case k_ESpirv_MemorySemanticsId: + if (peFlags[uParam]==k_ESpirvOperandFlags_None) + { + uParam++; + } + SET_LAST(f.instructions.data[u+c+1]); + break; + default: + break; + } + + } + u+=uOpLen; + V_free(peOps); + + } + } + current = last; + + /* now we can combine shaders*/ + CUtlVector functions = {}; + for (auto &shader: m_shaders) + { + mspv_module *s = mspv_read_module(shader.m_size, shader.m_data); + for ( int i = 0; i < s->capabilities.count; i++ ) + { + mspv_array_push(mod->capabilities, s->capabilities.data[i]); + } + for ( int i = 0; i < s->extensions.count; i++ ) + { + mspv_array_push(mod->extensions, s->extensions.data[i]); + } + + for ( int i = 0; i < s->ext_instructions.count; i++ ) + { + SET_LAST(s->ext_instructions.data[i].id); + } + + for ( int i = 0; i < s->entry_points.count; i++ ) + { + functions.AppendTail(s->entry_points.data[i].id+current); + SET_LAST(s->entry_points.data[i].id+current); + } + + for ( int i = 0; i < s->variables.count; i++ ) + { + s->variables.data[i].result+=current; + s->variables.data[i].resulttype+=current; + SET_LAST(s->variables.data[i].result) + SET_LAST(s->variables.data[i].resulttype) + mspv_array_push(mod->variables, s->variables.data[i]); + } + for ( int i = 0; i < s->types.count; i++ ) + { + s->types.data[i].id+=current; + mspv_data_view &dv = s->types.data[i].dv; + SET_LAST(s->types.data[i].id); + + SpvOp op = (SpvOp)(dv.data[0]&0xFFFF); + uint32_t uOpLen = dv.data[0]>>16; + uint32_t uOpCount = SpvGetOperandCount(op); + if (uOpCount == 0) + { + continue; + } + ESpirvOperandType *peOps = (ESpirvOperandType *)V_malloc(uOpCount*sizeof(ESpirvOperandType)); + ESpirvOperandFlags *peFlags = (ESpirvOperandFlags *)V_malloc(uOpCount*sizeof(ESpirvOperandFlags)); + SpvGetOperands(op, peOps); + SpvGetOperandFlags(op, peFlags); + /* shift the stuff */ + for ( int c = 0, uParam = 0; (c < uOpCount) && (c < uOpLen-1); c++ ) + { + switch (peOps[uParam]) + { + case k_ESpirv_RefId: + case k_ESpirv_ResultId: + case k_ESpirv_ResultTypeId: + case k_ESpirv_ScopeId: + case k_ESpirv_MemorySemanticsId: + + if (peFlags[uParam]==k_ESpirvOperandFlags_None) + { + dv.data[c+1]+=current; + uParam++; + + } + if (peFlags[uParam]==k_ESpirvOperandFlags_Array) + { + dv.data[c+1]+=current; + }; + SET_LAST(dv.data[c+1]); + break; + default: + break; + } + + } + V_free(peFlags); + V_free(peOps); + mspv_array_push(mod->types, s->types.data[i]); + } + + for ( int i = 0; i < s->functions.count; i++ ) + { + s->functions.data[i].result+=current; + SET_LAST(s->functions.data[i].result); + mspv_function &f = s->functions.data[i]; + for ( int u = 0; u < f.instructions.len; ) + { + SpvOp op = (SpvOp)(f.instructions.data[u]&0xFFFF); + uint32_t uOpLen = f.instructions.data[u]>>16; + uint32_t uOpCount = SpvGetOperandCount(op); + if (uOpCount == 0) + { + u+=uOpLen; + continue; + } + ESpirvOperandType *peOps = (ESpirvOperandType *)V_malloc(uOpCount*sizeof(ESpirvOperandType)); + SpvGetOperands(op, peOps); + /* shift the stuff */ + for ( int c = 0; c < uOpCount && c < (uOpLen-1); c++ ) + { + switch (peOps[c]) + { + case k_ESpirv_RefId: + case k_ESpirv_ResultId: + case k_ESpirv_ResultTypeId: + case k_ESpirv_ScopeId: + case k_ESpirv_MemorySemanticsId: + + f.instructions.data[u+c+1]+=current; + SET_LAST(f.instructions.data[u+c+1]); + break; + default: + break; + } + + } + u+=uOpLen; + V_free(peOps); + + } + mspv_array_push(mod->functions, s->functions.data[i]); + } + current = last; + } + + mspv_spv spv = mspv_write_module(mod); + mspv_close_module(mod); + m_out.m_data = spv.data; + m_out.m_size = spv.count; + + IFileHandle *ph = filesystem->Open("a.txt", FILEMODE_WRITE); + filesystem->Write(ph, spv.data, spv.count*4); + filesystem->Close(ph); + + + mspv_array_destroy(spv); + + +} +uint32_t CVkShaderLinker::GetSize() +{ + return m_out.m_size; + +} +uint32_t *CVkShaderLinker::GetData() +{ + return m_out.m_data; + +} diff --git a/materialsystem/vulkan/rtlinker.h b/materialsystem/vulkan/rtlinker.h new file mode 100644 index 0000000..0cf86b5 --- /dev/null +++ b/materialsystem/vulkan/rtlinker.h @@ -0,0 +1,28 @@ +#ifndef VULKAN_RT_COMPILER_H +#define VULKAN_RT_COMPILER_H + +#include "tier1/utlvector.h" + +class CVkShaderLinker +{ +public: + void SetMainSpirv( uint32_t size, uint32_t *data ); + void AddSpirv( uint32_t size, uint32_t *data ); + void Build(); + uint32_t GetSize(); + uint32_t *GetData(); + +private: + + struct SpirvShader_t + { + uint32_t m_size; + uint32_t *m_data; + }; + + CUtlVector m_shaders; + SpirvShader_t m_main; + SpirvShader_t m_out; +}; + +#endif diff --git a/materialsystem/vulkan/rtlinker_gen.cpp b/materialsystem/vulkan/rtlinker_gen.cpp new file mode 100644 index 0000000..a2ca141 --- /dev/null +++ b/materialsystem/vulkan/rtlinker_gen.cpp @@ -0,0 +1,11197 @@ +#include "rtlinker_gen.h" +int SpvGetOperandCount( int op ) +{ +switch ( op ) { +case 1: return 2; +case 2: return 1; +case 3: return 4; +case 4: return 1; +case 5: return 2; +case 6: return 3; +case 7: return 2; +case 8: return 3; +case 10: return 1; +case 11: return 2; +case 12: return 5; +case 14: return 2; +case 15: return 4; +case 16: return 2; +case 17: return 1; +case 19: return 1; +case 20: return 1; +case 21: return 3; +case 22: return 3; +case 23: return 3; +case 24: return 3; +case 25: return 9; +case 26: return 1; +case 27: return 2; +case 28: return 3; +case 29: return 2; +case 30: return 2; +case 31: return 2; +case 32: return 3; +case 33: return 3; +case 34: return 1; +case 35: return 1; +case 36: return 1; +case 37: return 1; +case 38: return 2; +case 39: return 2; +case 41: return 2; +case 42: return 2; +case 43: return 3; +case 44: return 3; +case 45: return 5; +case 46: return 2; +case 48: return 2; +case 49: return 2; +case 50: return 3; +case 51: return 3; +case 52: return 3; +case 54: return 4; +case 55: return 2; +case 57: return 4; +case 59: return 4; +case 60: return 5; +case 61: return 4; +case 62: return 3; +case 63: return 4; +case 64: return 5; +case 65: return 4; +case 66: return 4; +case 67: return 5; +case 68: return 4; +case 69: return 3; +case 70: return 5; +case 71: return 2; +case 72: return 3; +case 73: return 1; +case 74: return 2; +case 75: return 2; +case 77: return 4; +case 78: return 5; +case 79: return 5; +case 80: return 3; +case 81: return 4; +case 82: return 5; +case 83: return 3; +case 84: return 3; +case 86: return 4; +case 87: return 5; +case 88: return 5; +case 89: return 6; +case 90: return 6; +case 91: return 5; +case 92: return 5; +case 93: return 6; +case 94: return 6; +case 95: return 5; +case 96: return 6; +case 97: return 6; +case 98: return 5; +case 99: return 4; +case 100: return 3; +case 101: return 3; +case 102: return 3; +case 103: return 4; +case 104: return 3; +case 105: return 4; +case 106: return 3; +case 107: return 3; +case 109: return 3; +case 110: return 3; +case 111: return 3; +case 112: return 3; +case 113: return 3; +case 114: return 3; +case 115: return 3; +case 116: return 3; +case 117: return 3; +case 118: return 3; +case 119: return 3; +case 120: return 3; +case 121: return 3; +case 122: return 3; +case 123: return 4; +case 124: return 3; +case 126: return 3; +case 127: return 3; +case 128: return 4; +case 129: return 4; +case 130: return 4; +case 131: return 4; +case 132: return 4; +case 133: return 4; +case 134: return 4; +case 135: return 4; +case 136: return 4; +case 137: return 4; +case 138: return 4; +case 139: return 4; +case 140: return 4; +case 141: return 4; +case 142: return 4; +case 143: return 4; +case 144: return 4; +case 145: return 4; +case 146: return 4; +case 147: return 4; +case 148: return 4; +case 149: return 4; +case 150: return 4; +case 151: return 4; +case 152: return 4; +case 154: return 3; +case 155: return 3; +case 156: return 3; +case 157: return 3; +case 158: return 3; +case 159: return 3; +case 160: return 3; +case 161: return 4; +case 162: return 4; +case 163: return 4; +case 164: return 4; +case 165: return 4; +case 166: return 4; +case 167: return 4; +case 168: return 3; +case 169: return 5; +case 170: return 4; +case 171: return 4; +case 172: return 4; +case 173: return 4; +case 174: return 4; +case 175: return 4; +case 176: return 4; +case 177: return 4; +case 178: return 4; +case 179: return 4; +case 180: return 4; +case 181: return 4; +case 182: return 4; +case 183: return 4; +case 184: return 4; +case 185: return 4; +case 186: return 4; +case 187: return 4; +case 188: return 4; +case 189: return 4; +case 190: return 4; +case 191: return 4; +case 194: return 4; +case 195: return 4; +case 196: return 4; +case 197: return 4; +case 198: return 4; +case 199: return 4; +case 200: return 3; +case 201: return 6; +case 202: return 5; +case 203: return 5; +case 204: return 3; +case 205: return 3; +case 207: return 3; +case 208: return 3; +case 209: return 3; +case 210: return 3; +case 211: return 3; +case 212: return 3; +case 213: return 3; +case 214: return 3; +case 215: return 3; +case 220: return 1; +case 221: return 1; +case 224: return 3; +case 225: return 2; +case 227: return 5; +case 228: return 4; +case 229: return 6; +case 230: return 8; +case 231: return 8; +case 232: return 5; +case 233: return 5; +case 234: return 6; +case 235: return 6; +case 236: return 6; +case 237: return 6; +case 238: return 6; +case 239: return 6; +case 240: return 6; +case 241: return 6; +case 242: return 6; +case 245: return 3; +case 246: return 3; +case 247: return 2; +case 248: return 1; +case 249: return 1; +case 250: return 4; +case 251: return 3; +case 254: return 1; +case 256: return 2; +case 257: return 2; +case 259: return 8; +case 260: return 3; +case 261: return 4; +case 262: return 4; +case 263: return 5; +case 264: return 5; +case 265: return 5; +case 266: return 5; +case 267: return 5; +case 268: return 5; +case 269: return 5; +case 270: return 5; +case 271: return 5; +case 274: return 6; +case 275: return 6; +case 276: return 8; +case 277: return 8; +case 278: return 6; +case 279: return 6; +case 280: return 4; +case 281: return 4; +case 282: return 3; +case 283: return 5; +case 284: return 5; +case 285: return 7; +case 286: return 7; +case 287: return 5; +case 288: return 5; +case 291: return 6; +case 292: return 13; +case 293: return 7; +case 294: return 7; +case 295: return 6; +case 296: return 6; +case 297: return 1; +case 298: return 1; +case 299: return 2; +case 300: return 3; +case 301: return 2; +case 302: return 3; +case 303: return 2; +case 304: return 5; +case 305: return 5; +case 306: return 5; +case 307: return 6; +case 308: return 6; +case 309: return 5; +case 310: return 5; +case 311: return 6; +case 312: return 6; +case 313: return 5; +case 314: return 6; +case 315: return 6; +case 316: return 3; +case 318: return 5; +case 319: return 3; +case 320: return 5; +case 321: return 3; +case 322: return 1; +case 323: return 5; +case 324: return 3; +case 325: return 7; +case 326: return 6; +case 327: return 1; +case 328: return 3; +case 329: return 3; +case 330: return 1; +case 331: return 2; +case 332: return 2; +case 333: return 3; +case 334: return 4; +case 335: return 4; +case 336: return 4; +case 337: return 5; +case 338: return 4; +case 339: return 4; +case 340: return 4; +case 341: return 5; +case 342: return 5; +case 343: return 4; +case 344: return 4; +case 345: return 5; +case 346: return 5; +case 347: return 5; +case 348: return 5; +case 349: return 6; +case 350: return 6; +case 351: return 6; +case 352: return 6; +case 353: return 6; +case 354: return 6; +case 355: return 6; +case 356: return 6; +case 357: return 6; +case 358: return 6; +case 359: return 6; +case 360: return 6; +case 361: return 6; +case 362: return 6; +case 363: return 6; +case 364: return 6; +case 365: return 5; +case 366: return 5; +case 400: return 3; +case 401: return 4; +case 402: return 4; +case 403: return 4; +case 4160: return 4; +case 4161: return 3; +case 4162: return 3; +case 4163: return 4; +case 4164: return 5; +case 4165: return 4; +case 4166: return 4; +case 4181: return 3; +case 4182: return 3; +case 4183: return 2; +case 4184: return 4; +case 4185: return 3; +case 4190: return 3; +case 4417: return 2; +case 4418: return 5; +case 4419: return 5; +case 4420: return 5; +case 4421: return 3; +case 4422: return 3; +case 4423: return 6; +case 4424: return 6; +case 4425: return 5; +case 4426: return 5; +case 4427: return 5; +case 4428: return 3; +case 4429: return 3; +case 4430: return 3; +case 4431: return 6; +case 4432: return 4; +case 4433: return 5; +case 4434: return 11; +case 4445: return 11; +case 4446: return 2; +case 4447: return 3; +case 4450: return 5; +case 4451: return 5; +case 4452: return 5; +case 4453: return 6; +case 4454: return 6; +case 4455: return 6; +case 4456: return 6; +case 4457: return 6; +case 4458: return 5; +case 4459: return 6; +case 4460: return 3; +case 4461: return 3; +case 4462: return 3; +case 4463: return 3; +case 4472: return 1; +case 4473: return 8; +case 4474: return 1; +case 4475: return 2; +case 4476: return 1; +case 4477: return 3; +case 4479: return 4; +case 4480: return 5; +case 4481: return 5; +case 4482: return 7; +case 4483: return 7; +case 4497: return 3; +case 4500: return 7; +case 4501: return 7; +case 4502: return 7; +case 4503: return 7; +case 4540: return 3; +case 4541: return 3; +case 4542: return 4; +case 5000: return 5; +case 5001: return 5; +case 5002: return 5; +case 5003: return 5; +case 5004: return 5; +case 5005: return 5; +case 5006: return 5; +case 5007: return 5; +case 5011: return 4; +case 5012: return 5; +case 5056: return 3; +case 5074: return 5; +case 5075: return 1; +case 5076: return 2; +case 5078: return 3; +case 5090: return 3; +case 5101: return 4; +case 5103: return 2; +case 5104: return 2; +case 5110: return 3; +case 5111: return 3; +case 5115: return 2; +case 5119: return 3; +case 5121: return 2; +case 5126: return 6; +case 5127: return 3; +case 5129: return 3; +case 5147: return 3; +case 5148: return 3; +case 5158: return 2; +case 5159: return 3; +case 5249: return 14; +case 5250: return 13; +case 5251: return 7; +case 5252: return 3; +case 5253: return 3; +case 5254: return 3; +case 5255: return 3; +case 5256: return 13; +case 5257: return 3; +case 5258: return 3; +case 5259: return 1; +case 5260: return 12; +case 5261: return 13; +case 5262: return 12; +case 5263: return 6; +case 5264: return 2; +case 5265: return 3; +case 5266: return 2; +case 5267: return 3; +case 5268: return 3; +case 5269: return 3; +case 5270: return 3; +case 5271: return 3; +case 5272: return 3; +case 5273: return 3; +case 5274: return 3; +case 5275: return 3; +case 5276: return 3; +case 5277: return 3; +case 5278: return 3; +case 5279: return 3; +case 5280: return 2; +case 5281: return 1; +case 5283: return 7; +case 5288: return 3; +case 5289: return 13; +case 5290: return 7; +case 5291: return 3; +case 5292: return 16; +case 5293: return 3; +case 5294: return 4; +case 5295: return 2; +case 5296: return 3; +case 5299: return 2; +case 5300: return 7; +case 5301: return 7; +case 5302: return 5; +case 5303: return 4; +case 5304: return 4; +case 5305: return 7; +case 5306: return 8; +case 5307: return 3; +case 5308: return 3; +case 5309: return 2; +case 5310: return 4; +case 5311: return 14; +case 5312: return 15; +case 5313: return 1; +case 5314: return 2; +case 5315: return 3; +case 5316: return 12; +case 5317: return 13; +case 5318: return 1; +case 5319: return 2; +case 5320: return 3; +case 5321: return 2; +case 5322: return 3; +case 5323: return 3; +case 5324: return 3; +case 5325: return 3; +case 5326: return 3; +case 5327: return 3; +case 5328: return 3; +case 5329: return 3; +case 5330: return 3; +case 5331: return 3; +case 5332: return 3; +case 5333: return 3; +case 5334: return 4; +case 5337: return 11; +case 5338: return 12; +case 5339: return 12; +case 5340: return 4; +case 5341: return 1; +case 5344: return 2; +case 5345: return 4; +case 5346: return 3; +case 5347: return 3; +case 5348: return 3; +case 5349: return 3; +case 5350: return 3; +case 5351: return 3; +case 5352: return 3; +case 5358: return 5; +case 5359: return 6; +case 5360: return 5; +case 5361: return 5; +case 5362: return 3; +case 5366: return 5; +case 5367: return 7; +case 5368: return 5; +case 5369: return 5; +case 5370: return 3; +case 5371: return 4; +case 5372: return 2; +case 5373: return 4; +case 5374: return 4; +case 5375: return 4; +case 5376: return 4; +case 5377: return 2; +case 5378: return 4; +case 5379: return 4; +case 5381: return 2; +case 5382: return 7; +case 5384: return 4; +case 5390: return 3; +case 5391: return 3; +case 5392: return 3; +case 5393: return 3; +case 5394: return 3; +case 5395: return 3; +case 5396: return 3; +case 5397: return 1; +case 5398: return 7; +case 5427: return 4; +case 5428: return 4; +case 5429: return 4; +case 5430: return 4; +case 5431: return 4; +case 5432: return 3; +case 5433: return 3; +case 5434: return 3; +case 5435: return 3; +case 5436: return 3; +case 5437: return 3; +case 5438: return 4; +case 5439: return 4; +case 5571: return 4; +case 5572: return 5; +case 5573: return 5; +case 5574: return 4; +case 5575: return 3; +case 5576: return 2; +case 5577: return 4; +case 5578: return 3; +case 5580: return 6; +case 5581: return 5; +case 5585: return 3; +case 5586: return 3; +case 5587: return 4; +case 5588: return 4; +case 5589: return 4; +case 5590: return 4; +case 5591: return 4; +case 5592: return 4; +case 5593: return 4; +case 5594: return 4; +case 5595: return 4; +case 5596: return 4; +case 5597: return 4; +case 5598: return 4; +case 5600: return 3; +case 5601: return 3; +case 5609: return 2; +case 5610: return 6; +case 5611: return 4; +case 5614: return 6; +case 5615: return 6; +case 5630: return 1; +case 5631: return 4; +case 5632: return 2; +case 5633: return 3; +case 5699: return 4; +case 5700: return 2; +case 5701: return 1; +case 5702: return 1; +case 5703: return 1; +case 5704: return 1; +case 5705: return 1; +case 5706: return 1; +case 5707: return 1; +case 5708: return 1; +case 5709: return 1; +case 5710: return 1; +case 5711: return 1; +case 5712: return 1; +case 5713: return 4; +case 5714: return 4; +case 5715: return 4; +case 5716: return 4; +case 5717: return 4; +case 5718: return 4; +case 5719: return 4; +case 5720: return 4; +case 5721: return 2; +case 5722: return 2; +case 5723: return 2; +case 5724: return 6; +case 5725: return 4; +case 5726: return 2; +case 5727: return 2; +case 5728: return 3; +case 5729: return 4; +case 5730: return 4; +case 5731: return 5; +case 5732: return 3; +case 5733: return 3; +case 5734: return 3; +case 5735: return 3; +case 5736: return 3; +case 5737: return 3; +case 5738: return 3; +case 5739: return 3; +case 5740: return 3; +case 5741: return 3; +case 5742: return 3; +case 5743: return 3; +case 5744: return 3; +case 5745: return 3; +case 5746: return 5; +case 5747: return 5; +case 5748: return 5; +case 5749: return 6; +case 5750: return 4; +case 5751: return 6; +case 5752: return 3; +case 5753: return 4; +case 5754: return 3; +case 5755: return 4; +case 5756: return 4; +case 5757: return 5; +case 5758: return 6; +case 5759: return 6; +case 5760: return 7; +case 5761: return 5; +case 5762: return 6; +case 5763: return 6; +case 5764: return 7; +case 5765: return 3; +case 5766: return 3; +case 5767: return 3; +case 5768: return 3; +case 5769: return 3; +case 5770: return 4; +case 5771: return 4; +case 5772: return 4; +case 5773: return 5; +case 5774: return 5; +case 5775: return 5; +case 5776: return 4; +case 5777: return 3; +case 5778: return 3; +case 5779: return 3; +case 5780: return 3; +case 5781: return 9; +case 5782: return 10; +case 5783: return 3; +case 5784: return 3; +case 5785: return 3; +case 5786: return 5; +case 5787: return 6; +case 5788: return 5; +case 5789: return 6; +case 5790: return 3; +case 5791: return 3; +case 5792: return 8; +case 5793: return 10; +case 5794: return 13; +case 5795: return 4; +case 5796: return 3; +case 5797: return 4; +case 5798: return 6; +case 5799: return 4; +case 5800: return 3; +case 5801: return 4; +case 5802: return 4; +case 5803: return 4; +case 5804: return 5; +case 5805: return 6; +case 5806: return 5; +case 5807: return 6; +case 5808: return 3; +case 5809: return 3; +case 5810: return 3; +case 5811: return 3; +case 5812: return 3; +case 5813: return 3; +case 5814: return 3; +case 5815: return 3; +case 5816: return 3; +case 5818: return 3; +case 5819: return 2; +case 5820: return 1; +case 5840: return 8; +case 5841: return 8; +case 5842: return 8; +case 5843: return 8; +case 5846: return 10; +case 5847: return 10; +case 5848: return 10; +case 5849: return 10; +case 5850: return 6; +case 5851: return 6; +case 5852: return 6; +case 5853: return 6; +case 5854: return 6; +case 5855: return 8; +case 5856: return 8; +case 5857: return 8; +case 5858: return 10; +case 5859: return 8; +case 5860: return 8; +case 5861: return 8; +case 5862: return 8; +case 5863: return 8; +case 5864: return 8; +case 5865: return 8; +case 5866: return 8; +case 5867: return 8; +case 5868: return 8; +case 5869: return 8; +case 5870: return 8; +case 5871: return 8; +case 5872: return 8; +case 5873: return 8; +case 5874: return 8; +case 5875: return 8; +case 5876: return 8; +case 5877: return 8; +case 5878: return 8; +case 5879: return 10; +case 5880: return 10; +case 5881: return 10; +case 5882: return 10; +case 5887: return 1; +case 5911: return 2; +case 5912: return 3; +case 5913: return 2; +case 5923: return 8; +case 5924: return 8; +case 5925: return 8; +case 5926: return 8; +case 5927: return 8; +case 5928: return 8; +case 5929: return 8; +case 5930: return 8; +case 5931: return 8; +case 5932: return 8; +case 5933: return 8; +case 5934: return 3; +case 5938: return 3; +case 5946: return 4; +case 5947: return 4; +case 5949: return 3; +case 6016: return 3; +case 6017: return 3; +case 6018: return 4; +case 6019: return 4; +case 6020: return 4; +case 6021: return 4; +case 6022: return 4; +case 6023: return 4; +case 6024: return 4; +case 6025: return 4; +case 6026: return 3; +case 6027: return 4; +case 6028: return 4; +case 6029: return 3; +case 6030: return 3; +case 6031: return 4; +case 6032: return 4; +case 6035: return 6; +case 6086: return 2; +case 6090: return 1; +case 6091: return 1; +case 6092: return 1; +case 6096: return 3; +case 6116: return 3; +case 6117: return 3; +case 6142: return 3; +case 6143: return 3; +case 6145: return 3; +case 6163: return 7; +case 6164: return 2; +case 6165: return 3; +case 6166: return 1; +case 6199: return 1; +case 6221: return 3; +case 6231: return 10; +case 6232: return 10; +case 6233: return 10; +case 6234: return 9; +case 6235: return 10; +case 6237: return 7; +case 6242: return 6; +case 6244: return 4; +case 6248: return 2; +case 6249: return 5; +case 6250: return 2; +case 6251: return 4; +case 6252: return 6; +case 6253: return 3; +case 6254: return 3; +case 6401: return 5; +case 6402: return 5; +case 6403: return 5; +case 6404: return 5; +case 6405: return 5; +case 6406: return 5; +case 6407: return 5; +case 6408: return 5; +case 6426: return 3; +case 6428: return 6; +case 6429: return 4; +case 6529: return 3; +case 6530: return 3; +case 6531: return 3; +case 6916: return 5; +case 6917: return 5; +case 6918: return 5; +default: break; +} +return 0; +} +void SpvGetOperands( int op, ESpirvOperandType *pTypes ) +{ +switch ( op ) { +case 1: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 2: +break; +case 3: +pTypes[2] = k_ESpirv_RefId; +break; +case 4: +break; +case 5: +pTypes[0] = k_ESpirv_RefId; +break; +case 6: +pTypes[0] = k_ESpirv_RefId; +break; +case 7: +pTypes[0] = k_ESpirv_ResultId; +break; +case 8: +pTypes[0] = k_ESpirv_RefId; +break; +case 10: +break; +case 11: +pTypes[0] = k_ESpirv_ResultId; +break; +case 12: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 14: +break; +case 15: +pTypes[1] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 16: +pTypes[0] = k_ESpirv_RefId; +break; +case 17: +break; +case 19: +pTypes[0] = k_ESpirv_ResultId; +break; +case 20: +pTypes[0] = k_ESpirv_ResultId; +break; +case 21: +pTypes[0] = k_ESpirv_ResultId; +break; +case 22: +pTypes[0] = k_ESpirv_ResultId; +break; +case 23: +pTypes[0] = k_ESpirv_ResultId; +pTypes[1] = k_ESpirv_RefId; +break; +case 24: +pTypes[0] = k_ESpirv_ResultId; +pTypes[1] = k_ESpirv_RefId; +break; +case 25: +pTypes[0] = k_ESpirv_ResultId; +pTypes[1] = k_ESpirv_RefId; +break; +case 26: +pTypes[0] = k_ESpirv_ResultId; +break; +case 27: +pTypes[0] = k_ESpirv_ResultId; +pTypes[1] = k_ESpirv_RefId; +break; +case 28: +pTypes[0] = k_ESpirv_ResultId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +break; +case 29: +pTypes[0] = k_ESpirv_ResultId; +pTypes[1] = k_ESpirv_RefId; +break; +case 30: +pTypes[0] = k_ESpirv_ResultId; +pTypes[1] = k_ESpirv_RefId; +break; +case 31: +pTypes[0] = k_ESpirv_ResultId; +break; +case 32: +pTypes[0] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 33: +pTypes[0] = k_ESpirv_ResultId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +break; +case 34: +pTypes[0] = k_ESpirv_ResultId; +break; +case 35: +pTypes[0] = k_ESpirv_ResultId; +break; +case 36: +pTypes[0] = k_ESpirv_ResultId; +break; +case 37: +pTypes[0] = k_ESpirv_ResultId; +break; +case 38: +pTypes[0] = k_ESpirv_ResultId; +break; +case 39: +pTypes[0] = k_ESpirv_RefId; +break; +case 41: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 42: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 43: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 44: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 45: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 46: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 48: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 49: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 50: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 51: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 52: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 54: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[3] = k_ESpirv_RefId; +break; +case 55: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 57: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 59: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[3] = k_ESpirv_RefId; +break; +case 60: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 61: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 62: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 63: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 64: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +break; +case 65: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 66: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 67: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 68: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 69: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 70: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 71: +pTypes[0] = k_ESpirv_RefId; +break; +case 72: +pTypes[0] = k_ESpirv_RefId; +break; +case 73: +pTypes[0] = k_ESpirv_ResultId; +break; +case 74: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 75: +pTypes[0] = k_ESpirv_RefId; +break; +case 77: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 78: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 79: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 80: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 81: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 82: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 83: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 84: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 86: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 87: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 88: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 89: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 90: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 91: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 92: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 93: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 94: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 95: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 96: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 97: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 98: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 99: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +break; +case 100: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 101: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 102: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 103: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 104: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 105: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 106: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 107: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 109: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 110: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 111: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 112: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 113: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 114: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 115: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 116: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 117: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 118: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 119: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 120: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 121: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 122: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 123: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 124: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 126: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 127: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 128: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 129: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 130: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 131: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 132: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 133: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 134: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 135: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 136: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 137: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 138: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 139: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 140: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 141: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 142: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 143: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 144: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 145: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 146: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 147: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 148: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 149: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 150: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 151: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 152: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 154: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 155: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 156: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 157: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 158: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 159: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 160: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 161: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 162: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 163: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 164: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 165: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 166: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 167: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 168: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 169: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 170: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 171: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 172: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 173: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 174: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 175: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 176: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 177: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 178: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 179: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 180: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 181: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 182: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 183: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 184: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 185: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 186: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 187: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 188: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 189: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 190: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 191: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 194: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 195: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 196: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 197: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 198: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 199: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 200: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 201: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 202: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 203: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 204: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 205: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 207: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 208: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 209: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 210: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 211: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 212: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 213: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 214: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 215: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 220: +pTypes[0] = k_ESpirv_RefId; +break; +case 221: +pTypes[0] = k_ESpirv_RefId; +break; +case 224: +pTypes[0] = k_ESpirv_ScopeId; +pTypes[1] = k_ESpirv_ScopeId; +pTypes[2] = k_ESpirv_MemorySemanticsId; +break; +case 225: +pTypes[0] = k_ESpirv_ScopeId; +pTypes[1] = k_ESpirv_MemorySemanticsId; +break; +case 227: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_MemorySemanticsId; +break; +case 228: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_ScopeId; +pTypes[2] = k_ESpirv_MemorySemanticsId; +pTypes[3] = k_ESpirv_RefId; +break; +case 229: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_MemorySemanticsId; +pTypes[5] = k_ESpirv_RefId; +break; +case 230: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_MemorySemanticsId; +pTypes[5] = k_ESpirv_MemorySemanticsId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +break; +case 231: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_MemorySemanticsId; +pTypes[5] = k_ESpirv_MemorySemanticsId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +break; +case 232: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_MemorySemanticsId; +break; +case 233: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_MemorySemanticsId; +break; +case 234: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_MemorySemanticsId; +pTypes[5] = k_ESpirv_RefId; +break; +case 235: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_MemorySemanticsId; +pTypes[5] = k_ESpirv_RefId; +break; +case 236: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_MemorySemanticsId; +pTypes[5] = k_ESpirv_RefId; +break; +case 237: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_MemorySemanticsId; +pTypes[5] = k_ESpirv_RefId; +break; +case 238: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_MemorySemanticsId; +pTypes[5] = k_ESpirv_RefId; +break; +case 239: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_MemorySemanticsId; +pTypes[5] = k_ESpirv_RefId; +break; +case 240: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_MemorySemanticsId; +pTypes[5] = k_ESpirv_RefId; +break; +case 241: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_MemorySemanticsId; +pTypes[5] = k_ESpirv_RefId; +break; +case 242: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_MemorySemanticsId; +pTypes[5] = k_ESpirv_RefId; +break; +case 245: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 246: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 247: +pTypes[0] = k_ESpirv_RefId; +break; +case 248: +pTypes[0] = k_ESpirv_ResultId; +break; +case 249: +pTypes[0] = k_ESpirv_RefId; +break; +case 250: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +break; +case 251: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 254: +pTypes[0] = k_ESpirv_RefId; +break; +case 256: +pTypes[0] = k_ESpirv_RefId; +break; +case 257: +pTypes[0] = k_ESpirv_RefId; +break; +case 259: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +break; +case 260: +pTypes[0] = k_ESpirv_ScopeId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +break; +case 261: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +break; +case 262: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +break; +case 263: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 264: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 265: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 266: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 267: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 268: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 269: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 270: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 271: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 274: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 275: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 276: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +break; +case 277: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +break; +case 278: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 279: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 280: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 281: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 282: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 283: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 284: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 285: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +break; +case 286: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +break; +case 287: +pTypes[0] = k_ESpirv_ScopeId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 288: +pTypes[0] = k_ESpirv_ScopeId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 291: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 292: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +pTypes[10] = k_ESpirv_RefId; +pTypes[11] = k_ESpirv_RefId; +pTypes[12] = k_ESpirv_RefId; +break; +case 293: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +break; +case 294: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +break; +case 295: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 296: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 297: +pTypes[0] = k_ESpirv_RefId; +break; +case 298: +pTypes[0] = k_ESpirv_RefId; +break; +case 299: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 300: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 301: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 302: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +break; +case 303: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 304: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 305: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 306: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 307: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 308: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 309: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 310: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 311: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 312: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 313: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 314: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 315: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 316: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 318: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_MemorySemanticsId; +break; +case 319: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_ScopeId; +pTypes[2] = k_ESpirv_MemorySemanticsId; +break; +case 320: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 321: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 322: +pTypes[0] = k_ESpirv_ResultId; +break; +case 323: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 324: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 325: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +break; +case 326: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 327: +pTypes[0] = k_ESpirv_ResultId; +break; +case 328: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 329: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_ScopeId; +pTypes[2] = k_ESpirv_MemorySemanticsId; +break; +case 330: +break; +case 331: +pTypes[0] = k_ESpirv_RefId; +break; +case 332: +pTypes[0] = k_ESpirv_RefId; +break; +case 333: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +break; +case 334: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +break; +case 335: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +break; +case 336: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +break; +case 337: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 338: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +break; +case 339: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +break; +case 340: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +break; +case 341: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 342: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 343: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +break; +case 344: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +break; +case 345: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 346: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 347: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 348: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 349: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 350: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 351: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 352: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 353: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 354: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 355: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 356: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 357: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 358: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 359: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 360: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 361: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 362: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 363: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 364: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 365: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 366: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 400: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 401: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 402: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 403: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 4160: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 4161: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 4162: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 4163: +pTypes[0] = k_ESpirv_ResultId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 4164: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 4165: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +break; +case 4166: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 4181: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 4182: +pTypes[0] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +break; +case 4183: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 4184: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 4185: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +break; +case 4190: +pTypes[0] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 4417: +pTypes[0] = k_ESpirv_ResultId; +break; +case 4418: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 4419: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 4420: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 4421: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 4422: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 4423: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 4424: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 4425: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 4426: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 4427: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 4428: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 4429: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 4430: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 4431: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 4432: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 4433: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 4434: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +break; +case 4445: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +pTypes[10] = k_ESpirv_RefId; +break; +case 4446: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 4447: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 4450: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 4451: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 4452: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 4453: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 4454: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 4455: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 4456: +pTypes[0] = k_ESpirv_ResultId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 4457: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 4458: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 4459: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 4460: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 4461: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 4462: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 4463: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 4472: +pTypes[0] = k_ESpirv_ResultId; +break; +case 4473: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +break; +case 4474: +pTypes[0] = k_ESpirv_RefId; +break; +case 4475: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 4476: +pTypes[0] = k_ESpirv_RefId; +break; +case 4477: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 4479: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 4480: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 4481: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 4482: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +break; +case 4483: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +break; +case 4497: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 4500: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +break; +case 4501: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +break; +case 4502: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +break; +case 4503: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +break; +case 4540: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 4541: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 4542: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5000: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5001: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5002: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5003: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5004: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5005: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5006: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5007: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5011: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5012: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5056: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +break; +case 5074: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5075: +pTypes[0] = k_ESpirv_RefId; +break; +case 5076: +pTypes[0] = k_ESpirv_ResultId; +pTypes[1] = k_ESpirv_RefId; +break; +case 5078: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5090: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5101: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5103: +pTypes[0] = k_ESpirv_ResultId; +break; +case 5104: +pTypes[0] = k_ESpirv_ResultId; +break; +case 5110: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5111: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5115: +pTypes[0] = k_ESpirv_ResultId; +break; +case 5119: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5121: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 5126: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 5127: +pTypes[0] = k_ESpirv_RefId; +break; +case 5129: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5147: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 5148: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 5158: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 5159: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5249: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +pTypes[10] = k_ESpirv_RefId; +pTypes[11] = k_ESpirv_RefId; +pTypes[12] = k_ESpirv_RefId; +pTypes[13] = k_ESpirv_RefId; +break; +case 5250: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +pTypes[10] = k_ESpirv_RefId; +pTypes[11] = k_ESpirv_RefId; +pTypes[12] = k_ESpirv_RefId; +break; +case 5251: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +break; +case 5252: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5253: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5254: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5255: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5256: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +pTypes[10] = k_ESpirv_RefId; +pTypes[11] = k_ESpirv_RefId; +pTypes[12] = k_ESpirv_RefId; +break; +case 5257: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5258: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5259: +pTypes[0] = k_ESpirv_RefId; +break; +case 5260: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +pTypes[10] = k_ESpirv_RefId; +pTypes[11] = k_ESpirv_RefId; +break; +case 5261: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +pTypes[10] = k_ESpirv_RefId; +pTypes[11] = k_ESpirv_RefId; +pTypes[12] = k_ESpirv_RefId; +break; +case 5262: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +pTypes[10] = k_ESpirv_RefId; +pTypes[11] = k_ESpirv_RefId; +break; +case 5263: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 5264: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 5265: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5266: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 5267: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5268: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5269: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5270: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5271: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5272: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5273: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5274: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5275: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5276: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5277: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5278: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5279: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5280: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 5281: +pTypes[0] = k_ESpirv_ResultId; +break; +case 5283: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 5288: +pTypes[0] = k_ESpirv_ResultId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5289: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +pTypes[10] = k_ESpirv_RefId; +pTypes[11] = k_ESpirv_RefId; +break; +case 5290: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +break; +case 5291: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5292: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +pTypes[10] = k_ESpirv_RefId; +pTypes[11] = k_ESpirv_RefId; +pTypes[12] = k_ESpirv_RefId; +pTypes[13] = k_ESpirv_RefId; +pTypes[14] = k_ESpirv_RefId; +break; +case 5293: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5294: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5295: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 5296: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5299: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 5300: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +break; +case 5301: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +break; +case 5302: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5303: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5304: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5305: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +break; +case 5306: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +break; +case 5307: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5308: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5309: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 5310: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5311: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +pTypes[10] = k_ESpirv_RefId; +pTypes[11] = k_ESpirv_RefId; +pTypes[12] = k_ESpirv_RefId; +pTypes[13] = k_ESpirv_RefId; +break; +case 5312: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +pTypes[10] = k_ESpirv_RefId; +pTypes[11] = k_ESpirv_RefId; +pTypes[12] = k_ESpirv_RefId; +pTypes[13] = k_ESpirv_RefId; +pTypes[14] = k_ESpirv_RefId; +break; +case 5313: +pTypes[0] = k_ESpirv_ResultId; +break; +case 5314: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 5315: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5316: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +pTypes[10] = k_ESpirv_RefId; +pTypes[11] = k_ESpirv_RefId; +break; +case 5317: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +pTypes[10] = k_ESpirv_RefId; +pTypes[11] = k_ESpirv_RefId; +pTypes[12] = k_ESpirv_RefId; +break; +case 5318: +pTypes[0] = k_ESpirv_RefId; +break; +case 5319: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 5320: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5321: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 5322: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5323: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5324: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5325: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5326: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5327: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5328: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5329: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5330: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5331: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5332: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5333: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5334: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5337: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +pTypes[10] = k_ESpirv_RefId; +break; +case 5338: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +pTypes[10] = k_ESpirv_RefId; +pTypes[11] = k_ESpirv_RefId; +break; +case 5339: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +pTypes[10] = k_ESpirv_RefId; +pTypes[11] = k_ESpirv_RefId; +break; +case 5340: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5341: +pTypes[0] = k_ESpirv_ResultId; +break; +case 5344: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 5345: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5346: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5347: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5348: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5349: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5350: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5351: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5352: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5358: +pTypes[0] = k_ESpirv_ResultId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5359: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5360: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5361: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5362: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5366: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5367: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5368: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5369: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5370: +pTypes[0] = k_ESpirv_ResultId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5371: +pTypes[0] = k_ESpirv_ResultId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5372: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 5373: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5374: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5375: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5376: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5377: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 5378: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5379: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5381: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 5382: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +break; +case 5384: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5390: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5391: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5392: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5393: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5394: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5395: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5396: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5397: +break; +case 5398: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 5427: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5428: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5429: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5430: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5431: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5432: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5433: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5434: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5435: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5436: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5437: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5438: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5439: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5571: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5572: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5573: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5574: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5575: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5576: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 5577: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5578: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5580: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 5581: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5585: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5586: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5587: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5588: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5589: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5590: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5591: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5592: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5593: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5594: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5595: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5596: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5597: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5598: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5600: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5601: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5609: +pTypes[0] = k_ESpirv_ResultId; +break; +case 5610: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5611: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5614: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_MemorySemanticsId; +pTypes[5] = k_ESpirv_RefId; +break; +case 5615: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_MemorySemanticsId; +pTypes[5] = k_ESpirv_RefId; +break; +case 5630: +pTypes[0] = k_ESpirv_RefId; +break; +case 5631: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5632: +pTypes[0] = k_ESpirv_RefId; +break; +case 5633: +pTypes[0] = k_ESpirv_RefId; +break; +case 5699: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5700: +pTypes[0] = k_ESpirv_ResultId; +pTypes[1] = k_ESpirv_RefId; +break; +case 5701: +pTypes[0] = k_ESpirv_ResultId; +break; +case 5702: +pTypes[0] = k_ESpirv_ResultId; +break; +case 5703: +pTypes[0] = k_ESpirv_ResultId; +break; +case 5704: +pTypes[0] = k_ESpirv_ResultId; +break; +case 5705: +pTypes[0] = k_ESpirv_ResultId; +break; +case 5706: +pTypes[0] = k_ESpirv_ResultId; +break; +case 5707: +pTypes[0] = k_ESpirv_ResultId; +break; +case 5708: +pTypes[0] = k_ESpirv_ResultId; +break; +case 5709: +pTypes[0] = k_ESpirv_ResultId; +break; +case 5710: +pTypes[0] = k_ESpirv_ResultId; +break; +case 5711: +pTypes[0] = k_ESpirv_ResultId; +break; +case 5712: +pTypes[0] = k_ESpirv_ResultId; +break; +case 5713: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5714: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5715: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5716: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5717: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5718: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5719: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5720: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5721: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 5722: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 5723: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 5724: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 5725: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5726: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 5727: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 5728: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5729: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5730: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5731: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5732: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5733: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5734: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5735: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5736: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5737: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5738: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5739: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5740: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5741: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5742: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5743: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5744: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5745: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5746: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5747: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5748: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5749: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 5750: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5751: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 5752: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5753: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5754: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5755: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5756: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5757: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5758: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 5759: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 5760: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +break; +case 5761: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5762: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 5763: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 5764: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +break; +case 5765: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5766: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5767: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5768: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5769: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5770: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5771: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5772: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5773: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5774: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5775: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5776: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5777: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5778: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5779: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5780: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5781: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +break; +case 5782: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +break; +case 5783: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5784: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5785: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5786: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5787: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 5788: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5789: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 5790: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5791: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5792: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +break; +case 5793: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +break; +case 5794: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +pTypes[10] = k_ESpirv_RefId; +pTypes[11] = k_ESpirv_RefId; +pTypes[12] = k_ESpirv_RefId; +break; +case 5795: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5796: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5797: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5798: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 5799: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5800: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5801: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5802: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5803: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5804: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5805: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 5806: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5807: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 5808: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5809: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5810: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5811: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5812: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5813: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5814: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5815: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5816: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5818: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5819: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 5820: +pTypes[0] = k_ESpirv_RefId; +break; +case 5840: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5841: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5842: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5843: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5846: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5847: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5848: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5849: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5850: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5851: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5852: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5853: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5854: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5855: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5856: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5857: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5858: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5859: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5860: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5861: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5862: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5863: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5864: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5865: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5866: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5867: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5868: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5869: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5870: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5871: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5872: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5873: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5874: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5875: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5876: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5877: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5878: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5879: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5880: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5881: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5882: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 5887: +break; +case 5911: +pTypes[0] = k_ESpirv_ResultId; +pTypes[1] = k_ESpirv_RefId; +break; +case 5912: +pTypes[0] = k_ESpirv_ResultId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5913: +pTypes[0] = k_ESpirv_ResultId; +pTypes[1] = k_ESpirv_RefId; +break; +case 5923: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5924: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5925: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5926: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5927: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5928: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5929: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5930: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5931: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5932: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5933: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5934: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5938: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 5946: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5947: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 5949: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 6016: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 6017: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 6018: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 6019: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 6020: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 6021: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 6022: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 6023: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 6024: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 6025: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 6026: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 6027: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 6028: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 6029: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 6030: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 6031: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 6032: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 6035: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_MemorySemanticsId; +pTypes[5] = k_ESpirv_RefId; +break; +case 6086: +pTypes[0] = k_ESpirv_ResultId; +break; +case 6090: +pTypes[0] = k_ESpirv_RefId; +break; +case 6091: +pTypes[0] = k_ESpirv_RefId; +break; +case 6092: +pTypes[0] = k_ESpirv_RefId; +break; +case 6096: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 6116: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 6117: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 6142: +pTypes[0] = k_ESpirv_ScopeId; +pTypes[1] = k_ESpirv_ScopeId; +pTypes[2] = k_ESpirv_MemorySemanticsId; +break; +case 6143: +pTypes[0] = k_ESpirv_ScopeId; +pTypes[1] = k_ESpirv_ScopeId; +pTypes[2] = k_ESpirv_MemorySemanticsId; +break; +case 6145: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 6163: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 6164: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 6165: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 6166: +pTypes[0] = k_ESpirv_RefId; +break; +case 6199: +pTypes[0] = k_ESpirv_ResultId; +break; +case 6221: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +break; +case 6231: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +break; +case 6232: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +break; +case 6233: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +break; +case 6234: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +break; +case 6235: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +pTypes[6] = k_ESpirv_RefId; +pTypes[7] = k_ESpirv_RefId; +pTypes[8] = k_ESpirv_RefId; +pTypes[9] = k_ESpirv_RefId; +break; +case 6237: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 6242: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 6244: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 6248: +pTypes[0] = k_ESpirv_RefId; +break; +case 6249: +pTypes[0] = k_ESpirv_RefId; +pTypes[2] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 6250: +pTypes[0] = k_ESpirv_RefId; +break; +case 6251: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 6252: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 6253: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +break; +case 6254: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 6401: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 6402: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 6403: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 6404: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 6405: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 6406: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 6407: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 6408: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_ScopeId; +pTypes[4] = k_ESpirv_RefId; +break; +case 6426: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 6428: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +pTypes[5] = k_ESpirv_RefId; +break; +case 6429: +pTypes[0] = k_ESpirv_RefId; +pTypes[1] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +break; +case 6529: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 6530: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 6531: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +break; +case 6916: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 6917: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +case 6918: +pTypes[0] = k_ESpirv_ResultTypeId; +pTypes[1] = k_ESpirv_ResultId; +pTypes[2] = k_ESpirv_RefId; +pTypes[3] = k_ESpirv_RefId; +pTypes[4] = k_ESpirv_RefId; +break; +default: break; +} +} +void SpvGetOperandFlags( int op, ESpirvOperandFlags *pTypes ) +{ +switch ( op ) { +case 1: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 2: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 3: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Optional; +pTypes[3] = k_ESpirvOperandFlags_Optional; +break; +case 4: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 6: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 7: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 8: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 10: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 11: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 12: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Array; +break; +case 14: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 15: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Array; +break; +case 16: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 17: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 19: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 20: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 21: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 22: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Optional; +break; +case 23: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 24: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 25: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_Optional; +break; +case 26: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 27: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 28: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 29: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 30: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_Array; +break; +case 31: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 32: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 33: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Array; +break; +case 34: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 35: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 36: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 37: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 38: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 39: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 41: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 42: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 43: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 44: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Array; +break; +case 45: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 46: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 48: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 49: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 50: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 51: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Array; +break; +case 52: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 54: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 55: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 57: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Array; +break; +case 59: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Optional; +break; +case 60: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 61: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Optional; +break; +case 62: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Optional; +break; +case 63: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Optional; +pTypes[3] = k_ESpirvOperandFlags_Optional; +break; +case 64: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Optional; +pTypes[4] = k_ESpirvOperandFlags_Optional; +break; +case 65: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Array; +break; +case 66: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Array; +break; +case 67: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Array; +break; +case 68: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 69: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 70: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Array; +break; +case 71: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 72: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 73: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 74: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_Array; +break; +case 75: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_Array; +break; +case 77: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 78: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 79: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Array; +break; +case 80: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Array; +break; +case 81: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Array; +break; +case 82: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Array; +break; +case 83: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 84: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 86: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 87: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Optional; +break; +case 88: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 89: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 90: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 91: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Optional; +break; +case 92: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 93: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 94: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 95: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Optional; +break; +case 96: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 97: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 98: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Optional; +break; +case 99: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Optional; +break; +case 100: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 101: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 102: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 103: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 104: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 105: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 106: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 107: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 109: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 110: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 111: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 112: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 113: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 114: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 115: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 116: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 117: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 118: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 119: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 120: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 121: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 122: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 123: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 124: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 126: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 127: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 128: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 129: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 130: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 131: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 132: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 133: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 134: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 135: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 136: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 137: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 138: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 139: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 140: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 141: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 142: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 143: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 144: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 145: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 146: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 147: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 148: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 149: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 150: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 151: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 152: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 154: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 155: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 156: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 157: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 158: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 159: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 160: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 161: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 162: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 163: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 164: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 165: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 166: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 167: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 168: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 169: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 170: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 171: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 172: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 173: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 174: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 175: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 176: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 177: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 178: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 179: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 180: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 181: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 182: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 183: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 184: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 185: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 186: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 187: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 188: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 189: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 190: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 191: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 194: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 195: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 196: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 197: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 198: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 199: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 200: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 201: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 202: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 203: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 204: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 205: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 207: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 208: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 209: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 210: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 211: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 212: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 213: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 214: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 215: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 220: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 221: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 224: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 225: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 227: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 228: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 229: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 230: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 231: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 232: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 233: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 234: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 235: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 236: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 237: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 238: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 239: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 240: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 241: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 242: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 245: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Array; +break; +case 246: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 247: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 248: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 249: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 250: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Array; +break; +case 251: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Array; +break; +case 254: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 256: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 257: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 259: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 260: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 261: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 262: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 263: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 264: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 265: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 266: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 267: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 268: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 269: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 270: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 271: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 274: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 275: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 276: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 277: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 278: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 279: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 280: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 281: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 282: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 283: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 284: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 285: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +break; +case 286: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +break; +case 287: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 288: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 291: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 292: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +pTypes[10] = k_ESpirvOperandFlags_None; +pTypes[11] = k_ESpirvOperandFlags_None; +pTypes[12] = k_ESpirvOperandFlags_Array; +break; +case 293: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +break; +case 294: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +break; +case 295: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 296: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 297: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 298: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 299: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 300: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 301: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 302: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 303: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 304: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 305: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Optional; +break; +case 306: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 307: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 308: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 309: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Optional; +break; +case 310: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 311: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 312: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 313: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Optional; +break; +case 314: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 315: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 316: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 318: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 319: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 320: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Optional; +break; +case 321: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 322: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 323: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 324: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 325: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +break; +case 326: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 327: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 328: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 329: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 330: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 331: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 332: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 333: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 334: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 335: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 336: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 337: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 338: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 339: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 340: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 341: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 342: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 343: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 344: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 345: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 346: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 347: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 348: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 349: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 350: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 351: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 352: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 353: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 354: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 355: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 356: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 357: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 358: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 359: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 360: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 361: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 362: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 363: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 364: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 365: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 366: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 400: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 401: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 402: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 403: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 4160: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Optional; +break; +case 4161: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Optional; +break; +case 4162: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Optional; +break; +case 4163: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Optional; +pTypes[3] = k_ESpirvOperandFlags_Optional; +break; +case 4164: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Optional; +break; +case 4165: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Optional; +break; +case 4166: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 4181: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 4182: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Array; +break; +case 4183: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 4184: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Array; +break; +case 4185: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Array; +break; +case 4190: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Array; +break; +case 4417: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 4418: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Optional; +pTypes[4] = k_ESpirvOperandFlags_Optional; +break; +case 4419: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Array; +break; +case 4420: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Array; +break; +case 4421: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 4422: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 4423: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Array; +break; +case 4424: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Array; +break; +case 4425: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 4426: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Optional; +pTypes[3] = k_ESpirvOperandFlags_Optional; +pTypes[4] = k_ESpirvOperandFlags_Optional; +break; +case 4427: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 4428: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 4429: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 4430: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 4431: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 4432: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 4433: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Array; +break; +case 4434: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_Optional; +pTypes[10] = k_ESpirvOperandFlags_Optional; +break; +case 4445: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +pTypes[10] = k_ESpirvOperandFlags_None; +break; +case 4446: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 4447: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 4450: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Optional; +break; +case 4451: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Optional; +break; +case 4452: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Optional; +break; +case 4453: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 4454: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 4455: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 4456: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 4457: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Optional; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 4458: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Optional; +pTypes[4] = k_ESpirvOperandFlags_Optional; +break; +case 4459: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 4460: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 4461: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 4462: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 4463: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 4472: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 4473: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 4474: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 4475: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 4476: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 4477: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 4479: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 4480: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 4481: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 4482: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +break; +case 4483: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +break; +case 4497: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 4500: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +break; +case 4501: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +break; +case 4502: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +break; +case 4503: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +break; +case 4540: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 4541: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 4542: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5000: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5001: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5002: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5003: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5004: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5005: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5006: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5007: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5011: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5012: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5056: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5074: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5075: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5076: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5078: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5090: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5101: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5103: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5104: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5110: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5111: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5115: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5119: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5121: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5126: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5127: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5129: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5147: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5148: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5158: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5159: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5249: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +pTypes[10] = k_ESpirvOperandFlags_None; +pTypes[11] = k_ESpirvOperandFlags_None; +pTypes[12] = k_ESpirvOperandFlags_None; +pTypes[13] = k_ESpirvOperandFlags_None; +break; +case 5250: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +pTypes[10] = k_ESpirvOperandFlags_None; +pTypes[11] = k_ESpirvOperandFlags_None; +pTypes[12] = k_ESpirvOperandFlags_None; +break; +case 5251: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +break; +case 5252: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5253: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5254: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5255: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5256: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +pTypes[10] = k_ESpirvOperandFlags_None; +pTypes[11] = k_ESpirvOperandFlags_None; +pTypes[12] = k_ESpirvOperandFlags_None; +break; +case 5257: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5258: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5259: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5260: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +pTypes[10] = k_ESpirvOperandFlags_None; +pTypes[11] = k_ESpirvOperandFlags_None; +break; +case 5261: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +pTypes[10] = k_ESpirvOperandFlags_None; +pTypes[11] = k_ESpirvOperandFlags_None; +pTypes[12] = k_ESpirvOperandFlags_None; +break; +case 5262: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +pTypes[10] = k_ESpirvOperandFlags_None; +pTypes[11] = k_ESpirvOperandFlags_None; +break; +case 5263: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5264: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5265: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5266: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5267: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5268: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5269: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5270: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5271: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5272: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5273: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5274: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5275: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5276: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5277: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5278: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5279: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_Optional; +pTypes[2] = k_ESpirvOperandFlags_Optional; +break; +case 5280: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5281: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5283: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_Optional; +break; +case 5288: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5289: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +pTypes[10] = k_ESpirvOperandFlags_None; +pTypes[11] = k_ESpirvOperandFlags_Optional; +pTypes[12] = k_ESpirvOperandFlags_Optional; +break; +case 5290: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_Optional; +break; +case 5291: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5292: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +pTypes[10] = k_ESpirvOperandFlags_None; +pTypes[11] = k_ESpirvOperandFlags_None; +pTypes[12] = k_ESpirvOperandFlags_None; +pTypes[13] = k_ESpirvOperandFlags_None; +pTypes[14] = k_ESpirvOperandFlags_Optional; +pTypes[15] = k_ESpirvOperandFlags_Optional; +break; +case 5293: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5294: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Optional; +break; +case 5295: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5296: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5299: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5300: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +break; +case 5301: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +break; +case 5302: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Optional; +break; +case 5303: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Optional; +break; +case 5304: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5305: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +break; +case 5306: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5307: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5308: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5309: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5310: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Optional; +pTypes[3] = k_ESpirvOperandFlags_Optional; +break; +case 5311: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +pTypes[10] = k_ESpirvOperandFlags_None; +pTypes[11] = k_ESpirvOperandFlags_None; +pTypes[12] = k_ESpirvOperandFlags_Optional; +pTypes[13] = k_ESpirvOperandFlags_Optional; +break; +case 5312: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +pTypes[10] = k_ESpirvOperandFlags_None; +pTypes[11] = k_ESpirvOperandFlags_None; +pTypes[12] = k_ESpirvOperandFlags_None; +pTypes[13] = k_ESpirvOperandFlags_Optional; +pTypes[14] = k_ESpirvOperandFlags_Optional; +break; +case 5313: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5314: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5315: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_Optional; +pTypes[2] = k_ESpirvOperandFlags_Optional; +break; +case 5316: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +pTypes[10] = k_ESpirvOperandFlags_None; +pTypes[11] = k_ESpirvOperandFlags_None; +break; +case 5317: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +pTypes[10] = k_ESpirvOperandFlags_None; +pTypes[11] = k_ESpirvOperandFlags_None; +pTypes[12] = k_ESpirvOperandFlags_None; +break; +case 5318: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5319: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5320: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5321: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5322: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5323: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5324: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5325: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5326: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5327: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5328: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5329: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5330: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5331: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5332: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5333: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5334: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5337: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +pTypes[10] = k_ESpirvOperandFlags_None; +break; +case 5338: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +pTypes[10] = k_ESpirvOperandFlags_None; +pTypes[11] = k_ESpirvOperandFlags_None; +break; +case 5339: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +pTypes[10] = k_ESpirvOperandFlags_None; +pTypes[11] = k_ESpirvOperandFlags_None; +break; +case 5340: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5341: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5344: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5345: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5346: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5347: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5348: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5349: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5350: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5351: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5352: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5358: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5359: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_Optional; +break; +case 5360: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Optional; +break; +case 5361: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5362: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5366: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5367: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +break; +case 5368: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5369: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Array; +break; +case 5370: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5371: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Array; +break; +case 5372: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5373: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Array; +break; +case 5374: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Array; +break; +case 5375: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Array; +break; +case 5376: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5377: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5378: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Array; +break; +case 5379: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Array; +break; +case 5381: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5382: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +break; +case 5384: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Array; +break; +case 5390: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5391: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5392: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5393: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5394: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5395: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5396: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5397: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5398: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_Optional; +break; +case 5427: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5428: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5429: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5430: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5431: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5432: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5433: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5434: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5435: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5436: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5437: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5438: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5439: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5571: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5572: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5573: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5574: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5575: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5576: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5577: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5578: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5580: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5581: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5585: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5586: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5587: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5588: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5589: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5590: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5591: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5592: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5593: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5594: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5595: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5596: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5597: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5598: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5600: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5601: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Array; +break; +case 5609: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5610: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5611: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Array; +break; +case 5614: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5615: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5630: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5631: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5632: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5633: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5699: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5700: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5701: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5702: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5703: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5704: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5705: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5706: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5707: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5708: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5709: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5710: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5711: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5712: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5713: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5714: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5715: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5716: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5717: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5718: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5719: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5720: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5721: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5722: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5723: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5724: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5725: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5726: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5727: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5728: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5729: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5730: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5731: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5732: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5733: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5734: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5735: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5736: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5737: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5738: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5739: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5740: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5741: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5742: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5743: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5744: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5745: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5746: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5747: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5748: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5749: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5750: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5751: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5752: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5753: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5754: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5755: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5756: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5757: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5758: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5759: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5760: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +break; +case 5761: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5762: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5763: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5764: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +break; +case 5765: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5766: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5767: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5768: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5769: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5770: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5771: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5772: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5773: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5774: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5775: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5776: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5777: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5778: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5779: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5780: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5781: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +break; +case 5782: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +break; +case 5783: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5784: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5785: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5786: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5787: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5788: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5789: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5790: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5791: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5792: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5793: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +break; +case 5794: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +pTypes[10] = k_ESpirvOperandFlags_None; +pTypes[11] = k_ESpirvOperandFlags_None; +pTypes[12] = k_ESpirvOperandFlags_None; +break; +case 5795: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5796: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5797: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5798: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5799: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5800: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5801: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5802: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5803: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5804: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5805: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5806: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 5807: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5808: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5809: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5810: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5811: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5812: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5813: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5814: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5815: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5816: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5818: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5819: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 5820: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 5840: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5841: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5842: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5843: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5846: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +break; +case 5847: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +break; +case 5848: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +break; +case 5849: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +break; +case 5850: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5851: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5852: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5853: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5854: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 5855: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5856: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5857: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5858: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +break; +case 5859: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5860: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5861: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5862: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5863: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5864: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5865: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5866: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5867: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5868: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5869: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5870: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5871: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5872: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5873: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5874: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5875: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5876: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5877: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5878: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5879: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +break; +case 5880: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +break; +case 5881: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +break; +case 5882: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +break; +case 5887: +pTypes[0] = k_ESpirvOperandFlags_Array; +break; +case 5911: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_Optional; +break; +case 5912: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Optional; +break; +case 5913: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_Array; +break; +case 5923: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5924: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5925: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5926: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5927: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5928: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5929: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5930: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5931: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5932: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5933: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +break; +case 5934: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5938: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 5946: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5947: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 5949: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 6016: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 6017: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 6018: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 6019: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 6020: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 6021: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 6022: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 6023: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 6024: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 6025: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 6026: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 6027: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 6028: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 6029: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 6030: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 6031: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 6032: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 6035: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 6086: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 6090: +pTypes[0] = k_ESpirvOperandFlags_Array; +break; +case 6091: +pTypes[0] = k_ESpirvOperandFlags_Array; +break; +case 6092: +pTypes[0] = k_ESpirvOperandFlags_Array; +break; +case 6096: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Array; +break; +case 6116: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 6117: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 6142: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 6143: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 6145: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 6163: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +break; +case 6164: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_Array; +break; +case 6165: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 6166: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 6199: +pTypes[0] = k_ESpirvOperandFlags_None; +break; +case 6221: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Optional; +break; +case 6231: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +break; +case 6232: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +break; +case 6233: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +break; +case 6234: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +break; +case 6235: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_None; +pTypes[7] = k_ESpirvOperandFlags_None; +pTypes[8] = k_ESpirvOperandFlags_None; +pTypes[9] = k_ESpirvOperandFlags_None; +break; +case 6237: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +pTypes[6] = k_ESpirvOperandFlags_Optional; +break; +case 6242: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 6244: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 6248: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 6249: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_Array; +break; +case 6250: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +break; +case 6251: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_Array; +break; +case 6252: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 6253: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Array; +break; +case 6254: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_Array; +break; +case 6401: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 6402: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 6403: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 6404: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 6405: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 6406: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 6407: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 6408: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 6426: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 6428: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +pTypes[5] = k_ESpirvOperandFlags_None; +break; +case 6429: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +break; +case 6529: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 6530: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 6531: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +break; +case 6916: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 6917: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +case 6918: +pTypes[0] = k_ESpirvOperandFlags_None; +pTypes[1] = k_ESpirvOperandFlags_None; +pTypes[2] = k_ESpirvOperandFlags_None; +pTypes[3] = k_ESpirvOperandFlags_None; +pTypes[4] = k_ESpirvOperandFlags_None; +break; +default: break; +} +} diff --git a/materialsystem/vulkan/rtlinker_gen.h b/materialsystem/vulkan/rtlinker_gen.h new file mode 100644 index 0000000..fe39149 --- /dev/null +++ b/materialsystem/vulkan/rtlinker_gen.h @@ -0,0 +1,5 @@ +#include "rtlinker_shared.h" + +int SpvGetOperandCount( int op ); +void SpvGetOperands( int op, ESpirvOperandType *pTypes ); +void SpvGetOperandFlags( int op, ESpirvOperandFlags *pTypes ); diff --git a/materialsystem/vulkan/rtlinker_shared.h b/materialsystem/vulkan/rtlinker_shared.h new file mode 100644 index 0000000..e455b8f --- /dev/null +++ b/materialsystem/vulkan/rtlinker_shared.h @@ -0,0 +1,25 @@ +#ifndef RTLINKER_SHARED_H +#define RTLINKER_SHARED_H + +enum ESpirvOperandType +{ + k_ESpirv_Unknown = 0, + k_ESpirv_ResultId, + k_ESpirv_ResultTypeId, + k_ESpirv_RefId, + k_ESpirv_MemorySemanticsId, + k_ESpirv_ScopeId, + + k_ESpirv_LiteralBool, + k_ESpirv_LiteralInt, + k_ESpirv_LiteralFloat, +}; + +enum ESpirvOperandFlags +{ + k_ESpirvOperandFlags_None, + k_ESpirvOperandFlags_Optional, + k_ESpirvOperandFlags_Array, +}; + +#endif diff --git a/materialsystem/vulkan/rtshader.cpp b/materialsystem/vulkan/rtshader.cpp new file mode 100644 index 0000000..7b79175 --- /dev/null +++ b/materialsystem/vulkan/rtshader.cpp @@ -0,0 +1,68 @@ +#include "vulkan_state.h" +#include "rtlinker.h" +#include "materialsystem/compiledshadermgr.h" + +uint32_t CVkRayTracingShader::GetMissShaderBinding( const char *szName ) +{ + +} + +uint32_t CVkRayTracingShader::GetClosestHitShaderBinding( const char *szName ) +{ + +} + +uint32_t CVkRayTracingShader::GetCallableShaderBinding( const char *szName ) +{ + +} + +void CVkRayTracingShader::AddShader( const char *szName, const char *szPath ) +{ + ICompiledShaderManager *pCompiledShaderManager = (ICompiledShaderManager*)CreateInterface(COMPILED_SHADER_MANAGER_INTERFACE_VERSION, NULL); + CCompiledShader shader = {}; + pCompiledShaderManager->ReadFromFile(&shader, szPath); + m_callableShaders.AppendTail( {szName, shader} ); +} + +void CVkRayTracingShader::RemoveShader( const char *szName ) +{ + +} + +void CVkRayTracingShader::Build() +{ + if (g_vkAvailableExtensions.bIsSupported_VK_KHR_RAY_TRACING_PIPELINE) + BuildTrace(); + else + BuildCompute(); + +} + +void CVkRayTracingShader::BuildCompute() +{ + CVkShaderLinker linker = {}; + ShaderObject_t *pShader; + + pShader = m_shader.FindShaderObject(SHADER_BACKEND_SPIRV_VULKAN, SHADER_STAGE_RAYGEN_SOFTWARE); + if (!pShader) + return; + + linker.SetMainSpirv(m_shader.GetLumpSize(pShader->m_nDataLump)/4, + (uint32_t*)m_shader.GetLumpPtr(pShader->m_nDataLump)); + for ( auto s: m_callableShaders ) + { + pShader = s.m_shader.FindShaderObject(SHADER_BACKEND_SPIRV_VULKAN, SHADER_STAGE_CALLABLE_SOFTWARE); + if (!pShader) + continue; + linker.AddSpirv(s.m_shader.GetLumpSize(pShader->m_nDataLump)/4, + (uint32_t*)s.m_shader.GetLumpPtr(pShader->m_nDataLump)); + } + linker.Build(); + +} + +void CVkRayTracingShader::BuildTrace() +{ + +} diff --git a/materialsystem/vulkan/vulkan_state.h b/materialsystem/vulkan/vulkan_state.h index acb8e46..76f1dcf 100644 --- a/materialsystem/vulkan/vulkan_state.h +++ b/materialsystem/vulkan/vulkan_state.h @@ -7,6 +7,7 @@ #include "vk_mem_alloc.h" #include "tier0/platform.h" #include "tier1/utlvector.h" +#include "tier1/utlstring.h" #include "tier2/iappsystem.h" #include "materialsystem/imaterialsystem.h" #include "materialsystem/shaderinternals.h" @@ -268,7 +269,7 @@ public: virtual void AddOutputImage( int iImageIndex, EImageFormat eFormat ) override; virtual void SetDepthImage( EImageFormat eFormat ) override; virtual void SetMultisampling( EMultisampleType eFormat ) override; - virtual void DisablePixelShader( bool bDisable) override; + virtual void DisablePixelShader( bool bDisable ) override; virtual void Build() override; VkPipeline m_hPipeline = NULL; @@ -285,7 +286,57 @@ private: EMultisampleType m_eMultiSampling; VkFormat m_eDepthFormat; bool m_bIsFragmentEnabled; +}; +class CVkComputeShader : public IComputeShader +{ +public: + virtual void Build() override; + void BuildCompute(); + void BuildTrace(); + + VkDevice m_hDevice; + CCompiledShader m_shader; + + VkPipeline m_hPipeline = NULL; + VkPipelineLayout m_hPipelineLayout; + CUtlVector m_setLayouts; + CUtlVector m_bindings; +private: + struct ShaderBinding_t + { + CUtlString m_szName; + CCompiledShader m_shader; + }; + CUtlVector m_callableShaders = {}; +}; + +class CVkRayTracingShader : public IRayTracingShader +{ +public: + virtual uint32_t GetMissShaderBinding( const char *szName ) override; + virtual uint32_t GetClosestHitShaderBinding( const char *szName ) override; + virtual uint32_t GetCallableShaderBinding( const char *szName ) override; + virtual void AddShader( const char *szName, const char *szPath ) override; + virtual void RemoveShader( const char *szName ) override; + virtual void Build() override; + void BuildCompute(); + void BuildTrace(); + + VkDevice m_hDevice; + CCompiledShader m_shader; + + VkPipeline m_hPipeline = NULL; + VkPipelineLayout m_hPipelineLayout; + CUtlVector m_setLayouts; + CUtlVector m_bindings; +private: + struct ShaderBinding_t + { + CUtlString m_szName; + CCompiledShader m_shader; + }; + CUtlVector m_callableShaders = {}; }; class CVkTextureArray: public ITextureArray diff --git a/minispv/minispv.h b/minispv/minispv.h new file mode 100644 index 0000000..a85458b --- /dev/null +++ b/minispv/minispv.h @@ -0,0 +1,507 @@ +#ifndef MINI_SPIRV_H +#define MINI_SPIRV_H +#include "stdlib.h" +#include "stdint.h" +#include "stdio.h" +#include "string.h" +#include "unistd.h" +#define SPV_ENABLE_UTILITY_CODE +#include "spirv/unified1/spirv.h" + +#ifdef __cplusplus +extern "C" +{ +#endif + +/* arrays */ + +static inline uint32_t _mspvalign2( uint32_t x ) +{ + if (x <= 1) return 1; + x--; + x |= x >> 1; + x |= x >> 2; + x |= x >> 4; + x |= x >> 8; + x |= x >> 16; + x++; + return x; +} + +#define mspv_array(T) \ +struct \ +{ \ + size_t count; \ + size_t capacity; \ + T *data; \ +} + +#define mspv_array_zero(array) \ + array.count = 0; \ + array.capacity = 0; \ + array.data = NULL; + +#define mspv_array_create(array, count) \ + array.count = count; \ + array.capacity = _mspvalign2(count); \ + array.data = malloc(array.capacity * sizeof(*array.data)); + +#define mspv_array_push(array, value) \ + do { \ + if (array.count >= array.capacity) { \ + if (array.capacity == 0) array.capacity = 4; \ + else array.capacity *= 2; \ + array.data = (typeof(array.data))realloc(array.data, array.capacity * sizeof(*array.data)); \ + } \ + array.data[array.count++] = value;\ + } while(0) \ + +#define mspv_array_destroy(array) \ + if (array.data) free(array.data); \ + mspv_array_zero(array) + +/* strings views for simplicity */ +typedef struct +{ + const char *data; + size_t len; +} mspv_string_view; + +typedef struct +{ + uint32_t *data; + size_t len; +} mspv_data_view; + +typedef struct +{ + uint32_t id; + mspv_string_view name; +} mspv_ext_import; + +typedef struct +{ + SpvExecutionModel model; + uint32_t id; + mspv_string_view name; + mspv_array(uint32_t) params; +} mspv_entry_point; + +typedef struct +{ + uint32_t id; + SpvExecutionMode mode; + mspv_data_view dv; +} mspv_execution_mode; + +typedef struct +{ + uint32_t resulttype; + uint32_t result; + uint32_t functionctrl; + uint32_t functiontype; + mspv_data_view instructions; +} mspv_function; + +typedef struct +{ + uint32_t magic; + uint32_t reserved1; + uint32_t reserved2; + uint32_t reserved3; + uint32_t reserved4; +} mspv_header; + +typedef struct +{ + uint32_t id; + mspv_data_view dv; +} mspv_type; + +typedef struct +{ + uint32_t resulttype; + uint32_t result; + uint32_t storageclass; + uint32_t initializer; +} mspv_variable; + +typedef struct +{ + uint32_t id; + mspv_string_view name; +} mspv_name; + +typedef struct +{ + mspv_header header; + SpvMemoryModel memory_model; + SpvAddressingModel addressing_model; + mspv_array(SpvCapability) capabilities; + mspv_array(mspv_string_view) extensions; + mspv_array(mspv_ext_import) ext_instructions; + mspv_array(mspv_string_view) instruction_imports; + mspv_array(mspv_entry_point) entry_points; + mspv_array(mspv_execution_mode) execution_modes; + mspv_array(mspv_name) names; + mspv_array(mspv_type) types; + mspv_array(mspv_variable) variables; + mspv_array(mspv_function) functions; + + uint32_t *data; + uint32_t count; +} mspv_module; + + +mspv_module *mspv_read_module( uint32_t count, uint32_t *data ); +void mspv_close_module( mspv_module* module ); + +#define mspv_todo(str) printf("todo!!! " str "\n"); _exit(0) + +#define mspv_sv_fmt "%.*s" +#define mspv_psv(sv) sv.len, sv.data + +//#ifdef MINI_SPIRV_IMPLEMENTATION +static inline mspv_string_view mspv_sv_from_op( uint32_t *op ) +{ + return { (char*)op, strlen((char*)op)}; + +}; + +mspv_module *mspv_read_module( uint32_t count, uint32_t *data ) +{ + mspv_module m; + mspv_header *h; + int i; + uint32_t u; + SpvOp op; + uint16_t instruction_size; + uint16_t local_offset; + mspv_string_view sv; + mspv_data_view dv; + mspv_entry_point ep; + mspv_ext_import imp; + mspv_execution_mode em; + mspv_type type; + mspv_variable var; + mspv_function fn; + mspv_name nm; + int isfn; + + if ( count == 0 || data == NULL) + return 0; + + m = {}; + m.data = data; + m.count = count; + + h = (mspv_header*)data; + if ( h->magic != SpvMagicNumber ) + return 0; + m.header = *h; + + /* loop instrucitons */ + isfn = 0; + + for ( u = 5; u < count; ) + { + instruction_size = data[u] >> 16; + op = (SpvOp)(data[u] & 0xFFFF); + switch (op) + { + case SpvOpCapability: + mspv_array_push(m.capabilities, (SpvCapability)data[u+1]); + break; + case SpvOpExtension: + sv.len = strlen((char*)(data + u + 1)); + sv.data = (char*)&data[u+1]; + mspv_array_push(m.extensions, sv); + break; + case SpvOpExtInstImport: + imp.id = data[u+1]; + imp.name.len = strlen((char*)(data + u + 2)); + imp.name.data = (char*)&data[u+2]; + mspv_array_push(m.ext_instructions, imp); + break; + case SpvOpMemoryModel: + m.addressing_model = (SpvAddressingModel)data[u+1]; + m.memory_model = (SpvMemoryModel)data[u+2]; + break; + case SpvOpEntryPoint: + ep.model = (SpvExecutionModel)data[u+1]; + ep.id = (SpvExecutionModel)data[u+2]; + ep.name = mspv_sv_from_op(data+u+3); + ep.params = {}; + for ( i = 4 + ep.name.len/4; i < instruction_size; i++ ) + { + mspv_array_push(ep.params, data[u+i]); + } + mspv_array_push(m.entry_points, ep); + break; + case SpvOpExecutionMode: + em.id = data[u+1]; + em.mode = (SpvExecutionMode)data[u+2]; + em.dv.data = data + u; + em.dv.len = instruction_size - 1; + mspv_array_push(m.execution_modes, em); + break; + case SpvOpString: + case SpvOpSourceExtension: + case SpvOpSource: + case SpvOpSourceContinued: + case SpvOpMemberName: + case SpvOpModuleProcessed: + break; + case SpvOpName: + nm.id = data[u+1]; + nm.name = mspv_sv_from_op(data+u+2); + mspv_array_push(m.names, nm); + + break; + + case SpvOpTypeVoid: + case SpvOpTypeBool: + case SpvOpTypeInt: + case SpvOpTypeFloat: + case SpvOpTypeVector: + case SpvOpTypeMatrix: + case SpvOpTypeImage: + case SpvOpTypeSampler: + case SpvOpTypeSampledImage: + case SpvOpTypeArray: + case SpvOpTypeRuntimeArray: + case SpvOpTypeStruct: + case SpvOpTypeOpaque: + case SpvOpTypePointer: + case SpvOpTypeFunction: + case SpvOpTypeEvent: + case SpvOpTypeDeviceEvent: + case SpvOpTypeReserveId: + case SpvOpTypeQueue: + case SpvOpTypePipe: + case SpvOpTypeForwardPointer: + type.dv.data = data+u; + type.dv.len = instruction_size; + type.id = data[u+1]; + mspv_array_push(m.types, type); + break; + + case SpvOpVariable: + var.resulttype = data[u+1]; + var.result = data[u+2]; + var.storageclass = data[u+3]; + if (instruction_size > 4) + var.initializer = data[u+4]; + else + var.initializer = 0; + if (!isfn) + mspv_array_push(m.variables, var); + else + fn.instructions.len += instruction_size; + break; + + + case SpvOpFunction: + fn = {}; + fn.resulttype = data[u+1]; + fn.result = data[u+2]; + fn.functionctrl = data[u+3]; + fn.functiontype = data[u+4]; + fn.instructions.data = data+u+instruction_size; + fn.instructions.len = 0; + isfn = 1; + break; + case SpvOpFunctionEnd: + mspv_array_push(m.functions, fn); + isfn = 0; + break; + + default: + fn.instructions.len += instruction_size; + break; + } + u += instruction_size; + + }; + return (mspv_module*)memcpy(malloc(sizeof(m)),&m, sizeof(m)); +} + +void mspv_close_module( mspv_module* m ) +{ + if (m == NULL) + return; + + mspv_array_destroy(m->capabilities); + mspv_array_destroy(m->extensions); + mspv_array_destroy(m->execution_modes); + mspv_array_destroy(m->entry_points); + mspv_array_destroy(m->types); + mspv_array_destroy(m->functions); + free(m); +} + +typedef struct +{ + SpvOp op; + uint16_t size; +} mspv_op; + + +typedef mspv_array(uint32_t) mspv_spv; +static inline void mspv_write_op( mspv_spv *as, SpvOp op, uint16_t ops ) +{ + mspv_array_push((*as), op | (ops+1) << 16); +}; + +static inline void mspv_write_string( mspv_spv *as, mspv_string_view s ) +{ + uint32_t u; + uint32_t val; + char cval[4]; + for ( u = 0; u < s.len/4; u++ ) + { + mspv_array_push((*as), *(uint32_t*)(s.data+u*4)); + } + if (!(s.len%4)) + { + mspv_array_push((*as), 0); + } + else + { + cval[0] = 0; + cval[0] = 1; + cval[0] = 2; + cval[0] = 3; + + for (u = 0; u < s.len%4; u++) + { + cval[u] = s.data[(s.len/4)*4+u]; + } + mspv_array_push((*as), *(uint32_t*)cval); + } +}; + +static inline void mspv_write_dv( mspv_spv *as, mspv_data_view s ) +{ + uint32_t u; + for ( u = 0; u < s.len; u++ ) + { + mspv_array_push((*as), *(s.data+u)); + } +} + +mspv_spv mspv_write_module( mspv_module *m ) +{ + mspv_spv as; + uint32_t u; + uint32_t n; + uint32_t il; + + mspv_array_zero(as); + + if (m == NULL) + return as; + + mspv_array_push(as, m->header.magic); + mspv_array_push(as, m->header.reserved1); + mspv_array_push(as, m->header.reserved2); + mspv_array_push(as, m->header.reserved3); + mspv_array_push(as, m->header.reserved4); + + for ( u = 0; u < m->capabilities.count; u++ ) + { + mspv_write_op(&as, SpvOpCapability, 1); + mspv_array_push(as, m->capabilities.data[u]); + } + for ( u = 0; u < m->extensions.count; u++ ) + { + il = 0; + if (m->extensions.data[u].len%4) + il = m->extensions.data[u].len/4+1; + else + il = m->extensions.data[u].len/4+2; + mspv_write_op(&as, SpvOpExtension, il); + mspv_write_string(&as, m->extensions.data[u]); + } + + for ( u = 0; u < m->ext_instructions.count; u++ ) + { + + il = 0; + if (m->ext_instructions.data[u].name.len%4) + il = m->ext_instructions.data[u].name.len/4+2; + else + il = m->ext_instructions.data[u].name.len/4+3; + mspv_write_op(&as, SpvOpExtInstImport, il); + mspv_array_push(as, m->ext_instructions.data[u].id); + mspv_write_string(&as, m->ext_instructions.data[u].name); + } + for ( u = 0; u < m->entry_points.count; u++ ) + { + il = 0; + if (m->entry_points.data[u].name.len%4) + il = m->entry_points.data[u].name.len/4+2; + else + il = m->entry_points.data[u].name.len/4+3; + il += m->entry_points.data[u].params.count; + mspv_write_op(&as, SpvOpEntryPoint, il); + mspv_array_push(as, m->entry_points.data[u].model); + mspv_array_push(as, m->entry_points.data[u].id); + mspv_write_string(&as, m->entry_points.data[u].name); + for ( n = 0; n < m->entry_points.data[u].params.count; n++ ) + { + mspv_array_push(as, m->entry_points.data[u].params.data[n]); + } + } + + + + mspv_write_op(&as, SpvOpMemoryModel, 2); + mspv_array_push(as, m->addressing_model); + mspv_array_push(as, m->memory_model); + + for ( u = 0; u < m->types.count; u++ ) + { + mspv_write_op(&as, (SpvOp)m->types.data[u].dv.data[0], m->types.data[u].dv.len-1); + mspv_array_push(as, m->types.data[u].id); + if (m->types.data[u].dv.len-2) + mspv_write_dv(&as, {m->types.data[u].dv.data+2, m->types.data[u].dv.len-2}); + } + for ( u = 0; u < m->variables.count; u++ ) + { + mspv_write_op(&as, SpvOpVariable, m->variables.data[u].initializer ? 4 : 3); + mspv_array_push(as, m->variables.data[u].resulttype); + mspv_array_push(as, m->variables.data[u].result); + mspv_array_push(as, m->variables.data[u].storageclass); + if (m->variables.data[u].initializer) + { + mspv_array_push(as, m->variables.data[u].initializer); + + } + } + + for ( u = 0; u < m->functions.count; u++ ) + { + mspv_write_op(&as, SpvOpFunction, 4); + mspv_array_push(as, m->functions.data[u].resulttype); + mspv_array_push(as, m->functions.data[u].result); + mspv_array_push(as, m->functions.data[u].functionctrl); + mspv_array_push(as, m->functions.data[u].functiontype); + + mspv_write_dv(&as, m->functions.data[u].instructions); + + mspv_write_op(&as, SpvOpFunctionEnd, 0); + } + + + + return as; + +} + +//#endif +#ifdef __cplusplus +} +#endif + +#endif diff --git a/public/iphysics.h b/public/iphysics.h index e4c87c5..2398049 100644 --- a/public/iphysics.h +++ b/public/iphysics.h @@ -40,6 +40,8 @@ struct CastResult_t float m_fTime; // 0 to lenght float m_fDistance; + + Vector m_vNormal; }; enum EPhysicsBodyType @@ -65,6 +67,8 @@ public: virtual void SetGravityScale( float fScale ) = 0; }; +typedef bool (*fnCheckCast)( HCollider hCollider ); + abstract_class IPhysicsWorld { public: @@ -75,8 +79,8 @@ public: virtual void SetGravity( float fGravity ) = 0; - virtual CastResult_t RayCast( Vector vBegin, Vector vEnd ) = 0; - virtual CastResult_t ShapeCast( HShape hShape, Quat vOrientation, Vector vBegin, Vector vEnd ) = 0; + virtual CastResult_t RayCast( Vector vBegin, Vector vEnd, fnCheckCast check ) = 0; + virtual CastResult_t ShapeCast( HShape hShape, Quat vOrientation, Vector vBegin, Vector vEnd, fnCheckCast check ) = 0; }; diff --git a/public/materialsystem/imaterialsystem.h b/public/materialsystem/imaterialsystem.h index 17e2efa..efd9b8c 100644 --- a/public/materialsystem/imaterialsystem.h +++ b/public/materialsystem/imaterialsystem.h @@ -200,6 +200,7 @@ public: abstract_class IBaseShader { public: + virtual ~IBaseShader() = default; virtual void Build() = 0; }; @@ -219,17 +220,19 @@ public: virtual void DisablePixelShader( bool bDisable) = 0; }; -abstract_class IComputeShader +abstract_class IComputeShader: public IBaseShader { public: }; -abstract_class IRayTracingShader +abstract_class IRayTracingShader: public IBaseShader { public: - virtual uint32_t GetMissShaderBinding( const char *szName ); - virtual uint32_t GetClosestHitShaderBinding( const char *szName ); - virtual uint32_t GetCallableShaderBinding( const char *szName ); + virtual uint32_t GetMissShaderBinding( const char *szName ) = 0; + virtual uint32_t GetClosestHitShaderBinding( const char *szName ) = 0; + virtual uint32_t GetCallableShaderBinding( const char *szName ) = 0; + virtual void AddShader( const char *szName, const char *szPath ) = 0; + virtual void RemoveShader( const char *szName ) = 0; }; //----------------------------------------------------------------------------- @@ -299,7 +302,9 @@ public: virtual void DestroyImage( IImage *pImage ) = 0; virtual IShader *CreateShader( const char *szName ) = 0; - virtual void DestroyShader( IShader *pMaterial ) = 0; + virtual IRayTracingShader *CreateRayShader( const char *szName ) = 0; + virtual IComputeShader *CreateComputeShader( const char *szName ) = 0; + virtual void DestroyShader( IBaseShader *pMaterial ) = 0; virtual IMaterial *CreateMaterial( IShader *pShader ) = 0; virtual void DestroyMaterial( IMaterial *pMaterial ) = 0; diff --git a/rapier/physics.cpp b/rapier/physics.cpp index ad80392..cc4a089 100644 --- a/rapier/physics.cpp +++ b/rapier/physics.cpp @@ -52,6 +52,12 @@ public: RapierPhysicsBody_t *m_pBody = NULL; }; + +struct Option_checkCastFn +{ + fnCheckCast c; +}; + class CRapierPhysicsWorld: public IPhysicsWorld { public: @@ -80,14 +86,14 @@ public: } - virtual CastResult_t RayCast( Vector vBegin, Vector vEnd ) override + virtual CastResult_t RayCast( Vector vBegin, Vector vEnd, fnCheckCast check ) override { - return CRapierPhysicsWorld_RayCast(m_pWorld, vBegin, vEnd); + return CRapierPhysicsWorld_RayCast(m_pWorld, vBegin, vEnd, (Option_checkCastFn){check} ); } - virtual CastResult_t ShapeCast( HShape hShape, Quat vOrientation, Vector vBegin, Vector vEnd ) override + virtual CastResult_t ShapeCast( HShape hShape, Quat vOrientation, Vector vBegin, Vector vEnd, fnCheckCast check ) override { - return CRapierPhysicsWorld_ShapeCast(m_pWorld, (RapierShape_t*)hShape, vOrientation, vBegin, vEnd ); + return CRapierPhysicsWorld_ShapeCast(m_pWorld, (RapierShape_t*)hShape, vOrientation, vBegin, vEnd, (Option_checkCastFn){check} ); } diff --git a/rapier/physics.h b/rapier/physics.h index d9d6326..e3829a6 100644 --- a/rapier/physics.h +++ b/rapier/physics.h @@ -10,6 +10,8 @@ typedef enum EPhysicsBodyType { k_EPhysics_KinematicVelocityBased, } EPhysicsBodyType; +typedef struct Option_checkCastFn Option_checkCastFn; + typedef struct RapierCollider_t RapierCollider_t; typedef struct RapierPhysicsBody_t RapierPhysicsBody_t; @@ -39,6 +41,7 @@ typedef struct CastResult_t { struct Vector m_vCollisionPoint; float m_fTime; float m_fDistance; + struct Vector m_vNormal; } CastResult_t; typedef struct BallShape_t { @@ -87,13 +90,15 @@ void CRapierPhysicsWorld_Frame(struct RapierWorld_t *this_, float fDelta); struct CastResult_t CRapierPhysicsWorld_RayCast(struct RapierWorld_t *this_, struct Vector vBegin, - struct Vector vEnd); + struct Vector vEnd, + struct Option_checkCastFn checkCast); struct CastResult_t CRapierPhysicsWorld_ShapeCast(struct RapierWorld_t *this_, struct RapierShape_t *pShape, struct Quat vOrientation, struct Vector vBegin, - struct Vector vEnd); + struct Vector vEnd, + struct Option_checkCastFn checkCast); struct RapierShape_t *CRapierPhysics_CreateBall(struct RapierPhysics_t *this_, struct BallShape_t ball); @@ -109,6 +114,8 @@ struct RapierShape_t *CRapierPhysics_CreateTriangleMesh(struct RapierPhysics_t * struct RapierWorld_t *CRapierPhysics_CreateWorld(struct RapierPhysics_t *this_); +void CRapierPhysics_DestroyShape(struct RapierPhysics_t *this_, struct RapierShape_t *shape); + struct RapierPhysics_t *CRapierPhysics_New(void); #ifdef __cplusplus diff --git a/rapier/physics.rs b/rapier/physics.rs index bf7cc89..bc514a6 100644 --- a/rapier/physics.rs +++ b/rapier/physics.rs @@ -20,6 +20,8 @@ use parry3d::{glamx::{Pose3A}, query::ShapeCastOptions}; use rapier3d::{geometry::Ball, na::{UnitQuaternion, Vector4, coordinates::XYZ}}; use rapier3d::prelude::*; use libc::{malloc, free}; +use std::ffi::c_void; +use std::sync::Mutex; #[repr(C)] #[derive(Default, Debug)] @@ -95,6 +97,7 @@ pub struct CastResult_t m_vCollisionPoint: Vector, m_fTime: f32, m_fDistance: f32, + m_vNormal: Vector, } #[derive(Clone)] @@ -242,8 +245,12 @@ pub unsafe extern "C" fn CRapierPhysicsWorld_CreateRigidBody( pBody } +type checkCastFn = extern "C" fn( pCollider: *mut RapierCollider_t ) -> bool; + + + #[no_mangle] -pub unsafe extern "C" fn CRapierPhysicsWorld_RayCast( this: *mut RapierWorld_t, vBegin: Vector, vEnd: Vector ) -> CastResult_t +pub unsafe extern "C" fn CRapierPhysicsWorld_RayCast( this: *mut RapierWorld_t, vBegin: Vector, vEnd: Vector, checkCast: Option ) -> CastResult_t { let mut cast = CastResult_t::default(); let vDir = Vector{ x: vEnd.x-vBegin.x, y:vEnd.y-vBegin.y, z:vEnd.z-vBegin.z}; @@ -252,11 +259,22 @@ pub unsafe extern "C" fn CRapierPhysicsWorld_RayCast( this: *mut RapierWorld_t, let ray = Ray::new( Vec3 { x: vBegin.x, y: vBegin.y, z: vBegin.z }, Vec3 { x: vNormalizedDir.x, y: vNormalizedDir.y, z: vNormalizedDir.z }); + + let mut filter = QueryFilter::default(); + + let predicate = |handle: ColliderHandle, collider: &Collider| -> bool { + checkCast.unwrap()(collider.user_data as *mut RapierCollider_t) + }; + if let Some(f) = checkCast + { + filter.predicate = Option::Some(&predicate); + } + let queryPipeline = (*this).m_broadPhase.as_query_pipeline( (*this).m_narrowPhase.query_dispatcher(), &(*this).m_rigidBodies, &(*this).m_colliders, - QueryFilter::default(), + filter, ); if let Some((handle, intersection)) = queryPipeline.cast_ray_and_get_normal(&ray, fMaxDistance, true) { @@ -268,25 +286,43 @@ pub unsafe extern "C" fn CRapierPhysicsWorld_RayCast( this: *mut RapierWorld_t, y: vBegin.y + vNormalizedDir.y * intersection.time_of_impact, z: vBegin.z + vNormalizedDir.z * intersection.time_of_impact, }; + cast.m_vNormal = Vector{ + x: intersection.normal.x, + y: intersection.normal.y, + z: intersection.normal.y, + } } cast } + #[no_mangle] -pub unsafe extern "C" fn CRapierPhysicsWorld_ShapeCast( this: *mut RapierWorld_t, pShape: *mut RapierShape_t, vOrientation: Quat, vBegin: Vector, vEnd: Vector ) -> CastResult_t +pub unsafe extern "C" fn CRapierPhysicsWorld_ShapeCast( this: *mut RapierWorld_t, pShape: *mut RapierShape_t, vOrientation: Quat, vBegin: Vector, vEnd: Vector, checkCast: Option ) -> CastResult_t { let mut cast = CastResult_t::default(); let vDir = Vector{ x: vEnd.x-vBegin.x, y:vEnd.y-vBegin.y, z:vEnd.z-vBegin.z}; let fMaxDistance = f32::sqrt(vDir.x*vDir.x+vDir.y*vDir.y+vDir.z*vDir.z); let vNormalizedDir = Vector{ x: vDir.x/fMaxDistance, y:vDir.y/fMaxDistance, z:vDir.z/fMaxDistance}; + + let mut filter = QueryFilter::default(); + + let predicate = |handle: ColliderHandle, collider: &Collider| -> bool { + checkCast.unwrap()(collider.user_data as *mut RapierCollider_t) + }; + if let Some(f) = checkCast + { + filter.predicate = Option::Some(&predicate); + } + let queryPipeline = (*this).m_broadPhase.as_query_pipeline( (*this).m_narrowPhase.query_dispatcher(), &(*this).m_rigidBodies, &(*this).m_colliders, - QueryFilter::default(), + filter, ); let vRustDir = Vector{ x: vNormalizedDir.x, y: vNormalizedDir.y, z: vNormalizedDir.z }; + let mut castOptions = ShapeCastOptions::default(); castOptions.stop_at_penetration = true; castOptions.max_time_of_impact = fMaxDistance; @@ -315,6 +351,11 @@ pub unsafe extern "C" fn CRapierPhysicsWorld_ShapeCast( this: *mut RapierWorld_t y: vBegin.y + vNormalizedDir.y * intersection.time_of_impact, z: vBegin.z + vNormalizedDir.z * intersection.time_of_impact, }; + cast.m_vNormal = Vector{ + x: intersection.normal1.x, + y: intersection.normal1.y, + z: intersection.normal1.z, + } } cast @@ -394,6 +435,12 @@ pub unsafe extern "C" fn CRapierPhysics_CreateTriangleMesh( this: *mut RapierPhy } pShapeMemory } +#[no_mangle] +pub unsafe extern "C" fn CRapierPhysics_DestroyShape( this: *mut RapierPhysics_t, shape: *mut RapierShape_t ) +{ + std::ptr::drop_in_place(&mut (*shape).m_sharedShape); + free(shape as *mut c_void); +} #[no_mangle] pub unsafe extern "C" fn CRapierPhysics_CreateCollider( this: *mut RapierPhysics_t, pShape: *mut RapierShape_t ) -> *mut RapierCollider_t @@ -401,6 +448,7 @@ pub unsafe extern "C" fn CRapierPhysics_CreateCollider( this: *mut RapierPhysics let shape: &SharedShape = &(*pShape).m_sharedShape; let pCollider = V_malloc!(RapierCollider_t, 1); std::ptr::write(&mut (*pCollider).m_collider, ColliderBuilder::new(shape.clone()).build()); + (*pCollider).m_collider.user_data = pCollider as u128; pCollider } diff --git a/shadercompiler/slang/vulkan_spirv.cpp b/shadercompiler/slang/vulkan_spirv.cpp index e902d40..87f6487 100644 --- a/shadercompiler/slang/vulkan_spirv.cpp +++ b/shadercompiler/slang/vulkan_spirv.cpp @@ -72,6 +72,9 @@ void CSlangVulkanSpirvShaderCompiler::CompileShaderStage( EShaderStage eStage, c case SHADER_STAGE_CALLABLE: eSlangStage = SLANG_STAGE_CALLABLE; break; + case SHADER_STAGE_CALLABLE_SOFTWARE: + eSlangStage = SLANG_STAGE_COMPUTE; + break; default: break; } @@ -88,16 +91,16 @@ void CSlangVulkanSpirvShaderCompiler::CompileShaderStage( EShaderStage eStage, c VariableLayoutReflection *pVar = pProgramLayout->getParameterByIndex(u); input = {}; input.uCount = 1; - V_printf("%s %i\n", pVar->getName(), pVar->getType()->getKind()); + //V_printf("%s %i\n", pVar->getName(), pVar->getType()->getKind()); TypeReflection *pType = pVar->getType(); trygetkind: - V_printf("%s %i\n", pType->getName(), pType->getKind()); + //V_printf("%s %i\n", pType->getName(), pType->getKind()); switch(pType->getKind()) { case slang::TypeReflection::Kind::ConstantBuffer: input.eDescriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; break; - V_printf("%s: %i\n", pType->getName(), pType->getResourceShape()); + //V_printf("%s: %i\n", pType->getName(), pType->getResourceShape()); switch(pType->getResourceShape()) { case SLANG_TEXTURE_2D: @@ -111,7 +114,7 @@ trygetkind: } break; case slang::TypeReflection::Kind::Resource: - V_printf("%s: %i\n", pType->getName(), pType->getResourceShape()); + //V_printf("%s: %i\n", pType->getName(), pType->getResourceShape()); switch(pType->getResourceShape()) { case SLANG_TEXTURE_2D: @@ -187,13 +190,9 @@ trygetkind: pShaderObject->m_nMetadataLump = pShader->AllocateLump(sizeof(VulkanInputMetaData_t)); V_memcpy(pShader->GetLumpPtr(pShaderObject->m_nDataLump), pBinary->getBufferPointer(), pBinary->getBufferSize()); V_memcpy(pShader->GetLumpPtr(pShaderObject->m_nMetadataLump), &stMetadata, sizeof(VulkanInputMetaData_t)); - if (eStage == SHADER_STAGE_CALLABLE) - { - IFileHandle *ph = filesystem->Open("a.txt", FILEMODE_WRITE); - filesystem->Write(ph, pBinary->getBufferPointer(), pBinary->getBufferSize()); - filesystem->Close(ph); - - } + IFileHandle *ph = filesystem->Open(szMain, FILEMODE_WRITE); + filesystem->Write(ph, pBinary->getBufferPointer(), pBinary->getBufferSize()); + filesystem->Close(ph); pEntryPoint->release(); } @@ -246,10 +245,6 @@ void CSlangVulkanSpirvShaderCompiler::CompileShader( const char *szInput, CCompi szMainName = "psMain"; stStageMacroDesc[0] = { "PS_SHADER", "Enabled" }; break; - case SHADER_STAGE_CALLABLE: - szMainName = "brdfMain"; - stStageMacroDesc[0] = { "BRDF_SHADER", "Enabled" }; - break; case SHADER_STAGE_RAYGEN: szMainName = "rayMain"; stStageMacroDesc[0] = { "RAY_SHADER", "Enabled" }; @@ -260,6 +255,16 @@ void CSlangVulkanSpirvShaderCompiler::CompileShader( const char *szInput, CCompi stStageMacroDesc[1] = { "SOFTWARE_RAY_TRACING", "Enabled" }; stSessionDesc.preprocessorMacroCount = 2; break; + case SHADER_STAGE_CALLABLE: + szMainName = "CallableMain"; + stStageMacroDesc[0] = { "CALLABLE_SHADER", "Enabled" }; + break; + case SHADER_STAGE_CALLABLE_SOFTWARE: + szMainName = "CallableMain"; + stStageMacroDesc[0] = { "CALLABLE_SHADER", "Enabled" }; + stStageMacroDesc[1] = { "SOFTWARE_RAY_TRACING", "Enabled" }; + stSessionDesc.preprocessorMacroCount = 2; + break; default: break; } @@ -267,7 +272,7 @@ void CSlangVulkanSpirvShaderCompiler::CompileShader( const char *szInput, CCompi if ( szMainName == NULL ) continue; pSession = NULL; - V_printf("Cool\n"); + //V_printf("Cool\n"); s_pGlobalSession->createSession(stSessionDesc, &pSession); pModule = pSession->loadModuleFromSource("main", szInput, pShaderSourceBlob, &m_pDiagnostics);