Google Git
Sign in
dawn / dawn / c0edc5b539404c4ac36c5971b0f0d63b8f670cb2 / . / src / tint / lang / hlsl / intrinsic / data.cc
blob: ff76180dd7152d27b2b94e8226787ba5b3d7c11f [file] [log] [blame]
// Copyright 2024 The Dawn & Tint Authors
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
////////////////////////////////////////////////////////////////////////////////
// File generated by 'tools/src/cmd/gen' using the template:
// src/tint/lang/hlsl/intrinsic/data.cc.tmpl
//
// To regenerate run: './tools/run gen'
//
// Do not modify this file directly
////////////////////////////////////////////////////////////////////////////////
#include <limits>
#include <string>
#include "src/tint/lang/core/intrinsic/type_matchers.h"
#include "src/tint/lang/hlsl/intrinsic/dialect.h"
#include "src/tint/lang/hlsl/intrinsic/type_matchers.h"
#include "src/tint/utils/text/string_stream.h"
namespace tint::hlsl::intrinsic {
using namespace tint::core::intrinsic; // NOLINT(build/namespaces)
namespace {
using ConstEvalFunctionIndex = tint::core::intrinsic::ConstEvalFunctionIndex;
using IntrinsicInfo = tint::core::intrinsic::IntrinsicInfo;
using MatcherIndicesIndex = tint::core::intrinsic::MatcherIndicesIndex;
using MatchState = tint::core::intrinsic::MatchState;
using Number = tint::core::intrinsic::Number;
using NumberMatcher = tint::core::intrinsic::NumberMatcher;
using NumberMatcherIndex = tint::core::intrinsic::NumberMatcherIndex;
using OverloadFlag = tint::core::intrinsic::OverloadFlag;
using OverloadFlags = tint::core::intrinsic::OverloadFlags;
using OverloadIndex = tint::core::intrinsic::OverloadIndex;
using OverloadInfo = tint::core::intrinsic::OverloadInfo;
using ParameterIndex = tint::core::intrinsic::ParameterIndex;
using ParameterInfo = tint::core::intrinsic::ParameterInfo;
using StringStream = tint::StringStream;
using TemplateIndex = tint::core::intrinsic::TemplateIndex;
using Type = tint::core::type::Type;
using TypeMatcher = tint::core::intrinsic::TypeMatcher;
using TypeMatcherIndex = tint::core::intrinsic::TypeMatcherIndex;
template <size_t N>
using TemplateNumberMatcher = tint::core::intrinsic::TemplateNumberMatcher<N>;
template <size_t N>
using TemplateTypeMatcher = tint::core::intrinsic::TemplateTypeMatcher<N>;
// clang-format off
/// TypeMatcher for 'type i32'
constexpr TypeMatcher kI32Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
if (!MatchI32(state, ty)) {
return nullptr;
}
return BuildI32(state, ty);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {
out << style::Type("i32");
}
};
/// TypeMatcher for 'type u32'
constexpr TypeMatcher kU32Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
if (!MatchU32(state, ty)) {
return nullptr;
}
return BuildU32(state, ty);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {
out << style::Type("u32");
}
};
/// TypeMatcher for 'type f32'
constexpr TypeMatcher kF32Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
if (!MatchF32(state, ty)) {
return nullptr;
}
return BuildF32(state, ty);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {
out << style::Type("f32");
}
};
/// TypeMatcher for 'type f16'
constexpr TypeMatcher kF16Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
if (!MatchF16(state, ty)) {
return nullptr;
}
return BuildF16(state, ty);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {
out << style::Type("f16");
}
};
/// TypeMatcher for 'type ptr'
constexpr TypeMatcher kPtrMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
Number S = Number::invalid;
const Type* T = nullptr;
Number A = Number::invalid;
if (!MatchPtr(state, ty, S, T, A)) {
return nullptr;
}
S = state.Num(S);
if (!S.IsValid()) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
A = state.Num(A);
if (!A.IsValid()) {
return nullptr;
}
return BuildPtr(state, ty, S, T, A);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText S;
state->PrintNum(S);StyledText T;
state->PrintType(T);StyledText A;
state->PrintNum(A);
out << style::Type("ptr", "<", S, ", ", T, ", ", A, ">");
}
};
/// TypeMatcher for 'type vec2'
constexpr TypeMatcher kVec2Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
const Type* T = nullptr;
if (!MatchVec2(state, ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return BuildVec2(state, ty, T);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
state->PrintType(T);
out << style::Type("vec2", "<", T, ">");
}
};
/// TypeMatcher for 'type vec3'
constexpr TypeMatcher kVec3Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
const Type* T = nullptr;
if (!MatchVec3(state, ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return BuildVec3(state, ty, T);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
state->PrintType(T);
out << style::Type("vec3", "<", T, ">");
}
};
/// TypeMatcher for 'type vec4'
constexpr TypeMatcher kVec4Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
const Type* T = nullptr;
if (!MatchVec4(state, ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return BuildVec4(state, ty, T);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
state->PrintType(T);
out << style::Type("vec4", "<", T, ">");
}
};
/// TypeMatcher for 'type vec'
constexpr TypeMatcher kVecMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
Number N = Number::invalid;
const Type* T = nullptr;
if (!MatchVec(state, ty, N, T)) {
return nullptr;
}
N = state.Num(N);
if (!N.IsValid()) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return BuildVec(state, ty, N, T);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText N;
state->PrintNum(N);StyledText T;
state->PrintType(T);
out << style::Type("vec", N, "<", T, ">");
}
};
/// TypeMatcher for 'type mat2x2'
constexpr TypeMatcher kMat2X2Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
const Type* T = nullptr;
if (!MatchMat2X2(state, ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return BuildMat2X2(state, ty, T);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
state->PrintType(T);
out << style::Type("mat2x2", "<", T, ">");
}
};
/// TypeMatcher for 'type mat2x3'
constexpr TypeMatcher kMat2X3Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
const Type* T = nullptr;
if (!MatchMat2X3(state, ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return BuildMat2X3(state, ty, T);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
state->PrintType(T);
out << style::Type("mat2x3", "<", T, ">");
}
};
/// TypeMatcher for 'type mat2x4'
constexpr TypeMatcher kMat2X4Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
const Type* T = nullptr;
if (!MatchMat2X4(state, ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return BuildMat2X4(state, ty, T);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
state->PrintType(T);
out << style::Type("mat2x4", "<", T, ">");
}
};
/// TypeMatcher for 'type mat3x2'
constexpr TypeMatcher kMat3X2Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
const Type* T = nullptr;
if (!MatchMat3X2(state, ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return BuildMat3X2(state, ty, T);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
state->PrintType(T);
out << style::Type("mat3x2", "<", T, ">");
}
};
/// TypeMatcher for 'type mat3x3'
constexpr TypeMatcher kMat3X3Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
const Type* T = nullptr;
if (!MatchMat3X3(state, ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return BuildMat3X3(state, ty, T);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
state->PrintType(T);
out << style::Type("mat3x3", "<", T, ">");
}
};
/// TypeMatcher for 'type mat3x4'
constexpr TypeMatcher kMat3X4Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
const Type* T = nullptr;
if (!MatchMat3X4(state, ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return BuildMat3X4(state, ty, T);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
state->PrintType(T);
out << style::Type("mat3x4", "<", T, ">");
}
};
/// TypeMatcher for 'type mat4x2'
constexpr TypeMatcher kMat4X2Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
const Type* T = nullptr;
if (!MatchMat4X2(state, ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return BuildMat4X2(state, ty, T);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
state->PrintType(T);
out << style::Type("mat4x2", "<", T, ">");
}
};
/// TypeMatcher for 'type mat4x3'
constexpr TypeMatcher kMat4X3Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
const Type* T = nullptr;
if (!MatchMat4X3(state, ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return BuildMat4X3(state, ty, T);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
state->PrintType(T);
out << style::Type("mat4x3", "<", T, ">");
}
};
/// TypeMatcher for 'type mat4x4'
constexpr TypeMatcher kMat4X4Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
const Type* T = nullptr;
if (!MatchMat4X4(state, ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return BuildMat4X4(state, ty, T);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
state->PrintType(T);
out << style::Type("mat4x4", "<", T, ">");
}
};
/// TypeMatcher for 'type mat'
constexpr TypeMatcher kMatMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
Number N = Number::invalid;
Number M = Number::invalid;
const Type* T = nullptr;
if (!MatchMat(state, ty, N, M, T)) {
return nullptr;
}
N = state.Num(N);
if (!N.IsValid()) {
return nullptr;
}
M = state.Num(M);
if (!M.IsValid()) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return BuildMat(state, ty, N, M, T);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText N;
state->PrintNum(N);StyledText M;
state->PrintNum(M);StyledText T;
state->PrintType(T);
out << style::Type("mat", N, "x", M, "<", T, ">");
}
};
/// TypeMatcher for 'type byte_address_buffer'
constexpr TypeMatcher kByteAddressBufferMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
Number A = Number::invalid;
if (!MatchByteAddressBuffer(state, ty, A)) {
return nullptr;
}
A = state.Num(A);
if (!A.IsValid()) {
return nullptr;
}
return BuildByteAddressBuffer(state, ty, A);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText A;
state->PrintNum(A);
out << style::Type("byte_address_buffer", "<", A, ">");
}
};
/// TypeMatcher for 'type sampler'
constexpr TypeMatcher kSamplerMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
if (!MatchSampler(state, ty)) {
return nullptr;
}
return BuildSampler(state, ty);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {
out << style::Type("sampler");
}
};
/// TypeMatcher for 'type sampler_comparison'
constexpr TypeMatcher kSamplerComparisonMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
if (!MatchSamplerComparison(state, ty)) {
return nullptr;
}
return BuildSamplerComparison(state, ty);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {
out << style::Type("sampler_comparison");
}
};
/// TypeMatcher for 'type texture_1d'
constexpr TypeMatcher kTexture1DMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
const Type* T = nullptr;
if (!MatchTexture1D(state, ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return BuildTexture1D(state, ty, T);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
state->PrintType(T);
out << style::Type("texture_1d", "<", T, ">");
}
};
/// TypeMatcher for 'type texture_2d'
constexpr TypeMatcher kTexture2DMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
const Type* T = nullptr;
if (!MatchTexture2D(state, ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return BuildTexture2D(state, ty, T);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
state->PrintType(T);
out << style::Type("texture_2d", "<", T, ">");
}
};
/// TypeMatcher for 'type texture_2d_array'
constexpr TypeMatcher kTexture2DArrayMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
const Type* T = nullptr;
if (!MatchTexture2DArray(state, ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return BuildTexture2DArray(state, ty, T);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
state->PrintType(T);
out << style::Type("texture_2d_array", "<", T, ">");
}
};
/// TypeMatcher for 'type texture_3d'
constexpr TypeMatcher kTexture3DMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
const Type* T = nullptr;
if (!MatchTexture3D(state, ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return BuildTexture3D(state, ty, T);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
state->PrintType(T);
out << style::Type("texture_3d", "<", T, ">");
}
};
/// TypeMatcher for 'type texture_cube'
constexpr TypeMatcher kTextureCubeMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
const Type* T = nullptr;
if (!MatchTextureCube(state, ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return BuildTextureCube(state, ty, T);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
state->PrintType(T);
out << style::Type("texture_cube", "<", T, ">");
}
};
/// TypeMatcher for 'type texture_cube_array'
constexpr TypeMatcher kTextureCubeArrayMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
const Type* T = nullptr;
if (!MatchTextureCubeArray(state, ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return BuildTextureCubeArray(state, ty, T);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
state->PrintType(T);
out << style::Type("texture_cube_array", "<", T, ">");
}
};
/// TypeMatcher for 'type texture_depth_2d'
constexpr TypeMatcher kTextureDepth2DMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
if (!MatchTextureDepth2D(state, ty)) {
return nullptr;
}
return BuildTextureDepth2D(state, ty);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {
out << style::Type("texture_depth_2d");
}
};
/// TypeMatcher for 'type texture_depth_2d_array'
constexpr TypeMatcher kTextureDepth2DArrayMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
if (!MatchTextureDepth2DArray(state, ty)) {
return nullptr;
}
return BuildTextureDepth2DArray(state, ty);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {
out << style::Type("texture_depth_2d_array");
}
};
/// TypeMatcher for 'type texture_depth_cube'
constexpr TypeMatcher kTextureDepthCubeMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
if (!MatchTextureDepthCube(state, ty)) {
return nullptr;
}
return BuildTextureDepthCube(state, ty);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {
out << style::Type("texture_depth_cube");
}
};
/// TypeMatcher for 'type texture_depth_cube_array'
constexpr TypeMatcher kTextureDepthCubeArrayMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
if (!MatchTextureDepthCubeArray(state, ty)) {
return nullptr;
}
return BuildTextureDepthCubeArray(state, ty);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {
out << style::Type("texture_depth_cube_array");
}
};
/// TypeMatcher for 'type texture_depth_multisampled_2d'
constexpr TypeMatcher kTextureDepthMultisampled2DMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
if (!MatchTextureDepthMultisampled2D(state, ty)) {
return nullptr;
}
return BuildTextureDepthMultisampled2D(state, ty);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {
out << style::Type("texture_depth_multisampled_2d");
}
};
/// TypeMatcher for 'type texture_multisampled_2d'
constexpr TypeMatcher kTextureMultisampled2DMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
const Type* T = nullptr;
if (!MatchTextureMultisampled2D(state, ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return BuildTextureMultisampled2D(state, ty, T);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
state->PrintType(T);
out << style::Type("texture_multisampled_2d", "<", T, ">");
}
};
/// TypeMatcher for 'type texture_storage_1d'
constexpr TypeMatcher kTextureStorage1DMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
Number F = Number::invalid;
Number A = Number::invalid;
if (!MatchTextureStorage1D(state, ty, F, A)) {
return nullptr;
}
F = state.Num(F);
if (!F.IsValid()) {
return nullptr;
}
A = state.Num(A);
if (!A.IsValid()) {
return nullptr;
}
return BuildTextureStorage1D(state, ty, F, A);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText F;
state->PrintNum(F);StyledText A;
state->PrintNum(A);
out << style::Type("texture_storage_1d", "<", F, ", ", A, ">");
}
};
/// TypeMatcher for 'type texture_storage_2d'
constexpr TypeMatcher kTextureStorage2DMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
Number F = Number::invalid;
Number A = Number::invalid;
if (!MatchTextureStorage2D(state, ty, F, A)) {
return nullptr;
}
F = state.Num(F);
if (!F.IsValid()) {
return nullptr;
}
A = state.Num(A);
if (!A.IsValid()) {
return nullptr;
}
return BuildTextureStorage2D(state, ty, F, A);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText F;
state->PrintNum(F);StyledText A;
state->PrintNum(A);
out << style::Type("texture_storage_2d", "<", F, ", ", A, ">");
}
};
/// TypeMatcher for 'type texture_storage_2d_array'
constexpr TypeMatcher kTextureStorage2DArrayMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
Number F = Number::invalid;
Number A = Number::invalid;
if (!MatchTextureStorage2DArray(state, ty, F, A)) {
return nullptr;
}
F = state.Num(F);
if (!F.IsValid()) {
return nullptr;
}
A = state.Num(A);
if (!A.IsValid()) {
return nullptr;
}
return BuildTextureStorage2DArray(state, ty, F, A);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText F;
state->PrintNum(F);StyledText A;
state->PrintNum(A);
out << style::Type("texture_storage_2d_array", "<", F, ", ", A, ">");
}
};
/// TypeMatcher for 'type texture_storage_3d'
constexpr TypeMatcher kTextureStorage3DMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
Number F = Number::invalid;
Number A = Number::invalid;
if (!MatchTextureStorage3D(state, ty, F, A)) {
return nullptr;
}
F = state.Num(F);
if (!F.IsValid()) {
return nullptr;
}
A = state.Num(A);
if (!A.IsValid()) {
return nullptr;
}
return BuildTextureStorage3D(state, ty, F, A);
},
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText F;
state->PrintNum(F);StyledText A;
state->PrintNum(A);
out << style::Type("texture_storage_3d", "<", F, ", ", A, ">");
}
};
/// TypeMatcher for 'match iu32'
constexpr TypeMatcher kIu32Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
if (MatchI32(state, ty)) {
return BuildI32(state, ty);
}
if (MatchU32(state, ty)) {
return BuildU32(state, ty);
}
return nullptr;
},
/* print */ [](MatchState*, StyledText& out) {
// Note: We pass nullptr to the Matcher.print() functions, as matchers do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
kI32Matcher.print(nullptr, out); out << style::Plain(" or "); kU32Matcher.print(nullptr, out);}
};
/// TypeMatcher for 'match fiu32'
constexpr TypeMatcher kFiu32Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
if (MatchF32(state, ty)) {
return BuildF32(state, ty);
}
if (MatchI32(state, ty)) {
return BuildI32(state, ty);
}
if (MatchU32(state, ty)) {
return BuildU32(state, ty);
}
return nullptr;
},
/* print */ [](MatchState*, StyledText& out) {
// Note: We pass nullptr to the Matcher.print() functions, as matchers do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
kF32Matcher.print(nullptr, out); out << style::Plain(", "); kI32Matcher.print(nullptr, out); out << style::Plain(" or "); kU32Matcher.print(nullptr, out);}
};
/// TypeMatcher for 'match f32_u32'
constexpr TypeMatcher kF32U32Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
if (MatchF32(state, ty)) {
return BuildF32(state, ty);
}
if (MatchU32(state, ty)) {
return BuildU32(state, ty);
}
return nullptr;
},
/* print */ [](MatchState*, StyledText& out) {
// Note: We pass nullptr to the Matcher.print() functions, as matchers do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
kF32Matcher.print(nullptr, out); out << style::Plain(" or "); kU32Matcher.print(nullptr, out);}
};
/// TypeMatcher for 'match f32_i32'
constexpr TypeMatcher kF32I32Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
if (MatchF32(state, ty)) {
return BuildF32(state, ty);
}
if (MatchI32(state, ty)) {
return BuildI32(state, ty);
}
return nullptr;
},
/* print */ [](MatchState*, StyledText& out) {
// Note: We pass nullptr to the Matcher.print() functions, as matchers do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
kF32Matcher.print(nullptr, out); out << style::Plain(" or "); kI32Matcher.print(nullptr, out);}
};
/// TypeMatcher for 'match f32_f16'
constexpr TypeMatcher kF32F16Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
if (MatchF32(state, ty)) {
return BuildF32(state, ty);
}
if (MatchF16(state, ty)) {
return BuildF16(state, ty);
}
return nullptr;
},
/* print */ [](MatchState*, StyledText& out) {
// Note: We pass nullptr to the Matcher.print() functions, as matchers do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
kF32Matcher.print(nullptr, out); out << style::Plain(" or "); kF16Matcher.print(nullptr, out);}
};
/// TypeMatcher for 'match fi32_f16'
constexpr TypeMatcher kFi32F16Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
if (MatchF32(state, ty)) {
return BuildF32(state, ty);
}
if (MatchI32(state, ty)) {
return BuildI32(state, ty);
}
if (MatchF16(state, ty)) {
return BuildF16(state, ty);
}
return nullptr;
},
/* print */ [](MatchState*, StyledText& out) {
// Note: We pass nullptr to the Matcher.print() functions, as matchers do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
kF32Matcher.print(nullptr, out); out << style::Plain(", "); kI32Matcher.print(nullptr, out); out << style::Plain(" or "); kF16Matcher.print(nullptr, out);}
};
/// EnumMatcher for 'match storage'
constexpr NumberMatcher kStorageMatcher {
/* match */ [](MatchState&, Number number) -> Number {
if (number.IsAny() || number.Value() == static_cast<uint32_t>(core::AddressSpace::kStorage)) {
return Number(static_cast<uint32_t>(core::AddressSpace::kStorage));
}
return Number::invalid;
},
/* print */ [](MatchState*, StyledText& out) {
out<< style::Enum("storage");
}
};
/// EnumMatcher for 'match function'
constexpr NumberMatcher kFunctionMatcher {
/* match */ [](MatchState&, Number number) -> Number {
if (number.IsAny() || number.Value() == static_cast<uint32_t>(core::AddressSpace::kFunction)) {
return Number(static_cast<uint32_t>(core::AddressSpace::kFunction));
}
return Number::invalid;
},
/* print */ [](MatchState*, StyledText& out) {
out<< style::Enum("function");
}
};
/// EnumMatcher for 'match readable'
constexpr NumberMatcher kReadableMatcher {
/* match */ [](MatchState&, Number number) -> Number {
switch (static_cast<core::Access>(number.Value())) {
case core::Access::kRead:
case core::Access::kReadWrite:
return number;
default:
return Number::invalid;
}
},
/* print */ [](MatchState*, StyledText& out) {
out<< style::Enum("read")<< style::Plain(" or ") << style::Enum("read_write");
}
};
/// EnumMatcher for 'match writable'
constexpr NumberMatcher kWritableMatcher {
/* match */ [](MatchState&, Number number) -> Number {
switch (static_cast<core::Access>(number.Value())) {
case core::Access::kWrite:
case core::Access::kReadWrite:
return number;
default:
return Number::invalid;
}
},
/* print */ [](MatchState*, StyledText& out) {
out<< style::Enum("write")<< style::Plain(" or ") << style::Enum("read_write");
}
};
/// Type and number matchers
/// The template types, types, and type matchers
constexpr TypeMatcher kTypeMatchers[] = {
/* [0] */ TemplateTypeMatcher<0>::matcher,
/* [1] */ TemplateTypeMatcher<1>::matcher,
/* [2] */ TemplateTypeMatcher<2>::matcher,
/* [3] */ TemplateTypeMatcher<3>::matcher,
/* [4] */ kI32Matcher,
/* [5] */ kU32Matcher,
/* [6] */ kF32Matcher,
/* [7] */ kF16Matcher,
/* [8] */ kPtrMatcher,
/* [9] */ kVec2Matcher,
/* [10] */ kVec3Matcher,
/* [11] */ kVec4Matcher,
/* [12] */ kVecMatcher,
/* [13] */ kMat2X2Matcher,
/* [14] */ kMat2X3Matcher,
/* [15] */ kMat2X4Matcher,
/* [16] */ kMat3X2Matcher,
/* [17] */ kMat3X3Matcher,
/* [18] */ kMat3X4Matcher,
/* [19] */ kMat4X2Matcher,
/* [20] */ kMat4X3Matcher,
/* [21] */ kMat4X4Matcher,
/* [22] */ kMatMatcher,
/* [23] */ kByteAddressBufferMatcher,
/* [24] */ kSamplerMatcher,
/* [25] */ kSamplerComparisonMatcher,
/* [26] */ kTexture1DMatcher,
/* [27] */ kTexture2DMatcher,
/* [28] */ kTexture2DArrayMatcher,
/* [29] */ kTexture3DMatcher,
/* [30] */ kTextureCubeMatcher,
/* [31] */ kTextureCubeArrayMatcher,
/* [32] */ kTextureDepth2DMatcher,
/* [33] */ kTextureDepth2DArrayMatcher,
/* [34] */ kTextureDepthCubeMatcher,
/* [35] */ kTextureDepthCubeArrayMatcher,
/* [36] */ kTextureDepthMultisampled2DMatcher,
/* [37] */ kTextureMultisampled2DMatcher,
/* [38] */ kTextureStorage1DMatcher,
/* [39] */ kTextureStorage2DMatcher,
/* [40] */ kTextureStorage2DArrayMatcher,
/* [41] */ kTextureStorage3DMatcher,
/* [42] */ kIu32Matcher,
/* [43] */ kFiu32Matcher,
/* [44] */ kF32U32Matcher,
/* [45] */ kF32I32Matcher,
/* [46] */ kF32F16Matcher,
/* [47] */ kFi32F16Matcher,
};
/// The template numbers, and number matchers
constexpr NumberMatcher kNumberMatchers[] = {
/* [0] */ TemplateNumberMatcher<0>::matcher,
/* [1] */ TemplateNumberMatcher<1>::matcher,
/* [2] */ TemplateNumberMatcher<2>::matcher,
/* [3] */ TemplateNumberMatcher<3>::matcher,
/* [4] */ kStorageMatcher,
/* [5] */ kFunctionMatcher,
/* [6] */ kReadableMatcher,
/* [7] */ kWritableMatcher,
};
constexpr MatcherIndex kMatcherIndices[] = {
/* [0] */ MatcherIndex(22),
/* [1] */ MatcherIndex(2),
/* [2] */ MatcherIndex(1),
/* [3] */ MatcherIndex(0),
/* [4] */ MatcherIndex(22),
/* [5] */ MatcherIndex(3),
/* [6] */ MatcherIndex(2),
/* [7] */ MatcherIndex(0),
/* [8] */ MatcherIndex(22),
/* [9] */ MatcherIndex(3),
/* [10] */ MatcherIndex(1),
/* [11] */ MatcherIndex(0),
/* [12] */ MatcherIndex(22),
/* [13] */ MatcherIndex(1),
/* [14] */ MatcherIndex(2),
/* [15] */ MatcherIndex(0),
/* [16] */ MatcherIndex(8),
/* [17] */ MatcherIndex(5),
/* [18] */ MatcherIndex(5),
/* [19] */ MatcherIndex(7),
/* [20] */ MatcherIndex(12),
/* [21] */ MatcherIndex(1),
/* [22] */ MatcherIndex(4),
/* [23] */ MatcherIndex(12),
/* [24] */ MatcherIndex(1),
/* [25] */ MatcherIndex(0),
/* [26] */ MatcherIndex(12),
/* [27] */ MatcherIndex(1),
/* [28] */ MatcherIndex(5),
/* [29] */ MatcherIndex(12),
/* [30] */ MatcherIndex(1),
/* [31] */ MatcherIndex(6),
/* [32] */ MatcherIndex(12),
/* [33] */ MatcherIndex(0),
/* [34] */ MatcherIndex(5),
/* [35] */ MatcherIndex(12),
/* [36] */ MatcherIndex(0),
/* [37] */ MatcherIndex(6),
/* [38] */ MatcherIndex(12),
/* [39] */ MatcherIndex(2),
/* [40] */ MatcherIndex(0),
/* [41] */ MatcherIndex(12),
/* [42] */ MatcherIndex(0),
/* [43] */ MatcherIndex(4),
/* [44] */ MatcherIndex(12),
/* [45] */ MatcherIndex(0),
/* [46] */ MatcherIndex(1),
/* [47] */ MatcherIndex(38),
/* [48] */ MatcherIndex(0),
/* [49] */ MatcherIndex(1),
/* [50] */ MatcherIndex(39),
/* [51] */ MatcherIndex(0),
/* [52] */ MatcherIndex(1),
/* [53] */ MatcherIndex(40),
/* [54] */ MatcherIndex(0),
/* [55] */ MatcherIndex(1),
/* [56] */ MatcherIndex(41),
/* [57] */ MatcherIndex(0),
/* [58] */ MatcherIndex(1),
/* [59] */ MatcherIndex(23),
/* [60] */ MatcherIndex(6),
/* [61] */ MatcherIndex(9),
/* [62] */ MatcherIndex(5),
/* [63] */ MatcherIndex(10),
/* [64] */ MatcherIndex(5),
/* [65] */ MatcherIndex(11),
/* [66] */ MatcherIndex(5),
/* [67] */ MatcherIndex(9),
/* [68] */ MatcherIndex(7),
/* [69] */ MatcherIndex(10),
/* [70] */ MatcherIndex(7),
/* [71] */ MatcherIndex(11),
/* [72] */ MatcherIndex(7),
/* [73] */ MatcherIndex(23),
/* [74] */ MatcherIndex(7),
/* [75] */ MatcherIndex(23),
/* [76] */ MatcherIndex(0),
/* [77] */ MatcherIndex(26),
/* [78] */ MatcherIndex(0),
/* [79] */ MatcherIndex(27),
/* [80] */ MatcherIndex(0),
/* [81] */ MatcherIndex(28),
/* [82] */ MatcherIndex(0),
/* [83] */ MatcherIndex(29),
/* [84] */ MatcherIndex(0),
/* [85] */ MatcherIndex(30),
/* [86] */ MatcherIndex(0),
/* [87] */ MatcherIndex(31),
/* [88] */ MatcherIndex(0),
/* [89] */ MatcherIndex(37),
/* [90] */ MatcherIndex(0),
/* [91] */ MatcherIndex(44),
/* [92] */ MatcherIndex(45),
/* [93] */ MatcherIndex(42),
/* [94] */ MatcherIndex(46),
/* [95] */ MatcherIndex(47),
/* [96] */ MatcherIndex(43),
/* [97] */ MatcherIndex(32),
/* [98] */ MatcherIndex(33),
/* [99] */ MatcherIndex(34),
/* [100] */ MatcherIndex(35),
/* [101] */ MatcherIndex(36),
};
static_assert(MatcherIndicesIndex::CanIndex(kMatcherIndices),
"MatcherIndicesIndex is not large enough to index kMatcherIndices");
constexpr ParameterInfo kParameters[] = {
{
/* [0] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(81),
},
{
/* [1] */
/* usage */ core::ParameterUsage::kLevel,
/* matcher_indices */ MatcherIndicesIndex(17),
},
{
/* [2] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [3] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [4] */
/* usage */ core::ParameterUsage::kElements,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [5] */
/* usage */ core::ParameterUsage::kNumLevels,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [6] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(83),
},
{
/* [7] */
/* usage */ core::ParameterUsage::kLevel,
/* matcher_indices */ MatcherIndicesIndex(17),
},
{
/* [8] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [9] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [10] */
/* usage */ core::ParameterUsage::kDepth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [11] */
/* usage */ core::ParameterUsage::kNumLevels,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [12] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(87),
},
{
/* [13] */
/* usage */ core::ParameterUsage::kLevel,
/* matcher_indices */ MatcherIndicesIndex(17),
},
{
/* [14] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [15] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [16] */
/* usage */ core::ParameterUsage::kElements,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [17] */
/* usage */ core::ParameterUsage::kNumLevels,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [18] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(98),
},
{
/* [19] */
/* usage */ core::ParameterUsage::kLevel,
/* matcher_indices */ MatcherIndicesIndex(17),
},
{
/* [20] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [21] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [22] */
/* usage */ core::ParameterUsage::kElements,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [23] */
/* usage */ core::ParameterUsage::kNumLevels,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [24] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(100),
},
{
/* [25] */
/* usage */ core::ParameterUsage::kLevel,
/* matcher_indices */ MatcherIndicesIndex(17),
},
{
/* [26] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [27] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [28] */
/* usage */ core::ParameterUsage::kElements,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [29] */
/* usage */ core::ParameterUsage::kNumLevels,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [30] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(79),
},
{
/* [31] */
/* usage */ core::ParameterUsage::kLevel,
/* matcher_indices */ MatcherIndicesIndex(17),
},
{
/* [32] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [33] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [34] */
/* usage */ core::ParameterUsage::kNumLevels,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [35] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(85),
},
{
/* [36] */
/* usage */ core::ParameterUsage::kLevel,
/* matcher_indices */ MatcherIndicesIndex(17),
},
{
/* [37] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [38] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [39] */
/* usage */ core::ParameterUsage::kNumLevels,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [40] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(97),
},
{
/* [41] */
/* usage */ core::ParameterUsage::kLevel,
/* matcher_indices */ MatcherIndicesIndex(17),
},
{
/* [42] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [43] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [44] */
/* usage */ core::ParameterUsage::kNumLevels,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [45] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(99),
},
{
/* [46] */
/* usage */ core::ParameterUsage::kLevel,
/* matcher_indices */ MatcherIndicesIndex(17),
},
{
/* [47] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [48] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [49] */
/* usage */ core::ParameterUsage::kNumLevels,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [50] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(77),
},
{
/* [51] */
/* usage */ core::ParameterUsage::kLevel,
/* matcher_indices */ MatcherIndicesIndex(17),
},
{
/* [52] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [53] */
/* usage */ core::ParameterUsage::kNumLevels,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [54] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(81),
},
{
/* [55] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [56] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [57] */
/* usage */ core::ParameterUsage::kElements,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [58] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(53),
},
{
/* [59] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [60] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [61] */
/* usage */ core::ParameterUsage::kElements,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [62] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(83),
},
{
/* [63] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [64] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [65] */
/* usage */ core::ParameterUsage::kDepth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [66] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(56),
},
{
/* [67] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [68] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [69] */
/* usage */ core::ParameterUsage::kDepth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [70] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(87),
},
{
/* [71] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [72] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [73] */
/* usage */ core::ParameterUsage::kElements,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [74] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(89),
},
{
/* [75] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [76] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [77] */
/* usage */ core::ParameterUsage::kSamples,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [78] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(98),
},
{
/* [79] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [80] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [81] */
/* usage */ core::ParameterUsage::kElements,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [82] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(100),
},
{
/* [83] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [84] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [85] */
/* usage */ core::ParameterUsage::kElements,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [86] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(101),
},
{
/* [87] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [88] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [89] */
/* usage */ core::ParameterUsage::kSamples,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [90] */
/* usage */ core::ParameterUsage::kNone,
/* matcher_indices */ MatcherIndicesIndex(73),
},
{
/* [91] */
/* usage */ core::ParameterUsage::kOffset,
/* matcher_indices */ MatcherIndicesIndex(17),
},
{
/* [92] */
/* usage */ core::ParameterUsage::kValue,
/* matcher_indices */ MatcherIndicesIndex(17),
},
{
/* [93] */
/* usage */ core::ParameterUsage::kNone,
/* matcher_indices */ MatcherIndicesIndex(73),
},
{
/* [94] */
/* usage */ core::ParameterUsage::kOffset,
/* matcher_indices */ MatcherIndicesIndex(17),
},
{
/* [95] */
/* usage */ core::ParameterUsage::kValue,
/* matcher_indices */ MatcherIndicesIndex(61),
},
{
/* [96] */
/* usage */ core::ParameterUsage::kNone,
/* matcher_indices */ MatcherIndicesIndex(73),
},
{
/* [97] */
/* usage */ core::ParameterUsage::kOffset,
/* matcher_indices */ MatcherIndicesIndex(17),
},
{
/* [98] */
/* usage */ core::ParameterUsage::kValue,
/* matcher_indices */ MatcherIndicesIndex(63),
},
{
/* [99] */
/* usage */ core::ParameterUsage::kNone,
/* matcher_indices */ MatcherIndicesIndex(73),
},
{
/* [100] */
/* usage */ core::ParameterUsage::kOffset,
/* matcher_indices */ MatcherIndicesIndex(17),
},
{
/* [101] */
/* usage */ core::ParameterUsage::kValue,
/* matcher_indices */ MatcherIndicesIndex(65),
},
{
/* [102] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(79),
},
{
/* [103] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [104] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [105] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(50),
},
{
/* [106] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [107] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [108] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(85),
},
{
/* [109] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [110] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [111] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(97),
},
{
/* [112] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [113] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [114] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(99),
},
{
/* [115] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [116] */
/* usage */ core::ParameterUsage::kHeight,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [117] */
/* usage */ core::ParameterUsage::kNone,
/* matcher_indices */ MatcherIndicesIndex(0),
},
{
/* [118] */
/* usage */ core::ParameterUsage::kNone,
/* matcher_indices */ MatcherIndicesIndex(23),
},
{
/* [119] */
/* usage */ core::ParameterUsage::kNone,
/* matcher_indices */ MatcherIndicesIndex(38),
},
{
/* [120] */
/* usage */ core::ParameterUsage::kNone,
/* matcher_indices */ MatcherIndicesIndex(0),
},
{
/* [121] */
/* usage */ core::ParameterUsage::kNone,
/* matcher_indices */ MatcherIndicesIndex(8),
},
{
/* [122] */
/* usage */ core::ParameterUsage::kNone,
/* matcher_indices */ MatcherIndicesIndex(12),
},
{
/* [123] */
/* usage */ core::ParameterUsage::kNone,
/* matcher_indices */ MatcherIndicesIndex(59),
},
{
/* [124] */
/* usage */ core::ParameterUsage::kOffset,
/* matcher_indices */ MatcherIndicesIndex(17),
},
{
/* [125] */
/* usage */ core::ParameterUsage::kNone,
/* matcher_indices */ MatcherIndicesIndex(75),
},
{
/* [126] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [127] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(77),
},
{
/* [128] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [129] */
/* usage */ core::ParameterUsage::kTexture,
/* matcher_indices */ MatcherIndicesIndex(47),
},
{
/* [130] */
/* usage */ core::ParameterUsage::kWidth,
/* matcher_indices */ MatcherIndicesIndex(16),
},
{
/* [131] */
/* usage */ core::ParameterUsage::kNone,
/* matcher_indices */ MatcherIndicesIndex(3),
},
{
/* [132] */
/* usage */ core::ParameterUsage::kNone,
/* matcher_indices */ MatcherIndicesIndex(31),
},
{
/* [133] */
/* usage */ core::ParameterUsage::kNone,
/* matcher_indices */ MatcherIndicesIndex(35),
},
{
/* [134] */
/* usage */ core::ParameterUsage::kNone,
/* matcher_indices */ MatcherIndicesIndex(17),
},
{
/* [135] */
/* usage */ core::ParameterUsage::kNone,
/* matcher_indices */ MatcherIndicesIndex(32),
},
{
/* [136] */
/* usage */ core::ParameterUsage::kNone,
/* matcher_indices */ MatcherIndicesIndex(44),
},
};
static_assert(ParameterIndex::CanIndex(kParameters),
"ParameterIndex is not large enough to index kParameters");
constexpr TemplateInfo kTemplates[] = {
{
/* [0] */
/* name */ "T",
/* matcher_indices */ MatcherIndicesIndex(94),
/* kind */ TemplateInfo::Kind::kType,
},
{
/* [1] */
/* name */ "K",
/* matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* kind */ TemplateInfo::Kind::kNumber,
},
{
/* [2] */
/* name */ "C",
/* matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* kind */ TemplateInfo::Kind::kNumber,
},
{
/* [3] */
/* name */ "R",
/* matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* kind */ TemplateInfo::Kind::kNumber,
},
{
/* [4] */
/* name */ "T",
/* matcher_indices */ MatcherIndicesIndex(94),
/* kind */ TemplateInfo::Kind::kType,
},
{
/* [5] */
/* name */ "C",
/* matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* kind */ TemplateInfo::Kind::kNumber,
},
{
/* [6] */
/* name */ "R",
/* matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* kind */ TemplateInfo::Kind::kNumber,
},
{
/* [7] */
/* name */ "T",
/* matcher_indices */ MatcherIndicesIndex(91),
/* kind */ TemplateInfo::Kind::kType,
},
{
/* [8] */
/* name */ "N",
/* matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* kind */ TemplateInfo::Kind::kNumber,
},
{
/* [9] */
/* name */ "T",
/* matcher_indices */ MatcherIndicesIndex(95),
/* kind */ TemplateInfo::Kind::kType,
},
{
/* [10] */
/* name */ "T",
/* matcher_indices */ MatcherIndicesIndex(92),
/* kind */ TemplateInfo::Kind::kType,
},
{
/* [11] */
/* name */ "N",
/* matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* kind */ TemplateInfo::Kind::kNumber,
},
{
/* [12] */
/* name */ "T",
/* matcher_indices */ MatcherIndicesIndex(93),
/* kind */ TemplateInfo::Kind::kType,
},
{
/* [13] */
/* name */ "N",
/* matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* kind */ TemplateInfo::Kind::kNumber,
},
{
/* [14] */
/* name */ "F",
/* matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* kind */ TemplateInfo::Kind::kNumber,
},
{
/* [15] */
/* name */ "A",
/* matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* kind */ TemplateInfo::Kind::kNumber,
},
{
/* [16] */
/* name */ "T",
/* matcher_indices */ MatcherIndicesIndex(96),
/* kind */ TemplateInfo::Kind::kType,
},
};
static_assert(TemplateIndex::CanIndex(kTemplates),
"TemplateIndex is not large enough to index kTemplates");
constexpr OverloadInfo kOverloads[] = {
{
/* [0] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 2,
/* num_explicit_templates */ 0,
/* num_templates */ 1,
/* templates */ TemplateIndex(15),
/* parameters */ ParameterIndex(125),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [1] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 2,
/* num_explicit_templates */ 0,
/* num_templates */ 1,
/* templates */ TemplateIndex(16),
/* parameters */ ParameterIndex(127),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [2] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 4,
/* num_explicit_templates */ 0,
/* num_templates */ 1,
/* templates */ TemplateIndex(16),
/* parameters */ ParameterIndex(50),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [3] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 2,
/* num_explicit_templates */ 0,
/* num_templates */ 2,
/* templates */ TemplateIndex(14),
/* parameters */ ParameterIndex(129),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [4] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 3,
/* num_explicit_templates */ 0,
/* num_templates */ 1,
/* templates */ TemplateIndex(16),
/* parameters */ ParameterIndex(102),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [5] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 5,
/* num_explicit_templates */ 0,
/* num_templates */ 1,
/* templates */ TemplateIndex(16),
/* parameters */ ParameterIndex(30),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [6] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 3,
/* num_explicit_templates */ 0,
/* num_templates */ 2,
/* templates */ TemplateIndex(14),
/* parameters */ ParameterIndex(105),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [7] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 4,
/* num_explicit_templates */ 0,
/* num_templates */ 1,
/* templates */ TemplateIndex(16),
/* parameters */ ParameterIndex(54),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [8] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 6,
/* num_explicit_templates */ 0,
/* num_templates */ 1,
/* templates */ TemplateIndex(16),
/* parameters */ ParameterIndex(0),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [9] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 4,
/* num_explicit_templates */ 0,
/* num_templates */ 2,
/* templates */ TemplateIndex(14),
/* parameters */ ParameterIndex(58),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [10] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 4,
/* num_explicit_templates */ 0,
/* num_templates */ 1,
/* templates */ TemplateIndex(16),
/* parameters */ ParameterIndex(62),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [11] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 6,
/* num_explicit_templates */ 0,
/* num_templates */ 1,
/* templates */ TemplateIndex(16),
/* parameters */ ParameterIndex(6),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [12] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 4,
/* num_explicit_templates */ 0,
/* num_templates */ 2,
/* templates */ TemplateIndex(14),
/* parameters */ ParameterIndex(66),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [13] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 3,
/* num_explicit_templates */ 0,
/* num_templates */ 1,
/* templates */ TemplateIndex(16),
/* parameters */ ParameterIndex(108),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [14] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 5,
/* num_explicit_templates */ 0,
/* num_templates */ 1,
/* templates */ TemplateIndex(16),
/* parameters */ ParameterIndex(35),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [15] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 4,
/* num_explicit_templates */ 0,
/* num_templates */ 1,
/* templates */ TemplateIndex(16),
/* parameters */ ParameterIndex(70),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [16] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 6,
/* num_explicit_templates */ 0,
/* num_templates */ 1,
/* templates */ TemplateIndex(16),
/* parameters */ ParameterIndex(12),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [17] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 4,
/* num_explicit_templates */ 0,
/* num_templates */ 1,
/* templates */ TemplateIndex(16),
/* parameters */ ParameterIndex(74),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [18] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 3,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(111),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [19] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 5,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(40),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [20] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 4,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(78),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [21] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 6,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(18),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [22] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 3,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(114),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [23] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 5,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(45),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [24] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 4,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(82),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [25] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 6,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(24),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [26] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 4,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(86),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [27] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* num_parameters */ 2,
/* num_explicit_templates */ 0,
/* num_templates */ 3,
/* templates */ TemplateIndex(4),
/* parameters */ ParameterIndex(117),
/* return_matcher_indices */ MatcherIndicesIndex(38),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [28] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* num_parameters */ 2,
/* num_explicit_templates */ 0,
/* num_templates */ 3,
/* templates */ TemplateIndex(4),
/* parameters */ ParameterIndex(119),
/* return_matcher_indices */ MatcherIndicesIndex(23),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [29] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* num_parameters */ 2,
/* num_explicit_templates */ 0,
/* num_templates */ 4,
/* templates */ TemplateIndex(0),
/* parameters */ ParameterIndex(121),
/* return_matcher_indices */ MatcherIndicesIndex(4),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [30] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* num_parameters */ 1,
/* num_explicit_templates */ 0,
/* num_templates */ 1,
/* templates */ TemplateIndex(7),
/* parameters */ ParameterIndex(131),
/* return_matcher_indices */ MatcherIndicesIndex(22),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [31] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* num_parameters */ 1,
/* num_explicit_templates */ 0,
/* num_templates */ 2,
/* templates */ TemplateIndex(7),
/* parameters */ ParameterIndex(118),
/* return_matcher_indices */ MatcherIndicesIndex(20),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [32] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* num_parameters */ 1,
/* num_explicit_templates */ 0,
/* num_templates */ 1,
/* templates */ TemplateIndex(10),
/* parameters */ ParameterIndex(131),
/* return_matcher_indices */ MatcherIndicesIndex(17),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [33] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* num_parameters */ 1,
/* num_explicit_templates */ 0,
/* num_templates */ 2,
/* templates */ TemplateIndex(10),
/* parameters */ ParameterIndex(118),
/* return_matcher_indices */ MatcherIndicesIndex(26),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [34] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* num_parameters */ 1,
/* num_explicit_templates */ 0,
/* num_templates */ 1,
/* templates */ TemplateIndex(12),
/* parameters */ ParameterIndex(131),
/* return_matcher_indices */ MatcherIndicesIndex(31),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [35] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* num_parameters */ 1,
/* num_explicit_templates */ 0,
/* num_templates */ 2,
/* templates */ TemplateIndex(12),
/* parameters */ ParameterIndex(118),
/* return_matcher_indices */ MatcherIndicesIndex(29),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [36] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* num_parameters */ 1,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(132),
/* return_matcher_indices */ MatcherIndicesIndex(17),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [37] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* num_parameters */ 1,
/* num_explicit_templates */ 0,
/* num_templates */ 1,
/* templates */ TemplateIndex(8),
/* parameters */ ParameterIndex(133),
/* return_matcher_indices */ MatcherIndicesIndex(32),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [38] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* num_parameters */ 1,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(134),
/* return_matcher_indices */ MatcherIndicesIndex(31),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [39] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* num_parameters */ 1,
/* num_explicit_templates */ 0,
/* num_templates */ 1,
/* templates */ TemplateIndex(8),
/* parameters */ ParameterIndex(135),
/* return_matcher_indices */ MatcherIndicesIndex(35),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [40] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* num_parameters */ 1,
/* num_explicit_templates */ 0,
/* num_templates */ 1,
/* templates */ TemplateIndex(9),
/* parameters */ ParameterIndex(131),
/* return_matcher_indices */ MatcherIndicesIndex(22),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [41] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* num_parameters */ 1,
/* num_explicit_templates */ 0,
/* num_templates */ 2,
/* templates */ TemplateIndex(8),
/* parameters */ ParameterIndex(136),
/* return_matcher_indices */ MatcherIndicesIndex(41),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [42] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 2,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(123),
/* return_matcher_indices */ MatcherIndicesIndex(17),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [43] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 2,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(123),
/* return_matcher_indices */ MatcherIndicesIndex(61),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [44] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 2,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(123),
/* return_matcher_indices */ MatcherIndicesIndex(63),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [45] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 2,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(123),
/* return_matcher_indices */ MatcherIndicesIndex(65),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [46] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 2,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(123),
/* return_matcher_indices */ MatcherIndicesIndex(19),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [47] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 2,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(123),
/* return_matcher_indices */ MatcherIndicesIndex(67),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [48] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 2,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(123),
/* return_matcher_indices */ MatcherIndicesIndex(69),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [49] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 2,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(123),
/* return_matcher_indices */ MatcherIndicesIndex(71),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [50] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 3,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(90),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [51] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 3,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(93),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [52] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 3,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(96),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
{
/* [53] */
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMemberFunction),
/* num_parameters */ 3,
/* num_explicit_templates */ 0,
/* num_templates */ 0,
/* templates */ TemplateIndex(/* invalid */),
/* parameters */ ParameterIndex(99),
/* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
/* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
},
};
static_assert(OverloadIndex::CanIndex(kOverloads),
"OverloadIndex is not large enough to index kOverloads");
constexpr IntrinsicInfo kBuiltins[] = {
{
/* [0] */
/* fn asint[T : f32_u32](T) -> i32 */
/* fn asint[T : f32_u32, N : num](vec<N, T>) -> vec<N, i32> */
/* num overloads */ 2,
/* overloads */ OverloadIndex(30),
},
{
/* [1] */
/* fn asuint[T : f32_i32](T) -> u32 */
/* fn asuint[T : f32_i32, N : num](vec<N, T>) -> vec<N, u32> */
/* num overloads */ 2,
/* overloads */ OverloadIndex(32),
},
{
/* [2] */
/* fn asfloat[T : iu32](T) -> f32 */
/* fn asfloat[T : iu32, N : num](vec<N, T>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ OverloadIndex(34),
},
{
/* [3] */
/* fn f32tof16(f32) -> u32 */
/* fn f32tof16[N : num](vec<N, f32>) -> vec<N, u32> */
/* num overloads */ 2,
/* overloads */ OverloadIndex(36),
},
{
/* [4] */
/* fn f16tof32(u32) -> f32 */
/* fn f16tof32[N : num](vec<N, u32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ OverloadIndex(38),
},
{
/* [5] */
/* fn mul[T : f32_f16, C : num, R : num](mat<R, C, T>, vec<C, T>) -> vec<R, T> */
/* fn mul[T : f32_f16, C : num, R : num](vec<R, T>, mat<R, C, T>) -> vec<C, T> */
/* fn mul[T : f32_f16, K : num, C : num, R : num](mat<R, K, T>, mat<K, C, T>) -> mat<R, C, T> */
/* num overloads */ 3,
/* overloads */ OverloadIndex(27),
},
{
/* [6] */
/* fn sign[T : fi32_f16](T) -> i32 */
/* fn sign[N : num, T : fi32_f16](vec<N, T>) -> vec<N, i32> */
/* num overloads */ 2,
/* overloads */ OverloadIndex(40),
},
{
/* [7] */
/* fn Load(byte_address_buffer<readable>, offset: u32) -> u32 */
/* num overloads */ 1,
/* overloads */ OverloadIndex(42),
},
{
/* [8] */
/* fn Load2(byte_address_buffer<readable>, offset: u32) -> vec2<u32> */
/* num overloads */ 1,
/* overloads */ OverloadIndex(43),
},
{
/* [9] */
/* fn Load3(byte_address_buffer<readable>, offset: u32) -> vec3<u32> */
/* num overloads */ 1,
/* overloads */ OverloadIndex(44),
},
{
/* [10] */
/* fn Load4(byte_address_buffer<readable>, offset: u32) -> vec4<u32> */
/* num overloads */ 1,
/* overloads */ OverloadIndex(45),
},
{
/* [11] */
/* fn LoadF16(byte_address_buffer<readable>, offset: u32) -> f16 */
/* num overloads */ 1,
/* overloads */ OverloadIndex(46),
},
{
/* [12] */
/* fn Load2F16(byte_address_buffer<readable>, offset: u32) -> vec2<f16> */
/* num overloads */ 1,
/* overloads */ OverloadIndex(47),
},
{
/* [13] */
/* fn Load3F16(byte_address_buffer<readable>, offset: u32) -> vec3<f16> */
/* num overloads */ 1,
/* overloads */ OverloadIndex(48),
},
{
/* [14] */
/* fn Load4F16(byte_address_buffer<readable>, offset: u32) -> vec4<f16> */
/* num overloads */ 1,
/* overloads */ OverloadIndex(49),
},
{
/* [15] */
/* fn Store(byte_address_buffer<writable>, offset: u32, value: u32) */
/* num overloads */ 1,
/* overloads */ OverloadIndex(50),
},
{
/* [16] */
/* fn Store2(byte_address_buffer<writable>, offset: u32, value: vec2<u32>) */
/* num overloads */ 1,
/* overloads */ OverloadIndex(51),
},
{
/* [17] */
/* fn Store3(byte_address_buffer<writable>, offset: u32, value: vec3<u32>) */
/* num overloads */ 1,
/* overloads */ OverloadIndex(52),
},
{
/* [18] */
/* fn Store4(byte_address_buffer<writable>, offset: u32, value: vec4<u32>) */
/* num overloads */ 1,
/* overloads */ OverloadIndex(53),
},
{
/* [19] */
/* fn GetDimensions[A : access](byte_address_buffer<A>, width: ptr<function, u32, writable>) */
/* fn GetDimensions[T : fiu32](texture: texture_1d<T>, width: ptr<function, u32, writable>) */
/* fn GetDimensions[T : fiu32](texture: texture_1d<T>, level: u32, width: ptr<function, u32, writable>, num_levels: ptr<function, u32, writable>) */
/* fn GetDimensions[F : texel_format, A : access](texture: texture_storage_1d<F, A>, width: ptr<function, u32, writable>) */
/* fn GetDimensions[T : fiu32](texture: texture_2d<T>, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>) */
/* fn GetDimensions[T : fiu32](texture: texture_2d<T>, level: u32, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>, num_levels: ptr<function, u32, writable>) */
/* fn GetDimensions[F : texel_format, A : access](texture: texture_storage_2d<F, A>, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>) */
/* fn GetDimensions[T : fiu32](texture: texture_2d_array<T>, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>, elements: ptr<function, u32, writable>) */
/* fn GetDimensions[T : fiu32](texture: texture_2d_array<T>, level: u32, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>, elements: ptr<function, u32, writable>, num_levels: ptr<function, u32, writable>) */
/* fn GetDimensions[F : texel_format, A : access](texture: texture_storage_2d_array<F, A>, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>, elements: ptr<function, u32, writable>) */
/* fn GetDimensions[T : fiu32](texture: texture_3d<T>, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>, depth: ptr<function, u32, writable>) */
/* fn GetDimensions[T : fiu32](texture: texture_3d<T>, level: u32, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>, depth: ptr<function, u32, writable>, num_levels: ptr<function, u32, writable>) */
/* fn GetDimensions[F : texel_format, A : access](texture: texture_storage_3d<F, A>, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>, depth: ptr<function, u32, writable>) */
/* fn GetDimensions[T : fiu32](texture: texture_cube<T>, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>) */
/* fn GetDimensions[T : fiu32](texture: texture_cube<T>, level: u32, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>, num_levels: ptr<function, u32, writable>) */
/* fn GetDimensions[T : fiu32](texture: texture_cube_array<T>, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>, elements: ptr<function, u32, writable>) */
/* fn GetDimensions[T : fiu32](texture: texture_cube_array<T>, level: u32, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>, elements: ptr<function, u32, writable>, num_levels: ptr<function, u32, writable>) */
/* fn GetDimensions[T : fiu32](texture: texture_multisampled_2d<T>, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>, samples: ptr<function, u32, writable>) */
/* fn GetDimensions(texture: texture_depth_2d, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>) */
/* fn GetDimensions(texture: texture_depth_2d, level: u32, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>, num_levels: ptr<function, u32, writable>) */
/* fn GetDimensions(texture: texture_depth_2d_array, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>, elements: ptr<function, u32, writable>) */
/* fn GetDimensions(texture: texture_depth_2d_array, level: u32, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>, elements: ptr<function, u32, writable>, num_levels: ptr<function, u32, writable>) */
/* fn GetDimensions(texture: texture_depth_cube, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>) */
/* fn GetDimensions(texture: texture_depth_cube, level: u32, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>, num_levels: ptr<function, u32, writable>) */
/* fn GetDimensions(texture: texture_depth_cube_array, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>, elements: ptr<function, u32, writable>) */
/* fn GetDimensions(texture: texture_depth_cube_array, level: u32, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>, elements: ptr<function, u32, writable>, num_levels: ptr<function, u32, writable>) */
/* fn GetDimensions(texture: texture_depth_multisampled_2d, width: ptr<function, u32, writable>, height: ptr<function, u32, writable>, samples: ptr<function, u32, writable>) */
/* num overloads */ 27,
/* overloads */ OverloadIndex(0),
},
};
// clang-format on
} // anonymous namespace
const core::intrinsic::TableData Dialect::kData{
/* templates */ kTemplates,
/* type_matcher_indices */ kMatcherIndices,
/* type_matchers */ kTypeMatchers,
/* number_matchers */ kNumberMatchers,
/* parameters */ kParameters,
/* overloads */ kOverloads,
/* const_eval_functions */ Empty,
/* ctor_conv */ Empty,
/* builtins */ kBuiltins,
/* binary '+' */ tint::core::intrinsic::kNoOverloads,
/* binary '-' */ tint::core::intrinsic::kNoOverloads,
/* binary '*' */ tint::core::intrinsic::kNoOverloads,
/* binary '/' */ tint::core::intrinsic::kNoOverloads,
/* binary '%' */ tint::core::intrinsic::kNoOverloads,
/* binary '^' */ tint::core::intrinsic::kNoOverloads,
/* binary '&' */ tint::core::intrinsic::kNoOverloads,
/* binary '|' */ tint::core::intrinsic::kNoOverloads,
/* binary '&&' */ tint::core::intrinsic::kNoOverloads,
/* binary '||' */ tint::core::intrinsic::kNoOverloads,
/* binary '==' */ tint::core::intrinsic::kNoOverloads,
/* binary '!=' */ tint::core::intrinsic::kNoOverloads,
/* binary '<' */ tint::core::intrinsic::kNoOverloads,
/* binary '>' */ tint::core::intrinsic::kNoOverloads,
/* binary '<=' */ tint::core::intrinsic::kNoOverloads,
/* binary '>=' */ tint::core::intrinsic::kNoOverloads,
/* binary '<<' */ tint::core::intrinsic::kNoOverloads,
/* binary '>>' */ tint::core::intrinsic::kNoOverloads,
/* unary '!' */ tint::core::intrinsic::kNoOverloads,
/* unary '~' */ tint::core::intrinsic::kNoOverloads,
/* unary '-' */ tint::core::intrinsic::kNoOverloads,
/* unary '*' */ tint::core::intrinsic::kNoOverloads,
/* unary '&' */ tint::core::intrinsic::kNoOverloads,
};
} // namespace tint::hlsl::intrinsic