| // Copyright 2021 The Tint Authors. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // File generated by tools/intrinsic-gen |
| // using the template: |
| // src/intrinsic_table.inl.tmpl |
| // and the intrinsic defintion file: |
| // src/intrinsics.def |
| // |
| // Do not modify this file directly |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| // clang-format off |
| |
| /// TypeMatcher for 'type bool' |
| /// @see src/intrinsics.def:68:6 |
| class Bool : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* Bool::Match(MatchState& state, const sem::Type* ty) const { |
| if (!match_bool(ty)) { |
| return nullptr; |
| } |
| return build_bool(state); |
| } |
| |
| std::string Bool::String(MatchState&) const { |
| return "bool"; |
| } |
| |
| /// TypeMatcher for 'type f32' |
| /// @see src/intrinsics.def:69:6 |
| class F32 : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* F32::Match(MatchState& state, const sem::Type* ty) const { |
| if (!match_f32(ty)) { |
| return nullptr; |
| } |
| return build_f32(state); |
| } |
| |
| std::string F32::String(MatchState&) const { |
| return "f32"; |
| } |
| |
| /// TypeMatcher for 'type i32' |
| /// @see src/intrinsics.def:70:6 |
| class I32 : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* I32::Match(MatchState& state, const sem::Type* ty) const { |
| if (!match_i32(ty)) { |
| return nullptr; |
| } |
| return build_i32(state); |
| } |
| |
| std::string I32::String(MatchState&) const { |
| return "i32"; |
| } |
| |
| /// TypeMatcher for 'type u32' |
| /// @see src/intrinsics.def:71:6 |
| class U32 : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* U32::Match(MatchState& state, const sem::Type* ty) const { |
| if (!match_u32(ty)) { |
| return nullptr; |
| } |
| return build_u32(state); |
| } |
| |
| std::string U32::String(MatchState&) const { |
| return "u32"; |
| } |
| |
| /// TypeMatcher for 'type vec2' |
| /// @see src/intrinsics.def:72:6 |
| class Vec2 : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* Vec2::Match(MatchState& state, const sem::Type* ty) const { |
| const sem::Type* T = nullptr; |
| if (!match_vec2(ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return build_vec2(state, T); |
| } |
| |
| std::string Vec2::String(MatchState& state) const { |
| const std::string T = state.TypeName(); |
| return "vec2<" + T + ">"; |
| } |
| |
| /// TypeMatcher for 'type vec3' |
| /// @see src/intrinsics.def:73:6 |
| class Vec3 : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* Vec3::Match(MatchState& state, const sem::Type* ty) const { |
| const sem::Type* T = nullptr; |
| if (!match_vec3(ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return build_vec3(state, T); |
| } |
| |
| std::string Vec3::String(MatchState& state) const { |
| const std::string T = state.TypeName(); |
| return "vec3<" + T + ">"; |
| } |
| |
| /// TypeMatcher for 'type vec4' |
| /// @see src/intrinsics.def:74:6 |
| class Vec4 : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* Vec4::Match(MatchState& state, const sem::Type* ty) const { |
| const sem::Type* T = nullptr; |
| if (!match_vec4(ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return build_vec4(state, T); |
| } |
| |
| std::string Vec4::String(MatchState& state) const { |
| const std::string T = state.TypeName(); |
| return "vec4<" + T + ">"; |
| } |
| |
| /// TypeMatcher for 'type vec' |
| /// @see src/intrinsics.def:75:37 |
| class Vec : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* Vec::Match(MatchState& state, const sem::Type* ty) const { |
| Number N = Number::invalid; |
| const sem::Type* T = nullptr; |
| if (!match_vec(ty, N, T)) { |
| return nullptr; |
| } |
| N = state.Num(N); |
| if (!N.IsValid()) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return build_vec(state, N, T); |
| } |
| |
| std::string Vec::String(MatchState& state) const { |
| const std::string N = state.NumName(); |
| const std::string T = state.TypeName(); |
| std::stringstream ss; |
| ss << "vec" << N << "<" << T << ">"; |
| return ss.str(); |
| } |
| |
| /// TypeMatcher for 'type mat' |
| /// @see src/intrinsics.def:76:37 |
| class Mat : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* Mat::Match(MatchState& state, const sem::Type* ty) const { |
| Number N = Number::invalid; |
| Number M = Number::invalid; |
| const sem::Type* T = nullptr; |
| if (!match_mat(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 build_mat(state, N, M, T); |
| } |
| |
| std::string Mat::String(MatchState& state) const { |
| const std::string N = state.NumName(); |
| const std::string M = state.NumName(); |
| const std::string T = state.TypeName(); |
| std::stringstream ss; |
| ss << "mat" << N << "x" << M << "<" << T << ">"; |
| return ss.str(); |
| } |
| |
| /// TypeMatcher for 'type ptr' |
| /// @see src/intrinsics.def:77:6 |
| class Ptr : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* Ptr::Match(MatchState& state, const sem::Type* ty) const { |
| Number S = Number::invalid; |
| const sem::Type* T = nullptr; |
| Number A = Number::invalid; |
| if (!match_ptr(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 build_ptr(state, S, T, A); |
| } |
| |
| std::string Ptr::String(MatchState& state) const { |
| const std::string S = state.NumName(); |
| const std::string T = state.TypeName(); |
| const std::string A = state.NumName(); |
| return "ptr<" + S + ", " + T + ", " + A + ">"; |
| } |
| |
| /// TypeMatcher for 'type atomic' |
| /// @see src/intrinsics.def:78:6 |
| class Atomic : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* Atomic::Match(MatchState& state, const sem::Type* ty) const { |
| const sem::Type* T = nullptr; |
| if (!match_atomic(ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return build_atomic(state, T); |
| } |
| |
| std::string Atomic::String(MatchState& state) const { |
| const std::string T = state.TypeName(); |
| return "atomic<" + T + ">"; |
| } |
| |
| /// TypeMatcher for 'type array' |
| /// @see src/intrinsics.def:79:6 |
| class Array : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* Array::Match(MatchState& state, const sem::Type* ty) const { |
| const sem::Type* T = nullptr; |
| if (!match_array(ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return build_array(state, T); |
| } |
| |
| std::string Array::String(MatchState& state) const { |
| const std::string T = state.TypeName(); |
| return "array<" + T + ">"; |
| } |
| |
| /// TypeMatcher for 'type sampler' |
| /// @see src/intrinsics.def:80:6 |
| class Sampler : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* Sampler::Match(MatchState& state, const sem::Type* ty) const { |
| if (!match_sampler(ty)) { |
| return nullptr; |
| } |
| return build_sampler(state); |
| } |
| |
| std::string Sampler::String(MatchState&) const { |
| return "sampler"; |
| } |
| |
| /// TypeMatcher for 'type sampler_comparison' |
| /// @see src/intrinsics.def:81:6 |
| class SamplerComparison : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* SamplerComparison::Match(MatchState& state, const sem::Type* ty) const { |
| if (!match_sampler_comparison(ty)) { |
| return nullptr; |
| } |
| return build_sampler_comparison(state); |
| } |
| |
| std::string SamplerComparison::String(MatchState&) const { |
| return "sampler_comparison"; |
| } |
| |
| /// TypeMatcher for 'type texture_1d' |
| /// @see src/intrinsics.def:82:6 |
| class Texture1D : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* Texture1D::Match(MatchState& state, const sem::Type* ty) const { |
| const sem::Type* T = nullptr; |
| if (!match_texture_1d(ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return build_texture_1d(state, T); |
| } |
| |
| std::string Texture1D::String(MatchState& state) const { |
| const std::string T = state.TypeName(); |
| return "texture_1d<" + T + ">"; |
| } |
| |
| /// TypeMatcher for 'type texture_2d' |
| /// @see src/intrinsics.def:83:6 |
| class Texture2D : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* Texture2D::Match(MatchState& state, const sem::Type* ty) const { |
| const sem::Type* T = nullptr; |
| if (!match_texture_2d(ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return build_texture_2d(state, T); |
| } |
| |
| std::string Texture2D::String(MatchState& state) const { |
| const std::string T = state.TypeName(); |
| return "texture_2d<" + T + ">"; |
| } |
| |
| /// TypeMatcher for 'type texture_2d_array' |
| /// @see src/intrinsics.def:84:6 |
| class Texture2DArray : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* Texture2DArray::Match(MatchState& state, const sem::Type* ty) const { |
| const sem::Type* T = nullptr; |
| if (!match_texture_2d_array(ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return build_texture_2d_array(state, T); |
| } |
| |
| std::string Texture2DArray::String(MatchState& state) const { |
| const std::string T = state.TypeName(); |
| return "texture_2d_array<" + T + ">"; |
| } |
| |
| /// TypeMatcher for 'type texture_3d' |
| /// @see src/intrinsics.def:85:6 |
| class Texture3D : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* Texture3D::Match(MatchState& state, const sem::Type* ty) const { |
| const sem::Type* T = nullptr; |
| if (!match_texture_3d(ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return build_texture_3d(state, T); |
| } |
| |
| std::string Texture3D::String(MatchState& state) const { |
| const std::string T = state.TypeName(); |
| return "texture_3d<" + T + ">"; |
| } |
| |
| /// TypeMatcher for 'type texture_cube' |
| /// @see src/intrinsics.def:86:6 |
| class TextureCube : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* TextureCube::Match(MatchState& state, const sem::Type* ty) const { |
| const sem::Type* T = nullptr; |
| if (!match_texture_cube(ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return build_texture_cube(state, T); |
| } |
| |
| std::string TextureCube::String(MatchState& state) const { |
| const std::string T = state.TypeName(); |
| return "texture_cube<" + T + ">"; |
| } |
| |
| /// TypeMatcher for 'type texture_cube_array' |
| /// @see src/intrinsics.def:87:6 |
| class TextureCubeArray : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* TextureCubeArray::Match(MatchState& state, const sem::Type* ty) const { |
| const sem::Type* T = nullptr; |
| if (!match_texture_cube_array(ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return build_texture_cube_array(state, T); |
| } |
| |
| std::string TextureCubeArray::String(MatchState& state) const { |
| const std::string T = state.TypeName(); |
| return "texture_cube_array<" + T + ">"; |
| } |
| |
| /// TypeMatcher for 'type texture_multisampled_2d' |
| /// @see src/intrinsics.def:88:6 |
| class TextureMultisampled2D : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* TextureMultisampled2D::Match(MatchState& state, const sem::Type* ty) const { |
| const sem::Type* T = nullptr; |
| if (!match_texture_multisampled_2d(ty, T)) { |
| return nullptr; |
| } |
| T = state.Type(T); |
| if (T == nullptr) { |
| return nullptr; |
| } |
| return build_texture_multisampled_2d(state, T); |
| } |
| |
| std::string TextureMultisampled2D::String(MatchState& state) const { |
| const std::string T = state.TypeName(); |
| return "texture_multisampled_2d<" + T + ">"; |
| } |
| |
| /// TypeMatcher for 'type texture_depth_2d' |
| /// @see src/intrinsics.def:89:6 |
| class TextureDepth2D : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* TextureDepth2D::Match(MatchState& state, const sem::Type* ty) const { |
| if (!match_texture_depth_2d(ty)) { |
| return nullptr; |
| } |
| return build_texture_depth_2d(state); |
| } |
| |
| std::string TextureDepth2D::String(MatchState&) const { |
| return "texture_depth_2d"; |
| } |
| |
| /// TypeMatcher for 'type texture_depth_2d_array' |
| /// @see src/intrinsics.def:90:6 |
| class TextureDepth2DArray : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* TextureDepth2DArray::Match(MatchState& state, const sem::Type* ty) const { |
| if (!match_texture_depth_2d_array(ty)) { |
| return nullptr; |
| } |
| return build_texture_depth_2d_array(state); |
| } |
| |
| std::string TextureDepth2DArray::String(MatchState&) const { |
| return "texture_depth_2d_array"; |
| } |
| |
| /// TypeMatcher for 'type texture_depth_cube' |
| /// @see src/intrinsics.def:91:6 |
| class TextureDepthCube : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* TextureDepthCube::Match(MatchState& state, const sem::Type* ty) const { |
| if (!match_texture_depth_cube(ty)) { |
| return nullptr; |
| } |
| return build_texture_depth_cube(state); |
| } |
| |
| std::string TextureDepthCube::String(MatchState&) const { |
| return "texture_depth_cube"; |
| } |
| |
| /// TypeMatcher for 'type texture_depth_cube_array' |
| /// @see src/intrinsics.def:92:6 |
| class TextureDepthCubeArray : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* TextureDepthCubeArray::Match(MatchState& state, const sem::Type* ty) const { |
| if (!match_texture_depth_cube_array(ty)) { |
| return nullptr; |
| } |
| return build_texture_depth_cube_array(state); |
| } |
| |
| std::string TextureDepthCubeArray::String(MatchState&) const { |
| return "texture_depth_cube_array"; |
| } |
| |
| /// TypeMatcher for 'type texture_depth_multisampled_2d' |
| /// @see src/intrinsics.def:93:6 |
| class TextureDepthMultisampled2D : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* TextureDepthMultisampled2D::Match(MatchState& state, const sem::Type* ty) const { |
| if (!match_texture_depth_multisampled_2d(ty)) { |
| return nullptr; |
| } |
| return build_texture_depth_multisampled_2d(state); |
| } |
| |
| std::string TextureDepthMultisampled2D::String(MatchState&) const { |
| return "texture_depth_multisampled_2d"; |
| } |
| |
| /// TypeMatcher for 'type texture_storage_1d' |
| /// @see src/intrinsics.def:94:6 |
| class TextureStorage1D : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* TextureStorage1D::Match(MatchState& state, const sem::Type* ty) const { |
| Number F = Number::invalid; |
| Number A = Number::invalid; |
| if (!match_texture_storage_1d(ty, F, A)) { |
| return nullptr; |
| } |
| F = state.Num(F); |
| if (!F.IsValid()) { |
| return nullptr; |
| } |
| A = state.Num(A); |
| if (!A.IsValid()) { |
| return nullptr; |
| } |
| return build_texture_storage_1d(state, F, A); |
| } |
| |
| std::string TextureStorage1D::String(MatchState& state) const { |
| const std::string F = state.NumName(); |
| const std::string A = state.NumName(); |
| return "texture_storage_1d<" + F + ", " + A + ">"; |
| } |
| |
| /// TypeMatcher for 'type texture_storage_2d' |
| /// @see src/intrinsics.def:95:6 |
| class TextureStorage2D : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* TextureStorage2D::Match(MatchState& state, const sem::Type* ty) const { |
| Number F = Number::invalid; |
| Number A = Number::invalid; |
| if (!match_texture_storage_2d(ty, F, A)) { |
| return nullptr; |
| } |
| F = state.Num(F); |
| if (!F.IsValid()) { |
| return nullptr; |
| } |
| A = state.Num(A); |
| if (!A.IsValid()) { |
| return nullptr; |
| } |
| return build_texture_storage_2d(state, F, A); |
| } |
| |
| std::string TextureStorage2D::String(MatchState& state) const { |
| const std::string F = state.NumName(); |
| const std::string A = state.NumName(); |
| return "texture_storage_2d<" + F + ", " + A + ">"; |
| } |
| |
| /// TypeMatcher for 'type texture_storage_2d_array' |
| /// @see src/intrinsics.def:96:6 |
| class TextureStorage2DArray : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* TextureStorage2DArray::Match(MatchState& state, const sem::Type* ty) const { |
| Number F = Number::invalid; |
| Number A = Number::invalid; |
| if (!match_texture_storage_2d_array(ty, F, A)) { |
| return nullptr; |
| } |
| F = state.Num(F); |
| if (!F.IsValid()) { |
| return nullptr; |
| } |
| A = state.Num(A); |
| if (!A.IsValid()) { |
| return nullptr; |
| } |
| return build_texture_storage_2d_array(state, F, A); |
| } |
| |
| std::string TextureStorage2DArray::String(MatchState& state) const { |
| const std::string F = state.NumName(); |
| const std::string A = state.NumName(); |
| return "texture_storage_2d_array<" + F + ", " + A + ">"; |
| } |
| |
| /// TypeMatcher for 'type texture_storage_3d' |
| /// @see src/intrinsics.def:97:6 |
| class TextureStorage3D : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* TextureStorage3D::Match(MatchState& state, const sem::Type* ty) const { |
| Number F = Number::invalid; |
| Number A = Number::invalid; |
| if (!match_texture_storage_3d(ty, F, A)) { |
| return nullptr; |
| } |
| F = state.Num(F); |
| if (!F.IsValid()) { |
| return nullptr; |
| } |
| A = state.Num(A); |
| if (!A.IsValid()) { |
| return nullptr; |
| } |
| return build_texture_storage_3d(state, F, A); |
| } |
| |
| std::string TextureStorage3D::String(MatchState& state) const { |
| const std::string F = state.NumName(); |
| const std::string A = state.NumName(); |
| return "texture_storage_3d<" + F + ", " + A + ">"; |
| } |
| |
| /// TypeMatcher for 'type texture_external' |
| /// @see src/intrinsics.def:98:6 |
| class TextureExternal : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* TextureExternal::Match(MatchState& state, const sem::Type* ty) const { |
| if (!match_texture_external(ty)) { |
| return nullptr; |
| } |
| return build_texture_external(state); |
| } |
| |
| std::string TextureExternal::String(MatchState&) const { |
| return "texture_external"; |
| } |
| |
| /// TypeMatcher for 'type _modf_result' |
| /// @see src/intrinsics.def:100:6 |
| class ModfResult : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* ModfResult::Match(MatchState& state, const sem::Type* ty) const { |
| if (!match_modf_result(ty)) { |
| return nullptr; |
| } |
| return build_modf_result(state); |
| } |
| |
| std::string ModfResult::String(MatchState&) const { |
| return "_modf_result"; |
| } |
| |
| /// TypeMatcher for 'type _modf_result_vec' |
| /// @see src/intrinsics.def:101:41 |
| class ModfResultVec : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* ModfResultVec::Match(MatchState& state, const sem::Type* ty) const { |
| Number N = Number::invalid; |
| if (!match_modf_result_vec(ty, N)) { |
| return nullptr; |
| } |
| N = state.Num(N); |
| if (!N.IsValid()) { |
| return nullptr; |
| } |
| return build_modf_result_vec(state, N); |
| } |
| |
| std::string ModfResultVec::String(MatchState& state) const { |
| const std::string N = state.NumName(); |
| std::stringstream ss; |
| ss << "_modf_result_vec" << N; |
| return ss.str(); |
| } |
| |
| /// TypeMatcher for 'type _frexp_result' |
| /// @see src/intrinsics.def:102:6 |
| class FrexpResult : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* FrexpResult::Match(MatchState& state, const sem::Type* ty) const { |
| if (!match_frexp_result(ty)) { |
| return nullptr; |
| } |
| return build_frexp_result(state); |
| } |
| |
| std::string FrexpResult::String(MatchState&) const { |
| return "_frexp_result"; |
| } |
| |
| /// TypeMatcher for 'type _frexp_result_vec' |
| /// @see src/intrinsics.def:103:42 |
| class FrexpResultVec : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* FrexpResultVec::Match(MatchState& state, const sem::Type* ty) const { |
| Number N = Number::invalid; |
| if (!match_frexp_result_vec(ty, N)) { |
| return nullptr; |
| } |
| N = state.Num(N); |
| if (!N.IsValid()) { |
| return nullptr; |
| } |
| return build_frexp_result_vec(state, N); |
| } |
| |
| std::string FrexpResultVec::String(MatchState& state) const { |
| const std::string N = state.NumName(); |
| std::stringstream ss; |
| ss << "_frexp_result_vec" << N; |
| return ss.str(); |
| } |
| |
| /// TypeMatcher for 'match fiu32' |
| /// @see src/intrinsics.def:111:7 |
| class Fiu32 : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules, and returns the |
| /// expected, canonicalized type on success. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* Fiu32::Match(MatchState& state, const sem::Type* ty) const { |
| if (match_f32(ty)) { |
| return build_f32(state); |
| } |
| if (match_i32(ty)) { |
| return build_i32(state); |
| } |
| if (match_u32(ty)) { |
| return build_u32(state); |
| } |
| return nullptr; |
| } |
| |
| std::string Fiu32::String(MatchState&) const { |
| return "f32, i32 or u32"; |
| } |
| |
| /// TypeMatcher for 'match iu32' |
| /// @see src/intrinsics.def:112:7 |
| class Iu32 : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules, and returns the |
| /// expected, canonicalized type on success. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* Iu32::Match(MatchState& state, const sem::Type* ty) const { |
| if (match_i32(ty)) { |
| return build_i32(state); |
| } |
| if (match_u32(ty)) { |
| return build_u32(state); |
| } |
| return nullptr; |
| } |
| |
| std::string Iu32::String(MatchState&) const { |
| return "i32 or u32"; |
| } |
| |
| /// TypeMatcher for 'match scalar' |
| /// @see src/intrinsics.def:113:7 |
| class Scalar : public TypeMatcher { |
| public: |
| /// Checks whether the given type matches the matcher rules, and returns the |
| /// expected, canonicalized type on success. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param type the type to match |
| /// @returns the canonicalized type on match, otherwise nullptr |
| const sem::Type* Match(MatchState& state, |
| const sem::Type* type) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| const sem::Type* Scalar::Match(MatchState& state, const sem::Type* ty) const { |
| if (match_f32(ty)) { |
| return build_f32(state); |
| } |
| if (match_i32(ty)) { |
| return build_i32(state); |
| } |
| if (match_u32(ty)) { |
| return build_u32(state); |
| } |
| if (match_bool(ty)) { |
| return build_bool(state); |
| } |
| return nullptr; |
| } |
| |
| std::string Scalar::String(MatchState&) const { |
| return "f32, i32, u32 or bool"; |
| } |
| |
| /// EnumMatcher for 'match f32_texel_format' |
| /// @see src/intrinsics.def:124:7 |
| class F32TexelFormat : public NumberMatcher { |
| public: |
| /// Checks whether the given number matches the enum matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param number the enum value as a Number |
| /// @return true if the enum value matches the set |
| Number Match(MatchState& state, Number number) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| Number F32TexelFormat::Match(MatchState&, Number number) const { |
| switch (static_cast<TexelFormat>(number.Value())) { |
| case TexelFormat::kRgba8Unorm: |
| case TexelFormat::kRgba8Snorm: |
| case TexelFormat::kRgba16Float: |
| case TexelFormat::kR32Float: |
| case TexelFormat::kRg32Float: |
| case TexelFormat::kRgba32Float: |
| return number; |
| default: |
| return Number::invalid; |
| } |
| } |
| |
| std::string F32TexelFormat::String(MatchState&) const { |
| return "rgba8unorm, rgba8snorm, rgba16float, r32float, rg32float or rgba32float"; |
| } |
| |
| /// EnumMatcher for 'match i32_texel_format' |
| /// @see src/intrinsics.def:126:7 |
| class I32TexelFormat : public NumberMatcher { |
| public: |
| /// Checks whether the given number matches the enum matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param number the enum value as a Number |
| /// @return true if the enum value matches the set |
| Number Match(MatchState& state, Number number) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| Number I32TexelFormat::Match(MatchState&, Number number) const { |
| switch (static_cast<TexelFormat>(number.Value())) { |
| case TexelFormat::kRgba8Sint: |
| case TexelFormat::kRgba16Sint: |
| case TexelFormat::kR32Sint: |
| case TexelFormat::kRg32Sint: |
| case TexelFormat::kRgba32Sint: |
| return number; |
| default: |
| return Number::invalid; |
| } |
| } |
| |
| std::string I32TexelFormat::String(MatchState&) const { |
| return "rgba8sint, rgba16sint, r32sint, rg32sint or rgba32sint"; |
| } |
| |
| /// EnumMatcher for 'match u32_texel_format' |
| /// @see src/intrinsics.def:128:7 |
| class U32TexelFormat : public NumberMatcher { |
| public: |
| /// Checks whether the given number matches the enum matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param number the enum value as a Number |
| /// @return true if the enum value matches the set |
| Number Match(MatchState& state, Number number) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| Number U32TexelFormat::Match(MatchState&, Number number) const { |
| switch (static_cast<TexelFormat>(number.Value())) { |
| case TexelFormat::kRgba8Uint: |
| case TexelFormat::kRgba16Uint: |
| case TexelFormat::kR32Uint: |
| case TexelFormat::kRg32Uint: |
| case TexelFormat::kRgba32Uint: |
| return number; |
| default: |
| return Number::invalid; |
| } |
| } |
| |
| std::string U32TexelFormat::String(MatchState&) const { |
| return "rgba8uint, rgba16uint, r32uint, rg32uint or rgba32uint"; |
| } |
| |
| /// EnumMatcher for 'match read_or_write' |
| /// @see src/intrinsics.def:131:7 |
| class ReadOrWrite : public NumberMatcher { |
| public: |
| /// Checks whether the given number matches the enum matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param number the enum value as a Number |
| /// @return true if the enum value matches the set |
| Number Match(MatchState& state, Number number) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| Number ReadOrWrite::Match(MatchState&, Number number) const { |
| switch (static_cast<Access>(number.Value())) { |
| case Access::kRead: |
| case Access::kWrite: |
| return number; |
| default: |
| return Number::invalid; |
| } |
| } |
| |
| std::string ReadOrWrite::String(MatchState&) const { |
| return "read or write"; |
| } |
| |
| /// EnumMatcher for 'match function_private_workgroup' |
| /// @see src/intrinsics.def:133:7 |
| class FunctionPrivateWorkgroup : public NumberMatcher { |
| public: |
| /// Checks whether the given number matches the enum matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param number the enum value as a Number |
| /// @return true if the enum value matches the set |
| Number Match(MatchState& state, Number number) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| Number FunctionPrivateWorkgroup::Match(MatchState&, Number number) const { |
| switch (static_cast<StorageClass>(number.Value())) { |
| case StorageClass::kFunction: |
| case StorageClass::kPrivate: |
| case StorageClass::kWorkgroup: |
| return number; |
| default: |
| return Number::invalid; |
| } |
| } |
| |
| std::string FunctionPrivateWorkgroup::String(MatchState&) const { |
| return "function, private or workgroup"; |
| } |
| |
| /// EnumMatcher for 'match workgroup_or_storage' |
| /// @see src/intrinsics.def:134:7 |
| class WorkgroupOrStorage : public NumberMatcher { |
| public: |
| /// Checks whether the given number matches the enum matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param number the enum value as a Number |
| /// @return true if the enum value matches the set |
| Number Match(MatchState& state, Number number) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| Number WorkgroupOrStorage::Match(MatchState&, Number number) const { |
| switch (static_cast<StorageClass>(number.Value())) { |
| case StorageClass::kWorkgroup: |
| case StorageClass::kStorage: |
| return number; |
| default: |
| return Number::invalid; |
| } |
| } |
| |
| std::string WorkgroupOrStorage::String(MatchState&) const { |
| return "workgroup or storage"; |
| } |
| |
| /// EnumMatcher for 'match storage' |
| class Storage : public NumberMatcher { |
| public: |
| /// Checks whether the given number matches the enum matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param number the enum value as a Number |
| /// @return true if the enum value matches the set |
| Number Match(MatchState& state, Number number) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| Number Storage::Match(MatchState&, Number number) const { |
| if (number.IsAny() || number.Value() == static_cast<uint32_t>(StorageClass::kStorage)) { |
| return Number(static_cast<uint32_t>(StorageClass::kStorage)); |
| } |
| return Number::invalid; |
| } |
| |
| std::string Storage::String(MatchState&) const { |
| return "storage"; |
| } |
| |
| /// EnumMatcher for 'match write' |
| class Write : public NumberMatcher { |
| public: |
| /// Checks whether the given number matches the enum matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param number the enum value as a Number |
| /// @return true if the enum value matches the set |
| Number Match(MatchState& state, Number number) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| Number Write::Match(MatchState&, Number number) const { |
| if (number.IsAny() || number.Value() == static_cast<uint32_t>(Access::kWrite)) { |
| return Number(static_cast<uint32_t>(Access::kWrite)); |
| } |
| return Number::invalid; |
| } |
| |
| std::string Write::String(MatchState&) const { |
| return "write"; |
| } |
| |
| /// EnumMatcher for 'match read' |
| class Read : public NumberMatcher { |
| public: |
| /// Checks whether the given number matches the enum matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param number the enum value as a Number |
| /// @return true if the enum value matches the set |
| Number Match(MatchState& state, Number number) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| Number Read::Match(MatchState&, Number number) const { |
| if (number.IsAny() || number.Value() == static_cast<uint32_t>(Access::kRead)) { |
| return Number(static_cast<uint32_t>(Access::kRead)); |
| } |
| return Number::invalid; |
| } |
| |
| std::string Read::String(MatchState&) const { |
| return "read"; |
| } |
| |
| /// EnumMatcher for 'match read_write' |
| class ReadWrite : public NumberMatcher { |
| public: |
| /// Checks whether the given number matches the enum matcher rules. |
| /// Match may close open types and numbers in state. |
| /// @param state the MatchState |
| /// @param number the enum value as a Number |
| /// @return true if the enum value matches the set |
| Number Match(MatchState& state, Number number) const override; |
| /// @param state the MatchState |
| /// @return a string representation of the matcher. |
| std::string String(MatchState& state) const override; |
| }; |
| |
| Number ReadWrite::Match(MatchState&, Number number) const { |
| if (number.IsAny() || number.Value() == static_cast<uint32_t>(Access::kReadWrite)) { |
| return Number(static_cast<uint32_t>(Access::kReadWrite)); |
| } |
| return Number::invalid; |
| } |
| |
| std::string ReadWrite::String(MatchState&) const { |
| return "read_write"; |
| } |
| |
| /// Matchers holds type and number matchers |
| class Matchers { |
| private: |
| OpenTypeMatcher open_type_0_{0}; |
| OpenNumberMatcher open_number_0_{0}; |
| OpenNumberMatcher open_number_1_{1}; |
| OpenNumberMatcher open_number_2_{2}; |
| Bool Bool_; |
| F32 F32_; |
| I32 I32_; |
| U32 U32_; |
| Vec2 Vec2_; |
| Vec3 Vec3_; |
| Vec4 Vec4_; |
| Vec Vec_; |
| Mat Mat_; |
| Ptr Ptr_; |
| Atomic Atomic_; |
| Array Array_; |
| Sampler Sampler_; |
| SamplerComparison SamplerComparison_; |
| Texture1D Texture1D_; |
| Texture2D Texture2D_; |
| Texture2DArray Texture2DArray_; |
| Texture3D Texture3D_; |
| TextureCube TextureCube_; |
| TextureCubeArray TextureCubeArray_; |
| TextureMultisampled2D TextureMultisampled2D_; |
| TextureDepth2D TextureDepth2D_; |
| TextureDepth2DArray TextureDepth2DArray_; |
| TextureDepthCube TextureDepthCube_; |
| TextureDepthCubeArray TextureDepthCubeArray_; |
| TextureDepthMultisampled2D TextureDepthMultisampled2D_; |
| TextureStorage1D TextureStorage1D_; |
| TextureStorage2D TextureStorage2D_; |
| TextureStorage2DArray TextureStorage2DArray_; |
| TextureStorage3D TextureStorage3D_; |
| TextureExternal TextureExternal_; |
| ModfResult ModfResult_; |
| ModfResultVec ModfResultVec_; |
| FrexpResult FrexpResult_; |
| FrexpResultVec FrexpResultVec_; |
| Fiu32 Fiu32_; |
| Iu32 Iu32_; |
| Scalar Scalar_; |
| F32TexelFormat F32TexelFormat_; |
| I32TexelFormat I32TexelFormat_; |
| U32TexelFormat U32TexelFormat_; |
| ReadOrWrite ReadOrWrite_; |
| FunctionPrivateWorkgroup FunctionPrivateWorkgroup_; |
| WorkgroupOrStorage WorkgroupOrStorage_; |
| Storage Storage_; |
| Write Write_; |
| Read Read_; |
| ReadWrite ReadWrite_; |
| |
| public: |
| /// Constructor |
| Matchers(); |
| /// Destructor |
| ~Matchers(); |
| |
| /// The open-types, types, and type matchers |
| TypeMatcher const* const type[39] = { |
| /* [0] */ &open_type_0_, |
| /* [1] */ &Bool_, |
| /* [2] */ &F32_, |
| /* [3] */ &I32_, |
| /* [4] */ &U32_, |
| /* [5] */ &Vec2_, |
| /* [6] */ &Vec3_, |
| /* [7] */ &Vec4_, |
| /* [8] */ &Vec_, |
| /* [9] */ &Mat_, |
| /* [10] */ &Ptr_, |
| /* [11] */ &Atomic_, |
| /* [12] */ &Array_, |
| /* [13] */ &Sampler_, |
| /* [14] */ &SamplerComparison_, |
| /* [15] */ &Texture1D_, |
| /* [16] */ &Texture2D_, |
| /* [17] */ &Texture2DArray_, |
| /* [18] */ &Texture3D_, |
| /* [19] */ &TextureCube_, |
| /* [20] */ &TextureCubeArray_, |
| /* [21] */ &TextureMultisampled2D_, |
| /* [22] */ &TextureDepth2D_, |
| /* [23] */ &TextureDepth2DArray_, |
| /* [24] */ &TextureDepthCube_, |
| /* [25] */ &TextureDepthCubeArray_, |
| /* [26] */ &TextureDepthMultisampled2D_, |
| /* [27] */ &TextureStorage1D_, |
| /* [28] */ &TextureStorage2D_, |
| /* [29] */ &TextureStorage2DArray_, |
| /* [30] */ &TextureStorage3D_, |
| /* [31] */ &TextureExternal_, |
| /* [32] */ &ModfResult_, |
| /* [33] */ &ModfResultVec_, |
| /* [34] */ &FrexpResult_, |
| /* [35] */ &FrexpResultVec_, |
| /* [36] */ &Fiu32_, |
| /* [37] */ &Iu32_, |
| /* [38] */ &Scalar_, |
| }; |
| |
| /// The open-numbers, and number matchers |
| NumberMatcher const* const number[13] = { |
| /* [0] */ &open_number_0_, |
| /* [1] */ &open_number_1_, |
| /* [2] */ &open_number_2_, |
| /* [3] */ &F32TexelFormat_, |
| /* [4] */ &I32TexelFormat_, |
| /* [5] */ &U32TexelFormat_, |
| /* [6] */ &ReadOrWrite_, |
| /* [7] */ &FunctionPrivateWorkgroup_, |
| /* [8] */ &WorkgroupOrStorage_, |
| /* [9] */ &Storage_, |
| /* [10] */ &Write_, |
| /* [11] */ &Read_, |
| /* [12] */ &ReadWrite_, |
| }; |
| }; |
| |
| Matchers::Matchers() = default; |
| Matchers::~Matchers() = default; |
| |
| constexpr MatcherIndex kMatcherIndices[] = { |
| /* [0] */ 28, |
| /* [1] */ 3, |
| /* [2] */ 10, |
| /* [3] */ 1, |
| /* [4] */ 8, |
| /* [5] */ 0, |
| /* [6] */ 3, |
| /* [7] */ 2, |
| /* [8] */ 10, |
| /* [9] */ 1, |
| /* [10] */ 8, |
| /* [11] */ 0, |
| /* [12] */ 2, |
| /* [13] */ 2, |
| /* [14] */ 10, |
| /* [15] */ 0, |
| /* [16] */ 11, |
| /* [17] */ 0, |
| /* [18] */ 12, |
| /* [19] */ 10, |
| /* [20] */ 9, |
| /* [21] */ 12, |
| /* [22] */ 0, |
| /* [23] */ 0, |
| /* [24] */ 9, |
| /* [25] */ 0, |
| /* [26] */ 1, |
| /* [27] */ 2, |
| /* [28] */ 9, |
| /* [29] */ 0, |
| /* [30] */ 0, |
| /* [31] */ 2, |
| /* [32] */ 10, |
| /* [33] */ 0, |
| /* [34] */ 3, |
| /* [35] */ 1, |
| /* [36] */ 9, |
| /* [37] */ 1, |
| /* [38] */ 0, |
| /* [39] */ 2, |
| /* [40] */ 10, |
| /* [41] */ 0, |
| /* [42] */ 2, |
| /* [43] */ 1, |
| /* [44] */ 29, |
| /* [45] */ 0, |
| /* [46] */ 1, |
| /* [47] */ 30, |
| /* [48] */ 0, |
| /* [49] */ 1, |
| /* [50] */ 28, |
| /* [51] */ 0, |
| /* [52] */ 1, |
| /* [53] */ 30, |
| /* [54] */ 5, |
| /* [55] */ 11, |
| /* [56] */ 27, |
| /* [57] */ 0, |
| /* [58] */ 1, |
| /* [59] */ 29, |
| /* [60] */ 5, |
| /* [61] */ 11, |
| /* [62] */ 8, |
| /* [63] */ 0, |
| /* [64] */ 0, |
| /* [65] */ 28, |
| /* [66] */ 5, |
| /* [67] */ 11, |
| /* [68] */ 8, |
| /* [69] */ 0, |
| /* [70] */ 1, |
| /* [71] */ 27, |
| /* [72] */ 5, |
| /* [73] */ 11, |
| /* [74] */ 30, |
| /* [75] */ 4, |
| /* [76] */ 11, |
| /* [77] */ 29, |
| /* [78] */ 4, |
| /* [79] */ 11, |
| /* [80] */ 28, |
| /* [81] */ 4, |
| /* [82] */ 11, |
| /* [83] */ 27, |
| /* [84] */ 4, |
| /* [85] */ 11, |
| /* [86] */ 30, |
| /* [87] */ 3, |
| /* [88] */ 11, |
| /* [89] */ 29, |
| /* [90] */ 3, |
| /* [91] */ 11, |
| /* [92] */ 28, |
| /* [93] */ 3, |
| /* [94] */ 11, |
| /* [95] */ 27, |
| /* [96] */ 3, |
| /* [97] */ 11, |
| /* [98] */ 30, |
| /* [99] */ 5, |
| /* [100] */ 10, |
| /* [101] */ 29, |
| /* [102] */ 5, |
| /* [103] */ 10, |
| /* [104] */ 28, |
| /* [105] */ 5, |
| /* [106] */ 10, |
| /* [107] */ 27, |
| /* [108] */ 5, |
| /* [109] */ 10, |
| /* [110] */ 30, |
| /* [111] */ 4, |
| /* [112] */ 10, |
| /* [113] */ 29, |
| /* [114] */ 4, |
| /* [115] */ 10, |
| /* [116] */ 28, |
| /* [117] */ 4, |
| /* [118] */ 10, |
| /* [119] */ 27, |
| /* [120] */ 4, |
| /* [121] */ 10, |
| /* [122] */ 30, |
| /* [123] */ 3, |
| /* [124] */ 10, |
| /* [125] */ 29, |
| /* [126] */ 3, |
| /* [127] */ 10, |
| /* [128] */ 27, |
| /* [129] */ 3, |
| /* [130] */ 10, |
| /* [131] */ 6, |
| /* [132] */ 2, |
| /* [133] */ 5, |
| /* [134] */ 3, |
| /* [135] */ 7, |
| /* [136] */ 2, |
| /* [137] */ 6, |
| /* [138] */ 3, |
| /* [139] */ 7, |
| /* [140] */ 3, |
| /* [141] */ 5, |
| /* [142] */ 2, |
| /* [143] */ 7, |
| /* [144] */ 4, |
| /* [145] */ 33, |
| /* [146] */ 0, |
| /* [147] */ 20, |
| /* [148] */ 2, |
| /* [149] */ 15, |
| /* [150] */ 0, |
| /* [151] */ 7, |
| /* [152] */ 0, |
| /* [153] */ 16, |
| /* [154] */ 0, |
| /* [155] */ 35, |
| /* [156] */ 0, |
| /* [157] */ 19, |
| /* [158] */ 2, |
| /* [159] */ 17, |
| /* [160] */ 0, |
| /* [161] */ 18, |
| /* [162] */ 0, |
| /* [163] */ 18, |
| /* [164] */ 2, |
| /* [165] */ 21, |
| /* [166] */ 0, |
| /* [167] */ 17, |
| /* [168] */ 2, |
| /* [169] */ 16, |
| /* [170] */ 2, |
| /* [171] */ 19, |
| /* [172] */ 0, |
| /* [173] */ 20, |
| /* [174] */ 0, |
| /* [175] */ 15, |
| /* [176] */ 2, |
| /* [177] */ 5, |
| /* [178] */ 0, |
| /* [179] */ 13, |
| /* [180] */ 25, |
| /* [181] */ 24, |
| /* [182] */ 23, |
| /* [183] */ 22, |
| /* [184] */ 14, |
| /* [185] */ 26, |
| /* [186] */ 31, |
| /* [187] */ 32, |
| /* [188] */ 34, |
| }; |
| |
| // Assert that the MatcherIndex is big enough to index all the matchers, plus |
| // kNoMatcher. |
| static_assert(static_cast<int>(sizeof(kMatcherIndices) / sizeof(kMatcherIndices[0])) < |
| static_cast<int>(std::numeric_limits<MatcherIndex>::max() - 1), |
| "MatcherIndex is not large enough to index kMatcherIndices"); |
| |
| constexpr ParameterInfo kParameters[] = { |
| { |
| /* [0] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[167], |
| }, |
| { |
| /* [1] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [2] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [3] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [4] */ |
| /* usage */ ParameterUsage::kDdx, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [5] */ |
| /* usage */ ParameterUsage::kDdy, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [6] */ |
| /* usage */ ParameterUsage::kOffset, |
| /* matcher indices */ &kMatcherIndices[133], |
| }, |
| { |
| /* [7] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[182], |
| }, |
| { |
| /* [8] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[184], |
| }, |
| { |
| /* [9] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [10] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [11] */ |
| /* usage */ ParameterUsage::kDepthRef, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [12] */ |
| /* usage */ ParameterUsage::kOffset, |
| /* matcher indices */ &kMatcherIndices[133], |
| }, |
| { |
| /* [13] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[182], |
| }, |
| { |
| /* [14] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [15] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [16] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [17] */ |
| /* usage */ ParameterUsage::kLevel, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [18] */ |
| /* usage */ ParameterUsage::kOffset, |
| /* matcher indices */ &kMatcherIndices[133], |
| }, |
| { |
| /* [19] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[182], |
| }, |
| { |
| /* [20] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[184], |
| }, |
| { |
| /* [21] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [22] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [23] */ |
| /* usage */ ParameterUsage::kDepthRef, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [24] */ |
| /* usage */ ParameterUsage::kOffset, |
| /* matcher indices */ &kMatcherIndices[133], |
| }, |
| { |
| /* [25] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[167], |
| }, |
| { |
| /* [26] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [27] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [28] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [29] */ |
| /* usage */ ParameterUsage::kDdx, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [30] */ |
| /* usage */ ParameterUsage::kDdy, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [31] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[169], |
| }, |
| { |
| /* [32] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [33] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [34] */ |
| /* usage */ ParameterUsage::kDdx, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [35] */ |
| /* usage */ ParameterUsage::kDdy, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [36] */ |
| /* usage */ ParameterUsage::kOffset, |
| /* matcher indices */ &kMatcherIndices[133], |
| }, |
| { |
| /* [37] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[167], |
| }, |
| { |
| /* [38] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [39] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [40] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [41] */ |
| /* usage */ ParameterUsage::kBias, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [42] */ |
| /* usage */ ParameterUsage::kOffset, |
| /* matcher indices */ &kMatcherIndices[133], |
| }, |
| { |
| /* [43] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[147], |
| }, |
| { |
| /* [44] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [45] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [46] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [47] */ |
| /* usage */ ParameterUsage::kDdx, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [48] */ |
| /* usage */ ParameterUsage::kDdy, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [49] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[167], |
| }, |
| { |
| /* [50] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [51] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [52] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [53] */ |
| /* usage */ ParameterUsage::kLevel, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [54] */ |
| /* usage */ ParameterUsage::kOffset, |
| /* matcher indices */ &kMatcherIndices[133], |
| }, |
| { |
| /* [55] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[163], |
| }, |
| { |
| /* [56] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [57] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [58] */ |
| /* usage */ ParameterUsage::kDdx, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [59] */ |
| /* usage */ ParameterUsage::kDdy, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [60] */ |
| /* usage */ ParameterUsage::kOffset, |
| /* matcher indices */ &kMatcherIndices[137], |
| }, |
| { |
| /* [61] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[163], |
| }, |
| { |
| /* [62] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [63] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [64] */ |
| /* usage */ ParameterUsage::kBias, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [65] */ |
| /* usage */ ParameterUsage::kOffset, |
| /* matcher indices */ &kMatcherIndices[137], |
| }, |
| { |
| /* [66] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[180], |
| }, |
| { |
| /* [67] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[184], |
| }, |
| { |
| /* [68] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [69] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [70] */ |
| /* usage */ ParameterUsage::kDepthRef, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [71] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[182], |
| }, |
| { |
| /* [72] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[184], |
| }, |
| { |
| /* [73] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [74] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [75] */ |
| /* usage */ ParameterUsage::kDepthRef, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [76] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[163], |
| }, |
| { |
| /* [77] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [78] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [79] */ |
| /* usage */ ParameterUsage::kLevel, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [80] */ |
| /* usage */ ParameterUsage::kOffset, |
| /* matcher indices */ &kMatcherIndices[137], |
| }, |
| { |
| /* [81] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[182], |
| }, |
| { |
| /* [82] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[184], |
| }, |
| { |
| /* [83] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [84] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [85] */ |
| /* usage */ ParameterUsage::kDepthRef, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [86] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[183], |
| }, |
| { |
| /* [87] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[184], |
| }, |
| { |
| /* [88] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [89] */ |
| /* usage */ ParameterUsage::kDepthRef, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [90] */ |
| /* usage */ ParameterUsage::kOffset, |
| /* matcher indices */ &kMatcherIndices[133], |
| }, |
| { |
| /* [91] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[169], |
| }, |
| { |
| /* [92] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [93] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [94] */ |
| /* usage */ ParameterUsage::kLevel, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [95] */ |
| /* usage */ ParameterUsage::kOffset, |
| /* matcher indices */ &kMatcherIndices[133], |
| }, |
| { |
| /* [96] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[182], |
| }, |
| { |
| /* [97] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [98] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [99] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [100] */ |
| /* usage */ ParameterUsage::kOffset, |
| /* matcher indices */ &kMatcherIndices[133], |
| }, |
| { |
| /* [101] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[147], |
| }, |
| { |
| /* [102] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [103] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [104] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [105] */ |
| /* usage */ ParameterUsage::kBias, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [106] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[180], |
| }, |
| { |
| /* [107] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[184], |
| }, |
| { |
| /* [108] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [109] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [110] */ |
| /* usage */ ParameterUsage::kDepthRef, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [111] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[182], |
| }, |
| { |
| /* [112] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [113] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [114] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [115] */ |
| /* usage */ ParameterUsage::kLevel, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [116] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[167], |
| }, |
| { |
| /* [117] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [118] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [119] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [120] */ |
| /* usage */ ParameterUsage::kOffset, |
| /* matcher indices */ &kMatcherIndices[133], |
| }, |
| { |
| /* [121] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[169], |
| }, |
| { |
| /* [122] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [123] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [124] */ |
| /* usage */ ParameterUsage::kDdx, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [125] */ |
| /* usage */ ParameterUsage::kDdy, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [126] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[147], |
| }, |
| { |
| /* [127] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [128] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [129] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [130] */ |
| /* usage */ ParameterUsage::kLevel, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [131] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[183], |
| }, |
| { |
| /* [132] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [133] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [134] */ |
| /* usage */ ParameterUsage::kLevel, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [135] */ |
| /* usage */ ParameterUsage::kOffset, |
| /* matcher indices */ &kMatcherIndices[133], |
| }, |
| { |
| /* [136] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[169], |
| }, |
| { |
| /* [137] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [138] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [139] */ |
| /* usage */ ParameterUsage::kBias, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [140] */ |
| /* usage */ ParameterUsage::kOffset, |
| /* matcher indices */ &kMatcherIndices[133], |
| }, |
| { |
| /* [141] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[167], |
| }, |
| { |
| /* [142] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [143] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [144] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [145] */ |
| /* usage */ ParameterUsage::kBias, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [146] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[157], |
| }, |
| { |
| /* [147] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [148] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [149] */ |
| /* usage */ ParameterUsage::kDdx, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [150] */ |
| /* usage */ ParameterUsage::kDdy, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [151] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[183], |
| }, |
| { |
| /* [152] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[184], |
| }, |
| { |
| /* [153] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [154] */ |
| /* usage */ ParameterUsage::kDepthRef, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [155] */ |
| /* usage */ ParameterUsage::kOffset, |
| /* matcher indices */ &kMatcherIndices[133], |
| }, |
| { |
| /* [156] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[163], |
| }, |
| { |
| /* [157] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [158] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [159] */ |
| /* usage */ ParameterUsage::kDdx, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [160] */ |
| /* usage */ ParameterUsage::kDdy, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [161] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[180], |
| }, |
| { |
| /* [162] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [163] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [164] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [165] */ |
| /* usage */ ParameterUsage::kLevel, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [166] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[167], |
| }, |
| { |
| /* [167] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [168] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [169] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [170] */ |
| /* usage */ ParameterUsage::kLevel, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [171] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[113], |
| }, |
| { |
| /* [172] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[133], |
| }, |
| { |
| /* [173] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [174] */ |
| /* usage */ ParameterUsage::kValue, |
| /* matcher indices */ &kMatcherIndices[139], |
| }, |
| { |
| /* [175] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[169], |
| }, |
| { |
| /* [176] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [177] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [178] */ |
| /* usage */ ParameterUsage::kBias, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [179] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[159], |
| }, |
| { |
| /* [180] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[133], |
| }, |
| { |
| /* [181] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [182] */ |
| /* usage */ ParameterUsage::kLevel, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [183] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[163], |
| }, |
| { |
| /* [184] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [185] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [186] */ |
| /* usage */ ParameterUsage::kBias, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [187] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[180], |
| }, |
| { |
| /* [188] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [189] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [190] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [191] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[169], |
| }, |
| { |
| /* [192] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [193] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [194] */ |
| /* usage */ ParameterUsage::kLevel, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [195] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[101], |
| }, |
| { |
| /* [196] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[133], |
| }, |
| { |
| /* [197] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [198] */ |
| /* usage */ ParameterUsage::kValue, |
| /* matcher indices */ &kMatcherIndices[143], |
| }, |
| { |
| /* [199] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[183], |
| }, |
| { |
| /* [200] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[184], |
| }, |
| { |
| /* [201] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [202] */ |
| /* usage */ ParameterUsage::kDepthRef, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [203] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[182], |
| }, |
| { |
| /* [204] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [205] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [206] */ |
| /* usage */ ParameterUsage::kArrayIndex, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [207] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[181], |
| }, |
| { |
| /* [208] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [209] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [210] */ |
| /* usage */ ParameterUsage::kLevel, |
| /* matcher indices */ &kMatcherIndices[1], |
| }, |
| { |
| /* [211] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[183], |
| }, |
| { |
| /* [212] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[184], |
| }, |
| { |
| /* [213] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [214] */ |
| /* usage */ ParameterUsage::kDepthRef, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [215] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[183], |
| }, |
| { |
| /* [216] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [217] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[141], |
| }, |
| { |
| /* [218] */ |
| /* usage */ ParameterUsage::kOffset, |
| /* matcher indices */ &kMatcherIndices[133], |
| }, |
| { |
| /* [219] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[163], |
| }, |
| { |
| /* [220] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [221] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [222] */ |
| /* usage */ ParameterUsage::kLevel, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [223] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[163], |
| }, |
| { |
| /* [224] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [225] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [226] */ |
| /* usage */ ParameterUsage::kOffset, |
| /* matcher indices */ &kMatcherIndices[137], |
| }, |
| { |
| /* [227] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[157], |
| }, |
| { |
| /* [228] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [229] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [230] */ |
| /* usage */ ParameterUsage::kLevel, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [231] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[181], |
| }, |
| { |
| /* [232] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[184], |
| }, |
| { |
| /* [233] */ |
| /* usage */ ParameterUsage::kCoords, |
| /* matcher indices */ &kMatcherIndices[131], |
| }, |
| { |
| /* [234] */ |
| /* usage */ ParameterUsage::kDepthRef, |
| /* matcher indices */ &kMatcherIndices[7], |
| }, |
| { |
| /* [235] */ |
| /* usage */ ParameterUsage::kTexture, |
| /* matcher indices */ &kMatcherIndices[167], |
| }, |
| { |
| /* [236] */ |
| /* usage */ ParameterUsage::kSampler, |
| /* matcher indices */ &kMatcherIndices[179], |
| }, |
| { |
| /* [237] */ |
|
|