| // 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/glsl/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/glsl/intrinsic/dialect.h" |
| #include "src/tint/utils/text/string_stream.h" |
| |
| namespace tint::glsl::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 bool' |
| constexpr TypeMatcher kBoolMatcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| if (!MatchBool(state, ty)) { |
| return nullptr; |
| } |
| return BuildBool(state, ty); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) { |
| out << style::Type("bool"); |
| } |
| }; |
| |
| |
| /// 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 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 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 atomic' |
| constexpr TypeMatcher kAtomicMatcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| const Type* T = nullptr; |
| if (!MatchAtomic(state, ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return BuildAtomic(state, ty, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; |
| state->PrintType(T); |
| out << style::Type("atomic", "<", T, ">"); |
| } |
| }; |
| |
| |
| /// 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 array' |
| constexpr TypeMatcher kArrayMatcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| const Type* T = nullptr; |
| if (!MatchArray(state, ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return BuildArray(state, ty, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; |
| state->PrintType(T); |
| out << style::Type("array", "<", T, ">"); |
| } |
| }; |
| |
| |
| /// 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_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_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_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 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);} |
| }; |
| |
| /// TypeMatcher for 'match fiu32_f16' |
| constexpr TypeMatcher kFiu32F16Matcher { |
| /* 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); |
| } |
| 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(", "); kU32Matcher.print(nullptr, out); out << style::Plain(" or "); kF16Matcher.print(nullptr, out);} |
| }; |
| |
| /// TypeMatcher for 'match fiu32_f16_bool' |
| constexpr TypeMatcher kFiu32F16BoolMatcher { |
| /* 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); |
| } |
| if (MatchF16(state, ty)) { |
| return BuildF16(state, ty); |
| } |
| if (MatchBool(state, ty)) { |
| return BuildBool(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(", "); kU32Matcher.print(nullptr, out); out << style::Plain(", "); kF16Matcher.print(nullptr, out); out << style::Plain(" or "); kBoolMatcher.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);} |
| }; |
| |
| /// EnumMatcher for 'match read_write' |
| constexpr NumberMatcher kReadWriteMatcher { |
| /* match */ [](MatchState&, Number number) -> Number { |
| if (number.IsAny() || number.Value() == static_cast<uint32_t>(core::Access::kReadWrite)) { |
| return Number(static_cast<uint32_t>(core::Access::kReadWrite)); |
| } |
| return Number::invalid; |
| }, |
| /* print */ [](MatchState*, StyledText& out) { |
| out<< style::Enum("read_write"); |
| } |
| }; |
| |
| /// 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"); |
| } |
| }; |
| |
| /// EnumMatcher for 'match workgroup_or_storage' |
| constexpr NumberMatcher kWorkgroupOrStorageMatcher { |
| /* match */ [](MatchState&, Number number) -> Number { |
| switch (static_cast<core::AddressSpace>(number.Value())) { |
| case core::AddressSpace::kStorage: |
| case core::AddressSpace::kWorkgroup: |
| return number; |
| default: |
| return Number::invalid; |
| } |
| }, |
| /* print */ [](MatchState*, StyledText& out) { |
| out<< style::Enum("storage")<< style::Plain(" or ") << style::Enum("workgroup"); |
| } |
| }; |
| |
| /// 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 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 f32_texel_format' |
| constexpr NumberMatcher kF32TexelFormatMatcher { |
| /* match */ [](MatchState&, Number number) -> Number { |
| switch (static_cast<core::TexelFormat>(number.Value())) { |
| case core::TexelFormat::kR8Unorm: |
| case core::TexelFormat::kBgra8Unorm: |
| case core::TexelFormat::kRgba8Unorm: |
| case core::TexelFormat::kRgba8Snorm: |
| case core::TexelFormat::kRgba16Float: |
| case core::TexelFormat::kR32Float: |
| case core::TexelFormat::kRg32Float: |
| case core::TexelFormat::kRgba32Float: |
| return number; |
| default: |
| return Number::invalid; |
| } |
| }, |
| /* print */ [](MatchState*, StyledText& out) { |
| out<< style::Enum("r8unorm")<< style::Plain(", ") << style::Enum("bgra8unorm")<< style::Plain(", ") << style::Enum("rgba8unorm")<< style::Plain(", ") << style::Enum("rgba8snorm")<< style::Plain(", ") << style::Enum("rgba16float")<< style::Plain(", ") << style::Enum("r32float")<< style::Plain(", ") << style::Enum("rg32float")<< style::Plain(" or ") << style::Enum("rgba32float"); |
| } |
| }; |
| |
| /// EnumMatcher for 'match u32_texel_format' |
| constexpr NumberMatcher kU32TexelFormatMatcher { |
| /* match */ [](MatchState&, Number number) -> Number { |
| switch (static_cast<core::TexelFormat>(number.Value())) { |
| case core::TexelFormat::kRgba8Uint: |
| case core::TexelFormat::kRgba16Uint: |
| case core::TexelFormat::kR32Uint: |
| case core::TexelFormat::kRg32Uint: |
| case core::TexelFormat::kRgba32Uint: |
| return number; |
| default: |
| return Number::invalid; |
| } |
| }, |
| /* print */ [](MatchState*, StyledText& out) { |
| out<< style::Enum("rgba8uint")<< style::Plain(", ") << style::Enum("rgba16uint")<< style::Plain(", ") << style::Enum("r32uint")<< style::Plain(", ") << style::Enum("rg32uint")<< style::Plain(" or ") << style::Enum("rgba32uint"); |
| } |
| }; |
| |
| /// EnumMatcher for 'match i32_texel_format' |
| constexpr NumberMatcher kI32TexelFormatMatcher { |
| /* match */ [](MatchState&, Number number) -> Number { |
| switch (static_cast<core::TexelFormat>(number.Value())) { |
| case core::TexelFormat::kRgba8Sint: |
| case core::TexelFormat::kRgba16Sint: |
| case core::TexelFormat::kR32Sint: |
| case core::TexelFormat::kRg32Sint: |
| case core::TexelFormat::kRgba32Sint: |
| return number; |
| default: |
| return Number::invalid; |
| } |
| }, |
| /* print */ [](MatchState*, StyledText& out) { |
| out<< style::Enum("rgba8sint")<< style::Plain(", ") << style::Enum("rgba16sint")<< style::Plain(", ") << style::Enum("r32sint")<< style::Plain(", ") << style::Enum("rg32sint")<< style::Plain(" or ") << style::Enum("rgba32sint"); |
| } |
| }; |
| |
| /// Type and number matchers |
| |
| /// The template types, types, and type matchers |
| constexpr TypeMatcher kTypeMatchers[] = { |
| /* [0] */ TemplateTypeMatcher<0>::matcher, |
| /* [1] */ TemplateTypeMatcher<1>::matcher, |
| /* [2] */ kBoolMatcher, |
| /* [3] */ kF16Matcher, |
| /* [4] */ kF32Matcher, |
| /* [5] */ kI32Matcher, |
| /* [6] */ kU32Matcher, |
| /* [7] */ kAtomicMatcher, |
| /* [8] */ kPtrMatcher, |
| /* [9] */ kVec2Matcher, |
| /* [10] */ kVec3Matcher, |
| /* [11] */ kVec4Matcher, |
| /* [12] */ kVecMatcher, |
| /* [13] */ kArrayMatcher, |
| /* [14] */ kTexture1DMatcher, |
| /* [15] */ kTexture2DMatcher, |
| /* [16] */ kTexture2DArrayMatcher, |
| /* [17] */ kTexture3DMatcher, |
| /* [18] */ kTextureCubeMatcher, |
| /* [19] */ kTextureCubeArrayMatcher, |
| /* [20] */ kTextureMultisampled2DMatcher, |
| /* [21] */ kTextureDepth2DMatcher, |
| /* [22] */ kTextureDepth2DArrayMatcher, |
| /* [23] */ kTextureDepthCubeMatcher, |
| /* [24] */ kTextureDepthCubeArrayMatcher, |
| /* [25] */ kTextureDepthMultisampled2DMatcher, |
| /* [26] */ kTextureStorage1DMatcher, |
| /* [27] */ kTextureStorage2DMatcher, |
| /* [28] */ kTextureStorage2DArrayMatcher, |
| /* [29] */ kTextureStorage3DMatcher, |
| /* [30] */ kIu32Matcher, |
| /* [31] */ kFiu32Matcher, |
| /* [32] */ kFi32F16Matcher, |
| /* [33] */ kFiu32F16Matcher, |
| /* [34] */ kFiu32F16BoolMatcher, |
| /* [35] */ kF32F16Matcher, |
| }; |
| |
| /// The template numbers, and number matchers |
| constexpr NumberMatcher kNumberMatchers[] = { |
| /* [0] */ TemplateNumberMatcher<0>::matcher, |
| /* [1] */ TemplateNumberMatcher<1>::matcher, |
| /* [2] */ kReadWriteMatcher, |
| /* [3] */ kReadableMatcher, |
| /* [4] */ kWritableMatcher, |
| /* [5] */ kWorkgroupOrStorageMatcher, |
| /* [6] */ kFunctionMatcher, |
| /* [7] */ kStorageMatcher, |
| /* [8] */ kF32TexelFormatMatcher, |
| /* [9] */ kU32TexelFormatMatcher, |
| /* [10] */ kI32TexelFormatMatcher, |
| }; |
| |
| constexpr MatcherIndex kMatcherIndices[] = { |
| /* [0] */ MatcherIndex(8), |
| /* [1] */ MatcherIndex(6), |
| /* [2] */ MatcherIndex(12), |
| /* [3] */ MatcherIndex(0), |
| /* [4] */ MatcherIndex(1), |
| /* [5] */ MatcherIndex(2), |
| /* [6] */ MatcherIndex(8), |
| /* [7] */ MatcherIndex(6), |
| /* [8] */ MatcherIndex(12), |
| /* [9] */ MatcherIndex(0), |
| /* [10] */ MatcherIndex(5), |
| /* [11] */ MatcherIndex(2), |
| /* [12] */ MatcherIndex(8), |
| /* [13] */ MatcherIndex(7), |
| /* [14] */ MatcherIndex(13), |
| /* [15] */ MatcherIndex(0), |
| /* [16] */ MatcherIndex(1), |
| /* [17] */ MatcherIndex(8), |
| /* [18] */ MatcherIndex(5), |
| /* [19] */ MatcherIndex(7), |
| /* [20] */ MatcherIndex(0), |
| /* [21] */ MatcherIndex(2), |
| /* [22] */ MatcherIndex(8), |
| /* [23] */ MatcherIndex(1), |
| /* [24] */ MatcherIndex(7), |
| /* [25] */ MatcherIndex(0), |
| /* [26] */ MatcherIndex(2), |
| /* [27] */ MatcherIndex(8), |
| /* [28] */ MatcherIndex(6), |
| /* [29] */ MatcherIndex(0), |
| /* [30] */ MatcherIndex(2), |
| /* [31] */ MatcherIndex(8), |
| /* [32] */ MatcherIndex(6), |
| /* [33] */ MatcherIndex(5), |
| /* [34] */ MatcherIndex(2), |
| /* [35] */ MatcherIndex(12), |
| /* [36] */ MatcherIndex(0), |
| /* [37] */ MatcherIndex(4), |
| /* [38] */ MatcherIndex(12), |
| /* [39] */ MatcherIndex(0), |
| /* [40] */ MatcherIndex(6), |
| /* [41] */ MatcherIndex(12), |
| /* [42] */ MatcherIndex(1), |
| /* [43] */ MatcherIndex(5), |
| /* [44] */ MatcherIndex(12), |
| /* [45] */ MatcherIndex(1), |
| /* [46] */ MatcherIndex(0), |
| /* [47] */ MatcherIndex(12), |
| /* [48] */ MatcherIndex(0), |
| /* [49] */ MatcherIndex(2), |
| /* [50] */ MatcherIndex(26), |
| /* [51] */ MatcherIndex(0), |
| /* [52] */ MatcherIndex(1), |
| /* [53] */ MatcherIndex(27), |
| /* [54] */ MatcherIndex(0), |
| /* [55] */ MatcherIndex(1), |
| /* [56] */ MatcherIndex(28), |
| /* [57] */ MatcherIndex(0), |
| /* [58] */ MatcherIndex(1), |
| /* [59] */ MatcherIndex(29), |
| /* [60] */ MatcherIndex(0), |
| /* [61] */ MatcherIndex(1), |
| /* [62] */ MatcherIndex(26), |
| /* [63] */ MatcherIndex(8), |
| /* [64] */ MatcherIndex(4), |
| /* [65] */ MatcherIndex(26), |
| /* [66] */ MatcherIndex(10), |
| /* [67] */ MatcherIndex(4), |
| /* [68] */ MatcherIndex(26), |
| /* [69] */ MatcherIndex(9), |
| /* [70] */ MatcherIndex(4), |
| /* [71] */ MatcherIndex(27), |
| /* [72] */ MatcherIndex(8), |
| /* [73] */ MatcherIndex(4), |
| /* [74] */ MatcherIndex(27), |
| /* [75] */ MatcherIndex(10), |
| /* [76] */ MatcherIndex(4), |
| /* [77] */ MatcherIndex(27), |
| /* [78] */ MatcherIndex(9), |
| /* [79] */ MatcherIndex(4), |
| /* [80] */ MatcherIndex(29), |
| /* [81] */ MatcherIndex(8), |
| /* [82] */ MatcherIndex(4), |
| /* [83] */ MatcherIndex(29), |
| /* [84] */ MatcherIndex(10), |
| /* [85] */ MatcherIndex(4), |
| /* [86] */ MatcherIndex(29), |
| /* [87] */ MatcherIndex(9), |
| /* [88] */ MatcherIndex(4), |
| /* [89] */ MatcherIndex(28), |
| /* [90] */ MatcherIndex(8), |
| /* [91] */ MatcherIndex(4), |
| /* [92] */ MatcherIndex(28), |
| /* [93] */ MatcherIndex(10), |
| /* [94] */ MatcherIndex(4), |
| /* [95] */ MatcherIndex(28), |
| /* [96] */ MatcherIndex(9), |
| /* [97] */ MatcherIndex(4), |
| /* [98] */ MatcherIndex(12), |
| /* [99] */ MatcherIndex(1), |
| /* [100] */ MatcherIndex(2), |
| /* [101] */ MatcherIndex(9), |
| /* [102] */ MatcherIndex(3), |
| /* [103] */ MatcherIndex(14), |
| /* [104] */ MatcherIndex(0), |
| /* [105] */ MatcherIndex(9), |
| /* [106] */ MatcherIndex(5), |
| /* [107] */ MatcherIndex(15), |
| /* [108] */ MatcherIndex(0), |
| /* [109] */ MatcherIndex(10), |
| /* [110] */ MatcherIndex(5), |
| /* [111] */ MatcherIndex(16), |
| /* [112] */ MatcherIndex(0), |
| /* [113] */ MatcherIndex(17), |
| /* [114] */ MatcherIndex(0), |
| /* [115] */ MatcherIndex(18), |
| /* [116] */ MatcherIndex(0), |
| /* [117] */ MatcherIndex(19), |
| /* [118] */ MatcherIndex(0), |
| /* [119] */ MatcherIndex(20), |
| /* [120] */ MatcherIndex(0), |
| /* [121] */ MatcherIndex(11), |
| /* [122] */ MatcherIndex(0), |
| /* [123] */ MatcherIndex(11), |
| /* [124] */ MatcherIndex(4), |
| /* [125] */ MatcherIndex(11), |
| /* [126] */ MatcherIndex(5), |
| /* [127] */ MatcherIndex(11), |
| /* [128] */ MatcherIndex(6), |
| /* [129] */ MatcherIndex(9), |
| /* [130] */ MatcherIndex(0), |
| /* [131] */ MatcherIndex(10), |
| /* [132] */ MatcherIndex(0), |
| /* [133] */ MatcherIndex(30), |
| /* [134] */ MatcherIndex(32), |
| /* [135] */ MatcherIndex(35), |
| /* [136] */ MatcherIndex(31), |
| /* [137] */ MatcherIndex(21), |
| /* [138] */ MatcherIndex(22), |
| /* [139] */ MatcherIndex(23), |
| /* [140] */ MatcherIndex(24), |
| /* [141] */ MatcherIndex(25), |
| /* [142] */ MatcherIndex(33), |
| /* [143] */ MatcherIndex(34), |
| }; |
| |
| static_assert(MatcherIndicesIndex::CanIndex(kMatcherIndices), |
| "MatcherIndicesIndex is not large enough to index kMatcherIndices"); |
| |
| constexpr ParameterInfo kParameters[] = { |
| { |
| /* [0] */ |
| /* usage */ core::ParameterUsage::kBase, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [1] */ |
| /* usage */ core::ParameterUsage::kInsert, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [2] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [3] */ |
| /* usage */ core::ParameterUsage::kBits, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [4] */ |
| /* usage */ core::ParameterUsage::kBase, |
| /* matcher_indices */ MatcherIndicesIndex(44), |
| }, |
| { |
| /* [5] */ |
| /* usage */ core::ParameterUsage::kInsert, |
| /* matcher_indices */ MatcherIndicesIndex(44), |
| }, |
| { |
| /* [6] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [7] */ |
| /* usage */ core::ParameterUsage::kBits, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [8] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(17), |
| }, |
| { |
| /* [9] */ |
| /* usage */ core::ParameterUsage::kCompareValue, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [10] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [11] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [12] */ |
| /* usage */ core::ParameterUsage::kBits, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [13] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(44), |
| }, |
| { |
| /* [14] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [15] */ |
| /* usage */ core::ParameterUsage::kBits, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [16] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(103), |
| }, |
| { |
| /* [17] */ |
| /* usage */ core::ParameterUsage::kLocation, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [18] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [19] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(107), |
| }, |
| { |
| /* [20] */ |
| /* usage */ core::ParameterUsage::kLocation, |
| /* matcher_indices */ MatcherIndicesIndex(105), |
| }, |
| { |
| /* [21] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [22] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(111), |
| }, |
| { |
| /* [23] */ |
| /* usage */ core::ParameterUsage::kLocation, |
| /* matcher_indices */ MatcherIndicesIndex(109), |
| }, |
| { |
| /* [24] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [25] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(119), |
| }, |
| { |
| /* [26] */ |
| /* usage */ core::ParameterUsage::kLocation, |
| /* matcher_indices */ MatcherIndicesIndex(105), |
| }, |
| { |
| /* [27] */ |
| /* usage */ core::ParameterUsage::kSampleIndex, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [28] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(113), |
| }, |
| { |
| /* [29] */ |
| /* usage */ core::ParameterUsage::kLocation, |
| /* matcher_indices */ MatcherIndicesIndex(109), |
| }, |
| { |
| /* [30] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [31] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(62), |
| }, |
| { |
| /* [32] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [33] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(123), |
| }, |
| { |
| /* [34] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(65), |
| }, |
| { |
| /* [35] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [36] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(125), |
| }, |
| { |
| /* [37] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(68), |
| }, |
| { |
| /* [38] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [39] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(127), |
| }, |
| { |
| /* [40] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(71), |
| }, |
| { |
| /* [41] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(129), |
| }, |
| { |
| /* [42] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(123), |
| }, |
| { |
| /* [43] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(74), |
| }, |
| { |
| /* [44] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(129), |
| }, |
| { |
| /* [45] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(125), |
| }, |
| { |
| /* [46] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(77), |
| }, |
| { |
| /* [47] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(129), |
| }, |
| { |
| /* [48] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(127), |
| }, |
| { |
| /* [49] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(80), |
| }, |
| { |
| /* [50] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(131), |
| }, |
| { |
| /* [51] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(123), |
| }, |
| { |
| /* [52] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(83), |
| }, |
| { |
| /* [53] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(131), |
| }, |
| { |
| /* [54] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(125), |
| }, |
| { |
| /* [55] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(86), |
| }, |
| { |
| /* [56] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(131), |
| }, |
| { |
| /* [57] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(127), |
| }, |
| { |
| /* [58] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(89), |
| }, |
| { |
| /* [59] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(131), |
| }, |
| { |
| /* [60] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(123), |
| }, |
| { |
| /* [61] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(92), |
| }, |
| { |
| /* [62] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(131), |
| }, |
| { |
| /* [63] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(125), |
| }, |
| { |
| /* [64] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(95), |
| }, |
| { |
| /* [65] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(131), |
| }, |
| { |
| /* [66] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(127), |
| }, |
| { |
| /* [67] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(22), |
| }, |
| { |
| /* [68] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [69] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(44), |
| }, |
| { |
| /* [70] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(44), |
| }, |
| { |
| /* [71] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [72] */ |
| /* usage */ core::ParameterUsage::kResult, |
| /* matcher_indices */ MatcherIndicesIndex(27), |
| }, |
| { |
| /* [73] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(2), |
| }, |
| { |
| /* [74] */ |
| /* usage */ core::ParameterUsage::kResult, |
| /* matcher_indices */ MatcherIndicesIndex(0), |
| }, |
| { |
| /* [75] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [76] */ |
| /* usage */ core::ParameterUsage::kExp, |
| /* matcher_indices */ MatcherIndicesIndex(31), |
| }, |
| { |
| /* [77] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(2), |
| }, |
| { |
| /* [78] */ |
| /* usage */ core::ParameterUsage::kExp, |
| /* matcher_indices */ MatcherIndicesIndex(6), |
| }, |
| { |
| /* [79] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(103), |
| }, |
| { |
| /* [80] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [81] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(107), |
| }, |
| { |
| /* [82] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [83] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(111), |
| }, |
| { |
| /* [84] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [85] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(113), |
| }, |
| { |
| /* [86] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [87] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(115), |
| }, |
| { |
| /* [88] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [89] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(117), |
| }, |
| { |
| /* [90] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [91] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(137), |
| }, |
| { |
| /* [92] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [93] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(138), |
| }, |
| { |
| /* [94] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [95] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(139), |
| }, |
| { |
| /* [96] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [97] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(140), |
| }, |
| { |
| /* [98] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [99] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(50), |
| }, |
| { |
| /* [100] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [101] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(53), |
| }, |
| { |
| /* [102] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(105), |
| }, |
| { |
| /* [103] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(56), |
| }, |
| { |
| /* [104] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(109), |
| }, |
| { |
| /* [105] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(59), |
| }, |
| { |
| /* [106] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(109), |
| }, |
| { |
| /* [107] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(12), |
| }, |
| { |
| /* [108] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(37), |
| }, |
| { |
| /* [109] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(35), |
| }, |
| { |
| /* [110] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| }, |
| { |
| /* [111] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(8), |
| }, |
| { |
| /* [112] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(1), |
| }, |
| { |
| /* [113] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(38), |
| }, |
| { |
| /* [114] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(101), |
| }, |
| { |
| /* [115] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(47), |
| }, |
| { |
| /* [116] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(141), |
| }, |
| }; |
| |
| static_assert(ParameterIndex::CanIndex(kParameters), |
| "ParameterIndex is not large enough to index kParameters"); |
| |
| constexpr TemplateInfo kTemplates[] = { |
| { |
| /* [0] */ |
| /* name */ "T", |
| /* matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* kind */ TemplateInfo::Kind::kType, |
| }, |
| { |
| /* [1] */ |
| /* name */ "A", |
| /* matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* kind */ TemplateInfo::Kind::kNumber, |
| }, |
| { |
| /* [2] */ |
| /* name */ "T", |
| /* matcher_indices */ MatcherIndicesIndex(133), |
| /* kind */ TemplateInfo::Kind::kType, |
| }, |
| { |
| /* [3] */ |
| /* name */ "S", |
| /* matcher_indices */ MatcherIndicesIndex(10), |
| /* kind */ TemplateInfo::Kind::kNumber, |
| }, |
| { |
| /* [4] */ |
| /* name */ "T", |
| /* matcher_indices */ MatcherIndicesIndex(133), |
| /* kind */ TemplateInfo::Kind::kType, |
| }, |
| { |
| /* [5] */ |
| /* name */ "N", |
| /* matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* kind */ TemplateInfo::Kind::kNumber, |
| }, |
| { |
| /* [6] */ |
| /* name */ "T", |
| /* matcher_indices */ MatcherIndicesIndex(135), |
| /* kind */ TemplateInfo::Kind::kType, |
| }, |
| { |
| /* [7] */ |
| /* name */ "N", |
| /* matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* kind */ TemplateInfo::Kind::kNumber, |
| }, |
| { |
| /* [8] */ |
| /* name */ "T", |
| /* matcher_indices */ MatcherIndicesIndex(134), |
| /* kind */ TemplateInfo::Kind::kType, |
| }, |
| { |
| /* [9] */ |
| /* name */ "N", |
| /* matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* kind */ TemplateInfo::Kind::kNumber, |
| }, |
| { |
| /* [10] */ |
| /* name */ "F", |
| /* matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* kind */ TemplateInfo::Kind::kNumber, |
| }, |
| { |
| /* [11] */ |
| /* name */ "A", |
| /* matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* kind */ TemplateInfo::Kind::kNumber, |
| }, |
| { |
| /* [12] */ |
| /* name */ "F", |
| /* matcher_indices */ MatcherIndicesIndex(0), |
| /* kind */ TemplateInfo::Kind::kNumber, |
| }, |
| { |
| /* [13] */ |
| /* name */ "A", |
| /* matcher_indices */ MatcherIndicesIndex(102), |
| /* kind */ TemplateInfo::Kind::kNumber, |
| }, |
| { |
| /* [14] */ |
| /* name */ "F", |
| /* matcher_indices */ MatcherIndicesIndex(66), |
| /* kind */ TemplateInfo::Kind::kNumber, |
| }, |
| { |
| /* [15] */ |
| /* name */ "A", |
| /* matcher_indices */ MatcherIndicesIndex(102), |
| /* kind */ TemplateInfo::Kind::kNumber, |
| }, |
| { |
| /* [16] */ |
| /* name */ "F", |
| /* matcher_indices */ MatcherIndicesIndex(69), |
| /* kind */ TemplateInfo::Kind::kNumber, |
| }, |
| { |
| /* [17] */ |
| /* name */ "A", |
| /* matcher_indices */ MatcherIndicesIndex(102), |
| /* kind */ TemplateInfo::Kind::kNumber, |
| }, |
| { |
| /* [18] */ |
| /* name */ "T", |
| /* matcher_indices */ MatcherIndicesIndex(142), |
| /* kind */ TemplateInfo::Kind::kType, |
| }, |
| { |
| /* [19] */ |
| /* name */ "N", |
| /* matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* kind */ TemplateInfo::Kind::kNumber, |
| }, |
| { |
| /* [20] */ |
| /* name */ "T", |
| /* matcher_indices */ MatcherIndicesIndex(143), |
| /* kind */ TemplateInfo::Kind::kType, |
| }, |
| { |
| /* [21] */ |
| /* name */ "N", |
| /* matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* kind */ TemplateInfo::Kind::kNumber, |
| }, |
| { |
| /* [22] */ |
| /* name */ "T", |
| /* matcher_indices */ MatcherIndicesIndex(136), |
| /* kind */ TemplateInfo::Kind::kType, |
| }, |
| { |
| /* [23] */ |
| /* name */ "C", |
| /* matcher_indices */ MatcherIndicesIndex(133), |
| /* kind */ TemplateInfo::Kind::kType, |
| }, |
| }; |
| |
| static_assert(TemplateIndex::CanIndex(kTemplates), |
| "TemplateIndex is not large enough to index kTemplates"); |
| |
| constexpr core::constant::Eval::Function kConstEvalFunctions[] = { |
| /* [0] */ &core::constant::Eval::modf, |
| /* [1] */ &core::constant::Eval::frexp, |
| }; |
| |
| static_assert(ConstEvalFunctionIndex::CanIndex(kConstEvalFunctions), |
| "ConstEvalFunctionIndex is not large enough to index kConstEvalFunctions"); |
| |
| constexpr OverloadInfo kOverloads[] = { |
| { |
| /* [0] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(22), |
| /* parameters */ ParameterIndex(79), |
| /* return_matcher_indices */ MatcherIndicesIndex(10), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [1] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(22), |
| /* parameters */ ParameterIndex(81), |
| /* return_matcher_indices */ MatcherIndicesIndex(105), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [2] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(22), |
| /* parameters */ ParameterIndex(83), |
| /* return_matcher_indices */ MatcherIndicesIndex(109), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [3] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(22), |
| /* parameters */ ParameterIndex(85), |
| /* return_matcher_indices */ MatcherIndicesIndex(109), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [4] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(22), |
| /* parameters */ ParameterIndex(87), |
| /* return_matcher_indices */ MatcherIndicesIndex(105), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [5] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(22), |
| /* parameters */ ParameterIndex(89), |
| /* return_matcher_indices */ MatcherIndicesIndex(109), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [6] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 0, |
| /* templates */ TemplateIndex(/* invalid */), |
| /* parameters */ ParameterIndex(91), |
| /* return_matcher_indices */ MatcherIndicesIndex(105), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [7] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 0, |
| /* templates */ TemplateIndex(/* invalid */), |
| /* parameters */ ParameterIndex(93), |
| /* return_matcher_indices */ MatcherIndicesIndex(109), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [8] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 0, |
| /* templates */ TemplateIndex(/* invalid */), |
| /* parameters */ ParameterIndex(95), |
| /* return_matcher_indices */ MatcherIndicesIndex(105), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [9] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 0, |
| /* templates */ TemplateIndex(/* invalid */), |
| /* parameters */ ParameterIndex(97), |
| /* return_matcher_indices */ MatcherIndicesIndex(109), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [10] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), |
| /* num_parameters */ 1, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(22), |
| /* parameters */ ParameterIndex(25), |
| /* return_matcher_indices */ MatcherIndicesIndex(105), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [11] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), |
| /* num_parameters */ 1, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 0, |
| /* templates */ TemplateIndex(/* invalid */), |
| /* parameters */ ParameterIndex(116), |
| /* return_matcher_indices */ MatcherIndicesIndex(105), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [12] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(12), |
| /* parameters */ ParameterIndex(99), |
| /* return_matcher_indices */ MatcherIndicesIndex(123), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [13] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(12), |
| /* parameters */ ParameterIndex(101), |
| /* return_matcher_indices */ MatcherIndicesIndex(123), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [14] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(12), |
| /* parameters */ ParameterIndex(103), |
| /* return_matcher_indices */ MatcherIndicesIndex(123), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [15] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(12), |
| /* parameters */ ParameterIndex(105), |
| /* return_matcher_indices */ MatcherIndicesIndex(123), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [16] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(14), |
| /* parameters */ ParameterIndex(99), |
| /* return_matcher_indices */ MatcherIndicesIndex(125), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [17] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(14), |
| /* parameters */ ParameterIndex(101), |
| /* return_matcher_indices */ MatcherIndicesIndex(125), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [18] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(14), |
| /* parameters */ ParameterIndex(103), |
| /* return_matcher_indices */ MatcherIndicesIndex(125), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [19] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(14), |
| /* parameters */ ParameterIndex(105), |
| /* return_matcher_indices */ MatcherIndicesIndex(125), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [20] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(16), |
| /* parameters */ ParameterIndex(99), |
| /* return_matcher_indices */ MatcherIndicesIndex(127), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [21] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(16), |
| /* parameters */ ParameterIndex(101), |
| /* return_matcher_indices */ MatcherIndicesIndex(127), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [22] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(16), |
| /* parameters */ ParameterIndex(103), |
| /* return_matcher_indices */ MatcherIndicesIndex(127), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [23] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(16), |
| /* parameters */ ParameterIndex(105), |
| /* return_matcher_indices */ MatcherIndicesIndex(127), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [24] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 3, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(23), |
| /* parameters */ ParameterIndex(31), |
| /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [25] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 3, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(23), |
| /* parameters */ ParameterIndex(34), |
| /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [26] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 3, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(23), |
| /* parameters */ ParameterIndex(37), |
| /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [27] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 3, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(23), |
| /* parameters */ ParameterIndex(40), |
| /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [28] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 3, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(23), |
| /* parameters */ ParameterIndex(43), |
| /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [29] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 3, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(23), |
| /* parameters */ ParameterIndex(46), |
| /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [30] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 3, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(23), |
| /* parameters */ ParameterIndex(49), |
| /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [31] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 3, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(23), |
| /* parameters */ ParameterIndex(52), |
| /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [32] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 3, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(23), |
| /* parameters */ ParameterIndex(55), |
| /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [33] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 3, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(23), |
| /* parameters */ ParameterIndex(58), |
| /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [34] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 3, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(23), |
| /* parameters */ ParameterIndex(61), |
| /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [35] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 3, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(23), |
| /* parameters */ ParameterIndex(64), |
| /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [36] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 3, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(22), |
| /* parameters */ ParameterIndex(16), |
| /* return_matcher_indices */ MatcherIndicesIndex(121), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [37] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 3, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(22), |
| /* parameters */ ParameterIndex(19), |
| /* return_matcher_indices */ MatcherIndicesIndex(121), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [38] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 3, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(22), |
| /* parameters */ ParameterIndex(22), |
| /* return_matcher_indices */ MatcherIndicesIndex(121), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [39] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 3, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(22), |
| /* parameters */ ParameterIndex(25), |
| /* return_matcher_indices */ MatcherIndicesIndex(121), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [40] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 3, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(22), |
| /* parameters */ ParameterIndex(28), |
| /* return_matcher_indices */ MatcherIndicesIndex(121), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [41] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), |
| /* num_parameters */ 1, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(10), |
| /* parameters */ ParameterIndex(99), |
| /* return_matcher_indices */ MatcherIndicesIndex(10), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [42] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), |
| /* num_parameters */ 1, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(10), |
| /* parameters */ ParameterIndex(101), |
| /* return_matcher_indices */ MatcherIndicesIndex(105), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [43] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), |
| /* num_parameters */ 1, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(10), |
| /* parameters */ ParameterIndex(103), |
| /* return_matcher_indices */ MatcherIndicesIndex(109), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [44] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), |
| /* num_parameters */ 1, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(10), |
| /* parameters */ ParameterIndex(105), |
| /* return_matcher_indices */ MatcherIndicesIndex(109), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [45] */ |
| /* 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(108), |
| /* return_matcher_indices */ MatcherIndicesIndex(10), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [46] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 1, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(5), |
| /* parameters */ ParameterIndex(109), |
| /* return_matcher_indices */ MatcherIndicesIndex(8), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [47] */ |
| /* 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(108), |
| /* return_matcher_indices */ MatcherIndicesIndex(1), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [48] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 1, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(5), |
| /* parameters */ ParameterIndex(109), |
| /* return_matcher_indices */ MatcherIndicesIndex(38), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [49] */ |
| /* 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(110), |
| /* return_matcher_indices */ MatcherIndicesIndex(37), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [50] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 1, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(5), |
| /* parameters */ ParameterIndex(111), |
| /* return_matcher_indices */ MatcherIndicesIndex(35), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [51] */ |
| /* 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(112), |
| /* return_matcher_indices */ MatcherIndicesIndex(37), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [52] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 1, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(5), |
| /* parameters */ ParameterIndex(113), |
| /* return_matcher_indices */ MatcherIndicesIndex(35), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [53] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 1, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(2), |
| /* parameters */ ParameterIndex(10), |
| /* return_matcher_indices */ MatcherIndicesIndex(10), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [54] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 1, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(4), |
| /* parameters */ ParameterIndex(13), |
| /* return_matcher_indices */ MatcherIndicesIndex(41), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [55] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 3, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(2), |
| /* parameters */ ParameterIndex(10), |
| /* return_matcher_indices */ MatcherIndicesIndex(3), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [56] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 3, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(4), |
| /* parameters */ ParameterIndex(13), |
| /* return_matcher_indices */ MatcherIndicesIndex(44), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [57] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 4, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(2), |
| /* parameters */ ParameterIndex(0), |
| /* return_matcher_indices */ MatcherIndicesIndex(3), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [58] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 4, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(4), |
| /* parameters */ ParameterIndex(4), |
| /* return_matcher_indices */ MatcherIndicesIndex(44), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [59] */ |
| /* 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(68), |
| /* return_matcher_indices */ MatcherIndicesIndex(3), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [60] */ |
| /* 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(69), |
| /* return_matcher_indices */ MatcherIndicesIndex(44), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [61] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(6), |
| /* parameters */ ParameterIndex(71), |
| /* return_matcher_indices */ MatcherIndicesIndex(3), |
| /* const_eval_fn */ ConstEvalFunctionIndex(0), |
| }, |
| { |
| /* [62] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(5), |
| /* parameters */ ParameterIndex(73), |
| /* return_matcher_indices */ MatcherIndicesIndex(2), |
| /* const_eval_fn */ ConstEvalFunctionIndex(0), |
| }, |
| { |
| /* [63] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(6), |
| /* parameters */ ParameterIndex(75), |
| /* return_matcher_indices */ MatcherIndicesIndex(3), |
| /* const_eval_fn */ ConstEvalFunctionIndex(1), |
| }, |
| { |
| /* [64] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(5), |
| /* parameters */ ParameterIndex(77), |
| /* return_matcher_indices */ MatcherIndicesIndex(2), |
| /* const_eval_fn */ ConstEvalFunctionIndex(1), |
| }, |
| { |
| /* [65] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse, OverloadFlag::kMemberFunction), |
| /* num_parameters */ 1, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(0), |
| /* parameters */ ParameterIndex(107), |
| /* return_matcher_indices */ MatcherIndicesIndex(10), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [66] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 0, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 0, |
| /* templates */ TemplateIndex(/* invalid */), |
| /* parameters */ ParameterIndex(/* invalid */), |
| /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [67] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 3, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(2), |
| /* parameters */ ParameterIndex(8), |
| /* return_matcher_indices */ MatcherIndicesIndex(3), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [68] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(2), |
| /* parameters */ ParameterIndex(67), |
| /* return_matcher_indices */ MatcherIndicesIndex(3), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [69] */ |
| /* 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(114), |
| /* return_matcher_indices */ MatcherIndicesIndex(1), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [70] */ |
| /* 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(112), |
| /* return_matcher_indices */ MatcherIndicesIndex(101), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [71] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 1, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 1, |
| /* templates */ TemplateIndex(5), |
| /* parameters */ ParameterIndex(115), |
| /* return_matcher_indices */ MatcherIndicesIndex(5), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [72] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(6), |
| /* parameters */ ParameterIndex(69), |
| /* return_matcher_indices */ MatcherIndicesIndex(3), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [73] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(18), |
| /* parameters */ ParameterIndex(69), |
| /* return_matcher_indices */ MatcherIndicesIndex(98), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| { |
| /* [74] */ |
| /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), |
| /* num_parameters */ 2, |
| /* num_explicit_templates */ 0, |
| /* num_templates */ 2, |
| /* templates */ TemplateIndex(20), |
| /* parameters */ ParameterIndex(69), |
| /* return_matcher_indices */ MatcherIndicesIndex(98), |
| /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), |
| }, |
| }; |
| |
| static_assert(OverloadIndex::CanIndex(kOverloads), |
| "OverloadIndex is not large enough to index kOverloads"); |
| |
| constexpr IntrinsicInfo kBuiltins[] = { |
| { |
| /* [0] */ |
| /* fn length[T, A : access](ptr<storage, array<T>, A>) -> i32 */ |
| /* num overloads */ 1, |
| /* overloads */ OverloadIndex(65), |
| }, |
| { |
| /* [1] */ |
| /* fn barrier() */ |
| /* num overloads */ 1, |
| /* overloads */ OverloadIndex(66), |
| }, |
| { |
| /* [2] */ |
| /* fn memoryBarrierBuffer() */ |
| /* num overloads */ 1, |
| /* overloads */ OverloadIndex(66), |
| }, |
| { |
| /* [3] */ |
| /* fn memoryBarrierImage() */ |
| /* num overloads */ 1, |
| /* overloads */ OverloadIndex(66), |
| }, |
| { |
| /* [4] */ |
| /* fn atomicCompSwap[T : iu32](ptr<workgroup_or_storage, atomic<T>, read_write>, compare_value: T, value: T) -> T */ |
| /* num overloads */ 1, |
| /* overloads */ OverloadIndex(67), |
| }, |
| { |
| /* [5] */ |
| /* fn atomicSub[T : iu32, S : workgroup_or_storage](ptr<S, atomic<T>, read_write>, T) -> T */ |
| /* num overloads */ 1, |
| /* overloads */ OverloadIndex(68), |
| }, |
| { |
| /* [6] */ |
| /* fn floatBitsToInt(value: f32) -> i32 */ |
| /* fn floatBitsToInt[N : num](value: vec<N, f32>) -> vec<N, i32> */ |
| /* num overloads */ 2, |
| /* overloads */ OverloadIndex(45), |
| }, |
| { |
| /* [7] */ |
| /* fn floatBitsToUint(value: f32) -> u32 */ |
| /* fn floatBitsToUint[N : num](value: vec<N, f32>) -> vec<N, u32> */ |
| /* num overloads */ 2, |
| /* overloads */ OverloadIndex(47), |
| }, |
| { |
| /* [8] */ |
| /* fn intBitsToFloat(value: i32) -> f32 */ |
| /* fn intBitsToFloat[N : num](value: vec<N, i32>) -> vec<N, f32> */ |
| /* num overloads */ 2, |
| /* overloads */ OverloadIndex(49), |
| }, |
| { |
| /* [9] */ |
| /* fn uintBitsToFloat(value: u32) -> f32 */ |
| /* fn uintBitsToFloat[N : num](value: vec<N, u32>) -> vec<N, f32> */ |
| /* num overloads */ 2, |
| /* overloads */ OverloadIndex(51), |
| }, |
| { |
| /* [10] */ |
| /* fn bitCount[T : iu32](value: T) -> i32 */ |
| /* fn bitCount[T : iu32, N : num](value: vec<N, T>) -> vec<N, i32> */ |
| /* num overloads */ 2, |
| /* overloads */ OverloadIndex(53), |
| }, |
| { |
| /* [11] */ |
| /* fn bitfieldExtract[T : iu32](value: T, offset: i32, bits: i32) -> T */ |
| /* fn bitfieldExtract[T : iu32, N : num](value: vec<N, T>, offset: i32, bits: i32) -> vec<N, T> */ |
| /* num overloads */ 2, |
| /* overloads */ OverloadIndex(55), |
| }, |
| { |
| /* [12] */ |
| /* fn bitfieldInsert[T : iu32](base: T, insert: T, offset: i32, bits: i32) -> T */ |
| /* fn bitfieldInsert[T : iu32, N : num](base: vec<N, T>, insert: vec<N, T>, offset: i32, bits: i32) -> vec<N, T> */ |
| /* num overloads */ 2, |
| /* overloads */ OverloadIndex(57), |
| }, |
| { |
| /* [13] */ |
| /* fn packFloat2x16(value: vec2<f16>) -> u32 */ |
| /* num overloads */ 1, |
| /* overloads */ OverloadIndex(69), |
| }, |
| { |
| /* [14] */ |
| /* fn unpackFloat2x16(value: u32) -> vec2<f16> */ |
| /* num overloads */ 1, |
| /* overloads */ OverloadIndex(70), |
| }, |
| { |
| /* [15] */ |
| /* fn abs[T : fi32_f16](T) -> T */ |
| /* fn abs[T : fi32_f16, N : num](vec<N, T>) -> vec<N, T> */ |
| /* num overloads */ 2, |
| /* overloads */ OverloadIndex(59), |
| }, |
| { |
| /* [16] */ |
| /* fn any[N : num](vec<N, bool>) -> bool */ |
| /* num overloads */ 1, |
| /* overloads */ OverloadIndex(71), |
| }, |
| { |
| /* [17] */ |
| /* fn all[N : num](vec<N, bool>) -> bool */ |
| /* num overloads */ 1, |
| /* overloads */ OverloadIndex(71), |
| }, |
| { |
| /* [18] */ |
| /* fn dot[T : f32_f16, N : num](vec<N, T>, vec<N, T>) -> T */ |
| /* num overloads */ 1, |
| /* overloads */ OverloadIndex(72), |
| }, |
| { |
| /* [19] */ |
| /* fn modf[T : f32_f16](value: T, result: ptr<function, T, read_write>) -> T */ |
| /* fn modf[N : num, T : f32_f16](value: vec<N, T>, result: ptr<function, vec<N, T>, read_write>) -> vec<N, T> */ |
| /* num overloads */ 2, |
| /* overloads */ OverloadIndex(61), |
| }, |
| { |
| /* [20] */ |
| /* fn frexp[T : f32_f16](value: T, exp: ptr<function, i32, read_write>) -> T */ |
| /* fn frexp[N : num, T : f32_f16](value: vec<N, T>, exp: ptr<function, vec<N, i32>, read_write>) -> vec<N, T> */ |
| /* num overloads */ 2, |
| /* overloads */ OverloadIndex(63), |
| }, |
| { |
| /* [21] */ |
| /* fn textureSize[T : fiu32](texture: texture_1d<T>, level: i32) -> i32 */ |
| /* fn textureSize[T : fiu32](texture: texture_2d<T>, level: i32) -> vec2<i32> */ |
| /* fn textureSize[T : fiu32](texture: texture_2d_array<T>, level: i32) -> vec3<i32> */ |
| /* fn textureSize[T : fiu32](texture: texture_3d<T>, level: i32) -> vec3<i32> */ |
| /* fn textureSize[T : fiu32](texture: texture_cube<T>, level: i32) -> vec2<i32> */ |
| /* fn textureSize[T : fiu32](texture: texture_cube_array<T>, level: i32) -> vec3<i32> */ |
| /* fn textureSize(texture: texture_depth_2d, level: i32) -> vec2<i32> */ |
| /* fn textureSize(texture: texture_depth_2d_array, level: i32) -> vec3<i32> */ |
| /* fn textureSize(texture: texture_depth_cube, level: i32) -> vec2<i32> */ |
| /* fn textureSize(texture: texture_depth_cube_array, level: i32) -> vec3<i32> */ |
| /* fn textureSize[T : fiu32](texture: texture_multisampled_2d<T>) -> vec2<i32> */ |
| /* fn textureSize(texture: texture_depth_multisampled_2d) -> vec2<i32> */ |
| /* num overloads */ 12, |
| /* overloads */ OverloadIndex(0), |
| }, |
| { |
| /* [22] */ |
| /* fn imageSize[F : texel_format, A : access](texture: texture_storage_1d<F, A>) -> i32 */ |
| /* fn imageSize[F : texel_format, A : access](texture: texture_storage_2d<F, A>) -> vec2<i32> */ |
| /* fn imageSize[F : texel_format, A : access](texture: texture_storage_2d_array<F, A>) -> vec3<i32> */ |
| /* fn imageSize[F : texel_format, A : access](texture: texture_storage_3d<F, A>) -> vec3<i32> */ |
| /* num overloads */ 4, |
| /* overloads */ OverloadIndex(41), |
| }, |
| { |
| /* [23] */ |
| /* fn texelFetch[T : fiu32](texture: texture_1d<T>, location: i32, level: i32) -> vec4<T> */ |
| /* fn texelFetch[T : fiu32](texture: texture_2d<T>, location: vec2<i32>, level: i32) -> vec4<T> */ |
| /* fn texelFetch[T : fiu32](texture: texture_2d_array<T>, location: vec3<i32>, level: i32) -> vec4<T> */ |
| /* fn texelFetch[T : fiu32](texture: texture_multisampled_2d<T>, location: vec2<i32>, sample_index: i32) -> vec4<T> */ |
| /* fn texelFetch[T : fiu32](texture: texture_3d<T>, location: vec3<i32>, level: i32) -> vec4<T> */ |
| /* num overloads */ 5, |
| /* overloads */ OverloadIndex(36), |
| }, |
| { |
| /* [24] */ |
| /* fn imageLoad[F : f32_texel_format, A : readable](texture: texture_storage_1d<F, A>, coords: i32) -> vec4<f32> */ |
| /* fn imageLoad[F : f32_texel_format, A : readable](texture: texture_storage_2d<F, A>, coords: vec2<i32>) -> vec4<f32> */ |
| /* fn imageLoad[F : f32_texel_format, A : readable](texture: texture_storage_2d_array<F, A>, coords: vec3<i32>) -> vec4<f32> */ |
| /* fn imageLoad[F : f32_texel_format, A : readable](texture: texture_storage_3d<F, A>, coords: vec3<i32>) -> vec4<f32> */ |
| /* fn imageLoad[F : i32_texel_format, A : readable](texture: texture_storage_1d<F, A>, coords: i32) -> vec4<i32> */ |
| /* fn imageLoad[F : i32_texel_format, A : readable](texture: texture_storage_2d<F, A>, coords: vec2<i32>) -> vec4<i32> */ |
| /* fn imageLoad[F : i32_texel_format, A : readable](texture: texture_storage_2d_array<F, A>, coords: vec3<i32>) -> vec4<i32> */ |
| /* fn imageLoad[F : i32_texel_format, A : readable](texture: texture_storage_3d<F, A>, coords: vec3<i32>) -> vec4<i32> */ |
| /* fn imageLoad[F : u32_texel_format, A : readable](texture: texture_storage_1d<F, A>, coords: i32) -> vec4<u32> */ |
| /* fn imageLoad[F : u32_texel_format, A : readable](texture: texture_storage_2d<F, A>, coords: vec2<i32>) -> vec4<u32> */ |
| /* fn imageLoad[F : u32_texel_format, A : readable](texture: texture_storage_2d_array<F, A>, coords: vec3<i32>) -> vec4<u32> */ |
| /* fn imageLoad[F : u32_texel_format, A : readable](texture: texture_storage_3d<F, A>, coords: vec3<i32>) -> vec4<u32> */ |
| /* num overloads */ 12, |
| /* overloads */ OverloadIndex(12), |
| }, |
| { |
| /* [25] */ |
| /* fn imageStore[C : iu32](texture: texture_storage_1d<f32_texel_format, writable>, coords: C, value: vec4<f32>) */ |
| /* fn imageStore[C : iu32](texture: texture_storage_1d<i32_texel_format, writable>, coords: C, value: vec4<i32>) */ |
| /* fn imageStore[C : iu32](texture: texture_storage_1d<u32_texel_format, writable>, coords: C, value: vec4<u32>) */ |
| /* fn imageStore[C : iu32](texture: texture_storage_2d<f32_texel_format, writable>, coords: vec2<C>, value: vec4<f32>) */ |
| /* fn imageStore[C : iu32](texture: texture_storage_2d<i32_texel_format, writable>, coords: vec2<C>, value: vec4<i32>) */ |
| /* fn imageStore[C : iu32](texture: texture_storage_2d<u32_texel_format, writable>, coords: vec2<C>, value: vec4<u32>) */ |
| /* fn imageStore[C : iu32](texture: texture_storage_3d<f32_texel_format, writable>, coords: vec3<C>, value: vec4<f32>) */ |
| /* fn imageStore[C : iu32](texture: texture_storage_3d<i32_texel_format, writable>, coords: vec3<C>, value: vec4<i32>) */ |
| /* fn imageStore[C : iu32](texture: texture_storage_3d<u32_texel_format, writable>, coords: vec3<C>, value: vec4<u32>) */ |
| /* fn imageStore[C : iu32](texture: texture_storage_2d_array<f32_texel_format, writable>, coords: vec3<C>, value: vec4<f32>) */ |
| /* fn imageStore[C : iu32](texture: texture_storage_2d_array<i32_texel_format, writable>, coords: vec3<C>, value: vec4<i32>) */ |
| /* fn imageStore[C : iu32](texture: texture_storage_2d_array<u32_texel_format, writable>, coords: vec3<C>, value: vec4<u32>) */ |
| /* num overloads */ 12, |
| /* overloads */ OverloadIndex(24), |
| }, |
| { |
| /* [26] */ |
| /* fn lessThan[T : fiu32_f16, N : num](vec<N, T>, vec<N, T>) -> vec<N, bool> */ |
| /* num overloads */ 1, |
| /* overloads */ OverloadIndex(73), |
| }, |
| { |
| /* [27] */ |
| /* fn lessThanEqual[T : fiu32_f16, N : num](vec<N, T>, vec<N, T>) -> vec<N, bool> */ |
| /* num overloads */ 1, |
| /* overloads */ OverloadIndex(73), |
| }, |
| { |
| /* [28] */ |
| /* fn greaterThan[T : fiu32_f16, N : num](vec<N, T>, vec<N, T>) -> vec<N, bool> */ |
| /* num overloads */ 1, |
| /* overloads */ OverloadIndex(73), |
| }, |
| { |
| /* [29] */ |
| /* fn greaterThanEqual[T : fiu32_f16, N : num](vec<N, T>, vec<N, T>) -> vec<N, bool> */ |
| /* num overloads */ 1, |
| /* overloads */ OverloadIndex(73), |
| }, |
| { |
| /* [30] */ |
| /* fn equal[T : fiu32_f16_bool, N : num](vec<N, T>, vec<N, T>) -> vec<N, bool> */ |
| /* num overloads */ 1, |
| /* overloads */ OverloadIndex(74), |
| }, |
| { |
| /* [31] */ |
| /* fn notEqual[T : fiu32_f16_bool, N : num](vec<N, T>, vec<N, T>) -> vec<N, bool> */ |
| /* num overloads */ 1, |
| /* overloads */ OverloadIndex(74), |
| }, |
| }; |
| |
| // 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 */ kConstEvalFunctions, |
| /* 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::glsl::intrinsic |
