| // Copyright 2023 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/core/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/dialect.h" |
| #include "src/tint/lang/core/intrinsic/type_matchers.h" |
| #include "src/tint/utils/text/string_stream.h" |
| |
| namespace tint::core::intrinsic { |
| |
| 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 i32' |
| constexpr TypeMatcher kI32Matcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| if (!MatchI32(state, ty)) { |
| return nullptr; |
| } |
| return BuildI32(state, ty); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) { |
| out << style::Type("i32"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type u32' |
| constexpr TypeMatcher kU32Matcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| if (!MatchU32(state, ty)) { |
| return nullptr; |
| } |
| return BuildU32(state, ty); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) { |
| out << style::Type("u32"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type f32' |
| constexpr TypeMatcher kF32Matcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| if (!MatchF32(state, ty)) { |
| return nullptr; |
| } |
| return BuildF32(state, ty); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) { |
| out << style::Type("f32"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type f16' |
| constexpr TypeMatcher kF16Matcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| if (!MatchF16(state, ty)) { |
| return nullptr; |
| } |
| return BuildF16(state, ty); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) { |
| out << style::Type("f16"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type 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 mat2x2' |
| constexpr TypeMatcher kMat2X2Matcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| const Type* T = nullptr; |
| if (!MatchMat2X2(state, ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return BuildMat2X2(state, ty, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; |
| state->PrintType(T); |
| out << style::Type("mat2x2", "<", T, ">"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type mat2x3' |
| constexpr TypeMatcher kMat2X3Matcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| const Type* T = nullptr; |
| if (!MatchMat2X3(state, ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return BuildMat2X3(state, ty, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; |
| state->PrintType(T); |
| out << style::Type("mat2x3", "<", T, ">"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type mat2x4' |
| constexpr TypeMatcher kMat2X4Matcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| const Type* T = nullptr; |
| if (!MatchMat2X4(state, ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return BuildMat2X4(state, ty, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; |
| state->PrintType(T); |
| out << style::Type("mat2x4", "<", T, ">"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type mat3x2' |
| constexpr TypeMatcher kMat3X2Matcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| const Type* T = nullptr; |
| if (!MatchMat3X2(state, ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return BuildMat3X2(state, ty, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; |
| state->PrintType(T); |
| out << style::Type("mat3x2", "<", T, ">"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type mat3x3' |
| constexpr TypeMatcher kMat3X3Matcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| const Type* T = nullptr; |
| if (!MatchMat3X3(state, ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return BuildMat3X3(state, ty, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; |
| state->PrintType(T); |
| out << style::Type("mat3x3", "<", T, ">"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type mat3x4' |
| constexpr TypeMatcher kMat3X4Matcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| const Type* T = nullptr; |
| if (!MatchMat3X4(state, ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return BuildMat3X4(state, ty, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; |
| state->PrintType(T); |
| out << style::Type("mat3x4", "<", T, ">"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type mat4x2' |
| constexpr TypeMatcher kMat4X2Matcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| const Type* T = nullptr; |
| if (!MatchMat4X2(state, ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return BuildMat4X2(state, ty, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; |
| state->PrintType(T); |
| out << style::Type("mat4x2", "<", T, ">"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type mat4x3' |
| constexpr TypeMatcher kMat4X3Matcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| const Type* T = nullptr; |
| if (!MatchMat4X3(state, ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return BuildMat4X3(state, ty, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; |
| state->PrintType(T); |
| out << style::Type("mat4x3", "<", T, ">"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type mat4x4' |
| constexpr TypeMatcher kMat4X4Matcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| const Type* T = nullptr; |
| if (!MatchMat4X4(state, ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return BuildMat4X4(state, ty, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; |
| state->PrintType(T); |
| out << style::Type("mat4x4", "<", T, ">"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type 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 mat' |
| constexpr TypeMatcher kMatMatcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| Number N = Number::invalid; |
| Number M = Number::invalid; |
| const Type* T = nullptr; |
| if (!MatchMat(state, ty, N, M, T)) { |
| return nullptr; |
| } |
| N = state.Num(N); |
| if (!N.IsValid()) { |
| return nullptr; |
| } |
| M = state.Num(M); |
| if (!M.IsValid()) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return BuildMat(state, ty, N, M, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText N; |
| state->PrintNum(N);StyledText M; |
| state->PrintNum(M);StyledText T; |
| state->PrintType(T); |
| out << style::Type("mat", N, "x", M, "<", T, ">"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type 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 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 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 sampler' |
| constexpr TypeMatcher kSamplerMatcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| if (!MatchSampler(state, ty)) { |
| return nullptr; |
| } |
| return BuildSampler(state, ty); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) { |
| out << style::Type("sampler"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type sampler_comparison' |
| constexpr TypeMatcher kSamplerComparisonMatcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| if (!MatchSamplerComparison(state, ty)) { |
| return nullptr; |
| } |
| return BuildSamplerComparison(state, ty); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) { |
| out << style::Type("sampler_comparison"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type texture_1d' |
| constexpr TypeMatcher kTexture1DMatcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| const Type* T = nullptr; |
| if (!MatchTexture1D(state, ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return BuildTexture1D(state, ty, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; |
| state->PrintType(T); |
| out << style::Type("texture_1d", "<", T, ">"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type texture_2d' |
| constexpr TypeMatcher kTexture2DMatcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| const Type* T = nullptr; |
| if (!MatchTexture2D(state, ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return BuildTexture2D(state, ty, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; |
| state->PrintType(T); |
| out << style::Type("texture_2d", "<", T, ">"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type texture_2d_array' |
| constexpr TypeMatcher kTexture2DArrayMatcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| const Type* T = nullptr; |
| if (!MatchTexture2DArray(state, ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return BuildTexture2DArray(state, ty, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; |
| state->PrintType(T); |
| out << style::Type("texture_2d_array", "<", T, ">"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type texture_3d' |
| constexpr TypeMatcher kTexture3DMatcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| const Type* T = nullptr; |
| if (!MatchTexture3D(state, ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return BuildTexture3D(state, ty, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; |
| state->PrintType(T); |
| out << style::Type("texture_3d", "<", T, ">"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type texture_cube' |
| constexpr TypeMatcher kTextureCubeMatcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| const Type* T = nullptr; |
| if (!MatchTextureCube(state, ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return BuildTextureCube(state, ty, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; |
| state->PrintType(T); |
| out << style::Type("texture_cube", "<", T, ">"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type texture_cube_array' |
| constexpr TypeMatcher kTextureCubeArrayMatcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| const Type* T = nullptr; |
| if (!MatchTextureCubeArray(state, ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return BuildTextureCubeArray(state, ty, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; |
| state->PrintType(T); |
| out << style::Type("texture_cube_array", "<", T, ">"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type texture_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 'type texture_external' |
| constexpr TypeMatcher kTextureExternalMatcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| if (!MatchTextureExternal(state, ty)) { |
| return nullptr; |
| } |
| return BuildTextureExternal(state, ty); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) { |
| out << style::Type("texture_external"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type __modf_result' |
| constexpr TypeMatcher kModfResultMatcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| const Type* T = nullptr; |
| if (!MatchModfResult(state, ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return BuildModfResult(state, ty, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; |
| state->PrintType(T); |
| out << style::Type("__modf_result_", T); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type __modf_result_vec' |
| constexpr TypeMatcher kModfResultVecMatcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| Number N = Number::invalid; |
| const Type* T = nullptr; |
| if (!MatchModfResultVec(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 BuildModfResultVec(state, ty, N, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText N; |
| state->PrintNum(N);StyledText T; |
| state->PrintType(T); |
| out << style::Type("__modf_result_vec", N, "_", T); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type __frexp_result' |
| constexpr TypeMatcher kFrexpResultMatcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| const Type* T = nullptr; |
| if (!MatchFrexpResult(state, ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return BuildFrexpResult(state, ty, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; |
| state->PrintType(T); |
| out << style::Type("__frexp_result_", T); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type __frexp_result_vec' |
| constexpr TypeMatcher kFrexpResultVecMatcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| Number N = Number::invalid; |
| const Type* T = nullptr; |
| if (!MatchFrexpResultVec(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 BuildFrexpResultVec(state, ty, N, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText N; |
| state->PrintNum(N);StyledText T; |
| state->PrintType(T); |
| out << style::Type("__frexp_result_vec", N, "_", T); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'type __atomic_compare_exchange_result' |
| constexpr TypeMatcher kAtomicCompareExchangeResultMatcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| const Type* T = nullptr; |
| if (!MatchAtomicCompareExchangeResult(state, ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return BuildAtomicCompareExchangeResult(state, ty, T); |
| }, |
| /* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; |
| state->PrintType(T); |
| out << style::Type("__atomic_compare_exchange_result", "<", T, ">"); |
| } |
| }; |
| |
| |
| /// TypeMatcher for 'match scalar' |
| constexpr TypeMatcher kScalarMatcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| if (MatchI32(state, ty)) { |
| return BuildI32(state, ty); |
| } |
| if (MatchU32(state, ty)) { |
| return BuildU32(state, ty); |
| } |
| if (MatchF32(state, ty)) { |
| return BuildF32(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(", "); kF16Matcher.print(nullptr, out); out << style::Plain(", "); kI32Matcher.print(nullptr, out); out << style::Plain(", "); kU32Matcher.print(nullptr, out); out << style::Plain(" or "); kBoolMatcher.print(nullptr, out);} |
| }; |
| |
| /// TypeMatcher for 'match scalar_no_f32' |
| constexpr TypeMatcher kScalarNoF32Matcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| 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. |
| kI32Matcher.print(nullptr, out); out << style::Plain(", "); kF16Matcher.print(nullptr, out); out << style::Plain(", "); kU32Matcher.print(nullptr, out); out << style::Plain(" or "); kBoolMatcher.print(nullptr, out);} |
| }; |
| |
| /// TypeMatcher for 'match scalar_no_f16' |
| constexpr TypeMatcher kScalarNoF16Matcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| if (MatchI32(state, ty)) { |
| return BuildI32(state, ty); |
| } |
| if (MatchU32(state, ty)) { |
| return BuildU32(state, ty); |
| } |
| if (MatchF32(state, ty)) { |
| return BuildF32(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(" or "); kBoolMatcher.print(nullptr, out);} |
| }; |
| |
| /// TypeMatcher for 'match scalar_no_i32' |
| constexpr TypeMatcher kScalarNoI32Matcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| if (MatchU32(state, ty)) { |
| return BuildU32(state, ty); |
| } |
| if (MatchF32(state, ty)) { |
| return BuildF32(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(", "); kF16Matcher.print(nullptr, out); out << style::Plain(", "); kU32Matcher.print(nullptr, out); out << style::Plain(" or "); kBoolMatcher.print(nullptr, out);} |
| }; |
| |
| /// TypeMatcher for 'match scalar_no_u32' |
| constexpr TypeMatcher kScalarNoU32Matcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| if (MatchI32(state, ty)) { |
| return BuildI32(state, ty); |
| } |
| if (MatchF32(state, ty)) { |
| return BuildF32(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(", "); kF16Matcher.print(nullptr, out); out << style::Plain(", "); kI32Matcher.print(nullptr, out); out << style::Plain(" or "); kBoolMatcher.print(nullptr, out);} |
| }; |
| |
| /// TypeMatcher for 'match scalar_no_bool' |
| constexpr TypeMatcher kScalarNoBoolMatcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| if (MatchI32(state, ty)) { |
| return BuildI32(state, ty); |
| } |
| if (MatchU32(state, ty)) { |
| return BuildU32(state, ty); |
| } |
| 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(", "); kF16Matcher.print(nullptr, out); out << style::Plain(", "); kI32Matcher.print(nullptr, out); out << style::Plain(" or "); kU32Matcher.print(nullptr, out);} |
| }; |
| |
| /// TypeMatcher for 'match fiu32_f16' |
| constexpr TypeMatcher kFiu32F16Matcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| if (MatchI32(state, ty)) { |
| return BuildI32(state, ty); |
| } |
| if (MatchU32(state, ty)) { |
| return BuildU32(state, ty); |
| } |
| 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(", "); kI32Matcher.print(nullptr, out); out << style::Plain(", "); kU32Matcher.print(nullptr, out); out << style::Plain(" or "); kF16Matcher.print(nullptr, out);} |
| }; |
| |
| /// TypeMatcher for 'match fiu32' |
| constexpr TypeMatcher kFiu32Matcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| if (MatchI32(state, ty)) { |
| return BuildI32(state, ty); |
| } |
| if (MatchU32(state, ty)) { |
| return BuildU32(state, ty); |
| } |
| if (MatchF32(state, ty)) { |
| return BuildF32(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 (MatchI32(state, ty)) { |
| return BuildI32(state, ty); |
| } |
| 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(", "); kI32Matcher.print(nullptr, out); out << style::Plain(" or "); kF16Matcher.print(nullptr, out);} |
| }; |
| |
| /// TypeMatcher for 'match fi32' |
| constexpr TypeMatcher kFi32Matcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| if (MatchI32(state, ty)) { |
| return BuildI32(state, ty); |
| } |
| if (MatchF32(state, ty)) { |
| return BuildF32(state, ty); |
| } |
| return nullptr; |
| }, |
| /* print */ [](MatchState*, StyledText& out) { |
| // Note: We pass nullptr to the Matcher.print() functions, as matchers do not support |
| // template arguments, nor can they match sub-types. As such, they have no use for the MatchState. |
| kF32Matcher.print(nullptr, out); out << style::Plain(" or "); kI32Matcher.print(nullptr, out);} |
| }; |
| |
| /// TypeMatcher for 'match f32_f16' |
| constexpr TypeMatcher kF32F16Matcher { |
| /* match */ [](MatchState& state, const Type* ty) -> const Type* { |
| if (MatchF32(state, ty)) { |
| return BuildF32(state, ty); |
| } |
| if (MatchF16(state, ty)) { |
| return BuildF16(state, ty); |
| } |
| return nullptr; |
| }, |
| /* print */ [](MatchState*, StyledText& out) { |
| // Note: We pass nullptr to the Matcher.print() functions, as matchers do not support |
| // template arguments, nor can they match sub-types. As such, they have no use for the MatchState. |
| kF32Matcher.print(nullptr, out); out << style::Plain(" or "); kF16Matcher.print(nullptr, out);} |
| }; |
| |
| /// TypeMatcher for 'match 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);} |
| }; |
| |
| /// 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 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"); |
| } |
| }; |
| |
| /// 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 write' |
| constexpr NumberMatcher kWriteMatcher { |
| /* match */ [](MatchState&, Number number) -> Number { |
| if (number.IsAny() || number.Value() == static_cast<uint32_t>(core::Access::kWrite)) { |
| return Number(static_cast<uint32_t>(core::Access::kWrite)); |
| } |
| return Number::invalid; |
| }, |
| /* print */ [](MatchState*, StyledText& out) { |
| out<< style::Enum("write"); |
| } |
| }; |
| |
| /// 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 function_private_workgroup' |
| constexpr NumberMatcher kFunctionPrivateWorkgroupMatcher { |
| /* match */ [](MatchState&, Number number) -> Number { |
| switch (static_cast<core::AddressSpace>(number.Value())) { |
| case core::AddressSpace::kFunction: |
| case core::AddressSpace::kPrivate: |
| case core::AddressSpace::kWorkgroup: |
| return number; |
| default: |
| return Number::invalid; |
| } |
| }, |
| /* print */ [](MatchState*, StyledText& out) { |
| out<< style::Enum("function")<< style::Plain(", ") << style::Enum("private")<< style::Plain(" or ") << style::Enum("workgroup"); |
| } |
| }; |
| |
| /// EnumMatcher for 'match workgroup_or_storage' |
| constexpr NumberMatcher kWorkgroupOrStorageMatcher { |
| /* match */ [](MatchState&, Number number) -> Number { |
| switch (static_cast<core::AddressSpace>(number.Value())) { |
| case core::AddressSpace::kWorkgroup: |
| case core::AddressSpace::kStorage: |
| return number; |
| default: |
| return Number::invalid; |
| } |
| }, |
| /* print */ [](MatchState*, StyledText& out) { |
| out<< style::Enum("workgroup")<< style::Plain(" or ") << style::Enum("storage"); |
| } |
| }; |
| |
| /// 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 workgroup' |
| constexpr NumberMatcher kWorkgroupMatcher { |
| /* match */ [](MatchState&, Number number) -> Number { |
| if (number.IsAny() || number.Value() == static_cast<uint32_t>(core::AddressSpace::kWorkgroup)) { |
| return Number(static_cast<uint32_t>(core::AddressSpace::kWorkgroup)); |
| } |
| return Number::invalid; |
| }, |
| /* print */ [](MatchState*, StyledText& out) { |
| out<< style::Enum("workgroup"); |
| } |
| }; |
| |
| /// Type and number matchers |
| |
| /// The template types, types, and type matchers |
| constexpr TypeMatcher kTypeMatchers[] = { |
| /* [0] */ TemplateTypeMatcher<0>::matcher, |
| /* [1] */ TemplateTypeMatcher<1>::matcher, |
| /* [2] */ TemplateTypeMatcher<2>::matcher, |
| /* [3] */ TemplateTypeMatcher<3>::matcher, |
| /* [4] */ kBoolMatcher, |
| /* [5] */ kI32Matcher, |
| /* [6] */ kU32Matcher, |
| /* [7] */ kF32Matcher, |
| /* [8] */ kF16Matcher, |
| /* [9] */ kVec2Matcher, |
| /* [10] */ kVec3Matcher, |
| /* [11] */ kVec4Matcher, |
| /* [12] */ kMat2X2Matcher, |
| /* [13] */ kMat2X3Matcher, |
| /* [14] */ kMat2X4Matcher, |
| /* [15] */ kMat3X2Matcher, |
| /* [16] */ kMat3X3Matcher, |
| /* [17] */ kMat3X4Matcher, |
| /* [18] */ kMat4X2Matcher, |
| /* [19] */ kMat4X3Matcher, |
| /* [20] */ kMat4X4Matcher, |
| /* [21] */ kVecMatcher, |
| /* [22] */ kMatMatcher, |
| /* [23] */ kPtrMatcher, |
| /* [24] */ kAtomicMatcher, |
| /* [25] */ kArrayMatcher, |
| /* [26] */ kSamplerMatcher, |
| /* [27] */ kSamplerComparisonMatcher, |
| /* [28] */ kTexture1DMatcher, |
| /* [29] */ kTexture2DMatcher, |
| /* [30] */ kTexture2DArrayMatcher, |
| /* [31] */ kTexture3DMatcher, |
| /* [32] */ kTextureCubeMatcher, |
| /* [33] */ kTextureCubeArrayMatcher, |
| /* [34] */ kTextureMultisampled2DMatcher, |
| /* [35] */ kTextureDepth2DMatcher, |
| /* [36] */ kTextureDepth2DArrayMatcher, |
| /* [37] */ kTextureDepthCubeMatcher, |
| /* [38] */ kTextureDepthCubeArrayMatcher, |
| /* [39] */ kTextureDepthMultisampled2DMatcher, |
| /* [40] */ kTextureStorage1DMatcher, |
| /* [41] */ kTextureStorage2DMatcher, |
| /* [42] */ kTextureStorage2DArrayMatcher, |
| /* [43] */ kTextureStorage3DMatcher, |
| /* [44] */ kTextureExternalMatcher, |
| /* [45] */ kModfResultMatcher, |
| /* [46] */ kModfResultVecMatcher, |
| /* [47] */ kFrexpResultMatcher, |
| /* [48] */ kFrexpResultVecMatcher, |
| /* [49] */ kAtomicCompareExchangeResultMatcher, |
| /* [50] */ kScalarMatcher, |
| /* [51] */ kScalarNoF32Matcher, |
| /* [52] */ kScalarNoF16Matcher, |
| /* [53] */ kScalarNoI32Matcher, |
| /* [54] */ kScalarNoU32Matcher, |
| /* [55] */ kScalarNoBoolMatcher, |
| /* [56] */ kFiu32F16Matcher, |
| /* [57] */ kFiu32Matcher, |
| /* [58] */ kFi32F16Matcher, |
| /* [59] */ kFi32Matcher, |
| /* [60] */ kF32F16Matcher, |
| /* [61] */ kIu32Matcher, |
| }; |
| |
| /// The template numbers, and number matchers |
| constexpr NumberMatcher kNumberMatchers[] = { |
| /* [0] */ TemplateNumberMatcher<0>::matcher, |
| /* [1] */ TemplateNumberMatcher<1>::matcher, |
| /* [2] */ TemplateNumberMatcher<2>::matcher, |
| /* [3] */ TemplateNumberMatcher<3>::matcher, |
| /* [4] */ kF32TexelFormatMatcher, |
| /* [5] */ kI32TexelFormatMatcher, |
| /* [6] */ kU32TexelFormatMatcher, |
| /* [7] */ kWriteMatcher, |
| /* [8] */ kReadWriteMatcher, |
| /* [9] */ kReadableMatcher, |
| /* [10] */ kWritableMatcher, |
| /* [11] */ kFunctionPrivateWorkgroupMatcher, |
| /* [12] */ kWorkgroupOrStorageMatcher, |
| /* [13] */ kStorageMatcher, |
| /* [14] */ kWorkgroupMatcher, |
| }; |
| |
| constexpr MatcherIndex kMatcherIndices[] = { |
| /* [0] */ MatcherIndex(23), |
| /* [1] */ MatcherIndex(13), |
| /* [2] */ MatcherIndex(25), |
| /* [3] */ MatcherIndex(0), |
| /* [4] */ MatcherIndex(1), |
| /* [5] */ MatcherIndex(23), |
| /* [6] */ MatcherIndex(1), |
| /* [7] */ MatcherIndex(24), |
| /* [8] */ MatcherIndex(0), |
| /* [9] */ MatcherIndex(8), |
| /* [10] */ MatcherIndex(22), |
| /* [11] */ MatcherIndex(0), |
| /* [12] */ MatcherIndex(0), |
| /* [13] */ MatcherIndex(1), |
| /* [14] */ MatcherIndex(22), |
| /* [15] */ MatcherIndex(1), |
| /* [16] */ MatcherIndex(0), |
| /* [17] */ MatcherIndex(2), |
| /* [18] */ MatcherIndex(22), |
| /* [19] */ MatcherIndex(0), |
| /* [20] */ MatcherIndex(1), |
| /* [21] */ MatcherIndex(2), |
| /* [22] */ MatcherIndex(22), |
| /* [23] */ MatcherIndex(1), |
| /* [24] */ MatcherIndex(2), |
| /* [25] */ MatcherIndex(0), |
| /* [26] */ MatcherIndex(22), |
| /* [27] */ MatcherIndex(2), |
| /* [28] */ MatcherIndex(3), |
| /* [29] */ MatcherIndex(0), |
| /* [30] */ MatcherIndex(22), |
| /* [31] */ MatcherIndex(1), |
| /* [32] */ MatcherIndex(3), |
| /* [33] */ MatcherIndex(0), |
| /* [34] */ MatcherIndex(22), |
| /* [35] */ MatcherIndex(2), |
| /* [36] */ MatcherIndex(1), |
| /* [37] */ MatcherIndex(0), |
| /* [38] */ MatcherIndex(21), |
| /* [39] */ MatcherIndex(0), |
| /* [40] */ MatcherIndex(1), |
| /* [41] */ MatcherIndex(21), |
| /* [42] */ MatcherIndex(0), |
| /* [43] */ MatcherIndex(4), |
| /* [44] */ MatcherIndex(21), |
| /* [45] */ MatcherIndex(1), |
| /* [46] */ MatcherIndex(0), |
| /* [47] */ MatcherIndex(21), |
| /* [48] */ MatcherIndex(0), |
| /* [49] */ MatcherIndex(7), |
| /* [50] */ MatcherIndex(48), |
| /* [51] */ MatcherIndex(0), |
| /* [52] */ MatcherIndex(1), |
| /* [53] */ MatcherIndex(21), |
| /* [54] */ MatcherIndex(0), |
| /* [55] */ MatcherIndex(2), |
| /* [56] */ MatcherIndex(46), |
| /* [57] */ MatcherIndex(0), |
| /* [58] */ MatcherIndex(1), |
| /* [59] */ MatcherIndex(40), |
| /* [60] */ MatcherIndex(0), |
| /* [61] */ MatcherIndex(1), |
| /* [62] */ MatcherIndex(41), |
| /* [63] */ MatcherIndex(0), |
| /* [64] */ MatcherIndex(1), |
| /* [65] */ MatcherIndex(42), |
| /* [66] */ MatcherIndex(0), |
| /* [67] */ MatcherIndex(1), |
| /* [68] */ MatcherIndex(43), |
| /* [69] */ MatcherIndex(0), |
| /* [70] */ MatcherIndex(1), |
| /* [71] */ MatcherIndex(40), |
| /* [72] */ MatcherIndex(4), |
| /* [73] */ MatcherIndex(10), |
| /* [74] */ MatcherIndex(0), |
| /* [75] */ MatcherIndex(41), |
| /* [76] */ MatcherIndex(4), |
| /* [77] */ MatcherIndex(10), |
| /* [78] */ MatcherIndex(6), |
| /* [79] */ MatcherIndex(42), |
| /* [80] */ MatcherIndex(4), |
| /* [81] */ MatcherIndex(10), |
| /* [82] */ MatcherIndex(7), |
| /* [83] */ MatcherIndex(43), |
| /* [84] */ MatcherIndex(4), |
| /* [85] */ MatcherIndex(10), |
| /* [86] */ MatcherIndex(5), |
| /* [87] */ MatcherIndex(40), |
| /* [88] */ MatcherIndex(5), |
| /* [89] */ MatcherIndex(10), |
| /* [90] */ MatcherIndex(1), |
| /* [91] */ MatcherIndex(41), |
| /* [92] */ MatcherIndex(5), |
| /* [93] */ MatcherIndex(10), |
| /* [94] */ MatcherIndex(42), |
| /* [95] */ MatcherIndex(5), |
| /* [96] */ MatcherIndex(10), |
| /* [97] */ MatcherIndex(43), |
| /* [98] */ MatcherIndex(5), |
| /* [99] */ MatcherIndex(10), |
| /* [100] */ MatcherIndex(40), |
| /* [101] */ MatcherIndex(6), |
| /* [102] */ MatcherIndex(10), |
| /* [103] */ MatcherIndex(41), |
| /* [104] */ MatcherIndex(6), |
| /* [105] */ MatcherIndex(10), |
| /* [106] */ MatcherIndex(42), |
| /* [107] */ MatcherIndex(6), |
| /* [108] */ MatcherIndex(10), |
| /* [109] */ MatcherIndex(43), |
| /* [110] */ MatcherIndex(6), |
| /* [111] */ MatcherIndex(10), |
| /* [112] */ MatcherIndex(40), |
| /* [113] */ MatcherIndex(4), |
| /* [114] */ MatcherIndex(9), |
| /* [115] */ MatcherIndex(7), |
| /* [116] */ MatcherIndex(40), |
| /* [117] */ MatcherIndex(5), |
| /* [118] */ MatcherIndex(9), |
| /* [119] */ MatcherIndex(6), |
| /* [120] */ MatcherIndex(40), |
| /* [121] */ MatcherIndex(6), |
| /* [122] */ MatcherIndex(9), |
| /* [123] */ MatcherIndex(5), |
| /* [124] */ MatcherIndex(41), |
| /* [125] */ MatcherIndex(4), |
| /* [126] */ MatcherIndex(9), |
| /* [127] */ MatcherIndex(0), |
| /* [128] */ MatcherIndex(41), |
| /* [129] */ MatcherIndex(5), |
| /* [130] */ MatcherIndex(9), |
| /* [131] */ MatcherIndex(1), |
| /* [132] */ MatcherIndex(41), |
| /* [133] */ MatcherIndex(6), |
| /* [134] */ MatcherIndex(9), |
| /* [135] */ MatcherIndex(42), |
| /* [136] */ MatcherIndex(4), |
| /* [137] */ MatcherIndex(9), |
| /* [138] */ MatcherIndex(42), |
| /* [139] */ MatcherIndex(5), |
| /* [140] */ MatcherIndex(9), |
| /* [141] */ MatcherIndex(42), |
| /* [142] */ MatcherIndex(6), |
| /* [143] */ MatcherIndex(9), |
| /* [144] */ MatcherIndex(43), |
| /* [145] */ MatcherIndex(4), |
| /* [146] */ MatcherIndex(9), |
| /* [147] */ MatcherIndex(43), |
| /* [148] */ MatcherIndex(5), |
| /* [149] */ MatcherIndex(9), |
| /* [150] */ MatcherIndex(43), |
| /* [151] */ MatcherIndex(6), |
| /* [152] */ MatcherIndex(9), |
| /* [153] */ MatcherIndex(21), |
| /* [154] */ MatcherIndex(2), |
| /* [155] */ MatcherIndex(0), |
| /* [156] */ MatcherIndex(21), |
| /* [157] */ MatcherIndex(1), |
| /* [158] */ MatcherIndex(4), |
| /* [159] */ MatcherIndex(21), |
| /* [160] */ MatcherIndex(1), |
| /* [161] */ MatcherIndex(6), |
| /* [162] */ MatcherIndex(47), |
| /* [163] */ MatcherIndex(0), |
| /* [164] */ MatcherIndex(45), |
| /* [165] */ MatcherIndex(0), |
| /* [166] */ MatcherIndex(11), |
| /* [167] */ MatcherIndex(7), |
| /* [168] */ MatcherIndex(11), |
| /* [169] */ MatcherIndex(5), |
| /* [170] */ MatcherIndex(11), |
| /* [171] */ MatcherIndex(6), |
| /* [172] */ MatcherIndex(28), |
| /* [173] */ MatcherIndex(0), |
| /* [174] */ MatcherIndex(29), |
| /* [175] */ MatcherIndex(0), |
| /* [176] */ MatcherIndex(30), |
| /* [177] */ MatcherIndex(0), |
| /* [178] */ MatcherIndex(31), |
| /* [179] */ MatcherIndex(0), |
| /* [180] */ MatcherIndex(32), |
| /* [181] */ MatcherIndex(0), |
| /* [182] */ MatcherIndex(33), |
| /* [183] */ MatcherIndex(0), |
| /* [184] */ MatcherIndex(34), |
| /* [185] */ MatcherIndex(0), |
| /* [186] */ MatcherIndex(11), |
| /* [187] */ MatcherIndex(0), |
| /* [188] */ MatcherIndex(28), |
| /* [189] */ MatcherIndex(7), |
| /* [190] */ MatcherIndex(29), |
| /* [191] */ MatcherIndex(7), |
| /* [192] */ MatcherIndex(30), |
| /* [193] */ MatcherIndex(7), |
| /* [194] */ MatcherIndex(31), |
| /* [195] */ MatcherIndex(7), |
| /* [196] */ MatcherIndex(32), |
| /* [197] */ MatcherIndex(7), |
| /* [198] */ MatcherIndex(33), |
| /* [199] */ MatcherIndex(7), |
| /* [200] */ MatcherIndex(49), |
| /* [201] */ MatcherIndex(0), |
| /* [202] */ MatcherIndex(11), |
| /* [203] */ MatcherIndex(1), |
| /* [204] */ MatcherIndex(12), |
| /* [205] */ MatcherIndex(0), |
| /* [206] */ MatcherIndex(12), |
| /* [207] */ MatcherIndex(7), |
| /* [208] */ MatcherIndex(12), |
| /* [209] */ MatcherIndex(8), |
| /* [210] */ MatcherIndex(13), |
| /* [211] */ MatcherIndex(0), |
| /* [212] */ MatcherIndex(13), |
| /* [213] */ MatcherIndex(7), |
| /* [214] */ MatcherIndex(13), |
| /* [215] */ MatcherIndex(8), |
| /* [216] */ MatcherIndex(14), |
| /* [217] */ MatcherIndex(0), |
| /* [218] */ MatcherIndex(14), |
| /* [219] */ MatcherIndex(7), |
| /* [220] */ MatcherIndex(14), |
| /* [221] */ MatcherIndex(8), |
| /* [222] */ MatcherIndex(15), |
| /* [223] */ MatcherIndex(0), |
| /* [224] */ MatcherIndex(15), |
| /* [225] */ MatcherIndex(7), |
| /* [226] */ MatcherIndex(15), |
| /* [227] */ MatcherIndex(8), |
| /* [228] */ MatcherIndex(16), |
| /* [229] */ MatcherIndex(0), |
| /* [230] */ MatcherIndex(16), |
| /* [231] */ MatcherIndex(7), |
| /* [232] */ MatcherIndex(16), |
| /* [233] */ MatcherIndex(8), |
| /* [234] */ MatcherIndex(17), |
| /* [235] */ MatcherIndex(0), |
| /* [236] */ MatcherIndex(17), |
| /* [237] */ MatcherIndex(7), |
| /* [238] */ MatcherIndex(17), |
| /* [239] */ MatcherIndex(8), |
| /* [240] */ MatcherIndex(18), |
| /* [241] */ MatcherIndex(0), |
| /* [242] */ MatcherIndex(18), |
| /* [243] */ MatcherIndex(7), |
| /* [244] */ MatcherIndex(18), |
| /* [245] */ MatcherIndex(8), |
| /* [246] */ MatcherIndex(19), |
| /* [247] */ MatcherIndex(0), |
| /* [248] */ MatcherIndex(19), |
| /* [249] */ MatcherIndex(7), |
| /* [250] */ MatcherIndex(19), |
| /* [251] */ MatcherIndex(8), |
| /* [252] */ MatcherIndex(20), |
| /* [253] */ MatcherIndex(0), |
| /* [254] */ MatcherIndex(20), |
| /* [255] */ MatcherIndex(7), |
| /* [256] */ MatcherIndex(20), |
| /* [257] */ MatcherIndex(8), |
| /* [258] */ MatcherIndex(56), |
| /* [259] */ MatcherIndex(60), |
| /* [260] */ MatcherIndex(61), |
| /* [261] */ MatcherIndex(50), |
| /* [262] */ MatcherIndex(58), |
| /* [263] */ MatcherIndex(57), |
| /* [264] */ MatcherIndex(35), |
| /* [265] */ MatcherIndex(36), |
| /* [266] */ MatcherIndex(37), |
| /* [267] */ MatcherIndex(38), |
| /* [268] */ MatcherIndex(39), |
| /* [269] */ MatcherIndex(44), |
| /* [270] */ MatcherIndex(26), |
| /* [271] */ MatcherIndex(27), |
| /* [272] */ MatcherIndex(53), |
| /* [273] */ MatcherIndex(54), |
| /* [274] */ MatcherIndex(51), |
| /* [275] */ MatcherIndex(52), |
| /* [276] */ MatcherIndex(55), |
| }; |
| |
| static_assert(MatcherIndicesIndex::CanIndex(kMatcherIndices), |
| "MatcherIndicesIndex is not large enough to index kMatcherIndices"); |
| |
| constexpr ParameterInfo kParameters[] = { |
| { |
| /* [0] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(5), |
| }, |
| { |
| /* [1] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [2] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [3] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [4] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [5] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [6] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [7] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [8] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [9] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [10] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [11] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [12] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [13] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [14] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [15] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [16] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [17] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(78), |
| }, |
| { |
| /* [18] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(78), |
| }, |
| { |
| /* [19] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(192), |
| }, |
| { |
| /* [20] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [21] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(114), |
| }, |
| { |
| /* [22] */ |
| /* usage */ core::ParameterUsage::kArrayIndex, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [23] */ |
| /* usage */ core::ParameterUsage::kDdx, |
| /* matcher_indices */ MatcherIndicesIndex(114), |
| }, |
| { |
| /* [24] */ |
| /* usage */ core::ParameterUsage::kDdy, |
| /* matcher_indices */ MatcherIndicesIndex(114), |
| }, |
| { |
| /* [25] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(122), |
| }, |
| { |
| /* [26] */ |
| /* usage */ core::ParameterUsage::kComponent, |
| /* matcher_indices */ MatcherIndicesIndex(4), |
| }, |
| { |
| /* [27] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(176), |
| }, |
| { |
| /* [28] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [29] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(114), |
| }, |
| { |
| /* [30] */ |
| /* usage */ core::ParameterUsage::kArrayIndex, |
| /* matcher_indices */ MatcherIndicesIndex(17), |
| }, |
| { |
| /* [31] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(122), |
| }, |
| { |
| /* [32] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(265), |
| }, |
| { |
| /* [33] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(271), |
| }, |
| { |
| /* [34] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(114), |
| }, |
| { |
| /* [35] */ |
| /* usage */ core::ParameterUsage::kArrayIndex, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [36] */ |
| /* usage */ core::ParameterUsage::kDepthRef, |
| /* matcher_indices */ MatcherIndicesIndex(49), |
| }, |
| { |
| /* [37] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(122), |
| }, |
| { |
| /* [38] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(192), |
| }, |
| { |
| /* [39] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [40] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(114), |
| }, |
| { |
| /* [41] */ |
| /* usage */ core::ParameterUsage::kArrayIndex, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [42] */ |
| /* usage */ core::ParameterUsage::kBias, |
| /* matcher_indices */ MatcherIndicesIndex(49), |
| }, |
| { |
| /* [43] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(122), |
| }, |
| { |
| /* [44] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(190), |
| }, |
| { |
| /* [45] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [46] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(114), |
| }, |
| { |
| /* [47] */ |
| /* usage */ core::ParameterUsage::kDdx, |
| /* matcher_indices */ MatcherIndicesIndex(114), |
| }, |
| { |
| /* [48] */ |
| /* usage */ core::ParameterUsage::kDdy, |
| /* matcher_indices */ MatcherIndicesIndex(114), |
| }, |
| { |
| /* [49] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(122), |
| }, |
| { |
| /* [50] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(194), |
| }, |
| { |
| /* [51] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [52] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [53] */ |
| /* usage */ core::ParameterUsage::kDdx, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [54] */ |
| /* usage */ core::ParameterUsage::kDdy, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [55] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(85), |
| }, |
| { |
| /* [56] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(198), |
| }, |
| { |
| /* [57] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [58] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [59] */ |
| /* usage */ core::ParameterUsage::kArrayIndex, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [60] */ |
| /* usage */ core::ParameterUsage::kDdx, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [61] */ |
| /* usage */ core::ParameterUsage::kDdy, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [62] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(192), |
| }, |
| { |
| /* [63] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [64] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(114), |
| }, |
| { |
| /* [65] */ |
| /* usage */ core::ParameterUsage::kArrayIndex, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [66] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(49), |
| }, |
| { |
| /* [67] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(122), |
| }, |
| { |
| /* [68] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(265), |
| }, |
| { |
| /* [69] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [70] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(114), |
| }, |
| { |
| /* [71] */ |
| /* usage */ core::ParameterUsage::kArrayIndex, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [72] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(4), |
| }, |
| { |
| /* [73] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(122), |
| }, |
| { |
| /* [74] */ |
| /* usage */ core::ParameterUsage::kComponent, |
| /* matcher_indices */ MatcherIndicesIndex(4), |
| }, |
| { |
| /* [75] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(174), |
| }, |
| { |
| /* [76] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [77] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(114), |
| }, |
| { |
| /* [78] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(122), |
| }, |
| { |
| /* [79] */ |
| /* usage */ core::ParameterUsage::kComponent, |
| /* matcher_indices */ MatcherIndicesIndex(4), |
| }, |
| { |
| /* [80] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(182), |
| }, |
| { |
| /* [81] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [82] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [83] */ |
| /* usage */ core::ParameterUsage::kArrayIndex, |
| /* matcher_indices */ MatcherIndicesIndex(17), |
| }, |
| { |
| /* [84] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(265), |
| }, |
| { |
| /* [85] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [86] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(114), |
| }, |
| { |
| /* [87] */ |
| /* usage */ core::ParameterUsage::kArrayIndex, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [88] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(122), |
| }, |
| { |
| /* [89] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(264), |
| }, |
| { |
| /* [90] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(271), |
| }, |
| { |
| /* [91] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(114), |
| }, |
| { |
| /* [92] */ |
| /* usage */ core::ParameterUsage::kDepthRef, |
| /* matcher_indices */ MatcherIndicesIndex(49), |
| }, |
| { |
| /* [93] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(122), |
| }, |
| { |
| /* [94] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(267), |
| }, |
| { |
| /* [95] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(271), |
| }, |
| { |
| /* [96] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [97] */ |
| /* usage */ core::ParameterUsage::kArrayIndex, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [98] */ |
| /* usage */ core::ParameterUsage::kDepthRef, |
| /* matcher_indices */ MatcherIndicesIndex(49), |
| }, |
| { |
| /* [99] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(192), |
| }, |
| { |
| /* [100] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [101] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(114), |
| }, |
| { |
| /* [102] */ |
| /* usage */ core::ParameterUsage::kArrayIndex, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [103] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(122), |
| }, |
| { |
| /* [104] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(190), |
| }, |
| { |
| /* [105] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [106] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(114), |
| }, |
| { |
| /* [107] */ |
| /* usage */ core::ParameterUsage::kBias, |
| /* matcher_indices */ MatcherIndicesIndex(49), |
| }, |
| { |
| /* [108] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(122), |
| }, |
| { |
| /* [109] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(194), |
| }, |
| { |
| /* [110] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [111] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [112] */ |
| /* usage */ core::ParameterUsage::kBias, |
| /* matcher_indices */ MatcherIndicesIndex(49), |
| }, |
| { |
| /* [113] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(85), |
| }, |
| { |
| /* [114] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(198), |
| }, |
| { |
| /* [115] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [116] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [117] */ |
| /* usage */ core::ParameterUsage::kArrayIndex, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [118] */ |
| /* usage */ core::ParameterUsage::kBias, |
| /* matcher_indices */ MatcherIndicesIndex(49), |
| }, |
| { |
| /* [119] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(196), |
| }, |
| { |
| /* [120] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [121] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [122] */ |
| /* usage */ core::ParameterUsage::kDdx, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [123] */ |
| /* usage */ core::ParameterUsage::kDdy, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [124] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(190), |
| }, |
| { |
| /* [125] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [126] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(114), |
| }, |
| { |
| /* [127] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(49), |
| }, |
| { |
| /* [128] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(122), |
| }, |
| { |
| /* [129] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(194), |
| }, |
| { |
| /* [130] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [131] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [132] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(49), |
| }, |
| { |
| /* [133] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(85), |
| }, |
| { |
| /* [134] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(198), |
| }, |
| { |
| /* [135] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [136] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [137] */ |
| /* usage */ core::ParameterUsage::kArrayIndex, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [138] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(49), |
| }, |
| { |
| /* [139] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(264), |
| }, |
| { |
| /* [140] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [141] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(114), |
| }, |
| { |
| /* [142] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [143] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(122), |
| }, |
| { |
| /* [144] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(267), |
| }, |
| { |
| /* [145] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [146] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [147] */ |
| /* usage */ core::ParameterUsage::kArrayIndex, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [148] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(4), |
| }, |
| { |
| /* [149] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(38), |
| }, |
| { |
| /* [150] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(38), |
| }, |
| { |
| /* [151] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(78), |
| }, |
| { |
| /* [152] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(78), |
| }, |
| { |
| /* [153] */ |
| /* usage */ core::ParameterUsage::kComponent, |
| /* matcher_indices */ MatcherIndicesIndex(4), |
| }, |
| { |
| /* [154] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(180), |
| }, |
| { |
| /* [155] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [156] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [157] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(264), |
| }, |
| { |
| /* [158] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [159] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(114), |
| }, |
| { |
| /* [160] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(122), |
| }, |
| { |
| /* [161] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(266), |
| }, |
| { |
| /* [162] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(271), |
| }, |
| { |
| /* [163] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [164] */ |
| /* usage */ core::ParameterUsage::kDepthRef, |
| /* matcher_indices */ MatcherIndicesIndex(49), |
| }, |
| { |
| /* [165] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(190), |
| }, |
| { |
| /* [166] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [167] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(114), |
| }, |
| { |
| /* [168] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(122), |
| }, |
| { |
| /* [169] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(194), |
| }, |
| { |
| /* [170] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [171] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [172] */ |
| /* usage */ core::ParameterUsage::kOffset, |
| /* matcher_indices */ MatcherIndicesIndex(85), |
| }, |
| { |
| /* [173] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(196), |
| }, |
| { |
| /* [174] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [175] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [176] */ |
| /* usage */ core::ParameterUsage::kBias, |
| /* matcher_indices */ MatcherIndicesIndex(49), |
| }, |
| { |
| /* [177] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(196), |
| }, |
| { |
| /* [178] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [179] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [180] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(49), |
| }, |
| { |
| /* [181] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(266), |
| }, |
| { |
| /* [182] */ |
| /* usage */ core::ParameterUsage::kSampler, |
| /* matcher_indices */ MatcherIndicesIndex(270), |
| }, |
| { |
| /* [183] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(81), |
| }, |
| { |
| /* [184] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [185] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(79), |
| }, |
| { |
| /* [186] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(126), |
| }, |
| { |
| /* [187] */ |
| /* usage */ core::ParameterUsage::kArrayIndex, |
| /* matcher_indices */ MatcherIndicesIndex(4), |
| }, |
| { |
| /* [188] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(166), |
| }, |
| { |
| /* [189] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(94), |
| }, |
| { |
| /* [190] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(126), |
| }, |
| { |
| /* [191] */ |
| /* usage */ core::ParameterUsage::kArrayIndex, |
| /* matcher_indices */ MatcherIndicesIndex(4), |
| }, |
| { |
| /* [192] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(168), |
| }, |
| { |
| /* [193] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(106), |
| }, |
| { |
| /* [194] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(126), |
| }, |
| { |
| /* [195] */ |
| /* usage */ core::ParameterUsage::kArrayIndex, |
| /* matcher_indices */ MatcherIndicesIndex(4), |
| }, |
| { |
| /* [196] */ |
| /* usage */ core::ParameterUsage::kValue, |
| /* matcher_indices */ MatcherIndicesIndex(170), |
| }, |
| { |
| /* [197] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(176), |
| }, |
| { |
| /* [198] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(130), |
| }, |
| { |
| /* [199] */ |
| /* usage */ core::ParameterUsage::kArrayIndex, |
| /* matcher_indices */ MatcherIndicesIndex(17), |
| }, |
| { |
| /* [200] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(28), |
| }, |
| { |
| /* [201] */ |
| /* usage */ core::ParameterUsage::kTexture, |
| /* matcher_indices */ MatcherIndicesIndex(265), |
| }, |
| { |
| /* [202] */ |
| /* usage */ core::ParameterUsage::kCoords, |
| /* matcher_indices */ MatcherIndicesIndex(126), |
| }, |
| { |
| /* [203] */ |
| /* usage */ core::ParameterUsage::kArrayIndex, |
| /* matcher_indices */ MatcherIndicesIndex(4), |
| }, |
| { |
| /* [204] */ |
| /* usage */ core::ParameterUsage::kLevel, |
| /* matcher_indices */ MatcherIndicesIndex(17), |
| }, |
| { |
| /* [205] */ |
| /* usage */ core::ParameterUsage::kX, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [206] */ |
| /* usage */ core::ParameterUsage::kY, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [207] */ |
| /* usage */ core::ParameterUsage::kZ, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [208] */ |
| /* usage */ core::ParameterUsage::kW, |
| /* matcher_indices */ MatcherIndicesIndex(3), |
| }, |
| { |
| /* [209] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(126), |
| }, |
| { |
| /* [210] */ |
| /* usage */ core::ParameterUsage::kNone, |
| /* matcher_indices */ MatcherIndicesIndex(126), |
| }, |
| { |
| /* [211] */ |
| /* usage */ core:: |